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 /* Display the contents of the relocation data found at the specified
853 dump_relocations (FILE *file
,
854 unsigned long rel_offset
,
855 unsigned long rel_size
,
856 Elf_Internal_Sym
*symtab
,
859 unsigned long strtablen
,
863 Elf_Internal_Rela
*rels
;
866 if (is_rela
== UNKNOWN
)
867 is_rela
= guess_is_rela (elf_header
.e_machine
);
871 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
876 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
885 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
887 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
892 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
894 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
902 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
904 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
909 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
911 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
915 for (i
= 0; i
< rel_size
; i
++)
918 const char *rtype2
= NULL
;
919 const char *rtype3
= NULL
;
922 bfd_vma symtab_index
;
927 offset
= rels
[i
].r_offset
;
928 info
= rels
[i
].r_info
;
932 type
= ELF32_R_TYPE (info
);
933 symtab_index
= ELF32_R_SYM (info
);
937 /* The #ifdef BFD64 below is to prevent a compile time warning.
938 We know that if we do not have a 64 bit data type that we
939 will never execute this code anyway. */
941 if (elf_header
.e_machine
== EM_MIPS
)
943 /* In little-endian objects, r_info isn't really a 64-bit
944 little-endian value: it has a 32-bit little-endian
945 symbol index followed by four individual byte fields.
946 Reorder INFO accordingly. */
947 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
948 info
= (((info
& 0xffffffff) << 32)
949 | ((info
>> 56) & 0xff)
950 | ((info
>> 40) & 0xff00)
951 | ((info
>> 24) & 0xff0000)
952 | ((info
>> 8) & 0xff000000));
953 type
= ELF64_MIPS_R_TYPE (info
);
954 type2
= ELF64_MIPS_R_TYPE2 (info
);
955 type3
= ELF64_MIPS_R_TYPE3 (info
);
957 else if (elf_header
.e_machine
== EM_SPARCV9
)
958 type
= ELF64_R_TYPE_ID (info
);
960 type
= ELF64_R_TYPE (info
);
962 symtab_index
= ELF64_R_SYM (info
);
968 printf ("%8.8lx %8.8lx ",
969 (unsigned long) offset
& 0xffffffff,
970 (unsigned long) info
& 0xffffffff);
974 #if BFD_HOST_64BIT_LONG
976 ? "%16.16lx %16.16lx "
977 : "%12.12lx %12.12lx ",
979 #elif BFD_HOST_64BIT_LONG_LONG
981 ? "%16.16llx %16.16llx "
982 : "%12.12llx %12.12llx ",
986 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
987 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
988 _bfd_int64_high (offset
),
989 _bfd_int64_low (offset
),
990 _bfd_int64_high (info
),
991 _bfd_int64_low (info
));
995 switch (elf_header
.e_machine
)
1002 case EM_CYGNUS_M32R
:
1003 rtype
= elf_m32r_reloc_type (type
);
1008 rtype
= elf_i386_reloc_type (type
);
1013 rtype
= elf_m68hc11_reloc_type (type
);
1017 rtype
= elf_m68k_reloc_type (type
);
1021 rtype
= elf_i960_reloc_type (type
);
1026 rtype
= elf_avr_reloc_type (type
);
1029 case EM_OLD_SPARCV9
:
1030 case EM_SPARC32PLUS
:
1033 rtype
= elf_sparc_reloc_type (type
);
1037 rtype
= elf_spu_reloc_type (type
);
1041 case EM_CYGNUS_V850
:
1042 rtype
= v850_reloc_type (type
);
1046 case EM_CYGNUS_D10V
:
1047 rtype
= elf_d10v_reloc_type (type
);
1051 case EM_CYGNUS_D30V
:
1052 rtype
= elf_d30v_reloc_type (type
);
1056 rtype
= elf_dlx_reloc_type (type
);
1060 rtype
= elf_sh_reloc_type (type
);
1064 case EM_CYGNUS_MN10300
:
1065 rtype
= elf_mn10300_reloc_type (type
);
1069 case EM_CYGNUS_MN10200
:
1070 rtype
= elf_mn10200_reloc_type (type
);
1074 case EM_CYGNUS_FR30
:
1075 rtype
= elf_fr30_reloc_type (type
);
1079 rtype
= elf_frv_reloc_type (type
);
1083 rtype
= elf_mcore_reloc_type (type
);
1087 rtype
= elf_mmix_reloc_type (type
);
1092 rtype
= elf_msp430_reloc_type (type
);
1096 rtype
= elf_ppc_reloc_type (type
);
1100 rtype
= elf_ppc64_reloc_type (type
);
1104 case EM_MIPS_RS3_LE
:
1105 rtype
= elf_mips_reloc_type (type
);
1108 rtype2
= elf_mips_reloc_type (type2
);
1109 rtype3
= elf_mips_reloc_type (type3
);
1114 rtype
= elf_alpha_reloc_type (type
);
1118 rtype
= elf_arm_reloc_type (type
);
1122 rtype
= elf_arc_reloc_type (type
);
1126 rtype
= elf_hppa_reloc_type (type
);
1132 rtype
= elf_h8_reloc_type (type
);
1137 rtype
= elf_or32_reloc_type (type
);
1142 rtype
= elf_pj_reloc_type (type
);
1145 rtype
= elf_ia64_reloc_type (type
);
1149 rtype
= elf_cris_reloc_type (type
);
1153 rtype
= elf_i860_reloc_type (type
);
1157 rtype
= elf_x86_64_reloc_type (type
);
1161 rtype
= i370_reloc_type (type
);
1166 rtype
= elf_s390_reloc_type (type
);
1170 rtype
= elf_score_reloc_type (type
);
1174 rtype
= elf_xstormy16_reloc_type (type
);
1178 rtype
= elf_crx_reloc_type (type
);
1182 rtype
= elf_vax_reloc_type (type
);
1187 rtype
= elf_ip2k_reloc_type (type
);
1191 rtype
= elf_iq2000_reloc_type (type
);
1196 rtype
= elf_xtensa_reloc_type (type
);
1200 rtype
= elf_m32c_reloc_type (type
);
1204 rtype
= elf_mt_reloc_type (type
);
1208 rtype
= elf_bfin_reloc_type (type
);
1212 rtype
= elf_mep_reloc_type (type
);
1216 rtype
= elf_cr16_reloc_type (type
);
1221 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1223 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1225 if (elf_header
.e_machine
== EM_ALPHA
1227 && streq (rtype
, "R_ALPHA_LITUSE")
1230 switch (rels
[i
].r_addend
)
1232 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1233 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1234 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1235 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1236 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1237 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1238 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1239 default: rtype
= NULL
;
1242 printf (" (%s)", rtype
);
1246 printf (_("<unknown addend: %lx>"),
1247 (unsigned long) rels
[i
].r_addend
);
1250 else if (symtab_index
)
1252 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1253 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1256 Elf_Internal_Sym
*psym
;
1258 psym
= symtab
+ symtab_index
;
1261 print_vma (psym
->st_value
, LONG_HEX
);
1262 printf (is_32bit_elf
? " " : " ");
1264 if (psym
->st_name
== 0)
1266 const char *sec_name
= "<null>";
1269 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1271 bfd_vma sec_index
= (bfd_vma
) -1;
1273 if (psym
->st_shndx
< SHN_LORESERVE
)
1274 sec_index
= psym
->st_shndx
;
1275 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1276 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1279 if (sec_index
!= (bfd_vma
) -1)
1280 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1281 else if (psym
->st_shndx
== SHN_ABS
)
1283 else if (psym
->st_shndx
== SHN_COMMON
)
1284 sec_name
= "COMMON";
1285 else if (elf_header
.e_machine
== EM_MIPS
1286 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1287 sec_name
= "SCOMMON";
1288 else if (elf_header
.e_machine
== EM_MIPS
1289 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1290 sec_name
= "SUNDEF";
1291 else if (elf_header
.e_machine
== EM_X86_64
1292 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1293 sec_name
= "LARGE_COMMON";
1294 else if (elf_header
.e_machine
== EM_IA_64
1295 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1296 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1297 sec_name
= "ANSI_COM";
1300 sprintf (name_buf
, "<section 0x%x>",
1301 (unsigned int) psym
->st_shndx
);
1302 sec_name
= name_buf
;
1305 print_symbol (22, sec_name
);
1307 else if (strtab
== NULL
)
1308 printf (_("<string table index: %3ld>"), psym
->st_name
);
1309 else if (psym
->st_name
>= strtablen
)
1310 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1312 print_symbol (22, strtab
+ psym
->st_name
);
1315 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1320 printf ("%*c", is_32bit_elf
?
1321 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1322 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1325 if (elf_header
.e_machine
== EM_SPARCV9
1327 && streq (rtype
, "R_SPARC_OLO10"))
1328 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1332 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1334 printf (" Type2: ");
1337 printf (_("unrecognized: %-7lx"),
1338 (unsigned long) type2
& 0xffffffff);
1340 printf ("%-17.17s", rtype2
);
1342 printf ("\n Type3: ");
1345 printf (_("unrecognized: %-7lx"),
1346 (unsigned long) type3
& 0xffffffff);
1348 printf ("%-17.17s", rtype3
);
1360 get_mips_dynamic_type (unsigned long type
)
1364 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1365 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1366 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1367 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1368 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1369 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1370 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1371 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1372 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1373 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1374 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1375 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1376 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1377 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1378 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1379 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1380 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1381 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1382 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1383 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1384 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1385 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1386 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1387 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1388 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1389 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1390 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1391 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1392 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1393 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1394 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1395 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1396 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1397 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1398 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1399 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1400 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1401 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1402 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1403 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1404 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1405 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1406 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1413 get_sparc64_dynamic_type (unsigned long type
)
1417 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1424 get_ppc_dynamic_type (unsigned long type
)
1428 case DT_PPC_GOT
: return "PPC_GOT";
1435 get_ppc64_dynamic_type (unsigned long type
)
1439 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1440 case DT_PPC64_OPD
: return "PPC64_OPD";
1441 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1448 get_parisc_dynamic_type (unsigned long type
)
1452 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1453 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1454 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1455 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1456 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1457 case DT_HP_PREINIT
: return "HP_PREINIT";
1458 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1459 case DT_HP_NEEDED
: return "HP_NEEDED";
1460 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1461 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1462 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1463 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1464 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1465 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1466 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1467 case DT_HP_FILTERED
: return "HP_FILTERED";
1468 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1469 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1470 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1471 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1472 case DT_PLT
: return "PLT";
1473 case DT_PLT_SIZE
: return "PLT_SIZE";
1474 case DT_DLT
: return "DLT";
1475 case DT_DLT_SIZE
: return "DLT_SIZE";
1482 get_ia64_dynamic_type (unsigned long type
)
1486 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1493 get_alpha_dynamic_type (unsigned long type
)
1497 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1504 get_score_dynamic_type (unsigned long type
)
1508 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1509 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1510 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1511 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1512 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1513 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1521 get_dynamic_type (unsigned long type
)
1523 static char buff
[64];
1527 case DT_NULL
: return "NULL";
1528 case DT_NEEDED
: return "NEEDED";
1529 case DT_PLTRELSZ
: return "PLTRELSZ";
1530 case DT_PLTGOT
: return "PLTGOT";
1531 case DT_HASH
: return "HASH";
1532 case DT_STRTAB
: return "STRTAB";
1533 case DT_SYMTAB
: return "SYMTAB";
1534 case DT_RELA
: return "RELA";
1535 case DT_RELASZ
: return "RELASZ";
1536 case DT_RELAENT
: return "RELAENT";
1537 case DT_STRSZ
: return "STRSZ";
1538 case DT_SYMENT
: return "SYMENT";
1539 case DT_INIT
: return "INIT";
1540 case DT_FINI
: return "FINI";
1541 case DT_SONAME
: return "SONAME";
1542 case DT_RPATH
: return "RPATH";
1543 case DT_SYMBOLIC
: return "SYMBOLIC";
1544 case DT_REL
: return "REL";
1545 case DT_RELSZ
: return "RELSZ";
1546 case DT_RELENT
: return "RELENT";
1547 case DT_PLTREL
: return "PLTREL";
1548 case DT_DEBUG
: return "DEBUG";
1549 case DT_TEXTREL
: return "TEXTREL";
1550 case DT_JMPREL
: return "JMPREL";
1551 case DT_BIND_NOW
: return "BIND_NOW";
1552 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1553 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1554 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1555 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1556 case DT_RUNPATH
: return "RUNPATH";
1557 case DT_FLAGS
: return "FLAGS";
1559 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1560 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1562 case DT_CHECKSUM
: return "CHECKSUM";
1563 case DT_PLTPADSZ
: return "PLTPADSZ";
1564 case DT_MOVEENT
: return "MOVEENT";
1565 case DT_MOVESZ
: return "MOVESZ";
1566 case DT_FEATURE
: return "FEATURE";
1567 case DT_POSFLAG_1
: return "POSFLAG_1";
1568 case DT_SYMINSZ
: return "SYMINSZ";
1569 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1571 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1572 case DT_CONFIG
: return "CONFIG";
1573 case DT_DEPAUDIT
: return "DEPAUDIT";
1574 case DT_AUDIT
: return "AUDIT";
1575 case DT_PLTPAD
: return "PLTPAD";
1576 case DT_MOVETAB
: return "MOVETAB";
1577 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1579 case DT_VERSYM
: return "VERSYM";
1581 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1582 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1583 case DT_RELACOUNT
: return "RELACOUNT";
1584 case DT_RELCOUNT
: return "RELCOUNT";
1585 case DT_FLAGS_1
: return "FLAGS_1";
1586 case DT_VERDEF
: return "VERDEF";
1587 case DT_VERDEFNUM
: return "VERDEFNUM";
1588 case DT_VERNEED
: return "VERNEED";
1589 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1591 case DT_AUXILIARY
: return "AUXILIARY";
1592 case DT_USED
: return "USED";
1593 case DT_FILTER
: return "FILTER";
1595 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1596 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1597 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1598 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1599 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1600 case DT_GNU_HASH
: return "GNU_HASH";
1603 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1607 switch (elf_header
.e_machine
)
1610 case EM_MIPS_RS3_LE
:
1611 result
= get_mips_dynamic_type (type
);
1614 result
= get_sparc64_dynamic_type (type
);
1617 result
= get_ppc_dynamic_type (type
);
1620 result
= get_ppc64_dynamic_type (type
);
1623 result
= get_ia64_dynamic_type (type
);
1626 result
= get_alpha_dynamic_type (type
);
1629 result
= get_score_dynamic_type (type
);
1639 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1641 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1642 || (elf_header
.e_machine
== EM_PARISC
1643 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1647 switch (elf_header
.e_machine
)
1650 result
= get_parisc_dynamic_type (type
);
1660 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1664 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1671 get_file_type (unsigned e_type
)
1673 static char buff
[32];
1677 case ET_NONE
: return _("NONE (None)");
1678 case ET_REL
: return _("REL (Relocatable file)");
1679 case ET_EXEC
: return _("EXEC (Executable file)");
1680 case ET_DYN
: return _("DYN (Shared object file)");
1681 case ET_CORE
: return _("CORE (Core file)");
1684 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1685 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1686 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1687 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1689 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1695 get_machine_name (unsigned e_machine
)
1697 static char buff
[64]; /* XXX */
1701 case EM_NONE
: return _("None");
1702 case EM_M32
: return "WE32100";
1703 case EM_SPARC
: return "Sparc";
1704 case EM_SPU
: return "SPU";
1705 case EM_386
: return "Intel 80386";
1706 case EM_68K
: return "MC68000";
1707 case EM_88K
: return "MC88000";
1708 case EM_486
: return "Intel 80486";
1709 case EM_860
: return "Intel 80860";
1710 case EM_MIPS
: return "MIPS R3000";
1711 case EM_S370
: return "IBM System/370";
1712 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1713 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1714 case EM_PARISC
: return "HPPA";
1715 case EM_PPC_OLD
: return "Power PC (old)";
1716 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1717 case EM_960
: return "Intel 90860";
1718 case EM_PPC
: return "PowerPC";
1719 case EM_PPC64
: return "PowerPC64";
1720 case EM_V800
: return "NEC V800";
1721 case EM_FR20
: return "Fujitsu FR20";
1722 case EM_RH32
: return "TRW RH32";
1723 case EM_MCORE
: return "MCORE";
1724 case EM_ARM
: return "ARM";
1725 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1726 case EM_SH
: return "Renesas / SuperH SH";
1727 case EM_SPARCV9
: return "Sparc v9";
1728 case EM_TRICORE
: return "Siemens Tricore";
1729 case EM_ARC
: return "ARC";
1730 case EM_H8_300
: return "Renesas H8/300";
1731 case EM_H8_300H
: return "Renesas H8/300H";
1732 case EM_H8S
: return "Renesas H8S";
1733 case EM_H8_500
: return "Renesas H8/500";
1734 case EM_IA_64
: return "Intel IA-64";
1735 case EM_MIPS_X
: return "Stanford MIPS-X";
1736 case EM_COLDFIRE
: return "Motorola Coldfire";
1737 case EM_68HC12
: return "Motorola M68HC12";
1738 case EM_ALPHA
: return "Alpha";
1739 case EM_CYGNUS_D10V
:
1740 case EM_D10V
: return "d10v";
1741 case EM_CYGNUS_D30V
:
1742 case EM_D30V
: return "d30v";
1743 case EM_CYGNUS_M32R
:
1744 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1745 case EM_CYGNUS_V850
:
1746 case EM_V850
: return "NEC v850";
1747 case EM_CYGNUS_MN10300
:
1748 case EM_MN10300
: return "mn10300";
1749 case EM_CYGNUS_MN10200
:
1750 case EM_MN10200
: return "mn10200";
1751 case EM_CYGNUS_FR30
:
1752 case EM_FR30
: return "Fujitsu FR30";
1753 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1755 case EM_PJ
: return "picoJava";
1756 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1757 case EM_PCP
: return "Siemens PCP";
1758 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1759 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1760 case EM_STARCORE
: return "Motorola Star*Core processor";
1761 case EM_ME16
: return "Toyota ME16 processor";
1762 case EM_ST100
: return "STMicroelectronics ST100 processor";
1763 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1764 case EM_FX66
: return "Siemens FX66 microcontroller";
1765 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1766 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1767 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1768 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1769 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1770 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1771 case EM_SVX
: return "Silicon Graphics SVx";
1772 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1773 case EM_VAX
: return "Digital VAX";
1775 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1776 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1777 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1778 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1779 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1780 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1781 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1782 case EM_PRISM
: return "Vitesse Prism";
1783 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1785 case EM_S390
: return "IBM S/390";
1786 case EM_SCORE
: return "SUNPLUS S+Core";
1787 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1789 case EM_OR32
: return "OpenRISC";
1790 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1791 case EM_DLX
: return "OpenDLX";
1793 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1794 case EM_IQ2000
: return "Vitesse IQ2000";
1796 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1797 case EM_M32C
: return "Renesas M32c";
1798 case EM_MT
: return "Morpho Techologies MT processor";
1799 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1800 case EM_NIOS32
: return "Altera Nios";
1801 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1802 case EM_XC16X
: return "Infineon Technologies xc16x";
1803 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1804 case EM_CR16
: return "National Semiconductor's CR16";
1806 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1812 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1817 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1818 e_flags
&= ~ EF_ARM_EABIMASK
;
1820 /* Handle "generic" ARM flags. */
1821 if (e_flags
& EF_ARM_RELEXEC
)
1823 strcat (buf
, ", relocatable executable");
1824 e_flags
&= ~ EF_ARM_RELEXEC
;
1827 if (e_flags
& EF_ARM_HASENTRY
)
1829 strcat (buf
, ", has entry point");
1830 e_flags
&= ~ EF_ARM_HASENTRY
;
1833 /* Now handle EABI specific flags. */
1837 strcat (buf
, ", <unrecognized EABI>");
1842 case EF_ARM_EABI_VER1
:
1843 strcat (buf
, ", Version1 EABI");
1848 /* Process flags one bit at a time. */
1849 flag
= e_flags
& - e_flags
;
1854 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1855 strcat (buf
, ", sorted symbol tables");
1865 case EF_ARM_EABI_VER2
:
1866 strcat (buf
, ", Version2 EABI");
1871 /* Process flags one bit at a time. */
1872 flag
= e_flags
& - e_flags
;
1877 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1878 strcat (buf
, ", sorted symbol tables");
1881 case EF_ARM_DYNSYMSUSESEGIDX
:
1882 strcat (buf
, ", dynamic symbols use segment index");
1885 case EF_ARM_MAPSYMSFIRST
:
1886 strcat (buf
, ", mapping symbols precede others");
1896 case EF_ARM_EABI_VER3
:
1897 strcat (buf
, ", Version3 EABI");
1900 case EF_ARM_EABI_VER4
:
1901 strcat (buf
, ", Version4 EABI");
1904 case EF_ARM_EABI_VER5
:
1905 strcat (buf
, ", Version5 EABI");
1911 /* Process flags one bit at a time. */
1912 flag
= e_flags
& - e_flags
;
1918 strcat (buf
, ", BE8");
1922 strcat (buf
, ", LE8");
1932 case EF_ARM_EABI_UNKNOWN
:
1933 strcat (buf
, ", GNU EABI");
1938 /* Process flags one bit at a time. */
1939 flag
= e_flags
& - e_flags
;
1944 case EF_ARM_INTERWORK
:
1945 strcat (buf
, ", interworking enabled");
1948 case EF_ARM_APCS_26
:
1949 strcat (buf
, ", uses APCS/26");
1952 case EF_ARM_APCS_FLOAT
:
1953 strcat (buf
, ", uses APCS/float");
1957 strcat (buf
, ", position independent");
1961 strcat (buf
, ", 8 bit structure alignment");
1964 case EF_ARM_NEW_ABI
:
1965 strcat (buf
, ", uses new ABI");
1968 case EF_ARM_OLD_ABI
:
1969 strcat (buf
, ", uses old ABI");
1972 case EF_ARM_SOFT_FLOAT
:
1973 strcat (buf
, ", software FP");
1976 case EF_ARM_VFP_FLOAT
:
1977 strcat (buf
, ", VFP");
1980 case EF_ARM_MAVERICK_FLOAT
:
1981 strcat (buf
, ", Maverick FP");
1992 strcat (buf
,", <unknown>");
1996 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1998 static char buf
[1024];
2010 decode_ARM_machine_flags (e_flags
, buf
);
2014 switch (e_flags
& EF_FRV_CPU_MASK
)
2016 case EF_FRV_CPU_GENERIC
:
2020 strcat (buf
, ", fr???");
2023 case EF_FRV_CPU_FR300
:
2024 strcat (buf
, ", fr300");
2027 case EF_FRV_CPU_FR400
:
2028 strcat (buf
, ", fr400");
2030 case EF_FRV_CPU_FR405
:
2031 strcat (buf
, ", fr405");
2034 case EF_FRV_CPU_FR450
:
2035 strcat (buf
, ", fr450");
2038 case EF_FRV_CPU_FR500
:
2039 strcat (buf
, ", fr500");
2041 case EF_FRV_CPU_FR550
:
2042 strcat (buf
, ", fr550");
2045 case EF_FRV_CPU_SIMPLE
:
2046 strcat (buf
, ", simple");
2048 case EF_FRV_CPU_TOMCAT
:
2049 strcat (buf
, ", tomcat");
2055 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2056 strcat (buf
, ", m68000");
2057 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2058 strcat (buf
, ", cpu32");
2059 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2060 strcat (buf
, ", fido_a");
2063 char const *isa
= _("unknown");
2064 char const *mac
= _("unknown mac");
2065 char const *additional
= NULL
;
2067 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2069 case EF_M68K_CF_ISA_A_NODIV
:
2071 additional
= ", nodiv";
2073 case EF_M68K_CF_ISA_A
:
2076 case EF_M68K_CF_ISA_A_PLUS
:
2079 case EF_M68K_CF_ISA_B_NOUSP
:
2081 additional
= ", nousp";
2083 case EF_M68K_CF_ISA_B
:
2087 strcat (buf
, ", cf, isa ");
2090 strcat (buf
, additional
);
2091 if (e_flags
& EF_M68K_CF_FLOAT
)
2092 strcat (buf
, ", float");
2093 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2098 case EF_M68K_CF_MAC
:
2101 case EF_M68K_CF_EMAC
:
2114 if (e_flags
& EF_PPC_EMB
)
2115 strcat (buf
, ", emb");
2117 if (e_flags
& EF_PPC_RELOCATABLE
)
2118 strcat (buf
, ", relocatable");
2120 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2121 strcat (buf
, ", relocatable-lib");
2125 case EM_CYGNUS_V850
:
2126 switch (e_flags
& EF_V850_ARCH
)
2129 strcat (buf
, ", v850e1");
2132 strcat (buf
, ", v850e");
2135 strcat (buf
, ", v850");
2138 strcat (buf
, ", unknown v850 architecture variant");
2144 case EM_CYGNUS_M32R
:
2145 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2146 strcat (buf
, ", m32r");
2150 case EM_MIPS_RS3_LE
:
2151 if (e_flags
& EF_MIPS_NOREORDER
)
2152 strcat (buf
, ", noreorder");
2154 if (e_flags
& EF_MIPS_PIC
)
2155 strcat (buf
, ", pic");
2157 if (e_flags
& EF_MIPS_CPIC
)
2158 strcat (buf
, ", cpic");
2160 if (e_flags
& EF_MIPS_UCODE
)
2161 strcat (buf
, ", ugen_reserved");
2163 if (e_flags
& EF_MIPS_ABI2
)
2164 strcat (buf
, ", abi2");
2166 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2167 strcat (buf
, ", odk first");
2169 if (e_flags
& EF_MIPS_32BITMODE
)
2170 strcat (buf
, ", 32bitmode");
2172 switch ((e_flags
& EF_MIPS_MACH
))
2174 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2175 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2176 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2177 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2178 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2179 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2180 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2181 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2182 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2183 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2185 /* We simply ignore the field in this case to avoid confusion:
2186 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2189 default: strcat (buf
, ", unknown CPU"); break;
2192 switch ((e_flags
& EF_MIPS_ABI
))
2194 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2195 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2196 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2197 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2199 /* We simply ignore the field in this case to avoid confusion:
2200 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2201 This means it is likely to be an o32 file, but not for
2204 default: strcat (buf
, ", unknown ABI"); break;
2207 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2208 strcat (buf
, ", mdmx");
2210 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2211 strcat (buf
, ", mips16");
2213 switch ((e_flags
& EF_MIPS_ARCH
))
2215 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2216 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2217 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2218 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2219 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2220 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2221 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2222 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2223 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2224 default: strcat (buf
, ", unknown ISA"); break;
2230 switch ((e_flags
& EF_SH_MACH_MASK
))
2232 case EF_SH1
: strcat (buf
, ", sh1"); break;
2233 case EF_SH2
: strcat (buf
, ", sh2"); break;
2234 case EF_SH3
: strcat (buf
, ", sh3"); break;
2235 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2236 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2237 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2238 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2239 case EF_SH4
: strcat (buf
, ", sh4"); break;
2240 case EF_SH5
: strcat (buf
, ", sh5"); break;
2241 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2242 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2243 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2244 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2245 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2246 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2247 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2248 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2249 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2250 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2251 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2252 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2253 default: strcat (buf
, ", unknown ISA"); break;
2259 if (e_flags
& EF_SPARC_32PLUS
)
2260 strcat (buf
, ", v8+");
2262 if (e_flags
& EF_SPARC_SUN_US1
)
2263 strcat (buf
, ", ultrasparcI");
2265 if (e_flags
& EF_SPARC_SUN_US3
)
2266 strcat (buf
, ", ultrasparcIII");
2268 if (e_flags
& EF_SPARC_HAL_R1
)
2269 strcat (buf
, ", halr1");
2271 if (e_flags
& EF_SPARC_LEDATA
)
2272 strcat (buf
, ", ledata");
2274 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2275 strcat (buf
, ", tso");
2277 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2278 strcat (buf
, ", pso");
2280 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2281 strcat (buf
, ", rmo");
2285 switch (e_flags
& EF_PARISC_ARCH
)
2287 case EFA_PARISC_1_0
:
2288 strcpy (buf
, ", PA-RISC 1.0");
2290 case EFA_PARISC_1_1
:
2291 strcpy (buf
, ", PA-RISC 1.1");
2293 case EFA_PARISC_2_0
:
2294 strcpy (buf
, ", PA-RISC 2.0");
2299 if (e_flags
& EF_PARISC_TRAPNIL
)
2300 strcat (buf
, ", trapnil");
2301 if (e_flags
& EF_PARISC_EXT
)
2302 strcat (buf
, ", ext");
2303 if (e_flags
& EF_PARISC_LSB
)
2304 strcat (buf
, ", lsb");
2305 if (e_flags
& EF_PARISC_WIDE
)
2306 strcat (buf
, ", wide");
2307 if (e_flags
& EF_PARISC_NO_KABP
)
2308 strcat (buf
, ", no kabp");
2309 if (e_flags
& EF_PARISC_LAZYSWAP
)
2310 strcat (buf
, ", lazyswap");
2315 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2316 strcat (buf
, ", new calling convention");
2318 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2319 strcat (buf
, ", gnu calling convention");
2323 if ((e_flags
& EF_IA_64_ABI64
))
2324 strcat (buf
, ", 64-bit");
2326 strcat (buf
, ", 32-bit");
2327 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2328 strcat (buf
, ", reduced fp model");
2329 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2330 strcat (buf
, ", no function descriptors, constant gp");
2331 else if ((e_flags
& EF_IA_64_CONS_GP
))
2332 strcat (buf
, ", constant gp");
2333 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2334 strcat (buf
, ", absolute");
2338 if ((e_flags
& EF_VAX_NONPIC
))
2339 strcat (buf
, ", non-PIC");
2340 if ((e_flags
& EF_VAX_DFLOAT
))
2341 strcat (buf
, ", D-Float");
2342 if ((e_flags
& EF_VAX_GFLOAT
))
2343 strcat (buf
, ", G-Float");
2352 get_osabi_name (unsigned int osabi
)
2354 static char buff
[32];
2358 case ELFOSABI_NONE
: return "UNIX - System V";
2359 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2360 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2361 case ELFOSABI_LINUX
: return "UNIX - Linux";
2362 case ELFOSABI_HURD
: return "GNU/Hurd";
2363 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2364 case ELFOSABI_AIX
: return "UNIX - AIX";
2365 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2366 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2367 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2368 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2369 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2370 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2371 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2372 case ELFOSABI_AROS
: return "Amiga Research OS";
2373 case ELFOSABI_STANDALONE
: return _("Standalone App");
2374 case ELFOSABI_ARM
: return "ARM";
2376 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2382 get_arm_segment_type (unsigned long type
)
2396 get_mips_segment_type (unsigned long type
)
2400 case PT_MIPS_REGINFO
:
2402 case PT_MIPS_RTPROC
:
2404 case PT_MIPS_OPTIONS
:
2414 get_parisc_segment_type (unsigned long type
)
2418 case PT_HP_TLS
: return "HP_TLS";
2419 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2420 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2421 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2422 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2423 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2424 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2425 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2426 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2427 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2428 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2429 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2430 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2431 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2432 case PT_HP_STACK
: return "HP_STACK";
2433 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2434 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2435 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2436 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2445 get_ia64_segment_type (unsigned long type
)
2449 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2450 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2451 case PT_HP_TLS
: return "HP_TLS";
2452 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2453 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2454 case PT_IA_64_HP_STACK
: return "HP_STACK";
2463 get_segment_type (unsigned long p_type
)
2465 static char buff
[32];
2469 case PT_NULL
: return "NULL";
2470 case PT_LOAD
: return "LOAD";
2471 case PT_DYNAMIC
: return "DYNAMIC";
2472 case PT_INTERP
: return "INTERP";
2473 case PT_NOTE
: return "NOTE";
2474 case PT_SHLIB
: return "SHLIB";
2475 case PT_PHDR
: return "PHDR";
2476 case PT_TLS
: return "TLS";
2478 case PT_GNU_EH_FRAME
:
2479 return "GNU_EH_FRAME";
2480 case PT_GNU_STACK
: return "GNU_STACK";
2481 case PT_GNU_RELRO
: return "GNU_RELRO";
2484 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2488 switch (elf_header
.e_machine
)
2491 result
= get_arm_segment_type (p_type
);
2494 case EM_MIPS_RS3_LE
:
2495 result
= get_mips_segment_type (p_type
);
2498 result
= get_parisc_segment_type (p_type
);
2501 result
= get_ia64_segment_type (p_type
);
2511 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2513 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2517 switch (elf_header
.e_machine
)
2520 result
= get_parisc_segment_type (p_type
);
2523 result
= get_ia64_segment_type (p_type
);
2533 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2536 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2543 get_mips_section_type_name (unsigned int sh_type
)
2547 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2548 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2549 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2550 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2551 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2552 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2553 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2554 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2555 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2556 case SHT_MIPS_RELD
: return "MIPS_RELD";
2557 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2558 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2559 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2560 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2561 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2562 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2563 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2564 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2565 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2566 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2567 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2568 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2569 case SHT_MIPS_LINE
: return "MIPS_LINE";
2570 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2571 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2572 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2573 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2574 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2575 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2576 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2577 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2578 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2579 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2580 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2581 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2582 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2583 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2584 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2585 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2593 get_parisc_section_type_name (unsigned int sh_type
)
2597 case SHT_PARISC_EXT
: return "PARISC_EXT";
2598 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2599 case SHT_PARISC_DOC
: return "PARISC_DOC";
2600 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2601 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2602 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2603 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2611 get_ia64_section_type_name (unsigned int sh_type
)
2613 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2614 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2615 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2619 case SHT_IA_64_EXT
: return "IA_64_EXT";
2620 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2621 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2629 get_x86_64_section_type_name (unsigned int sh_type
)
2633 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2641 get_arm_section_type_name (unsigned int sh_type
)
2647 case SHT_ARM_PREEMPTMAP
:
2648 return "ARM_PREEMPTMAP";
2649 case SHT_ARM_ATTRIBUTES
:
2650 return "ARM_ATTRIBUTES";
2658 get_section_type_name (unsigned int sh_type
)
2660 static char buff
[32];
2664 case SHT_NULL
: return "NULL";
2665 case SHT_PROGBITS
: return "PROGBITS";
2666 case SHT_SYMTAB
: return "SYMTAB";
2667 case SHT_STRTAB
: return "STRTAB";
2668 case SHT_RELA
: return "RELA";
2669 case SHT_HASH
: return "HASH";
2670 case SHT_DYNAMIC
: return "DYNAMIC";
2671 case SHT_NOTE
: return "NOTE";
2672 case SHT_NOBITS
: return "NOBITS";
2673 case SHT_REL
: return "REL";
2674 case SHT_SHLIB
: return "SHLIB";
2675 case SHT_DYNSYM
: return "DYNSYM";
2676 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2677 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2678 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2679 case SHT_GNU_HASH
: return "GNU_HASH";
2680 case SHT_GROUP
: return "GROUP";
2681 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2682 case SHT_GNU_verdef
: return "VERDEF";
2683 case SHT_GNU_verneed
: return "VERNEED";
2684 case SHT_GNU_versym
: return "VERSYM";
2685 case 0x6ffffff0: return "VERSYM";
2686 case 0x6ffffffc: return "VERDEF";
2687 case 0x7ffffffd: return "AUXILIARY";
2688 case 0x7fffffff: return "FILTER";
2689 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2692 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2696 switch (elf_header
.e_machine
)
2699 case EM_MIPS_RS3_LE
:
2700 result
= get_mips_section_type_name (sh_type
);
2703 result
= get_parisc_section_type_name (sh_type
);
2706 result
= get_ia64_section_type_name (sh_type
);
2709 result
= get_x86_64_section_type_name (sh_type
);
2712 result
= get_arm_section_type_name (sh_type
);
2722 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2724 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2725 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2726 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2727 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2729 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2735 #define OPTION_DEBUG_DUMP 512
2737 static struct option options
[] =
2739 {"all", no_argument
, 0, 'a'},
2740 {"file-header", no_argument
, 0, 'h'},
2741 {"program-headers", no_argument
, 0, 'l'},
2742 {"headers", no_argument
, 0, 'e'},
2743 {"histogram", no_argument
, 0, 'I'},
2744 {"segments", no_argument
, 0, 'l'},
2745 {"sections", no_argument
, 0, 'S'},
2746 {"section-headers", no_argument
, 0, 'S'},
2747 {"section-groups", no_argument
, 0, 'g'},
2748 {"section-details", no_argument
, 0, 't'},
2749 {"full-section-name",no_argument
, 0, 'N'},
2750 {"symbols", no_argument
, 0, 's'},
2751 {"syms", no_argument
, 0, 's'},
2752 {"relocs", no_argument
, 0, 'r'},
2753 {"notes", no_argument
, 0, 'n'},
2754 {"dynamic", no_argument
, 0, 'd'},
2755 {"arch-specific", no_argument
, 0, 'A'},
2756 {"version-info", no_argument
, 0, 'V'},
2757 {"use-dynamic", no_argument
, 0, 'D'},
2758 {"unwind", no_argument
, 0, 'u'},
2759 {"archive-index", no_argument
, 0, 'c'},
2760 {"hex-dump", required_argument
, 0, 'x'},
2761 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2762 {"string-dump", required_argument
, 0, 'p'},
2763 #ifdef SUPPORT_DISASSEMBLY
2764 {"instruction-dump", required_argument
, 0, 'i'},
2767 {"version", no_argument
, 0, 'v'},
2768 {"wide", no_argument
, 0, 'W'},
2769 {"help", no_argument
, 0, 'H'},
2770 {0, no_argument
, 0, 0}
2774 usage (FILE *stream
)
2776 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2777 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2778 fprintf (stream
, _(" Options are:\n\
2779 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2780 -h --file-header Display the ELF file header\n\
2781 -l --program-headers Display the program headers\n\
2782 --segments An alias for --program-headers\n\
2783 -S --section-headers Display the sections' header\n\
2784 --sections An alias for --section-headers\n\
2785 -g --section-groups Display the section groups\n\
2786 -t --section-details Display the section details\n\
2787 -e --headers Equivalent to: -h -l -S\n\
2788 -s --syms Display the symbol table\n\
2789 --symbols An alias for --syms\n\
2790 -n --notes Display the core notes (if present)\n\
2791 -r --relocs Display the relocations (if present)\n\
2792 -u --unwind Display the unwind info (if present)\n\
2793 -d --dynamic Display the dynamic section (if present)\n\
2794 -V --version-info Display the version sections (if present)\n\
2795 -A --arch-specific Display architecture specific information (if any).\n\
2796 -c --archive-index Display the symbol/file index in an archive\n\
2797 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2798 -x --hex-dump=<number|name>\n\
2799 Dump the contents of section <number|name> as bytes\n\
2800 -p --string-dump=<number|name>\n\
2801 Dump the contents of section <number|name> as strings\n\
2802 -w[liaprmfFsoR] or\n\
2803 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2804 Display the contents of DWARF2 debug sections\n"));
2805 #ifdef SUPPORT_DISASSEMBLY
2806 fprintf (stream
, _("\
2807 -i --instruction-dump=<number|name>\n\
2808 Disassemble the contents of section <number|name>\n"));
2810 fprintf (stream
, _("\
2811 -I --histogram Display histogram of bucket list lengths\n\
2812 -W --wide Allow output width to exceed 80 characters\n\
2813 @<file> Read options from <file>\n\
2814 -H --help Display this information\n\
2815 -v --version Display the version number of readelf\n"));
2817 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2818 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2820 exit (stream
== stdout
? 0 : 1);
2823 /* Record the fact that the user wants the contents of section number
2824 SECTION to be displayed using the method(s) encoded as flags bits
2825 in TYPE. Note, TYPE can be zero if we are creating the array for
2829 request_dump_bynumber (unsigned int section
, dump_type type
)
2831 if (section
>= num_dump_sects
)
2833 dump_type
*new_dump_sects
;
2835 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2837 if (new_dump_sects
== NULL
)
2838 error (_("Out of memory allocating dump request table.\n"));
2841 /* Copy current flag settings. */
2842 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2846 dump_sects
= new_dump_sects
;
2847 num_dump_sects
= section
+ 1;
2852 dump_sects
[section
] |= type
;
2857 /* Request a dump by section name. */
2860 request_dump_byname (const char *section
, dump_type type
)
2862 struct dump_list_entry
*new_request
;
2864 new_request
= malloc (sizeof (struct dump_list_entry
));
2866 error (_("Out of memory allocating dump request table.\n"));
2868 new_request
->name
= strdup (section
);
2869 if (!new_request
->name
)
2870 error (_("Out of memory allocating dump request table.\n"));
2872 new_request
->type
= type
;
2874 new_request
->next
= dump_sects_byname
;
2875 dump_sects_byname
= new_request
;
2879 parse_args (int argc
, char **argv
)
2886 while ((c
= getopt_long
2887 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
2908 do_section_groups
++;
2916 do_section_groups
++;
2921 do_section_details
++;
2966 section
= strtoul (optarg
, & cp
, 0);
2967 if (! *cp
&& section
>= 0)
2968 request_dump_bynumber (section
, HEX_DUMP
);
2970 request_dump_byname (optarg
, HEX_DUMP
);
2974 section
= strtoul (optarg
, & cp
, 0);
2975 if (! *cp
&& section
>= 0)
2976 request_dump_bynumber (section
, STRING_DUMP
);
2978 request_dump_byname (optarg
, STRING_DUMP
);
2986 unsigned int index
= 0;
2990 while (optarg
[index
])
2991 switch (optarg
[index
++])
3000 do_debug_abbrevs
= 1;
3010 do_debug_pubnames
= 1;
3014 do_debug_aranges
= 1;
3018 do_debug_ranges
= 1;
3022 do_debug_frames_interp
= 1;
3024 do_debug_frames
= 1;
3029 do_debug_macinfo
= 1;
3043 warn (_("Unrecognized debug option '%s'\n"), optarg
);
3048 case OPTION_DEBUG_DUMP
:
3056 const char * option
;
3059 debug_dump_long_opts
;
3061 debug_dump_long_opts opts_table
[] =
3063 /* Please keep this table alpha- sorted. */
3064 { "Ranges", & do_debug_ranges
},
3065 { "abbrev", & do_debug_abbrevs
},
3066 { "aranges", & do_debug_aranges
},
3067 { "frames", & do_debug_frames
},
3068 { "frames-interp", & do_debug_frames_interp
},
3069 { "info", & do_debug_info
},
3070 { "line", & do_debug_lines
},
3071 { "loc", & do_debug_loc
},
3072 { "macro", & do_debug_macinfo
},
3073 { "pubnames", & do_debug_pubnames
},
3074 /* This entry is for compatability
3075 with earlier versions of readelf. */
3076 { "ranges", & do_debug_aranges
},
3077 { "str", & do_debug_str
},
3088 debug_dump_long_opts
* entry
;
3090 for (entry
= opts_table
; entry
->option
; entry
++)
3092 size_t len
= strlen (entry
->option
);
3094 if (strneq (p
, entry
->option
, len
)
3095 && (p
[len
] == ',' || p
[len
] == '\0'))
3097 * entry
->variable
= 1;
3099 /* The --debug-dump=frames-interp option also
3100 enables the --debug-dump=frames option. */
3101 if (do_debug_frames_interp
)
3102 do_debug_frames
= 1;
3109 if (entry
->option
== NULL
)
3111 warn (_("Unrecognized debug option '%s'\n"), p
);
3112 p
= strchr (p
, ',');
3122 #ifdef SUPPORT_DISASSEMBLY
3125 section
= strtoul (optarg
, & cp
, 0);
3126 if (! *cp
&& section
>= 0)
3127 request_dump_bynumber (section
, DISASS_DUMP
);
3129 request_dump_byname (optarg
, DISASS_DUMP
);
3132 print_version (program_name
);
3141 /* xgettext:c-format */
3142 error (_("Invalid option '-%c'\n"), c
);
3149 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3150 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3151 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3152 && !do_section_groups
&& !do_archive_index
)
3156 warn (_("Nothing to do.\n"));
3162 get_elf_class (unsigned int elf_class
)
3164 static char buff
[32];
3168 case ELFCLASSNONE
: return _("none");
3169 case ELFCLASS32
: return "ELF32";
3170 case ELFCLASS64
: return "ELF64";
3172 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3178 get_data_encoding (unsigned int encoding
)
3180 static char buff
[32];
3184 case ELFDATANONE
: return _("none");
3185 case ELFDATA2LSB
: return _("2's complement, little endian");
3186 case ELFDATA2MSB
: return _("2's complement, big endian");
3188 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3193 /* Decode the data held in 'elf_header'. */
3196 process_file_header (void)
3198 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3199 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3200 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3201 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3204 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3212 printf (_("ELF Header:\n"));
3213 printf (_(" Magic: "));
3214 for (i
= 0; i
< EI_NIDENT
; i
++)
3215 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3217 printf (_(" Class: %s\n"),
3218 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3219 printf (_(" Data: %s\n"),
3220 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3221 printf (_(" Version: %d %s\n"),
3222 elf_header
.e_ident
[EI_VERSION
],
3223 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3225 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3228 printf (_(" OS/ABI: %s\n"),
3229 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3230 printf (_(" ABI Version: %d\n"),
3231 elf_header
.e_ident
[EI_ABIVERSION
]);
3232 printf (_(" Type: %s\n"),
3233 get_file_type (elf_header
.e_type
));
3234 printf (_(" Machine: %s\n"),
3235 get_machine_name (elf_header
.e_machine
));
3236 printf (_(" Version: 0x%lx\n"),
3237 (unsigned long) elf_header
.e_version
);
3239 printf (_(" Entry point address: "));
3240 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3241 printf (_("\n Start of program headers: "));
3242 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3243 printf (_(" (bytes into file)\n Start of section headers: "));
3244 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3245 printf (_(" (bytes into file)\n"));
3247 printf (_(" Flags: 0x%lx%s\n"),
3248 (unsigned long) elf_header
.e_flags
,
3249 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3250 printf (_(" Size of this header: %ld (bytes)\n"),
3251 (long) elf_header
.e_ehsize
);
3252 printf (_(" Size of program headers: %ld (bytes)\n"),
3253 (long) elf_header
.e_phentsize
);
3254 printf (_(" Number of program headers: %ld\n"),
3255 (long) elf_header
.e_phnum
);
3256 printf (_(" Size of section headers: %ld (bytes)\n"),
3257 (long) elf_header
.e_shentsize
);
3258 printf (_(" Number of section headers: %ld"),
3259 (long) elf_header
.e_shnum
);
3260 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3261 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3262 putc ('\n', stdout
);
3263 printf (_(" Section header string table index: %ld"),
3264 (long) elf_header
.e_shstrndx
);
3265 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3266 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3267 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3268 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3269 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3270 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3271 printf (" <corrupt: out of range>");
3272 putc ('\n', stdout
);
3275 if (section_headers
!= NULL
)
3277 if (elf_header
.e_shnum
== 0)
3278 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3279 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3280 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3281 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3282 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3283 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3284 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3285 elf_header
.e_shstrndx
= SHN_UNDEF
;
3286 free (section_headers
);
3287 section_headers
= NULL
;
3295 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3297 Elf32_External_Phdr
*phdrs
;
3298 Elf32_External_Phdr
*external
;
3299 Elf_Internal_Phdr
*internal
;
3302 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3303 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3304 _("program headers"));
3308 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3309 i
< elf_header
.e_phnum
;
3310 i
++, internal
++, external
++)
3312 internal
->p_type
= BYTE_GET (external
->p_type
);
3313 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3314 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3315 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3316 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3317 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3318 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3319 internal
->p_align
= BYTE_GET (external
->p_align
);
3328 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3330 Elf64_External_Phdr
*phdrs
;
3331 Elf64_External_Phdr
*external
;
3332 Elf_Internal_Phdr
*internal
;
3335 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3336 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3337 _("program headers"));
3341 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3342 i
< elf_header
.e_phnum
;
3343 i
++, internal
++, external
++)
3345 internal
->p_type
= BYTE_GET (external
->p_type
);
3346 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3347 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3348 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3349 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3350 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3351 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3352 internal
->p_align
= BYTE_GET (external
->p_align
);
3360 /* Returns 1 if the program headers were read into `program_headers'. */
3363 get_program_headers (FILE *file
)
3365 Elf_Internal_Phdr
*phdrs
;
3367 /* Check cache of prior read. */
3368 if (program_headers
!= NULL
)
3371 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3375 error (_("Out of memory\n"));
3380 ? get_32bit_program_headers (file
, phdrs
)
3381 : get_64bit_program_headers (file
, phdrs
))
3383 program_headers
= phdrs
;
3391 /* Returns 1 if the program headers were loaded. */
3394 process_program_headers (FILE *file
)
3396 Elf_Internal_Phdr
*segment
;
3399 if (elf_header
.e_phnum
== 0)
3402 printf (_("\nThere are no program headers in this file.\n"));
3406 if (do_segments
&& !do_header
)
3408 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3409 printf (_("Entry point "));
3410 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3411 printf (_("\nThere are %d program headers, starting at offset "),
3412 elf_header
.e_phnum
);
3413 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3417 if (! get_program_headers (file
))
3422 if (elf_header
.e_phnum
> 1)
3423 printf (_("\nProgram Headers:\n"));
3425 printf (_("\nProgram Headers:\n"));
3429 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3432 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3436 (_(" Type Offset VirtAddr PhysAddr\n"));
3438 (_(" FileSiz MemSiz Flags Align\n"));
3445 for (i
= 0, segment
= program_headers
;
3446 i
< elf_header
.e_phnum
;
3451 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3455 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3456 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3457 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3458 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3459 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3461 (segment
->p_flags
& PF_R
? 'R' : ' '),
3462 (segment
->p_flags
& PF_W
? 'W' : ' '),
3463 (segment
->p_flags
& PF_X
? 'E' : ' '));
3464 printf ("%#lx", (unsigned long) segment
->p_align
);
3468 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3469 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3472 print_vma (segment
->p_offset
, FULL_HEX
);
3476 print_vma (segment
->p_vaddr
, FULL_HEX
);
3478 print_vma (segment
->p_paddr
, FULL_HEX
);
3481 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3482 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3485 print_vma (segment
->p_filesz
, FULL_HEX
);
3489 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3490 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3493 print_vma (segment
->p_offset
, FULL_HEX
);
3497 (segment
->p_flags
& PF_R
? 'R' : ' '),
3498 (segment
->p_flags
& PF_W
? 'W' : ' '),
3499 (segment
->p_flags
& PF_X
? 'E' : ' '));
3501 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3502 printf ("%#lx", (unsigned long) segment
->p_align
);
3505 print_vma (segment
->p_align
, PREFIX_HEX
);
3510 print_vma (segment
->p_offset
, FULL_HEX
);
3512 print_vma (segment
->p_vaddr
, FULL_HEX
);
3514 print_vma (segment
->p_paddr
, FULL_HEX
);
3516 print_vma (segment
->p_filesz
, FULL_HEX
);
3518 print_vma (segment
->p_memsz
, FULL_HEX
);
3520 (segment
->p_flags
& PF_R
? 'R' : ' '),
3521 (segment
->p_flags
& PF_W
? 'W' : ' '),
3522 (segment
->p_flags
& PF_X
? 'E' : ' '));
3523 print_vma (segment
->p_align
, HEX
);
3527 switch (segment
->p_type
)
3531 error (_("more than one dynamic segment\n"));
3533 /* By default, assume that the .dynamic section is the first
3534 section in the DYNAMIC segment. */
3535 dynamic_addr
= segment
->p_offset
;
3536 dynamic_size
= segment
->p_filesz
;
3538 /* Try to locate the .dynamic section. If there is
3539 a section header table, we can easily locate it. */
3540 if (section_headers
!= NULL
)
3542 Elf_Internal_Shdr
*sec
;
3544 sec
= find_section (".dynamic");
3545 if (sec
== NULL
|| sec
->sh_size
== 0)
3547 error (_("no .dynamic section in the dynamic segment\n"));
3551 if (sec
->sh_type
== SHT_NOBITS
)
3557 dynamic_addr
= sec
->sh_offset
;
3558 dynamic_size
= sec
->sh_size
;
3560 if (dynamic_addr
< segment
->p_offset
3561 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3562 warn (_("the .dynamic section is not contained"
3563 " within the dynamic segment\n"));
3564 else if (dynamic_addr
> segment
->p_offset
)
3565 warn (_("the .dynamic section is not the first section"
3566 " in the dynamic segment.\n"));
3571 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3573 error (_("Unable to find program interpreter name\n"));
3577 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3579 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3580 error (_("Internal error: failed to create format string to display program interpreter\n"));
3582 program_interpreter
[0] = 0;
3583 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3584 error (_("Unable to read program interpreter name\n"));
3587 printf (_("\n [Requesting program interpreter: %s]"),
3588 program_interpreter
);
3594 putc ('\n', stdout
);
3597 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3599 printf (_("\n Section to Segment mapping:\n"));
3600 printf (_(" Segment Sections...\n"));
3602 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3605 Elf_Internal_Shdr
*section
;
3607 segment
= program_headers
+ i
;
3608 section
= section_headers
;
3610 printf (" %2.2d ", i
);
3612 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3614 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3615 printf ("%s ", SECTION_NAME (section
));
3626 /* Find the file offset corresponding to VMA by using the program headers. */
3629 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3631 Elf_Internal_Phdr
*seg
;
3633 if (! get_program_headers (file
))
3635 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3639 for (seg
= program_headers
;
3640 seg
< program_headers
+ elf_header
.e_phnum
;
3643 if (seg
->p_type
!= PT_LOAD
)
3646 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3647 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3648 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3651 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3658 get_32bit_section_headers (FILE *file
, unsigned int num
)
3660 Elf32_External_Shdr
*shdrs
;
3661 Elf_Internal_Shdr
*internal
;
3664 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3665 elf_header
.e_shentsize
, num
, _("section headers"));
3669 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3671 if (section_headers
== NULL
)
3673 error (_("Out of memory\n"));
3677 for (i
= 0, internal
= section_headers
;
3681 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3682 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3683 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3684 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3685 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3686 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3687 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3688 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3689 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3690 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3699 get_64bit_section_headers (FILE *file
, unsigned int num
)
3701 Elf64_External_Shdr
*shdrs
;
3702 Elf_Internal_Shdr
*internal
;
3705 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3706 elf_header
.e_shentsize
, num
, _("section headers"));
3710 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3712 if (section_headers
== NULL
)
3714 error (_("Out of memory\n"));
3718 for (i
= 0, internal
= section_headers
;
3722 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3723 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3724 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3725 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3726 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3727 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3728 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3729 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3730 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3731 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3739 static Elf_Internal_Sym
*
3740 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3742 unsigned long number
;
3743 Elf32_External_Sym
*esyms
;
3744 Elf_External_Sym_Shndx
*shndx
;
3745 Elf_Internal_Sym
*isyms
;
3746 Elf_Internal_Sym
*psym
;
3749 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3755 if (symtab_shndx_hdr
!= NULL
3756 && (symtab_shndx_hdr
->sh_link
3757 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3759 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3760 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3768 number
= section
->sh_size
/ section
->sh_entsize
;
3769 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3773 error (_("Out of memory\n"));
3780 for (j
= 0, psym
= isyms
;
3784 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3785 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3786 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3787 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3788 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3790 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3791 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3792 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3802 static Elf_Internal_Sym
*
3803 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3805 unsigned long number
;
3806 Elf64_External_Sym
*esyms
;
3807 Elf_External_Sym_Shndx
*shndx
;
3808 Elf_Internal_Sym
*isyms
;
3809 Elf_Internal_Sym
*psym
;
3812 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3818 if (symtab_shndx_hdr
!= NULL
3819 && (symtab_shndx_hdr
->sh_link
3820 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3822 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3823 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3831 number
= section
->sh_size
/ section
->sh_entsize
;
3832 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3836 error (_("Out of memory\n"));
3843 for (j
= 0, psym
= isyms
;
3847 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3848 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3849 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3850 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3851 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3853 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3854 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3855 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3866 get_elf_section_flags (bfd_vma sh_flags
)
3868 static char buff
[1024];
3870 int field_size
= is_32bit_elf
? 8 : 16;
3871 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3872 bfd_vma os_flags
= 0;
3873 bfd_vma proc_flags
= 0;
3874 bfd_vma unknown_flags
= 0;
3888 { "LINK ORDER", 10 },
3889 { "OS NONCONF", 10 },
3894 if (do_section_details
)
3896 sprintf (buff
, "[%*.*lx]: ",
3897 field_size
, field_size
, (unsigned long) sh_flags
);
3898 p
+= field_size
+ 4;
3905 flag
= sh_flags
& - sh_flags
;
3908 if (do_section_details
)
3912 case SHF_WRITE
: index
= 0; break;
3913 case SHF_ALLOC
: index
= 1; break;
3914 case SHF_EXECINSTR
: index
= 2; break;
3915 case SHF_MERGE
: index
= 3; break;
3916 case SHF_STRINGS
: index
= 4; break;
3917 case SHF_INFO_LINK
: index
= 5; break;
3918 case SHF_LINK_ORDER
: index
= 6; break;
3919 case SHF_OS_NONCONFORMING
: index
= 7; break;
3920 case SHF_GROUP
: index
= 8; break;
3921 case SHF_TLS
: index
= 9; break;
3930 if (p
!= buff
+ field_size
+ 4)
3932 if (size
< (10 + 2))
3939 size
-= flags
[index
].len
;
3940 p
= stpcpy (p
, flags
[index
].str
);
3942 else if (flag
& SHF_MASKOS
)
3944 else if (flag
& SHF_MASKPROC
)
3947 unknown_flags
|= flag
;
3953 case SHF_WRITE
: *p
= 'W'; break;
3954 case SHF_ALLOC
: *p
= 'A'; break;
3955 case SHF_EXECINSTR
: *p
= 'X'; break;
3956 case SHF_MERGE
: *p
= 'M'; break;
3957 case SHF_STRINGS
: *p
= 'S'; break;
3958 case SHF_INFO_LINK
: *p
= 'I'; break;
3959 case SHF_LINK_ORDER
: *p
= 'L'; break;
3960 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3961 case SHF_GROUP
: *p
= 'G'; break;
3962 case SHF_TLS
: *p
= 'T'; break;
3965 if (elf_header
.e_machine
== EM_X86_64
3966 && flag
== SHF_X86_64_LARGE
)
3968 else if (flag
& SHF_MASKOS
)
3971 sh_flags
&= ~ SHF_MASKOS
;
3973 else if (flag
& SHF_MASKPROC
)
3976 sh_flags
&= ~ SHF_MASKPROC
;
3986 if (do_section_details
)
3990 size
-= 5 + field_size
;
3991 if (p
!= buff
+ field_size
+ 4)
3999 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4000 (unsigned long) os_flags
);
4001 p
+= 5 + field_size
;
4005 size
-= 7 + field_size
;
4006 if (p
!= buff
+ field_size
+ 4)
4014 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4015 (unsigned long) proc_flags
);
4016 p
+= 7 + field_size
;
4020 size
-= 10 + field_size
;
4021 if (p
!= buff
+ field_size
+ 4)
4029 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4030 (unsigned long) unknown_flags
);
4031 p
+= 10 + field_size
;
4040 process_section_headers (FILE *file
)
4042 Elf_Internal_Shdr
*section
;
4045 section_headers
= NULL
;
4047 if (elf_header
.e_shnum
== 0)
4050 printf (_("\nThere are no sections in this file.\n"));
4055 if (do_sections
&& !do_header
)
4056 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4057 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4061 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4064 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4067 /* Read in the string table, so that we have names to display. */
4068 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4069 && SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
4071 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
4073 if (section
->sh_size
!= 0)
4075 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4076 1, section
->sh_size
, _("string table"));
4078 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4082 /* Scan the sections for the dynamic symbol table
4083 and dynamic string table and debug sections. */
4084 dynamic_symbols
= NULL
;
4085 dynamic_strings
= NULL
;
4086 dynamic_syminfo
= NULL
;
4087 symtab_shndx_hdr
= NULL
;
4089 eh_addr_size
= is_32bit_elf
? 4 : 8;
4090 switch (elf_header
.e_machine
)
4093 case EM_MIPS_RS3_LE
:
4094 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4095 FDE addresses. However, the ABI also has a semi-official ILP32
4096 variant for which the normal FDE address size rules apply.
4098 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4099 section, where XX is the size of longs in bits. Unfortunately,
4100 earlier compilers provided no way of distinguishing ILP32 objects
4101 from LP64 objects, so if there's any doubt, we should assume that
4102 the official LP64 form is being used. */
4103 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4104 && find_section (".gcc_compiled_long32") == NULL
)
4110 switch (elf_header
.e_flags
& EF_H8_MACH
)
4112 case E_H8_MACH_H8300
:
4113 case E_H8_MACH_H8300HN
:
4114 case E_H8_MACH_H8300SN
:
4115 case E_H8_MACH_H8300SXN
:
4118 case E_H8_MACH_H8300H
:
4119 case E_H8_MACH_H8300S
:
4120 case E_H8_MACH_H8300SX
:
4126 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4129 size_t expected_entsize \
4130 = is_32bit_elf ? size32 : size64; \
4131 if (section->sh_entsize != expected_entsize) \
4132 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4133 i, (unsigned long int) section->sh_entsize, \
4134 (unsigned long int) expected_entsize); \
4135 section->sh_entsize = expected_entsize; \
4138 #define CHECK_ENTSIZE(section, i, type) \
4139 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4140 sizeof (Elf64_External_##type))
4142 for (i
= 0, section
= section_headers
;
4143 i
< elf_header
.e_shnum
;
4146 char *name
= SECTION_NAME (section
);
4148 if (section
->sh_type
== SHT_DYNSYM
)
4150 if (dynamic_symbols
!= NULL
)
4152 error (_("File contains multiple dynamic symbol tables\n"));
4156 CHECK_ENTSIZE (section
, i
, Sym
);
4157 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4158 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4160 else if (section
->sh_type
== SHT_STRTAB
4161 && streq (name
, ".dynstr"))
4163 if (dynamic_strings
!= NULL
)
4165 error (_("File contains multiple dynamic string tables\n"));
4169 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4170 1, section
->sh_size
, _("dynamic strings"));
4171 dynamic_strings_length
= section
->sh_size
;
4173 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4175 if (symtab_shndx_hdr
!= NULL
)
4177 error (_("File contains multiple symtab shndx tables\n"));
4180 symtab_shndx_hdr
= section
;
4182 else if (section
->sh_type
== SHT_SYMTAB
)
4183 CHECK_ENTSIZE (section
, i
, Sym
);
4184 else if (section
->sh_type
== SHT_GROUP
)
4185 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4186 else if (section
->sh_type
== SHT_REL
)
4187 CHECK_ENTSIZE (section
, i
, Rel
);
4188 else if (section
->sh_type
== SHT_RELA
)
4189 CHECK_ENTSIZE (section
, i
, Rela
);
4190 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4191 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4192 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4193 || do_debug_loc
|| do_debug_ranges
)
4194 && const_strneq (name
, ".debug_"))
4199 || (do_debug_info
&& streq (name
, "info"))
4200 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4201 || (do_debug_lines
&& streq (name
, "line"))
4202 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4203 || (do_debug_aranges
&& streq (name
, "aranges"))
4204 || (do_debug_ranges
&& streq (name
, "ranges"))
4205 || (do_debug_frames
&& streq (name
, "frame"))
4206 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4207 || (do_debug_str
&& streq (name
, "str"))
4208 || (do_debug_loc
&& streq (name
, "loc"))
4210 request_dump_bynumber (i
, DEBUG_DUMP
);
4212 /* linkonce section to be combined with .debug_info at link time. */
4213 else if ((do_debugging
|| do_debug_info
)
4214 && const_strneq (name
, ".gnu.linkonce.wi."))
4215 request_dump_bynumber (i
, DEBUG_DUMP
);
4216 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4217 request_dump_bynumber (i
, DEBUG_DUMP
);
4223 if (elf_header
.e_shnum
> 1)
4224 printf (_("\nSection Headers:\n"));
4226 printf (_("\nSection Header:\n"));
4230 if (do_section_details
)
4232 printf (_(" [Nr] Name\n"));
4233 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4237 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4241 if (do_section_details
)
4243 printf (_(" [Nr] Name\n"));
4244 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4248 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4252 if (do_section_details
)
4254 printf (_(" [Nr] Name\n"));
4255 printf (_(" Type Address Offset Link\n"));
4256 printf (_(" Size EntSize Info Align\n"));
4260 printf (_(" [Nr] Name Type Address Offset\n"));
4261 printf (_(" Size EntSize Flags Link Info Align\n"));
4265 if (do_section_details
)
4266 printf (_(" Flags\n"));
4268 for (i
= 0, section
= section_headers
;
4269 i
< elf_header
.e_shnum
;
4272 if (do_section_details
)
4274 printf (" [%2u] %s\n",
4275 SECTION_HEADER_NUM (i
),
4276 SECTION_NAME (section
));
4277 if (is_32bit_elf
|| do_wide
)
4278 printf (" %-15.15s ",
4279 get_section_type_name (section
->sh_type
));
4282 printf (" [%2u] %-17.17s %-15.15s ",
4283 SECTION_HEADER_NUM (i
),
4284 SECTION_NAME (section
),
4285 get_section_type_name (section
->sh_type
));
4289 print_vma (section
->sh_addr
, LONG_HEX
);
4291 printf ( " %6.6lx %6.6lx %2.2lx",
4292 (unsigned long) section
->sh_offset
,
4293 (unsigned long) section
->sh_size
,
4294 (unsigned long) section
->sh_entsize
);
4296 if (do_section_details
)
4297 fputs (" ", stdout
);
4299 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4301 printf ("%2ld %3lu %2ld\n",
4302 (unsigned long) section
->sh_link
,
4303 (unsigned long) section
->sh_info
,
4304 (unsigned long) section
->sh_addralign
);
4308 print_vma (section
->sh_addr
, LONG_HEX
);
4310 if ((long) section
->sh_offset
== section
->sh_offset
)
4311 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4315 print_vma (section
->sh_offset
, LONG_HEX
);
4318 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4319 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4323 print_vma (section
->sh_size
, LONG_HEX
);
4326 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4327 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4331 print_vma (section
->sh_entsize
, LONG_HEX
);
4334 if (do_section_details
)
4335 fputs (" ", stdout
);
4337 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4339 printf ("%2ld %3lu ",
4340 (unsigned long) section
->sh_link
,
4341 (unsigned long) section
->sh_info
);
4343 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4344 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4347 print_vma (section
->sh_addralign
, DEC
);
4351 else if (do_section_details
)
4353 printf (" %-15.15s ",
4354 get_section_type_name (section
->sh_type
));
4355 print_vma (section
->sh_addr
, LONG_HEX
);
4356 if ((long) section
->sh_offset
== section
->sh_offset
)
4357 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4361 print_vma (section
->sh_offset
, LONG_HEX
);
4363 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4364 print_vma (section
->sh_size
, LONG_HEX
);
4366 print_vma (section
->sh_entsize
, LONG_HEX
);
4368 printf (" %-16lu %ld\n",
4369 (unsigned long) section
->sh_info
,
4370 (unsigned long) section
->sh_addralign
);
4375 print_vma (section
->sh_addr
, LONG_HEX
);
4376 if ((long) section
->sh_offset
== section
->sh_offset
)
4377 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4381 print_vma (section
->sh_offset
, LONG_HEX
);
4384 print_vma (section
->sh_size
, LONG_HEX
);
4386 print_vma (section
->sh_entsize
, LONG_HEX
);
4388 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4390 printf (" %2ld %3lu %ld\n",
4391 (unsigned long) section
->sh_link
,
4392 (unsigned long) section
->sh_info
,
4393 (unsigned long) section
->sh_addralign
);
4396 if (do_section_details
)
4397 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4400 if (!do_section_details
)
4401 printf (_("Key to Flags:\n\
4402 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4403 I (info), L (link order), G (group), x (unknown)\n\
4404 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4410 get_group_flags (unsigned int flags
)
4412 static char buff
[32];
4419 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4426 process_section_groups (FILE *file
)
4428 Elf_Internal_Shdr
*section
;
4430 struct group
*group
;
4431 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4432 Elf_Internal_Sym
*symtab
;
4436 /* Don't process section groups unless needed. */
4437 if (!do_unwind
&& !do_section_groups
)
4440 if (elf_header
.e_shnum
== 0)
4442 if (do_section_groups
)
4443 printf (_("\nThere are no sections in this file.\n"));
4448 if (section_headers
== NULL
)
4450 error (_("Section headers are not available!\n"));
4454 section_headers_groups
= calloc (elf_header
.e_shnum
,
4455 sizeof (struct group
*));
4457 if (section_headers_groups
== NULL
)
4459 error (_("Out of memory\n"));
4463 /* Scan the sections for the group section. */
4465 for (i
= 0, section
= section_headers
;
4466 i
< elf_header
.e_shnum
;
4468 if (section
->sh_type
== SHT_GROUP
)
4471 if (group_count
== 0)
4473 if (do_section_groups
)
4474 printf (_("\nThere are no section groups in this file.\n"));
4479 section_groups
= calloc (group_count
, sizeof (struct group
));
4481 if (section_groups
== NULL
)
4483 error (_("Out of memory\n"));
4492 for (i
= 0, section
= section_headers
, group
= section_groups
;
4493 i
< elf_header
.e_shnum
;
4496 if (section
->sh_type
== SHT_GROUP
)
4498 char *name
= SECTION_NAME (section
);
4500 unsigned char *start
, *indices
;
4501 unsigned int entry
, j
, size
;
4502 Elf_Internal_Shdr
*sec
;
4503 Elf_Internal_Sym
*sym
;
4505 /* Get the symbol table. */
4506 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4507 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4510 error (_("Bad sh_link in group section `%s'\n"), name
);
4514 if (symtab_sec
!= sec
)
4519 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4522 sym
= symtab
+ section
->sh_info
;
4524 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4526 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4529 error (_("Bad sh_info in group section `%s'\n"), name
);
4533 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4542 /* Get the string table. */
4543 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4544 >= elf_header
.e_shnum
)
4553 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4558 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4559 1, strtab_sec
->sh_size
,
4561 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4563 group_name
= sym
->st_name
< strtab_size
4564 ? strtab
+ sym
->st_name
: "<corrupt>";
4567 start
= get_data (NULL
, file
, section
->sh_offset
,
4568 1, section
->sh_size
, _("section data"));
4571 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4572 entry
= byte_get (indices
, 4);
4575 if (do_section_groups
)
4577 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4578 get_group_flags (entry
), i
, name
, group_name
, size
);
4580 printf (_(" [Index] Name\n"));
4583 group
->group_index
= i
;
4585 for (j
= 0; j
< size
; j
++)
4587 struct group_list
*g
;
4589 entry
= byte_get (indices
, 4);
4592 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4594 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4595 entry
, i
, elf_header
.e_shnum
- 1);
4598 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4600 error (_("invalid section [%5u] in group section [%5u]\n"),
4605 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4610 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4612 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4617 /* Intel C/C++ compiler may put section 0 in a
4618 section group. We just warn it the first time
4619 and ignore it afterwards. */
4620 static int warned
= 0;
4623 error (_("section 0 in group section [%5u]\n"),
4624 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4630 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4633 if (do_section_groups
)
4635 sec
= SECTION_HEADER (entry
);
4636 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4639 g
= xmalloc (sizeof (struct group_list
));
4640 g
->section_index
= entry
;
4641 g
->next
= group
->root
;
4665 } dynamic_relocations
[] =
4667 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4668 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4669 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4672 /* Process the reloc section. */
4675 process_relocs (FILE *file
)
4677 unsigned long rel_size
;
4678 unsigned long rel_offset
;
4684 if (do_using_dynamic
)
4688 int has_dynamic_reloc
;
4691 has_dynamic_reloc
= 0;
4693 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4695 is_rela
= dynamic_relocations
[i
].rela
;
4696 name
= dynamic_relocations
[i
].name
;
4697 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4698 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4700 has_dynamic_reloc
|= rel_size
;
4702 if (is_rela
== UNKNOWN
)
4704 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4705 switch (dynamic_info
[DT_PLTREL
])
4719 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4720 name
, rel_offset
, rel_size
);
4722 dump_relocations (file
,
4723 offset_from_vma (file
, rel_offset
, rel_size
),
4725 dynamic_symbols
, num_dynamic_syms
,
4726 dynamic_strings
, dynamic_strings_length
, is_rela
);
4730 if (! has_dynamic_reloc
)
4731 printf (_("\nThere are no dynamic relocations in this file.\n"));
4735 Elf_Internal_Shdr
*section
;
4739 for (i
= 0, section
= section_headers
;
4740 i
< elf_header
.e_shnum
;
4743 if ( section
->sh_type
!= SHT_RELA
4744 && section
->sh_type
!= SHT_REL
)
4747 rel_offset
= section
->sh_offset
;
4748 rel_size
= section
->sh_size
;
4752 Elf_Internal_Shdr
*strsec
;
4755 printf (_("\nRelocation section "));
4757 if (string_table
== NULL
)
4758 printf ("%d", section
->sh_name
);
4760 printf (_("'%s'"), SECTION_NAME (section
));
4762 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4763 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4765 is_rela
= section
->sh_type
== SHT_RELA
;
4767 if (section
->sh_link
4768 && SECTION_HEADER_INDEX (section
->sh_link
)
4769 < elf_header
.e_shnum
)
4771 Elf_Internal_Shdr
*symsec
;
4772 Elf_Internal_Sym
*symtab
;
4773 unsigned long nsyms
;
4774 unsigned long strtablen
= 0;
4775 char *strtab
= NULL
;
4777 symsec
= SECTION_HEADER (section
->sh_link
);
4778 if (symsec
->sh_type
!= SHT_SYMTAB
4779 && symsec
->sh_type
!= SHT_DYNSYM
)
4782 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4783 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4788 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4789 < elf_header
.e_shnum
)
4791 strsec
= SECTION_HEADER (symsec
->sh_link
);
4793 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4796 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4799 dump_relocations (file
, rel_offset
, rel_size
,
4800 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4806 dump_relocations (file
, rel_offset
, rel_size
,
4807 NULL
, 0, NULL
, 0, is_rela
);
4814 printf (_("\nThere are no relocations in this file.\n"));
4820 /* Process the unwind section. */
4822 #include "unwind-ia64.h"
4824 /* An absolute address consists of a section and an offset. If the
4825 section is NULL, the offset itself is the address, otherwise, the
4826 address equals to LOAD_ADDRESS(section) + offset. */
4830 unsigned short section
;
4834 #define ABSADDR(a) \
4836 ? section_headers [(a).section].sh_addr + (a).offset \
4839 struct ia64_unw_aux_info
4841 struct ia64_unw_table_entry
4843 struct absaddr start
;
4845 struct absaddr info
;
4847 *table
; /* Unwind table. */
4848 unsigned long table_len
; /* Length of unwind table. */
4849 unsigned char *info
; /* Unwind info. */
4850 unsigned long info_size
; /* Size of unwind info. */
4851 bfd_vma info_addr
; /* starting address of unwind info. */
4852 bfd_vma seg_base
; /* Starting address of segment. */
4853 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4854 unsigned long nsyms
; /* Number of symbols. */
4855 char *strtab
; /* The string table. */
4856 unsigned long strtab_size
; /* Size of string table. */
4860 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4861 unsigned long nsyms
,
4863 unsigned long strtab_size
,
4864 struct absaddr addr
,
4865 const char **symname
,
4868 bfd_vma dist
= 0x100000;
4869 Elf_Internal_Sym
*sym
, *best
= NULL
;
4872 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4874 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4875 && sym
->st_name
!= 0
4876 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4877 && addr
.offset
>= sym
->st_value
4878 && addr
.offset
- sym
->st_value
< dist
)
4881 dist
= addr
.offset
- sym
->st_value
;
4888 *symname
= (best
->st_name
>= strtab_size
4889 ? "<corrupt>" : strtab
+ best
->st_name
);
4894 *offset
= addr
.offset
;
4898 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4900 struct ia64_unw_table_entry
*tp
;
4903 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4907 const unsigned char *dp
;
4908 const unsigned char *head
;
4909 const char *procname
;
4911 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4912 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4914 fputs ("\n<", stdout
);
4918 fputs (procname
, stdout
);
4921 printf ("+%lx", (unsigned long) offset
);
4924 fputs (">: [", stdout
);
4925 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4926 fputc ('-', stdout
);
4927 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4928 printf ("], info at +0x%lx\n",
4929 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4931 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4932 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4934 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4935 (unsigned) UNW_VER (stamp
),
4936 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4937 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4938 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4939 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4941 if (UNW_VER (stamp
) != 1)
4943 printf ("\tUnknown version.\n");
4948 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4949 dp
= unw_decode (dp
, in_body
, & in_body
);
4954 slurp_ia64_unwind_table (FILE *file
,
4955 struct ia64_unw_aux_info
*aux
,
4956 Elf_Internal_Shdr
*sec
)
4958 unsigned long size
, nrelas
, i
;
4959 Elf_Internal_Phdr
*seg
;
4960 struct ia64_unw_table_entry
*tep
;
4961 Elf_Internal_Shdr
*relsec
;
4962 Elf_Internal_Rela
*rela
, *rp
;
4963 unsigned char *table
, *tp
;
4964 Elf_Internal_Sym
*sym
;
4965 const char *relname
;
4967 /* First, find the starting address of the segment that includes
4970 if (elf_header
.e_phnum
)
4972 if (! get_program_headers (file
))
4975 for (seg
= program_headers
;
4976 seg
< program_headers
+ elf_header
.e_phnum
;
4979 if (seg
->p_type
!= PT_LOAD
)
4982 if (sec
->sh_addr
>= seg
->p_vaddr
4983 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4985 aux
->seg_base
= seg
->p_vaddr
;
4991 /* Second, build the unwind table from the contents of the unwind section: */
4992 size
= sec
->sh_size
;
4993 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4997 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4999 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
5001 tep
->start
.section
= SHN_UNDEF
;
5002 tep
->end
.section
= SHN_UNDEF
;
5003 tep
->info
.section
= SHN_UNDEF
;
5006 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5007 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5008 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5012 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5013 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5014 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5016 tep
->start
.offset
+= aux
->seg_base
;
5017 tep
->end
.offset
+= aux
->seg_base
;
5018 tep
->info
.offset
+= aux
->seg_base
;
5022 /* Third, apply any relocations to the unwind table: */
5024 for (relsec
= section_headers
;
5025 relsec
< section_headers
+ elf_header
.e_shnum
;
5028 if (relsec
->sh_type
!= SHT_RELA
5029 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5030 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5033 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5037 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5041 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5042 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5046 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5047 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5050 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5052 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5056 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5058 switch (rp
->r_offset
/eh_addr_size
% 3)
5061 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5062 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5065 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5066 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5069 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5070 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5080 aux
->table_len
= size
/ (3 * eh_addr_size
);
5085 ia64_process_unwind (FILE *file
)
5087 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5088 unsigned long i
, unwcount
= 0, unwstart
= 0;
5089 struct ia64_unw_aux_info aux
;
5091 memset (& aux
, 0, sizeof (aux
));
5093 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5095 if (sec
->sh_type
== SHT_SYMTAB
5096 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5098 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5099 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5101 strsec
= SECTION_HEADER (sec
->sh_link
);
5102 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5103 1, strsec
->sh_size
, _("string table"));
5104 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5106 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5111 printf (_("\nThere are no unwind sections in this file.\n"));
5113 while (unwcount
-- > 0)
5118 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5119 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5120 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5127 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5129 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5131 /* We need to find which section group it is in. */
5132 struct group_list
*g
= section_headers_groups
[i
]->root
;
5134 for (; g
!= NULL
; g
= g
->next
)
5136 sec
= SECTION_HEADER (g
->section_index
);
5138 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5143 i
= elf_header
.e_shnum
;
5145 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5147 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5148 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5149 suffix
= SECTION_NAME (unwsec
) + len
;
5150 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5152 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5153 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5158 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5159 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5160 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5161 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5163 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5164 suffix
= SECTION_NAME (unwsec
) + len
;
5165 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5167 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5168 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5172 if (i
== elf_header
.e_shnum
)
5174 printf (_("\nCould not find unwind info section for "));
5176 if (string_table
== NULL
)
5177 printf ("%d", unwsec
->sh_name
);
5179 printf (_("'%s'"), SECTION_NAME (unwsec
));
5183 aux
.info_size
= sec
->sh_size
;
5184 aux
.info_addr
= sec
->sh_addr
;
5185 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5188 printf (_("\nUnwind section "));
5190 if (string_table
== NULL
)
5191 printf ("%d", unwsec
->sh_name
);
5193 printf (_("'%s'"), SECTION_NAME (unwsec
));
5195 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5196 (unsigned long) unwsec
->sh_offset
,
5197 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5199 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5201 if (aux
.table_len
> 0)
5202 dump_ia64_unwind (& aux
);
5205 free ((char *) aux
.table
);
5207 free ((char *) aux
.info
);
5216 free ((char *) aux
.strtab
);
5221 struct hppa_unw_aux_info
5223 struct hppa_unw_table_entry
5225 struct absaddr start
;
5227 unsigned int Cannot_unwind
:1; /* 0 */
5228 unsigned int Millicode
:1; /* 1 */
5229 unsigned int Millicode_save_sr0
:1; /* 2 */
5230 unsigned int Region_description
:2; /* 3..4 */
5231 unsigned int reserved1
:1; /* 5 */
5232 unsigned int Entry_SR
:1; /* 6 */
5233 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5234 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5235 unsigned int Args_stored
:1; /* 16 */
5236 unsigned int Variable_Frame
:1; /* 17 */
5237 unsigned int Separate_Package_Body
:1; /* 18 */
5238 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5239 unsigned int Stack_Overflow_Check
:1; /* 20 */
5240 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5241 unsigned int Ada_Region
:1; /* 22 */
5242 unsigned int cxx_info
:1; /* 23 */
5243 unsigned int cxx_try_catch
:1; /* 24 */
5244 unsigned int sched_entry_seq
:1; /* 25 */
5245 unsigned int reserved2
:1; /* 26 */
5246 unsigned int Save_SP
:1; /* 27 */
5247 unsigned int Save_RP
:1; /* 28 */
5248 unsigned int Save_MRP_in_frame
:1; /* 29 */
5249 unsigned int extn_ptr_defined
:1; /* 30 */
5250 unsigned int Cleanup_defined
:1; /* 31 */
5252 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5253 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5254 unsigned int Large_frame
:1; /* 2 */
5255 unsigned int Pseudo_SP_Set
:1; /* 3 */
5256 unsigned int reserved4
:1; /* 4 */
5257 unsigned int Total_frame_size
:27; /* 5..31 */
5259 *table
; /* Unwind table. */
5260 unsigned long table_len
; /* Length of unwind table. */
5261 bfd_vma seg_base
; /* Starting address of segment. */
5262 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5263 unsigned long nsyms
; /* Number of symbols. */
5264 char *strtab
; /* The string table. */
5265 unsigned long strtab_size
; /* Size of string table. */
5269 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5271 struct hppa_unw_table_entry
*tp
;
5273 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5276 const char *procname
;
5278 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5279 aux
->strtab_size
, tp
->start
, &procname
,
5282 fputs ("\n<", stdout
);
5286 fputs (procname
, stdout
);
5289 printf ("+%lx", (unsigned long) offset
);
5292 fputs (">: [", stdout
);
5293 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5294 fputc ('-', stdout
);
5295 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5298 #define PF(_m) if (tp->_m) printf (#_m " ");
5299 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5302 PF(Millicode_save_sr0
);
5303 /* PV(Region_description); */
5309 PF(Separate_Package_Body
);
5310 PF(Frame_Extension_Millicode
);
5311 PF(Stack_Overflow_Check
);
5312 PF(Two_Instruction_SP_Increment
);
5316 PF(sched_entry_seq
);
5319 PF(Save_MRP_in_frame
);
5320 PF(extn_ptr_defined
);
5321 PF(Cleanup_defined
);
5322 PF(MPE_XL_interrupt_marker
);
5323 PF(HP_UX_interrupt_marker
);
5326 PV(Total_frame_size
);
5335 slurp_hppa_unwind_table (FILE *file
,
5336 struct hppa_unw_aux_info
*aux
,
5337 Elf_Internal_Shdr
*sec
)
5339 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5340 Elf_Internal_Phdr
*seg
;
5341 struct hppa_unw_table_entry
*tep
;
5342 Elf_Internal_Shdr
*relsec
;
5343 Elf_Internal_Rela
*rela
, *rp
;
5344 unsigned char *table
, *tp
;
5345 Elf_Internal_Sym
*sym
;
5346 const char *relname
;
5348 /* First, find the starting address of the segment that includes
5351 if (elf_header
.e_phnum
)
5353 if (! get_program_headers (file
))
5356 for (seg
= program_headers
;
5357 seg
< program_headers
+ elf_header
.e_phnum
;
5360 if (seg
->p_type
!= PT_LOAD
)
5363 if (sec
->sh_addr
>= seg
->p_vaddr
5364 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5366 aux
->seg_base
= seg
->p_vaddr
;
5372 /* Second, build the unwind table from the contents of the unwind
5374 size
= sec
->sh_size
;
5375 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5380 nentries
= size
/ unw_ent_size
;
5381 size
= unw_ent_size
* nentries
;
5383 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5385 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5387 unsigned int tmp1
, tmp2
;
5389 tep
->start
.section
= SHN_UNDEF
;
5390 tep
->end
.section
= SHN_UNDEF
;
5392 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5393 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5394 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5395 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5397 tep
->start
.offset
+= aux
->seg_base
;
5398 tep
->end
.offset
+= aux
->seg_base
;
5400 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5401 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5402 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5403 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5404 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5405 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5406 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5407 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5408 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5409 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5410 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5411 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5412 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5413 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5414 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5415 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5416 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5417 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5418 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5419 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5420 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5421 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5422 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5423 tep
->Cleanup_defined
= tmp1
& 0x1;
5425 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5426 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5427 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5428 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5429 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5430 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5434 /* Third, apply any relocations to the unwind table. */
5436 for (relsec
= section_headers
;
5437 relsec
< section_headers
+ elf_header
.e_shnum
;
5440 if (relsec
->sh_type
!= SHT_RELA
5441 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5442 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5445 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5449 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5453 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5454 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5458 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5459 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5462 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5463 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5465 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5469 i
= rp
->r_offset
/ unw_ent_size
;
5471 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5474 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5475 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5478 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5479 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5489 aux
->table_len
= nentries
;
5495 hppa_process_unwind (FILE *file
)
5497 struct hppa_unw_aux_info aux
;
5498 Elf_Internal_Shdr
*unwsec
= NULL
;
5499 Elf_Internal_Shdr
*strsec
;
5500 Elf_Internal_Shdr
*sec
;
5503 memset (& aux
, 0, sizeof (aux
));
5505 if (string_table
== NULL
)
5508 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5510 if (sec
->sh_type
== SHT_SYMTAB
5511 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5513 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5514 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5516 strsec
= SECTION_HEADER (sec
->sh_link
);
5517 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5518 1, strsec
->sh_size
, _("string table"));
5519 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5521 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5526 printf (_("\nThere are no unwind sections in this file.\n"));
5528 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5530 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5532 printf (_("\nUnwind section "));
5533 printf (_("'%s'"), SECTION_NAME (sec
));
5535 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5536 (unsigned long) sec
->sh_offset
,
5537 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5539 slurp_hppa_unwind_table (file
, &aux
, sec
);
5540 if (aux
.table_len
> 0)
5541 dump_hppa_unwind (&aux
);
5544 free ((char *) aux
.table
);
5552 free ((char *) aux
.strtab
);
5558 process_unwind (FILE *file
)
5560 struct unwind_handler
{
5562 int (*handler
)(FILE *file
);
5564 { EM_IA_64
, ia64_process_unwind
},
5565 { EM_PARISC
, hppa_process_unwind
},
5573 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5574 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5575 return handlers
[i
].handler (file
);
5577 printf (_("\nThere are no unwind sections in this file.\n"));
5582 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5584 switch (entry
->d_tag
)
5587 if (entry
->d_un
.d_val
== 0)
5591 static const char * opts
[] =
5593 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5594 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5595 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5596 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5601 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5602 if (entry
->d_un
.d_val
& (1 << cnt
))
5604 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5611 case DT_MIPS_IVERSION
:
5612 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5613 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5615 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5618 case DT_MIPS_TIME_STAMP
:
5623 time_t time
= entry
->d_un
.d_val
;
5624 tmp
= gmtime (&time
);
5625 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5626 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5627 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5628 printf ("Time Stamp: %s\n", timebuf
);
5632 case DT_MIPS_RLD_VERSION
:
5633 case DT_MIPS_LOCAL_GOTNO
:
5634 case DT_MIPS_CONFLICTNO
:
5635 case DT_MIPS_LIBLISTNO
:
5636 case DT_MIPS_SYMTABNO
:
5637 case DT_MIPS_UNREFEXTNO
:
5638 case DT_MIPS_HIPAGENO
:
5639 case DT_MIPS_DELTA_CLASS_NO
:
5640 case DT_MIPS_DELTA_INSTANCE_NO
:
5641 case DT_MIPS_DELTA_RELOC_NO
:
5642 case DT_MIPS_DELTA_SYM_NO
:
5643 case DT_MIPS_DELTA_CLASSSYM_NO
:
5644 case DT_MIPS_COMPACT_SIZE
:
5645 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5649 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5655 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5657 switch (entry
->d_tag
)
5659 case DT_HP_DLD_FLAGS
:
5668 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5669 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5670 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5671 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5672 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5673 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5674 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5675 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5676 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5677 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5678 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5679 { DT_HP_GST
, "HP_GST" },
5680 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5681 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5682 { DT_HP_NODELETE
, "HP_NODELETE" },
5683 { DT_HP_GROUP
, "HP_GROUP" },
5684 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5688 bfd_vma val
= entry
->d_un
.d_val
;
5690 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5691 if (val
& flags
[cnt
].bit
)
5695 fputs (flags
[cnt
].str
, stdout
);
5697 val
^= flags
[cnt
].bit
;
5700 if (val
!= 0 || first
)
5704 print_vma (val
, HEX
);
5710 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5717 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5719 switch (entry
->d_tag
)
5721 case DT_IA_64_PLT_RESERVE
:
5722 /* First 3 slots reserved. */
5723 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5725 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5729 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5736 get_32bit_dynamic_section (FILE *file
)
5738 Elf32_External_Dyn
*edyn
, *ext
;
5739 Elf_Internal_Dyn
*entry
;
5741 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5742 _("dynamic section"));
5746 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5747 might not have the luxury of section headers. Look for the DT_NULL
5748 terminator to determine the number of entries. */
5749 for (ext
= edyn
, dynamic_nent
= 0;
5750 (char *) ext
< (char *) edyn
+ dynamic_size
;
5754 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5758 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5759 if (dynamic_section
== NULL
)
5761 error (_("Out of memory\n"));
5766 for (ext
= edyn
, entry
= dynamic_section
;
5767 entry
< dynamic_section
+ dynamic_nent
;
5770 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5771 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5780 get_64bit_dynamic_section (FILE *file
)
5782 Elf64_External_Dyn
*edyn
, *ext
;
5783 Elf_Internal_Dyn
*entry
;
5785 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5786 _("dynamic section"));
5790 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5791 might not have the luxury of section headers. Look for the DT_NULL
5792 terminator to determine the number of entries. */
5793 for (ext
= edyn
, dynamic_nent
= 0;
5794 (char *) ext
< (char *) edyn
+ dynamic_size
;
5798 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5802 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5803 if (dynamic_section
== NULL
)
5805 error (_("Out of memory\n"));
5810 for (ext
= edyn
, entry
= dynamic_section
;
5811 entry
< dynamic_section
+ dynamic_nent
;
5814 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5815 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5824 print_dynamic_flags (bfd_vma flags
)
5832 flag
= flags
& - flags
;
5842 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5843 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5844 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5845 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5846 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5847 default: fputs ("unknown", stdout
); break;
5853 /* Parse and display the contents of the dynamic section. */
5856 process_dynamic_section (FILE *file
)
5858 Elf_Internal_Dyn
*entry
;
5860 if (dynamic_size
== 0)
5863 printf (_("\nThere is no dynamic section in this file.\n"));
5870 if (! get_32bit_dynamic_section (file
))
5873 else if (! get_64bit_dynamic_section (file
))
5876 /* Find the appropriate symbol table. */
5877 if (dynamic_symbols
== NULL
)
5879 for (entry
= dynamic_section
;
5880 entry
< dynamic_section
+ dynamic_nent
;
5883 Elf_Internal_Shdr section
;
5885 if (entry
->d_tag
!= DT_SYMTAB
)
5888 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5890 /* Since we do not know how big the symbol table is,
5891 we default to reading in the entire file (!) and
5892 processing that. This is overkill, I know, but it
5894 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5896 if (archive_file_offset
!= 0)
5897 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5900 if (fseek (file
, 0, SEEK_END
))
5901 error (_("Unable to seek to end of file!\n"));
5903 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5907 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5909 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5911 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5912 if (num_dynamic_syms
< 1)
5914 error (_("Unable to determine the number of symbols to load\n"));
5918 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5922 /* Similarly find a string table. */
5923 if (dynamic_strings
== NULL
)
5925 for (entry
= dynamic_section
;
5926 entry
< dynamic_section
+ dynamic_nent
;
5929 unsigned long offset
;
5932 if (entry
->d_tag
!= DT_STRTAB
)
5935 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5937 /* Since we do not know how big the string table is,
5938 we default to reading in the entire file (!) and
5939 processing that. This is overkill, I know, but it
5942 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5944 if (archive_file_offset
!= 0)
5945 str_tab_len
= archive_file_size
- offset
;
5948 if (fseek (file
, 0, SEEK_END
))
5949 error (_("Unable to seek to end of file\n"));
5950 str_tab_len
= ftell (file
) - offset
;
5953 if (str_tab_len
< 1)
5956 (_("Unable to determine the length of the dynamic string table\n"));
5960 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5961 _("dynamic string table"));
5962 dynamic_strings_length
= str_tab_len
;
5967 /* And find the syminfo section if available. */
5968 if (dynamic_syminfo
== NULL
)
5970 unsigned long syminsz
= 0;
5972 for (entry
= dynamic_section
;
5973 entry
< dynamic_section
+ dynamic_nent
;
5976 if (entry
->d_tag
== DT_SYMINENT
)
5978 /* Note: these braces are necessary to avoid a syntax
5979 error from the SunOS4 C compiler. */
5980 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5982 else if (entry
->d_tag
== DT_SYMINSZ
)
5983 syminsz
= entry
->d_un
.d_val
;
5984 else if (entry
->d_tag
== DT_SYMINFO
)
5985 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5989 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5991 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5992 Elf_Internal_Syminfo
*syminfo
;
5994 /* There is a syminfo section. Read the data. */
5995 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5996 syminsz
, _("symbol information"));
6000 dynamic_syminfo
= malloc (syminsz
);
6001 if (dynamic_syminfo
== NULL
)
6003 error (_("Out of memory\n"));
6007 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6008 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6009 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6010 ++syminfo
, ++extsym
)
6012 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6013 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6020 if (do_dynamic
&& dynamic_addr
)
6021 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6022 dynamic_addr
, dynamic_nent
);
6024 printf (_(" Tag Type Name/Value\n"));
6026 for (entry
= dynamic_section
;
6027 entry
< dynamic_section
+ dynamic_nent
;
6035 print_vma (entry
->d_tag
, FULL_HEX
);
6036 dtype
= get_dynamic_type (entry
->d_tag
);
6037 printf (" (%s)%*s", dtype
,
6038 ((is_32bit_elf
? 27 : 19)
6039 - (int) strlen (dtype
)),
6043 switch (entry
->d_tag
)
6047 print_dynamic_flags (entry
->d_un
.d_val
);
6057 switch (entry
->d_tag
)
6060 printf (_("Auxiliary library"));
6064 printf (_("Filter library"));
6068 printf (_("Configuration file"));
6072 printf (_("Dependency audit library"));
6076 printf (_("Audit library"));
6080 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6081 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6085 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6094 printf (_("Flags:"));
6096 if (entry
->d_un
.d_val
== 0)
6097 printf (_(" None\n"));
6100 unsigned long int val
= entry
->d_un
.d_val
;
6102 if (val
& DTF_1_PARINIT
)
6104 printf (" PARINIT");
6105 val
^= DTF_1_PARINIT
;
6107 if (val
& DTF_1_CONFEXP
)
6109 printf (" CONFEXP");
6110 val
^= DTF_1_CONFEXP
;
6113 printf (" %lx", val
);
6122 printf (_("Flags:"));
6124 if (entry
->d_un
.d_val
== 0)
6125 printf (_(" None\n"));
6128 unsigned long int val
= entry
->d_un
.d_val
;
6130 if (val
& DF_P1_LAZYLOAD
)
6132 printf (" LAZYLOAD");
6133 val
^= DF_P1_LAZYLOAD
;
6135 if (val
& DF_P1_GROUPPERM
)
6137 printf (" GROUPPERM");
6138 val
^= DF_P1_GROUPPERM
;
6141 printf (" %lx", val
);
6150 printf (_("Flags:"));
6151 if (entry
->d_un
.d_val
== 0)
6152 printf (_(" None\n"));
6155 unsigned long int val
= entry
->d_un
.d_val
;
6162 if (val
& DF_1_GLOBAL
)
6167 if (val
& DF_1_GROUP
)
6172 if (val
& DF_1_NODELETE
)
6174 printf (" NODELETE");
6175 val
^= DF_1_NODELETE
;
6177 if (val
& DF_1_LOADFLTR
)
6179 printf (" LOADFLTR");
6180 val
^= DF_1_LOADFLTR
;
6182 if (val
& DF_1_INITFIRST
)
6184 printf (" INITFIRST");
6185 val
^= DF_1_INITFIRST
;
6187 if (val
& DF_1_NOOPEN
)
6192 if (val
& DF_1_ORIGIN
)
6197 if (val
& DF_1_DIRECT
)
6202 if (val
& DF_1_TRANS
)
6207 if (val
& DF_1_INTERPOSE
)
6209 printf (" INTERPOSE");
6210 val
^= DF_1_INTERPOSE
;
6212 if (val
& DF_1_NODEFLIB
)
6214 printf (" NODEFLIB");
6215 val
^= DF_1_NODEFLIB
;
6217 if (val
& DF_1_NODUMP
)
6222 if (val
& DF_1_CONLFAT
)
6224 printf (" CONLFAT");
6225 val
^= DF_1_CONLFAT
;
6228 printf (" %lx", val
);
6235 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6237 puts (get_dynamic_type (entry
->d_un
.d_val
));
6257 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6263 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6264 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6270 switch (entry
->d_tag
)
6273 printf (_("Shared library: [%s]"), name
);
6275 if (streq (name
, program_interpreter
))
6276 printf (_(" program interpreter"));
6280 printf (_("Library soname: [%s]"), name
);
6284 printf (_("Library rpath: [%s]"), name
);
6288 printf (_("Library runpath: [%s]"), name
);
6292 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6297 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6310 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6314 case DT_INIT_ARRAYSZ
:
6315 case DT_FINI_ARRAYSZ
:
6316 case DT_GNU_CONFLICTSZ
:
6317 case DT_GNU_LIBLISTSZ
:
6320 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6321 printf (" (bytes)\n");
6331 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6344 if (entry
->d_tag
== DT_USED
6345 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6347 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6351 printf (_("Not needed object: [%s]\n"), name
);
6356 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6362 /* The value of this entry is ignored. */
6367 case DT_GNU_PRELINKED
:
6371 time_t time
= entry
->d_un
.d_val
;
6373 tmp
= gmtime (&time
);
6374 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6375 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6376 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6382 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6385 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6391 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6392 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6397 switch (elf_header
.e_machine
)
6400 case EM_MIPS_RS3_LE
:
6401 dynamic_section_mips_val (entry
);
6404 dynamic_section_parisc_val (entry
);
6407 dynamic_section_ia64_val (entry
);
6410 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6422 get_ver_flags (unsigned int flags
)
6424 static char buff
[32];
6431 if (flags
& VER_FLG_BASE
)
6432 strcat (buff
, "BASE ");
6434 if (flags
& VER_FLG_WEAK
)
6436 if (flags
& VER_FLG_BASE
)
6437 strcat (buff
, "| ");
6439 strcat (buff
, "WEAK ");
6442 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6443 strcat (buff
, "| <unknown>");
6448 /* Display the contents of the version sections. */
6450 process_version_sections (FILE *file
)
6452 Elf_Internal_Shdr
*section
;
6459 for (i
= 0, section
= section_headers
;
6460 i
< elf_header
.e_shnum
;
6463 switch (section
->sh_type
)
6465 case SHT_GNU_verdef
:
6467 Elf_External_Verdef
*edefs
;
6475 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6476 SECTION_NAME (section
), section
->sh_info
);
6478 printf (_(" Addr: 0x"));
6479 printf_vma (section
->sh_addr
);
6480 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6481 (unsigned long) section
->sh_offset
, section
->sh_link
,
6482 SECTION_HEADER_INDEX (section
->sh_link
)
6483 < elf_header
.e_shnum
6484 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6487 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6489 _("version definition section"));
6490 endbuf
= (char *) edefs
+ section
->sh_size
;
6494 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6497 Elf_External_Verdef
*edef
;
6498 Elf_Internal_Verdef ent
;
6499 Elf_External_Verdaux
*eaux
;
6500 Elf_Internal_Verdaux aux
;
6504 vstart
= ((char *) edefs
) + idx
;
6505 if (vstart
+ sizeof (*edef
) > endbuf
)
6508 edef
= (Elf_External_Verdef
*) vstart
;
6510 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6511 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6512 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6513 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6514 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6515 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6516 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6518 printf (_(" %#06x: Rev: %d Flags: %s"),
6519 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6521 printf (_(" Index: %d Cnt: %d "),
6522 ent
.vd_ndx
, ent
.vd_cnt
);
6524 vstart
+= ent
.vd_aux
;
6526 eaux
= (Elf_External_Verdaux
*) vstart
;
6528 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6529 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6531 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6532 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6534 printf (_("Name index: %ld\n"), aux
.vda_name
);
6536 isum
= idx
+ ent
.vd_aux
;
6538 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6540 isum
+= aux
.vda_next
;
6541 vstart
+= aux
.vda_next
;
6543 eaux
= (Elf_External_Verdaux
*) vstart
;
6544 if (vstart
+ sizeof (*eaux
) > endbuf
)
6547 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6548 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6550 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6551 printf (_(" %#06x: Parent %d: %s\n"),
6552 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6554 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6555 isum
, j
, aux
.vda_name
);
6558 printf (_(" Version def aux past end of section\n"));
6562 if (cnt
< section
->sh_info
)
6563 printf (_(" Version definition past end of section\n"));
6569 case SHT_GNU_verneed
:
6571 Elf_External_Verneed
*eneed
;
6578 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6579 SECTION_NAME (section
), section
->sh_info
);
6581 printf (_(" Addr: 0x"));
6582 printf_vma (section
->sh_addr
);
6583 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6584 (unsigned long) section
->sh_offset
, section
->sh_link
,
6585 SECTION_HEADER_INDEX (section
->sh_link
)
6586 < elf_header
.e_shnum
6587 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6590 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6592 _("version need section"));
6593 endbuf
= (char *) eneed
+ section
->sh_size
;
6597 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6599 Elf_External_Verneed
*entry
;
6600 Elf_Internal_Verneed ent
;
6605 vstart
= ((char *) eneed
) + idx
;
6606 if (vstart
+ sizeof (*entry
) > endbuf
)
6609 entry
= (Elf_External_Verneed
*) vstart
;
6611 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6612 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6613 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6614 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6615 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6617 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6619 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6620 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6622 printf (_(" File: %lx"), ent
.vn_file
);
6624 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6626 vstart
+= ent
.vn_aux
;
6628 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6630 Elf_External_Vernaux
*eaux
;
6631 Elf_Internal_Vernaux aux
;
6633 if (vstart
+ sizeof (*eaux
) > endbuf
)
6635 eaux
= (Elf_External_Vernaux
*) vstart
;
6637 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6638 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6639 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6640 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6641 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6643 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6644 printf (_(" %#06x: Name: %s"),
6645 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6647 printf (_(" %#06x: Name index: %lx"),
6648 isum
, aux
.vna_name
);
6650 printf (_(" Flags: %s Version: %d\n"),
6651 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6653 isum
+= aux
.vna_next
;
6654 vstart
+= aux
.vna_next
;
6657 printf (_(" Version need aux past end of section\n"));
6661 if (cnt
< section
->sh_info
)
6662 printf (_(" Version need past end of section\n"));
6668 case SHT_GNU_versym
:
6670 Elf_Internal_Shdr
*link_section
;
6673 unsigned char *edata
;
6674 unsigned short *data
;
6676 Elf_Internal_Sym
*symbols
;
6677 Elf_Internal_Shdr
*string_sec
;
6680 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6683 link_section
= SECTION_HEADER (section
->sh_link
);
6684 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6686 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6687 >= elf_header
.e_shnum
)
6692 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6694 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6696 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6697 string_sec
->sh_size
, _("version string table"));
6701 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6702 SECTION_NAME (section
), total
);
6704 printf (_(" Addr: "));
6705 printf_vma (section
->sh_addr
);
6706 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6707 (unsigned long) section
->sh_offset
, section
->sh_link
,
6708 SECTION_NAME (link_section
));
6710 off
= offset_from_vma (file
,
6711 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6712 total
* sizeof (short));
6713 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6714 _("version symbol data"));
6721 data
= cmalloc (total
, sizeof (short));
6723 for (cnt
= total
; cnt
--;)
6724 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6729 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6732 int check_def
, check_need
;
6735 printf (" %03x:", cnt
);
6737 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6738 switch (data
[cnt
+ j
])
6741 fputs (_(" 0 (*local*) "), stdout
);
6745 fputs (_(" 1 (*global*) "), stdout
);
6749 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6750 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6754 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6755 >= elf_header
.e_shnum
6756 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6759 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6766 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6768 Elf_Internal_Verneed ivn
;
6769 unsigned long offset
;
6771 offset
= offset_from_vma
6772 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6773 sizeof (Elf_External_Verneed
));
6777 Elf_Internal_Vernaux ivna
;
6778 Elf_External_Verneed evn
;
6779 Elf_External_Vernaux evna
;
6780 unsigned long a_off
;
6782 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6785 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6786 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6788 a_off
= offset
+ ivn
.vn_aux
;
6792 get_data (&evna
, file
, a_off
, sizeof (evna
),
6793 1, _("version need aux (2)"));
6795 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6796 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6798 a_off
+= ivna
.vna_next
;
6800 while (ivna
.vna_other
!= data
[cnt
+ j
]
6801 && ivna
.vna_next
!= 0);
6803 if (ivna
.vna_other
== data
[cnt
+ j
])
6805 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6807 if (ivna
.vna_name
>= string_sec
->sh_size
)
6808 name
= _("*invalid*");
6810 name
= strtab
+ ivna
.vna_name
;
6811 nn
+= printf ("(%s%-*s",
6813 12 - (int) strlen (name
),
6819 offset
+= ivn
.vn_next
;
6821 while (ivn
.vn_next
);
6824 if (check_def
&& data
[cnt
+ j
] != 0x8001
6825 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6827 Elf_Internal_Verdef ivd
;
6828 Elf_External_Verdef evd
;
6829 unsigned long offset
;
6831 offset
= offset_from_vma
6832 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6837 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6840 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6841 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6843 offset
+= ivd
.vd_next
;
6845 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6846 && ivd
.vd_next
!= 0);
6848 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6850 Elf_External_Verdaux evda
;
6851 Elf_Internal_Verdaux ivda
;
6853 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6855 get_data (&evda
, file
,
6856 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6858 _("version def aux"));
6860 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6862 if (ivda
.vda_name
>= string_sec
->sh_size
)
6863 name
= _("*invalid*");
6865 name
= strtab
+ ivda
.vda_name
;
6866 nn
+= printf ("(%s%-*s",
6868 12 - (int) strlen (name
),
6874 printf ("%*c", 18 - nn
, ' ');
6892 printf (_("\nNo version information found in this file.\n"));
6898 get_symbol_binding (unsigned int binding
)
6900 static char buff
[32];
6904 case STB_LOCAL
: return "LOCAL";
6905 case STB_GLOBAL
: return "GLOBAL";
6906 case STB_WEAK
: return "WEAK";
6908 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6909 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6911 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6912 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6914 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6920 get_symbol_type (unsigned int type
)
6922 static char buff
[32];
6926 case STT_NOTYPE
: return "NOTYPE";
6927 case STT_OBJECT
: return "OBJECT";
6928 case STT_FUNC
: return "FUNC";
6929 case STT_SECTION
: return "SECTION";
6930 case STT_FILE
: return "FILE";
6931 case STT_COMMON
: return "COMMON";
6932 case STT_TLS
: return "TLS";
6933 case STT_RELC
: return "RELC";
6934 case STT_SRELC
: return "SRELC";
6936 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6938 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6939 return "THUMB_FUNC";
6941 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6944 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6945 return "PARISC_MILLI";
6947 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6949 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6951 if (elf_header
.e_machine
== EM_PARISC
)
6953 if (type
== STT_HP_OPAQUE
)
6955 if (type
== STT_HP_STUB
)
6959 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6962 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6968 get_symbol_visibility (unsigned int visibility
)
6972 case STV_DEFAULT
: return "DEFAULT";
6973 case STV_INTERNAL
: return "INTERNAL";
6974 case STV_HIDDEN
: return "HIDDEN";
6975 case STV_PROTECTED
: return "PROTECTED";
6981 get_mips_symbol_other (unsigned int other
)
6985 case STO_OPTIONAL
: return "OPTIONAL";
6986 case STO_MIPS16
: return "MIPS16";
6987 default: return NULL
;
6992 get_symbol_other (unsigned int other
)
6994 const char * result
= NULL
;
6995 static char buff
[32];
7000 switch (elf_header
.e_machine
)
7003 result
= get_mips_symbol_other (other
);
7011 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7016 get_symbol_index_type (unsigned int type
)
7018 static char buff
[32];
7022 case SHN_UNDEF
: return "UND";
7023 case SHN_ABS
: return "ABS";
7024 case SHN_COMMON
: return "COM";
7026 if (type
== SHN_IA_64_ANSI_COMMON
7027 && elf_header
.e_machine
== EM_IA_64
7028 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7030 else if (elf_header
.e_machine
== EM_X86_64
7031 && type
== SHN_X86_64_LCOMMON
)
7033 else if (type
== SHN_MIPS_SCOMMON
7034 && elf_header
.e_machine
== EM_MIPS
)
7036 else if (type
== SHN_MIPS_SUNDEFINED
7037 && elf_header
.e_machine
== EM_MIPS
)
7039 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7040 sprintf (buff
, "PRC[0x%04x]", type
);
7041 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7042 sprintf (buff
, "OS [0x%04x]", type
);
7043 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
7044 sprintf (buff
, "RSV[0x%04x]", type
);
7046 sprintf (buff
, "%3d", type
);
7054 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7056 unsigned char *e_data
;
7059 e_data
= cmalloc (number
, ent_size
);
7063 error (_("Out of memory\n"));
7067 if (fread (e_data
, ent_size
, number
, file
) != number
)
7069 error (_("Unable to read in dynamic data\n"));
7073 i_data
= cmalloc (number
, sizeof (*i_data
));
7077 error (_("Out of memory\n"));
7083 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7091 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7093 Elf_Internal_Sym
*psym
;
7096 psym
= dynamic_symbols
+ si
;
7098 n
= print_vma (si
, DEC_5
);
7100 fputs (" " + n
, stdout
);
7101 printf (" %3lu: ", hn
);
7102 print_vma (psym
->st_value
, LONG_HEX
);
7104 print_vma (psym
->st_size
, DEC_5
);
7106 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7107 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7108 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7109 /* Check to see if any other bits in the st_other field are set.
7110 Note - displaying this information disrupts the layout of the
7111 table being generated, but for the moment this case is very
7113 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7114 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7115 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7116 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7117 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7119 printf (" <corrupt: %14ld>", psym
->st_name
);
7123 /* Dump the symbol table. */
7125 process_symbol_table (FILE *file
)
7127 Elf_Internal_Shdr
*section
;
7128 bfd_vma nbuckets
= 0;
7129 bfd_vma nchains
= 0;
7130 bfd_vma
*buckets
= NULL
;
7131 bfd_vma
*chains
= NULL
;
7132 bfd_vma ngnubuckets
= 0;
7133 bfd_vma
*gnubuckets
= NULL
;
7134 bfd_vma
*gnuchains
= NULL
;
7135 bfd_vma gnusymidx
= 0;
7137 if (! do_syms
&& !do_histogram
)
7140 if (dynamic_info
[DT_HASH
]
7142 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7144 unsigned char nb
[8];
7145 unsigned char nc
[8];
7146 int hash_ent_size
= 4;
7148 if ((elf_header
.e_machine
== EM_ALPHA
7149 || elf_header
.e_machine
== EM_S390
7150 || elf_header
.e_machine
== EM_S390_OLD
)
7151 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7155 (archive_file_offset
7156 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7157 sizeof nb
+ sizeof nc
)),
7160 error (_("Unable to seek to start of dynamic information\n"));
7164 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7166 error (_("Failed to read in number of buckets\n"));
7170 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7172 error (_("Failed to read in number of chains\n"));
7176 nbuckets
= byte_get (nb
, hash_ent_size
);
7177 nchains
= byte_get (nc
, hash_ent_size
);
7179 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7180 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7182 if (buckets
== NULL
|| chains
== NULL
)
7186 if (dynamic_info_DT_GNU_HASH
7188 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7190 unsigned char nb
[16];
7191 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7192 bfd_vma buckets_vma
;
7195 (archive_file_offset
7196 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7200 error (_("Unable to seek to start of dynamic information\n"));
7204 if (fread (nb
, 16, 1, file
) != 1)
7206 error (_("Failed to read in number of buckets\n"));
7210 ngnubuckets
= byte_get (nb
, 4);
7211 gnusymidx
= byte_get (nb
+ 4, 4);
7212 bitmaskwords
= byte_get (nb
+ 8, 4);
7213 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7215 buckets_vma
+= bitmaskwords
* 4;
7217 buckets_vma
+= bitmaskwords
* 8;
7220 (archive_file_offset
7221 + offset_from_vma (file
, buckets_vma
, 4)),
7224 error (_("Unable to seek to start of dynamic information\n"));
7228 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7230 if (gnubuckets
== NULL
)
7233 for (i
= 0; i
< ngnubuckets
; i
++)
7234 if (gnubuckets
[i
] != 0)
7236 if (gnubuckets
[i
] < gnusymidx
)
7239 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7240 maxchain
= gnubuckets
[i
];
7243 if (maxchain
== 0xffffffff)
7246 maxchain
-= gnusymidx
;
7249 (archive_file_offset
7250 + offset_from_vma (file
, buckets_vma
7251 + 4 * (ngnubuckets
+ maxchain
), 4)),
7254 error (_("Unable to seek to start of dynamic information\n"));
7260 if (fread (nb
, 4, 1, file
) != 1)
7262 error (_("Failed to determine last chain length\n"));
7266 if (maxchain
+ 1 == 0)
7271 while ((byte_get (nb
, 4) & 1) == 0);
7274 (archive_file_offset
7275 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7278 error (_("Unable to seek to start of dynamic information\n"));
7282 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7284 if (gnuchains
== NULL
)
7288 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7291 && dynamic_strings
!= NULL
)
7295 if (dynamic_info
[DT_HASH
])
7299 printf (_("\nSymbol table for image:\n"));
7301 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7303 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7305 for (hn
= 0; hn
< nbuckets
; hn
++)
7310 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7311 print_dynamic_symbol (si
, hn
);
7315 if (dynamic_info_DT_GNU_HASH
)
7317 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7319 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7321 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7323 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7324 if (gnubuckets
[hn
] != 0)
7326 bfd_vma si
= gnubuckets
[hn
];
7327 bfd_vma off
= si
- gnusymidx
;
7331 print_dynamic_symbol (si
, hn
);
7334 while ((gnuchains
[off
++] & 1) == 0);
7338 else if (do_syms
&& !do_using_dynamic
)
7342 for (i
= 0, section
= section_headers
;
7343 i
< elf_header
.e_shnum
;
7347 char *strtab
= NULL
;
7348 unsigned long int strtab_size
= 0;
7349 Elf_Internal_Sym
*symtab
;
7350 Elf_Internal_Sym
*psym
;
7353 if ( section
->sh_type
!= SHT_SYMTAB
7354 && section
->sh_type
!= SHT_DYNSYM
)
7357 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7358 SECTION_NAME (section
),
7359 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7361 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7363 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7365 symtab
= GET_ELF_SYMBOLS (file
, section
);
7369 if (section
->sh_link
== elf_header
.e_shstrndx
)
7371 strtab
= string_table
;
7372 strtab_size
= string_table_length
;
7374 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7376 Elf_Internal_Shdr
*string_sec
;
7378 string_sec
= SECTION_HEADER (section
->sh_link
);
7380 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7381 1, string_sec
->sh_size
, _("string table"));
7382 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7385 for (si
= 0, psym
= symtab
;
7386 si
< section
->sh_size
/ section
->sh_entsize
;
7389 printf ("%6d: ", si
);
7390 print_vma (psym
->st_value
, LONG_HEX
);
7392 print_vma (psym
->st_size
, DEC_5
);
7393 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7394 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7395 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7396 /* Check to see if any other bits in the st_other field are set.
7397 Note - displaying this information disrupts the layout of the
7398 table being generated, but for the moment this case is very rare. */
7399 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7400 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7401 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7402 print_symbol (25, psym
->st_name
< strtab_size
7403 ? strtab
+ psym
->st_name
: "<corrupt>");
7405 if (section
->sh_type
== SHT_DYNSYM
&&
7406 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7408 unsigned char data
[2];
7409 unsigned short vers_data
;
7410 unsigned long offset
;
7414 offset
= offset_from_vma
7415 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7416 sizeof data
+ si
* sizeof (vers_data
));
7418 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7419 sizeof (data
), 1, _("version data"));
7421 vers_data
= byte_get (data
, 2);
7423 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7424 < elf_header
.e_shnum
7425 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7428 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7430 if ((vers_data
& 0x8000) || vers_data
> 1)
7432 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7433 && (is_nobits
|| ! check_def
))
7435 Elf_External_Verneed evn
;
7436 Elf_Internal_Verneed ivn
;
7437 Elf_Internal_Vernaux ivna
;
7439 /* We must test both. */
7440 offset
= offset_from_vma
7441 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7446 unsigned long vna_off
;
7448 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7451 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7452 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7454 vna_off
= offset
+ ivn
.vn_aux
;
7458 Elf_External_Vernaux evna
;
7460 get_data (&evna
, file
, vna_off
,
7462 _("version need aux (3)"));
7464 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7465 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7466 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7468 vna_off
+= ivna
.vna_next
;
7470 while (ivna
.vna_other
!= vers_data
7471 && ivna
.vna_next
!= 0);
7473 if (ivna
.vna_other
== vers_data
)
7476 offset
+= ivn
.vn_next
;
7478 while (ivn
.vn_next
!= 0);
7480 if (ivna
.vna_other
== vers_data
)
7483 ivna
.vna_name
< strtab_size
7484 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7488 else if (! is_nobits
)
7489 error (_("bad dynamic symbol\n"));
7496 if (vers_data
!= 0x8001
7497 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7499 Elf_Internal_Verdef ivd
;
7500 Elf_Internal_Verdaux ivda
;
7501 Elf_External_Verdaux evda
;
7502 unsigned long offset
;
7504 offset
= offset_from_vma
7506 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7507 sizeof (Elf_External_Verdef
));
7511 Elf_External_Verdef evd
;
7513 get_data (&evd
, file
, offset
, sizeof (evd
),
7514 1, _("version def"));
7516 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7517 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7518 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7520 offset
+= ivd
.vd_next
;
7522 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7523 && ivd
.vd_next
!= 0);
7525 offset
-= ivd
.vd_next
;
7526 offset
+= ivd
.vd_aux
;
7528 get_data (&evda
, file
, offset
, sizeof (evda
),
7529 1, _("version def aux"));
7531 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7533 if (psym
->st_name
!= ivda
.vda_name
)
7534 printf ((vers_data
& 0x8000)
7536 ivda
.vda_name
< strtab_size
7537 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7547 if (strtab
!= string_table
)
7553 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7555 if (do_histogram
&& buckets
!= NULL
)
7557 unsigned long *lengths
;
7558 unsigned long *counts
;
7561 unsigned long maxlength
= 0;
7562 unsigned long nzero_counts
= 0;
7563 unsigned long nsyms
= 0;
7565 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7566 (unsigned long) nbuckets
);
7567 printf (_(" Length Number %% of total Coverage\n"));
7569 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7570 if (lengths
== NULL
)
7572 error (_("Out of memory\n"));
7575 for (hn
= 0; hn
< nbuckets
; ++hn
)
7577 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7580 if (maxlength
< ++lengths
[hn
])
7585 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7588 error (_("Out of memory\n"));
7592 for (hn
= 0; hn
< nbuckets
; ++hn
)
7593 ++counts
[lengths
[hn
]];
7598 printf (" 0 %-10lu (%5.1f%%)\n",
7599 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7600 for (i
= 1; i
<= maxlength
; ++i
)
7602 nzero_counts
+= counts
[i
] * i
;
7603 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7604 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7605 (nzero_counts
* 100.0) / nsyms
);
7613 if (buckets
!= NULL
)
7619 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7621 unsigned long *lengths
;
7622 unsigned long *counts
;
7624 unsigned long maxlength
= 0;
7625 unsigned long nzero_counts
= 0;
7626 unsigned long nsyms
= 0;
7628 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7629 if (lengths
== NULL
)
7631 error (_("Out of memory\n"));
7635 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7636 (unsigned long) ngnubuckets
);
7637 printf (_(" Length Number %% of total Coverage\n"));
7639 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7640 if (gnubuckets
[hn
] != 0)
7642 bfd_vma off
, length
= 1;
7644 for (off
= gnubuckets
[hn
] - gnusymidx
;
7645 (gnuchains
[off
] & 1) == 0; ++off
)
7647 lengths
[hn
] = length
;
7648 if (length
> maxlength
)
7653 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7656 error (_("Out of memory\n"));
7660 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7661 ++counts
[lengths
[hn
]];
7663 if (ngnubuckets
> 0)
7666 printf (" 0 %-10lu (%5.1f%%)\n",
7667 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7668 for (j
= 1; j
<= maxlength
; ++j
)
7670 nzero_counts
+= counts
[j
] * j
;
7671 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7672 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7673 (nzero_counts
* 100.0) / nsyms
);
7687 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7691 if (dynamic_syminfo
== NULL
7693 /* No syminfo, this is ok. */
7696 /* There better should be a dynamic symbol section. */
7697 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7701 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7702 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7704 printf (_(" Num: Name BoundTo Flags\n"));
7705 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7707 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7709 printf ("%4d: ", i
);
7710 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7711 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7713 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7716 switch (dynamic_syminfo
[i
].si_boundto
)
7718 case SYMINFO_BT_SELF
:
7719 fputs ("SELF ", stdout
);
7721 case SYMINFO_BT_PARENT
:
7722 fputs ("PARENT ", stdout
);
7725 if (dynamic_syminfo
[i
].si_boundto
> 0
7726 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7727 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7729 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7733 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7737 if (flags
& SYMINFO_FLG_DIRECT
)
7739 if (flags
& SYMINFO_FLG_PASSTHRU
)
7740 printf (" PASSTHRU");
7741 if (flags
& SYMINFO_FLG_COPY
)
7743 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7744 printf (" LAZYLOAD");
7752 #ifdef SUPPORT_DISASSEMBLY
7754 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7756 printf (_("\nAssembly dump of section %s\n"),
7757 SECTION_NAME (section
));
7759 /* XXX -- to be done --- XXX */
7766 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7768 Elf_Internal_Shdr
*relsec
;
7769 bfd_size_type num_bytes
;
7774 char *name
= SECTION_NAME (section
);
7775 bfd_boolean some_strings_shown
;
7777 num_bytes
= section
->sh_size
;
7779 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7781 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7785 addr
= section
->sh_addr
;
7787 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7792 printf (_("\nString dump of section '%s':\n"), name
);
7794 /* If the section being dumped has relocations against it the user might
7795 be expecting these relocations to have been applied. Check for this
7796 case and issue a warning message in order to avoid confusion.
7797 FIXME: Maybe we ought to have an option that dumps a section with
7799 for (relsec
= section_headers
;
7800 relsec
< section_headers
+ elf_header
.e_shnum
;
7803 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7804 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7805 || SECTION_HEADER (relsec
->sh_info
) != section
7806 || relsec
->sh_size
== 0
7807 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7810 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7815 end
= start
+ num_bytes
;
7816 some_strings_shown
= FALSE
;
7820 while (!ISPRINT (* data
))
7826 printf (" [%6tx] %s\n", data
- start
, data
);
7827 data
+= strlen (data
);
7828 some_strings_shown
= TRUE
;
7832 if (! some_strings_shown
)
7833 printf (_(" No strings found in this section."));
7843 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
7845 Elf_Internal_Shdr
*relsec
;
7846 bfd_size_type bytes
;
7848 unsigned char *data
;
7849 unsigned char *start
;
7851 bytes
= section
->sh_size
;
7853 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7855 printf (_("\nSection '%s' has no data to dump.\n"),
7856 SECTION_NAME (section
));
7860 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7862 addr
= section
->sh_addr
;
7864 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7869 /* If the section being dumped has relocations against it the user might
7870 be expecting these relocations to have been applied. Check for this
7871 case and issue a warning message in order to avoid confusion.
7872 FIXME: Maybe we ought to have an option that dumps a section with
7874 for (relsec
= section_headers
;
7875 relsec
< section_headers
+ elf_header
.e_shnum
;
7878 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7879 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7880 || SECTION_HEADER (relsec
->sh_info
) != section
7881 || relsec
->sh_size
== 0
7882 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7885 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7897 lbytes
= (bytes
> 16 ? 16 : bytes
);
7899 printf (" 0x%8.8lx ", (unsigned long) addr
);
7901 for (j
= 0; j
< 16; j
++)
7904 printf ("%2.2x", data
[j
]);
7912 for (j
= 0; j
< lbytes
; j
++)
7915 if (k
>= ' ' && k
< 0x7f)
7934 /* Return the number of bytes affected by a given reloc.
7935 This information is architecture and reloc dependent.
7936 Returns 4 by default, although this is not always correct.
7937 It should return 0 if a decision cannot be made.
7938 FIXME: This is not the correct way to solve this problem.
7939 The proper way is to have target specific reloc sizing functions
7940 created by the reloc-macros.h header, in the same way that it
7941 already creates the reloc naming functions. */
7944 get_reloc_size (Elf_Internal_Rela
* reloc
)
7946 switch (elf_header
.e_machine
)
7952 switch (ELF32_R_TYPE (reloc
->r_info
))
7954 /* PR gas/3800 - without this information we do not correctly
7955 decode the debug information generated by the h8300 assembler. */
7962 /* FIXME: We need to extend this switch statement to cope with other
7963 architecture's relocs. (When those relocs are used against debug
7964 sections, and when their size is not 4). But see the multiple
7965 inclusions of <elf/h8.h> for an example of the hoops that we need
7966 to jump through in order to obtain the reloc numbers. */
7971 /* Apply addends of RELA relocations. */
7974 debug_apply_rela_addends (void *file
,
7975 Elf_Internal_Shdr
*section
,
7976 unsigned char *start
)
7978 Elf_Internal_Shdr
*relsec
;
7979 unsigned char *end
= start
+ section
->sh_size
;
7981 if (!is_relocatable
)
7984 /* SH uses RELA but uses in place value instead of the addend field. */
7985 if (elf_header
.e_machine
== EM_SH
)
7988 for (relsec
= section_headers
;
7989 relsec
< section_headers
+ elf_header
.e_shnum
;
7992 unsigned long nrelas
;
7993 Elf_Internal_Rela
*rela
, *rp
;
7994 Elf_Internal_Shdr
*symsec
;
7995 Elf_Internal_Sym
*symtab
;
7996 Elf_Internal_Sym
*sym
;
7998 if (relsec
->sh_type
!= SHT_RELA
7999 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
8000 || SECTION_HEADER (relsec
->sh_info
) != section
8001 || relsec
->sh_size
== 0
8002 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
8005 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8009 symsec
= SECTION_HEADER (relsec
->sh_link
);
8010 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8012 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8015 unsigned int reloc_size
;
8017 reloc_size
= get_reloc_size (rp
);
8018 if (reloc_size
== 0)
8020 warn (_("skipping relocation of unknown size against offset 0x%lx in section %s\n"),
8021 (unsigned long) rp
->r_offset
,
8022 SECTION_NAME (section
));
8026 loc
= start
+ rp
->r_offset
;
8027 if ((loc
+ reloc_size
) > end
)
8029 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8030 (unsigned long) rp
->r_offset
,
8031 SECTION_NAME (section
));
8037 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8039 if (ELF32_R_SYM (rp
->r_info
) != 0
8040 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
8041 /* Relocations against symbols without type can happen.
8042 Gcc -feliminate-dwarf2-dups may generate symbols
8043 without type for debug info. */
8044 && ELF32_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8045 /* Relocations against object symbols can happen,
8046 eg when referencing a global array. For an
8047 example of this see the _clz.o binary in libgcc.a. */
8048 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8050 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
8051 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
8052 SECTION_NAME (section
));
8058 /* In MIPS little-endian objects, r_info isn't really a
8059 64-bit little-endian value: it has a 32-bit little-endian
8060 symbol index followed by four individual byte fields.
8061 Reorder INFO accordingly. */
8062 if (elf_header
.e_machine
== EM_MIPS
8063 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
8064 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
8065 | ((rp
->r_info
>> 56) & 0xff)
8066 | ((rp
->r_info
>> 40) & 0xff00)
8067 | ((rp
->r_info
>> 24) & 0xff0000)
8068 | ((rp
->r_info
>> 8) & 0xff000000));
8070 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8072 if (ELF64_R_SYM (rp
->r_info
) != 0
8073 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
8074 && ELF64_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8075 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8077 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
8078 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
8079 SECTION_NAME (section
));
8084 byte_put (loc
, rp
->r_addend
, reloc_size
);
8095 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8097 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8098 Elf_Internal_Shdr
*sec
;
8101 /* If it is already loaded, do nothing. */
8102 if (section
->start
!= NULL
)
8105 /* Locate the debug section. */
8106 sec
= find_section (section
->name
);
8110 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8111 section
->address
= sec
->sh_addr
;
8112 section
->size
= sec
->sh_size
;
8113 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8116 if (debug_displays
[debug
].relocate
)
8117 debug_apply_rela_addends (file
, sec
, section
->start
);
8119 return section
->start
!= NULL
;
8123 free_debug_section (enum dwarf_section_display_enum debug
)
8125 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8127 if (section
->start
== NULL
)
8130 free ((char *) section
->start
);
8131 section
->start
= NULL
;
8132 section
->address
= 0;
8137 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8139 char *name
= SECTION_NAME (section
);
8140 bfd_size_type length
;
8142 enum dwarf_section_display_enum i
;
8144 length
= section
->sh_size
;
8147 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8151 if (const_strneq (name
, ".gnu.linkonce.wi."))
8152 name
= ".debug_info";
8154 /* See if we know how to display the contents of this section. */
8155 for (i
= 0; i
< max
; i
++)
8156 if (streq (debug_displays
[i
].section
.name
, name
))
8158 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8160 if (load_debug_section (i
, file
))
8162 result
&= debug_displays
[i
].display (sec
, file
);
8164 if (i
!= info
&& i
!= abbrev
)
8165 free_debug_section (i
);
8173 printf (_("Unrecognized debug section: %s\n"), name
);
8180 /* Set DUMP_SECTS for all sections where dumps were requested
8181 based on section name. */
8184 initialise_dumps_byname (void)
8186 struct dump_list_entry
*cur
;
8188 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8193 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8194 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8196 request_dump_bynumber (i
, cur
->type
);
8201 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8207 process_section_contents (FILE *file
)
8209 Elf_Internal_Shdr
*section
;
8215 initialise_dumps_byname ();
8217 for (i
= 0, section
= section_headers
;
8218 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8221 #ifdef SUPPORT_DISASSEMBLY
8222 if (dump_sects
[i
] & DISASS_DUMP
)
8223 disassemble_section (section
, file
);
8225 if (dump_sects
[i
] & HEX_DUMP
)
8226 dump_section_as_bytes (section
, file
);
8228 if (dump_sects
[i
] & DEBUG_DUMP
)
8229 display_debug_section (section
, file
);
8231 if (dump_sects
[i
] & STRING_DUMP
)
8232 dump_section_as_strings (section
, file
);
8235 /* Check to see if the user requested a
8236 dump of a section that does not exist. */
8237 while (i
++ < num_dump_sects
)
8239 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8243 process_mips_fpe_exception (int mask
)
8248 if (mask
& OEX_FPU_INEX
)
8249 fputs ("INEX", stdout
), first
= 0;
8250 if (mask
& OEX_FPU_UFLO
)
8251 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8252 if (mask
& OEX_FPU_OFLO
)
8253 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8254 if (mask
& OEX_FPU_DIV0
)
8255 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8256 if (mask
& OEX_FPU_INVAL
)
8257 printf ("%sINVAL", first
? "" : "|");
8260 fputs ("0", stdout
);
8263 /* ARM EABI attributes section. */
8268 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8271 } arm_attr_public_tag
;
8273 static const char *arm_attr_tag_CPU_arch
[] =
8274 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8276 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8277 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8278 {"No", "Thumb-1", "Thumb-2"};
8279 /* FIXME: VFPv3 encoding was extrapolated! */
8280 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8281 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8282 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8283 static const char *arm_attr_tag_ABI_PCS_config
[] =
8284 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8285 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8286 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8287 {"V6", "SB", "TLS", "Unused"};
8288 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8289 {"Absolute", "PC-relative", "SB-relative", "None"};
8290 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8291 {"Absolute", "PC-relative", "None"};
8292 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8293 {"None", "direct", "GOT-indirect"};
8294 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8295 {"None", "??? 1", "2", "??? 3", "4"};
8296 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8297 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8298 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8299 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8300 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8301 {"Unused", "Finite", "RTABI", "IEEE 754"};
8302 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8303 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8304 {"No", "Yes, except leaf SP", "Yes"};
8305 static const char *arm_attr_tag_ABI_enum_size
[] =
8306 {"Unused", "small", "int", "forced to int"};
8307 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8308 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8309 static const char *arm_attr_tag_ABI_VFP_args
[] =
8310 {"AAPCS", "VFP registers", "custom"};
8311 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8312 {"AAPCS", "WMMX registers", "custom"};
8313 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8314 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8315 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8316 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8317 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8318 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8320 #define LOOKUP(id, name) \
8321 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8322 static arm_attr_public_tag arm_attr_public_tags
[] =
8324 {4, "CPU_raw_name", 1, NULL
},
8325 {5, "CPU_name", 1, NULL
},
8326 LOOKUP(6, CPU_arch
),
8327 {7, "CPU_arch_profile", 0, NULL
},
8328 LOOKUP(8, ARM_ISA_use
),
8329 LOOKUP(9, THUMB_ISA_use
),
8330 LOOKUP(10, VFP_arch
),
8331 LOOKUP(11, WMMX_arch
),
8332 LOOKUP(12, NEON_arch
),
8333 LOOKUP(13, ABI_PCS_config
),
8334 LOOKUP(14, ABI_PCS_R9_use
),
8335 LOOKUP(15, ABI_PCS_RW_data
),
8336 LOOKUP(16, ABI_PCS_RO_DATA
),
8337 LOOKUP(17, ABI_PCS_GOT_use
),
8338 LOOKUP(18, ABI_PCS_wchar_t
),
8339 LOOKUP(19, ABI_FP_rounding
),
8340 LOOKUP(20, ABI_FP_denormal
),
8341 LOOKUP(21, ABI_FP_exceptions
),
8342 LOOKUP(22, ABI_FP_user_exceptions
),
8343 LOOKUP(23, ABI_FP_number_model
),
8344 LOOKUP(24, ABI_align8_needed
),
8345 LOOKUP(25, ABI_align8_preserved
),
8346 LOOKUP(26, ABI_enum_size
),
8347 LOOKUP(27, ABI_HardFP_use
),
8348 LOOKUP(28, ABI_VFP_args
),
8349 LOOKUP(29, ABI_WMMX_args
),
8350 LOOKUP(30, ABI_optimization_goals
),
8351 LOOKUP(31, ABI_FP_optimization_goals
),
8352 {32, "compatibility", 0, NULL
}
8356 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8359 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8373 val
|= ((unsigned int)c
& 0x7f) << shift
;
8382 static unsigned char *
8383 display_arm_attribute (unsigned char *p
)
8388 arm_attr_public_tag
*attr
;
8392 tag
= read_uleb128 (p
, &len
);
8395 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8397 if (arm_attr_public_tags
[i
].tag
== tag
)
8399 attr
= &arm_attr_public_tags
[i
];
8406 printf (" Tag_%s: ", attr
->name
);
8412 case 7: /* Tag_CPU_arch_profile. */
8413 val
= read_uleb128 (p
, &len
);
8417 case 0: printf ("None\n"); break;
8418 case 'A': printf ("Application\n"); break;
8419 case 'R': printf ("Realtime\n"); break;
8420 case 'M': printf ("Microcontroller\n"); break;
8421 default: printf ("??? (%d)\n", val
); break;
8425 case 32: /* Tag_compatibility. */
8426 val
= read_uleb128 (p
, &len
);
8428 printf ("flag = %d, vendor = %s\n", val
, p
);
8429 p
+= strlen((char *)p
) + 1;
8443 assert (attr
->type
& 0x80);
8444 val
= read_uleb128 (p
, &len
);
8446 type
= attr
->type
& 0x7f;
8448 printf ("??? (%d)\n", val
);
8450 printf ("%s\n", attr
->table
[val
]);
8457 type
= 1; /* String. */
8459 type
= 2; /* uleb128. */
8460 printf (" Tag_unknown_%d: ", tag
);
8465 printf ("\"%s\"\n", p
);
8466 p
+= strlen((char *)p
) + 1;
8470 val
= read_uleb128 (p
, &len
);
8472 printf ("%d (0x%x)\n", val
, val
);
8478 static unsigned char *
8479 display_gnu_attribute (unsigned char * p
,
8480 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8487 tag
= read_uleb128 (p
, &len
);
8490 /* Tag_compatibility is the only generic GNU attribute defined at
8494 val
= read_uleb128 (p
, &len
);
8496 printf ("flag = %d, vendor = %s\n", val
, p
);
8497 p
+= strlen ((char *) p
) + 1;
8501 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8502 return display_proc_gnu_attribute (p
, tag
);
8505 type
= 1; /* String. */
8507 type
= 2; /* uleb128. */
8508 printf (" Tag_unknown_%d: ", tag
);
8512 printf ("\"%s\"\n", p
);
8513 p
+= strlen ((char *) p
) + 1;
8517 val
= read_uleb128 (p
, &len
);
8519 printf ("%d (0x%x)\n", val
, val
);
8525 static unsigned char *
8526 display_power_gnu_attribute (unsigned char *p
, int tag
)
8532 if (tag
== Tag_GNU_Power_ABI_FP
)
8534 val
= read_uleb128 (p
, &len
);
8536 printf (" Tag_GNU_Power_ABI_FP: ");
8541 printf ("Hard or soft float\n");
8544 printf ("Hard float\n");
8547 printf ("Soft float\n");
8550 printf ("??? (%d)\n", val
);
8556 if (tag
== Tag_GNU_Power_ABI_Vector
)
8558 val
= read_uleb128 (p
, &len
);
8560 printf (" Tag_GNU_Power_ABI_Vector: ");
8567 printf ("Generic\n");
8570 printf ("AltiVec\n");
8576 printf ("??? (%d)\n", val
);
8583 type
= 1; /* String. */
8585 type
= 2; /* uleb128. */
8586 printf (" Tag_unknown_%d: ", tag
);
8590 printf ("\"%s\"\n", p
);
8591 p
+= strlen ((char *) p
) + 1;
8595 val
= read_uleb128 (p
, &len
);
8597 printf ("%d (0x%x)\n", val
, val
);
8603 static unsigned char *
8604 display_mips_gnu_attribute (unsigned char *p
, int tag
)
8610 if (tag
== Tag_GNU_MIPS_ABI_FP
)
8612 val
= read_uleb128 (p
, &len
);
8614 printf (" Tag_GNU_MIPS_ABI_FP: ");
8619 printf ("Hard or soft float\n");
8622 printf ("Hard float (-mdouble-float)\n");
8625 printf ("Hard float (-msingle-float)\n");
8628 printf ("Soft float\n");
8631 printf ("??? (%d)\n", val
);
8638 type
= 1; /* String. */
8640 type
= 2; /* uleb128. */
8641 printf (" Tag_unknown_%d: ", tag
);
8645 printf ("\"%s\"\n", p
);
8646 p
+= strlen ((char *) p
) + 1;
8650 val
= read_uleb128 (p
, &len
);
8652 printf ("%d (0x%x)\n", val
, val
);
8659 process_attributes (FILE * file
,
8660 const char * public_name
,
8661 unsigned int proc_type
,
8662 unsigned char * (* display_pub_attribute
) (unsigned char *),
8663 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8665 Elf_Internal_Shdr
*sect
;
8666 unsigned char *contents
;
8669 bfd_vma section_len
;
8673 /* Find the section header so that we get the size. */
8674 for (i
= 0, sect
= section_headers
;
8675 i
< elf_header
.e_shnum
;
8678 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
8681 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
8683 if (contents
== NULL
)
8689 len
= sect
->sh_size
- 1;
8695 bfd_boolean public_section
;
8696 bfd_boolean gnu_section
;
8698 section_len
= byte_get (p
, 4);
8701 if (section_len
> len
)
8703 printf (_("ERROR: Bad section length (%d > %d)\n"),
8704 (int) section_len
, (int) len
);
8709 printf ("Attribute Section: %s\n", p
);
8711 if (public_name
&& streq ((char *) p
, public_name
))
8712 public_section
= TRUE
;
8714 public_section
= FALSE
;
8716 if (streq ((char *) p
, "gnu"))
8719 gnu_section
= FALSE
;
8721 namelen
= strlen ((char *) p
) + 1;
8723 section_len
-= namelen
+ 4;
8725 while (section_len
> 0)
8731 size
= byte_get (p
, 4);
8732 if (size
> section_len
)
8734 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8735 (int) size
, (int) section_len
);
8739 section_len
-= size
;
8746 printf ("File Attributes\n");
8749 printf ("Section Attributes:");
8752 printf ("Symbol Attributes:");
8758 val
= read_uleb128 (p
, &i
);
8762 printf (" %d", val
);
8767 printf ("Unknown tag: %d\n", tag
);
8768 public_section
= FALSE
;
8775 p
= display_pub_attribute (p
);
8777 else if (gnu_section
)
8780 p
= display_gnu_attribute (p
,
8781 display_proc_gnu_attribute
);
8785 /* ??? Do something sensible, like dump hex. */
8786 printf (" Unknown section contexts\n");
8793 printf (_("Unknown format '%c'\n"), *p
);
8801 process_arm_specific (FILE *file
)
8803 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
8804 display_arm_attribute
, NULL
);
8808 process_power_specific (FILE *file
)
8810 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
8811 display_power_gnu_attribute
);
8815 process_mips_specific (FILE *file
)
8817 Elf_Internal_Dyn
*entry
;
8818 size_t liblist_offset
= 0;
8819 size_t liblistno
= 0;
8820 size_t conflictsno
= 0;
8821 size_t options_offset
= 0;
8822 size_t conflicts_offset
= 0;
8824 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
8825 display_mips_gnu_attribute
);
8827 /* We have a lot of special sections. Thanks SGI! */
8828 if (dynamic_section
== NULL
)
8829 /* No information available. */
8832 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
8833 switch (entry
->d_tag
)
8835 case DT_MIPS_LIBLIST
:
8837 = offset_from_vma (file
, entry
->d_un
.d_val
,
8838 liblistno
* sizeof (Elf32_External_Lib
));
8840 case DT_MIPS_LIBLISTNO
:
8841 liblistno
= entry
->d_un
.d_val
;
8843 case DT_MIPS_OPTIONS
:
8844 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8846 case DT_MIPS_CONFLICT
:
8848 = offset_from_vma (file
, entry
->d_un
.d_val
,
8849 conflictsno
* sizeof (Elf32_External_Conflict
));
8851 case DT_MIPS_CONFLICTNO
:
8852 conflictsno
= entry
->d_un
.d_val
;
8858 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8860 Elf32_External_Lib
*elib
;
8863 elib
= get_data (NULL
, file
, liblist_offset
,
8864 liblistno
, sizeof (Elf32_External_Lib
),
8868 printf ("\nSection '.liblist' contains %lu entries:\n",
8869 (unsigned long) liblistno
);
8870 fputs (" Library Time Stamp Checksum Version Flags\n",
8873 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8880 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8881 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8882 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8883 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8884 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8886 tmp
= gmtime (&time
);
8887 snprintf (timebuf
, sizeof (timebuf
),
8888 "%04u-%02u-%02uT%02u:%02u:%02u",
8889 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8890 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8892 printf ("%3lu: ", (unsigned long) cnt
);
8893 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
8894 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
8896 printf ("<corrupt: %9ld>", liblist
.l_name
);
8897 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8900 if (liblist
.l_flags
== 0)
8911 { " EXACT_MATCH", LL_EXACT_MATCH
},
8912 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8913 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8914 { " EXPORTS", LL_EXPORTS
},
8915 { " DELAY_LOAD", LL_DELAY_LOAD
},
8916 { " DELTA", LL_DELTA
}
8918 int flags
= liblist
.l_flags
;
8921 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
8922 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8924 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8925 flags
^= l_flags_vals
[fcnt
].bit
;
8928 printf (" %#x", (unsigned int) flags
);
8938 if (options_offset
!= 0)
8940 Elf_External_Options
*eopt
;
8941 Elf_Internal_Shdr
*sect
= section_headers
;
8942 Elf_Internal_Options
*iopt
;
8943 Elf_Internal_Options
*option
;
8947 /* Find the section header so that we get the size. */
8948 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8951 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8955 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8958 error (_("Out of memory\n"));
8965 while (offset
< sect
->sh_size
)
8967 Elf_External_Options
*eoption
;
8969 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8971 option
->kind
= BYTE_GET (eoption
->kind
);
8972 option
->size
= BYTE_GET (eoption
->size
);
8973 option
->section
= BYTE_GET (eoption
->section
);
8974 option
->info
= BYTE_GET (eoption
->info
);
8976 offset
+= option
->size
;
8982 printf (_("\nSection '%s' contains %d entries:\n"),
8983 SECTION_NAME (sect
), cnt
);
8991 switch (option
->kind
)
8994 /* This shouldn't happen. */
8995 printf (" NULL %d %lx", option
->section
, option
->info
);
8998 printf (" REGINFO ");
8999 if (elf_header
.e_machine
== EM_MIPS
)
9002 Elf32_External_RegInfo
*ereg
;
9003 Elf32_RegInfo reginfo
;
9005 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9006 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9007 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9008 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9009 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9010 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9011 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9013 printf ("GPR %08lx GP 0x%lx\n",
9015 (unsigned long) reginfo
.ri_gp_value
);
9016 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9017 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9018 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9023 Elf64_External_RegInfo
*ereg
;
9024 Elf64_Internal_RegInfo reginfo
;
9026 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9027 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9028 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9029 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9030 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9031 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9032 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9034 printf ("GPR %08lx GP 0x",
9035 reginfo
.ri_gprmask
);
9036 printf_vma (reginfo
.ri_gp_value
);
9039 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9040 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9041 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9045 case ODK_EXCEPTIONS
:
9046 fputs (" EXCEPTIONS fpe_min(", stdout
);
9047 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9048 fputs (") fpe_max(", stdout
);
9049 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9050 fputs (")", stdout
);
9052 if (option
->info
& OEX_PAGE0
)
9053 fputs (" PAGE0", stdout
);
9054 if (option
->info
& OEX_SMM
)
9055 fputs (" SMM", stdout
);
9056 if (option
->info
& OEX_FPDBUG
)
9057 fputs (" FPDBUG", stdout
);
9058 if (option
->info
& OEX_DISMISS
)
9059 fputs (" DISMISS", stdout
);
9062 fputs (" PAD ", stdout
);
9063 if (option
->info
& OPAD_PREFIX
)
9064 fputs (" PREFIX", stdout
);
9065 if (option
->info
& OPAD_POSTFIX
)
9066 fputs (" POSTFIX", stdout
);
9067 if (option
->info
& OPAD_SYMBOL
)
9068 fputs (" SYMBOL", stdout
);
9071 fputs (" HWPATCH ", stdout
);
9072 if (option
->info
& OHW_R4KEOP
)
9073 fputs (" R4KEOP", stdout
);
9074 if (option
->info
& OHW_R8KPFETCH
)
9075 fputs (" R8KPFETCH", stdout
);
9076 if (option
->info
& OHW_R5KEOP
)
9077 fputs (" R5KEOP", stdout
);
9078 if (option
->info
& OHW_R5KCVTL
)
9079 fputs (" R5KCVTL", stdout
);
9082 fputs (" FILL ", stdout
);
9083 /* XXX Print content of info word? */
9086 fputs (" TAGS ", stdout
);
9087 /* XXX Print content of info word? */
9090 fputs (" HWAND ", stdout
);
9091 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9092 fputs (" R4KEOP_CHECKED", stdout
);
9093 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9094 fputs (" R4KEOP_CLEAN", stdout
);
9097 fputs (" HWOR ", stdout
);
9098 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9099 fputs (" R4KEOP_CHECKED", stdout
);
9100 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9101 fputs (" R4KEOP_CLEAN", stdout
);
9104 printf (" GP_GROUP %#06lx self-contained %#06lx",
9105 option
->info
& OGP_GROUP
,
9106 (option
->info
& OGP_SELF
) >> 16);
9109 printf (" IDENT %#06lx self-contained %#06lx",
9110 option
->info
& OGP_GROUP
,
9111 (option
->info
& OGP_SELF
) >> 16);
9114 /* This shouldn't happen. */
9115 printf (" %3d ??? %d %lx",
9116 option
->kind
, option
->section
, option
->info
);
9120 len
= sizeof (*eopt
);
9121 while (len
< option
->size
)
9122 if (((char *) option
)[len
] >= ' '
9123 && ((char *) option
)[len
] < 0x7f)
9124 printf ("%c", ((char *) option
)[len
++]);
9126 printf ("\\%03o", ((char *) option
)[len
++]);
9128 fputs ("\n", stdout
);
9136 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9138 Elf32_Conflict
*iconf
;
9141 if (dynamic_symbols
== NULL
)
9143 error (_("conflict list found without a dynamic symbol table\n"));
9147 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9150 error (_("Out of memory\n"));
9156 Elf32_External_Conflict
*econf32
;
9158 econf32
= get_data (NULL
, file
, conflicts_offset
,
9159 conflictsno
, sizeof (*econf32
), _("conflict"));
9163 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9164 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9170 Elf64_External_Conflict
*econf64
;
9172 econf64
= get_data (NULL
, file
, conflicts_offset
,
9173 conflictsno
, sizeof (*econf64
), _("conflict"));
9177 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9178 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9183 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9184 (unsigned long) conflictsno
);
9185 puts (_(" Num: Index Value Name"));
9187 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9189 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9191 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9192 print_vma (psym
->st_value
, FULL_HEX
);
9194 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9195 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9197 printf ("<corrupt: %14ld>", psym
->st_name
);
9208 process_gnu_liblist (FILE *file
)
9210 Elf_Internal_Shdr
*section
, *string_sec
;
9211 Elf32_External_Lib
*elib
;
9220 for (i
= 0, section
= section_headers
;
9221 i
< elf_header
.e_shnum
;
9224 switch (section
->sh_type
)
9226 case SHT_GNU_LIBLIST
:
9227 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
9230 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9235 string_sec
= SECTION_HEADER (section
->sh_link
);
9237 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9238 string_sec
->sh_size
, _("liblist string table"));
9239 strtab_size
= string_sec
->sh_size
;
9242 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9248 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9249 SECTION_NAME (section
),
9250 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9252 puts (" Library Time Stamp Checksum Version Flags");
9254 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9262 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9263 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9264 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9265 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9266 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9268 tmp
= gmtime (&time
);
9269 snprintf (timebuf
, sizeof (timebuf
),
9270 "%04u-%02u-%02uT%02u:%02u:%02u",
9271 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9272 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9274 printf ("%3lu: ", (unsigned long) cnt
);
9276 printf ("%-20s", liblist
.l_name
< strtab_size
9277 ? strtab
+ liblist
.l_name
: "<corrupt>");
9279 printf ("%-20.20s", liblist
.l_name
< strtab_size
9280 ? strtab
+ liblist
.l_name
: "<corrupt>");
9281 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9282 liblist
.l_version
, liblist
.l_flags
);
9293 get_note_type (unsigned e_type
)
9295 static char buff
[64];
9297 if (elf_header
.e_type
== ET_CORE
)
9301 return _("NT_AUXV (auxiliary vector)");
9303 return _("NT_PRSTATUS (prstatus structure)");
9305 return _("NT_FPREGSET (floating point registers)");
9307 return _("NT_PRPSINFO (prpsinfo structure)");
9309 return _("NT_TASKSTRUCT (task structure)");
9311 return _("NT_PRXFPREG (user_xfpregs structure)");
9313 return _("NT_PPC_VMX (ppc Altivec registers)");
9315 return _("NT_PSTATUS (pstatus structure)");
9317 return _("NT_FPREGS (floating point registers)");
9319 return _("NT_PSINFO (psinfo structure)");
9321 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9323 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9324 case NT_WIN32PSTATUS
:
9325 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9333 return _("NT_VERSION (version)");
9335 return _("NT_ARCH (architecture)");
9340 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9345 get_gnu_elf_note_type (unsigned e_type
)
9347 static char buff
[64];
9351 case NT_GNU_ABI_TAG
:
9352 return _("NT_GNU_ABI_TAG (ABI version tag)");
9354 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9355 case NT_GNU_BUILD_ID
:
9356 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9361 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9366 get_netbsd_elfcore_note_type (unsigned e_type
)
9368 static char buff
[64];
9370 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9372 /* NetBSD core "procinfo" structure. */
9373 return _("NetBSD procinfo structure");
9376 /* As of Jan 2002 there are no other machine-independent notes
9377 defined for NetBSD core files. If the note type is less
9378 than the start of the machine-dependent note types, we don't
9381 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9383 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9387 switch (elf_header
.e_machine
)
9389 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9390 and PT_GETFPREGS == mach+2. */
9395 case EM_SPARC32PLUS
:
9399 case NT_NETBSDCORE_FIRSTMACH
+0:
9400 return _("PT_GETREGS (reg structure)");
9401 case NT_NETBSDCORE_FIRSTMACH
+2:
9402 return _("PT_GETFPREGS (fpreg structure)");
9408 /* On all other arch's, PT_GETREGS == mach+1 and
9409 PT_GETFPREGS == mach+3. */
9413 case NT_NETBSDCORE_FIRSTMACH
+1:
9414 return _("PT_GETREGS (reg structure)");
9415 case NT_NETBSDCORE_FIRSTMACH
+3:
9416 return _("PT_GETFPREGS (fpreg structure)");
9422 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
9423 e_type
- NT_NETBSDCORE_FIRSTMACH
);
9427 /* Note that by the ELF standard, the name field is already null byte
9428 terminated, and namesz includes the terminating null byte.
9429 I.E. the value of namesz for the name "FSF" is 4.
9431 If the value of namesz is zero, there is no name present. */
9433 process_note (Elf_Internal_Note
*pnote
)
9435 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
9438 if (pnote
->namesz
== 0)
9439 /* If there is no note name, then use the default set of
9440 note type strings. */
9441 nt
= get_note_type (pnote
->type
);
9443 else if (const_strneq (pnote
->namedata
, "GNU"))
9444 /* GNU-specific object file notes. */
9445 nt
= get_gnu_elf_note_type (pnote
->type
);
9447 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
9448 /* NetBSD-specific core file notes. */
9449 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9451 else if (strneq (pnote
->namedata
, "SPU/", 4))
9453 /* SPU-specific core file notes. */
9454 nt
= pnote
->namedata
+ 4;
9459 /* Don't recognize this note name; just use the default set of
9460 note type strings. */
9461 nt
= get_note_type (pnote
->type
);
9463 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
9469 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
9471 Elf_External_Note
*pnotes
;
9472 Elf_External_Note
*external
;
9478 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
9484 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9485 (unsigned long) offset
, (unsigned long) length
);
9486 printf (_(" Owner\t\tData size\tDescription\n"));
9488 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9490 Elf_External_Note
*next
;
9491 Elf_Internal_Note inote
;
9494 inote
.type
= BYTE_GET (external
->type
);
9495 inote
.namesz
= BYTE_GET (external
->namesz
);
9496 inote
.namedata
= external
->name
;
9497 inote
.descsz
= BYTE_GET (external
->descsz
);
9498 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9499 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9501 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9503 if (((char *) next
) > (((char *) pnotes
) + length
))
9505 warn (_("corrupt note found at offset %lx into core notes\n"),
9506 (long)((char *)external
- (char *)pnotes
));
9507 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
9508 inote
.type
, inote
.namesz
, inote
.descsz
);
9514 /* Verify that name is null terminated. It appears that at least
9515 one version of Linux (RedHat 6.0) generates corefiles that don't
9516 comply with the ELF spec by failing to include the null byte in
9518 if (inote
.namedata
[inote
.namesz
] != '\0')
9520 temp
= malloc (inote
.namesz
+ 1);
9524 error (_("Out of memory\n"));
9529 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9530 temp
[inote
.namesz
] = 0;
9532 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9533 inote
.namedata
= temp
;
9536 res
&= process_note (& inote
);
9551 process_corefile_note_segments (FILE *file
)
9553 Elf_Internal_Phdr
*segment
;
9557 if (! get_program_headers (file
))
9560 for (i
= 0, segment
= program_headers
;
9561 i
< elf_header
.e_phnum
;
9564 if (segment
->p_type
== PT_NOTE
)
9565 res
&= process_corefile_note_segment (file
,
9566 (bfd_vma
) segment
->p_offset
,
9567 (bfd_vma
) segment
->p_filesz
);
9574 process_note_sections (FILE *file
)
9576 Elf_Internal_Shdr
*section
;
9580 for (i
= 0, section
= section_headers
;
9581 i
< elf_header
.e_shnum
;
9583 if (section
->sh_type
== SHT_NOTE
)
9584 res
&= process_corefile_note_segment (file
,
9585 (bfd_vma
) section
->sh_offset
,
9586 (bfd_vma
) section
->sh_size
);
9592 process_notes (FILE *file
)
9594 /* If we have not been asked to display the notes then do nothing. */
9598 if (elf_header
.e_type
!= ET_CORE
)
9599 return process_note_sections (file
);
9601 /* No program headers means no NOTE segment. */
9602 if (elf_header
.e_phnum
> 0)
9603 return process_corefile_note_segments (file
);
9605 printf (_("No note segments present in the core file.\n"));
9610 process_arch_specific (FILE *file
)
9615 switch (elf_header
.e_machine
)
9618 return process_arm_specific (file
);
9620 case EM_MIPS_RS3_LE
:
9621 return process_mips_specific (file
);
9624 return process_power_specific (file
);
9633 get_file_header (FILE *file
)
9635 /* Read in the identity array. */
9636 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9639 /* Determine how to read the rest of the header. */
9640 switch (elf_header
.e_ident
[EI_DATA
])
9642 default: /* fall through */
9643 case ELFDATANONE
: /* fall through */
9645 byte_get
= byte_get_little_endian
;
9646 byte_put
= byte_put_little_endian
;
9649 byte_get
= byte_get_big_endian
;
9650 byte_put
= byte_put_big_endian
;
9654 /* For now we only support 32 bit and 64 bit ELF files. */
9655 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9657 /* Read in the rest of the header. */
9660 Elf32_External_Ehdr ehdr32
;
9662 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9665 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9666 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9667 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9668 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9669 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9670 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9671 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9672 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9673 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9674 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9675 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9676 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9677 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9681 Elf64_External_Ehdr ehdr64
;
9683 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9684 we will not be able to cope with the 64bit data found in
9685 64 ELF files. Detect this now and abort before we start
9686 overwriting things. */
9687 if (sizeof (bfd_vma
) < 8)
9689 error (_("This instance of readelf has been built without support for a\n\
9690 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9694 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9697 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9698 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9699 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9700 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
9701 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
9702 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
9703 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9704 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9705 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9706 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9707 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9708 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9709 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9712 if (elf_header
.e_shoff
)
9714 /* There may be some extensions in the first section header. Don't
9715 bomb if we can't read it. */
9717 get_32bit_section_headers (file
, 1);
9719 get_64bit_section_headers (file
, 1);
9722 is_relocatable
= elf_header
.e_type
== ET_REL
;
9727 /* Process one ELF object file according to the command line options.
9728 This file may actually be stored in an archive. The file is
9729 positioned at the start of the ELF object. */
9732 process_object (char *file_name
, FILE *file
)
9736 if (! get_file_header (file
))
9738 error (_("%s: Failed to read file header\n"), file_name
);
9742 /* Initialise per file variables. */
9743 for (i
= ARRAY_SIZE (version_info
); i
--;)
9744 version_info
[i
] = 0;
9746 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
9747 dynamic_info
[i
] = 0;
9749 /* Process the file. */
9751 printf (_("\nFile: %s\n"), file_name
);
9753 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9754 Note we do this even if cmdline_dump_sects is empty because we
9755 must make sure that the dump_sets array is zeroed out before each
9756 object file is processed. */
9757 if (num_dump_sects
> num_cmdline_dump_sects
)
9758 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
9760 if (num_cmdline_dump_sects
> 0)
9762 if (num_dump_sects
== 0)
9763 /* A sneaky way of allocating the dump_sects array. */
9764 request_dump_bynumber (num_cmdline_dump_sects
, 0);
9766 assert (num_dump_sects
>= num_cmdline_dump_sects
);
9767 memcpy (dump_sects
, cmdline_dump_sects
,
9768 num_cmdline_dump_sects
* sizeof (* dump_sects
));
9771 if (! process_file_header ())
9774 if (! process_section_headers (file
))
9776 /* Without loaded section headers we cannot process lots of
9778 do_unwind
= do_version
= do_dump
= do_arch
= 0;
9780 if (! do_using_dynamic
)
9781 do_syms
= do_reloc
= 0;
9784 if (! process_section_groups (file
))
9786 /* Without loaded section groups we cannot process unwind. */
9790 if (process_program_headers (file
))
9791 process_dynamic_section (file
);
9793 process_relocs (file
);
9795 process_unwind (file
);
9797 process_symbol_table (file
);
9799 process_syminfo (file
);
9801 process_version_sections (file
);
9803 process_section_contents (file
);
9805 process_notes (file
);
9807 process_gnu_liblist (file
);
9809 process_arch_specific (file
);
9811 if (program_headers
)
9813 free (program_headers
);
9814 program_headers
= NULL
;
9817 if (section_headers
)
9819 free (section_headers
);
9820 section_headers
= NULL
;
9825 free (string_table
);
9826 string_table
= NULL
;
9827 string_table_length
= 0;
9830 if (dynamic_strings
)
9832 free (dynamic_strings
);
9833 dynamic_strings
= NULL
;
9834 dynamic_strings_length
= 0;
9837 if (dynamic_symbols
)
9839 free (dynamic_symbols
);
9840 dynamic_symbols
= NULL
;
9841 num_dynamic_syms
= 0;
9844 if (dynamic_syminfo
)
9846 free (dynamic_syminfo
);
9847 dynamic_syminfo
= NULL
;
9850 if (section_headers_groups
)
9852 free (section_headers_groups
);
9853 section_headers_groups
= NULL
;
9858 struct group_list
*g
, *next
;
9860 for (i
= 0; i
< group_count
; i
++)
9862 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
9869 free (section_groups
);
9870 section_groups
= NULL
;
9873 free_debug_memory ();
9878 /* Process an ELF archive.
9879 On entry the file is positioned just after the ARMAG string. */
9882 process_archive (char *file_name
, FILE *file
)
9884 struct ar_hdr arhdr
;
9887 unsigned long index_num
= 0;
9888 unsigned long *index_array
= NULL
;
9889 char *sym_table
= NULL
;
9890 unsigned long sym_size
= 0;
9891 char *longnames
= NULL
;
9892 unsigned long longnames_size
= 0;
9893 size_t file_name_size
;
9898 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9899 if (got
!= sizeof arhdr
)
9904 error (_("%s: failed to read archive header\n"), file_name
);
9908 /* See if this is the archive symbol table. */
9909 if (const_strneq (arhdr
.ar_name
, "/ ")
9910 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
9912 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9913 size
= size
+ (size
& 1);
9915 if (do_archive_index
)
9918 /* A buffer used to hold numbers read in from an archive index.
9919 These are always 4 bytes long and stored in big-endian format. */
9920 #define SIZEOF_AR_INDEX_NUMBERS 4
9921 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
9922 unsigned char * index_buffer
;
9924 /* Check the size of the archive index. */
9925 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
9927 error (_("%s: the archive index is empty\n"), file_name
);
9931 /* Read the numer of entries in the archive index. */
9932 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
9933 if (got
!= sizeof (integer_buffer
))
9935 error (_("%s: failed to read archive index\n"), file_name
);
9938 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
9939 size
-= SIZEOF_AR_INDEX_NUMBERS
;
9941 /* Read in the archive index. */
9942 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
9944 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
9945 file_name
, index_num
);
9948 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
9949 if (index_buffer
== NULL
)
9951 error (_("Out of memory whilst trying to read archive symbol index\n"));
9954 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
9955 if (got
!= index_num
)
9957 free (index_buffer
);
9958 error (_("%s: failed to read archive index\n"), file_name
);
9962 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
9964 /* Convert the index numbers into the host's numeric format. */
9965 index_array
= malloc (index_num
* sizeof (* index_array
));
9966 if (index_array
== NULL
)
9968 free (index_buffer
);
9969 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
9973 for (i
= 0; i
< index_num
; i
++)
9974 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
9975 SIZEOF_AR_INDEX_NUMBERS
);
9976 free (index_buffer
);
9978 /* The remaining space in the header is taken up by the symbol table. */
9981 error (_("%s: the archive has an index but no symbols\n"), file_name
);
9985 sym_table
= malloc (size
);
9987 if (sym_table
== NULL
)
9989 error (_("Out of memory whilst trying to read archive index symbol table\n"));
9993 got
= fread (sym_table
, 1, size
, file
);
9996 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10003 if (fseek (file
, size
, SEEK_CUR
) != 0)
10005 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10010 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10011 if (got
!= sizeof arhdr
)
10019 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10024 else if (do_archive_index
)
10025 printf (_("%s has no archive index\n"), file_name
);
10027 if (const_strneq (arhdr
.ar_name
, "// "))
10029 /* This is the archive string table holding long member
10032 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10033 longnames
= malloc (longnames_size
);
10034 if (longnames
== NULL
)
10036 error (_("Out of memory reading long symbol names in archive\n"));
10041 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10044 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10049 if ((longnames_size
& 1) != 0)
10052 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10053 if (got
!= sizeof arhdr
)
10059 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10066 if (do_archive_index
)
10068 if (sym_table
== NULL
)
10069 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10072 unsigned int i
, j
, k
, l
;
10074 unsigned long current_pos
;
10076 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10077 file_name
, index_num
, sym_size
);
10078 current_pos
= ftell (file
);
10080 for (i
= l
= 0; i
< index_num
; i
++)
10082 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10084 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10086 error (_("%s: failed to seek to next file name\n"), file_name
);
10090 got
= fread (elf_name
, 1, 16, file
);
10093 error (_("%s: failed to read file name\n"), file_name
);
10098 if (elf_name
[0] == '/')
10100 /* We have a long name. */
10101 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10102 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10104 longnames
[j
] = '\0';
10105 printf (_("Binary %s contains:\n"), longnames
+ k
);
10106 longnames
[j
] = '/';
10111 while ((elf_name
[j
] != '/') && (j
< 16))
10113 elf_name
[j
] = '\0';
10114 printf(_("Binary %s contains:\n"), elf_name
);
10119 error (_("%s: end of the symbol table reached before the end of the index\n"),
10123 printf ("\t%s\n", sym_table
+ l
);
10124 l
+= strlen (sym_table
+ l
) + 1;
10128 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10131 free (index_array
);
10132 index_array
= NULL
;
10135 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10137 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10142 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10143 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10144 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10145 && !do_section_groups
)
10146 return 0; /* Archive index only. */
10149 file_name_size
= strlen (file_name
);
10158 if (arhdr
.ar_name
[0] == '/')
10162 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10163 if (off
>= longnames_size
)
10165 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10170 name
= longnames
+ off
;
10171 nameend
= memchr (name
, '/', longnames_size
- off
);
10175 name
= arhdr
.ar_name
;
10176 nameend
= memchr (name
, '/', 16);
10179 if (nameend
== NULL
)
10181 error (_("%s: bad archive file name\n"), file_name
);
10186 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10187 if (namealc
== NULL
)
10189 error (_("Out of memory\n"));
10194 memcpy (namealc
, file_name
, file_name_size
);
10195 namealc
[file_name_size
] = '(';
10196 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10197 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10198 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10200 archive_file_offset
= ftell (file
);
10201 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10203 ret
|= process_object (namealc
, file
);
10208 (archive_file_offset
10209 + archive_file_size
10210 + (archive_file_size
& 1)),
10213 error (_("%s: failed to seek to next archive header\n"), file_name
);
10218 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10219 if (got
!= sizeof arhdr
)
10224 error (_("%s: failed to read archive header\n"), file_name
);
10231 if (index_array
!= NULL
)
10232 free (index_array
);
10233 if (sym_table
!= NULL
)
10235 if (longnames
!= NULL
)
10242 process_file (char *file_name
)
10245 struct stat statbuf
;
10246 char armag
[SARMAG
];
10249 if (stat (file_name
, &statbuf
) < 0)
10251 if (errno
== ENOENT
)
10252 error (_("'%s': No such file\n"), file_name
);
10254 error (_("Could not locate '%s'. System error message: %s\n"),
10255 file_name
, strerror (errno
));
10259 if (! S_ISREG (statbuf
.st_mode
))
10261 error (_("'%s' is not an ordinary file\n"), file_name
);
10265 file
= fopen (file_name
, "rb");
10268 error (_("Input file '%s' is not readable.\n"), file_name
);
10272 if (fread (armag
, SARMAG
, 1, file
) != 1)
10274 error (_("%s: Failed to read file's magic number\n"), file_name
);
10279 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10280 ret
= process_archive (file_name
, file
);
10283 if (do_archive_index
)
10284 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10288 archive_file_size
= archive_file_offset
= 0;
10289 ret
= process_object (file_name
, file
);
10297 #ifdef SUPPORT_DISASSEMBLY
10298 /* Needed by the i386 disassembler. For extra credit, someone could
10299 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10303 print_address (unsigned int addr
, FILE *outfile
)
10305 fprintf (outfile
,"0x%8.8x", addr
);
10308 /* Needed by the i386 disassembler. */
10310 db_task_printsym (unsigned int addr
)
10312 print_address (addr
, stderr
);
10317 main (int argc
, char **argv
)
10321 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10322 setlocale (LC_MESSAGES
, "");
10324 #if defined (HAVE_SETLOCALE)
10325 setlocale (LC_CTYPE
, "");
10327 bindtextdomain (PACKAGE
, LOCALEDIR
);
10328 textdomain (PACKAGE
);
10330 expandargv (&argc
, &argv
);
10332 parse_args (argc
, argv
);
10334 if (num_dump_sects
> 0)
10336 /* Make a copy of the dump_sects array. */
10337 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10338 if (cmdline_dump_sects
== NULL
)
10339 error (_("Out of memory allocating dump request table.\n"));
10342 memcpy (cmdline_dump_sects
, dump_sects
,
10343 num_dump_sects
* sizeof (* dump_sects
));
10344 num_cmdline_dump_sects
= num_dump_sects
;
10348 if (optind
< (argc
- 1))
10352 while (optind
< argc
)
10353 err
|= process_file (argv
[optind
++]);
10355 if (dump_sects
!= NULL
)
10357 if (cmdline_dump_sects
!= NULL
)
10358 free (cmdline_dump_sects
);