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 /* Try to locate the .dynamic section. If there is
3534 a section header table, we can easily locate it. */
3535 if (section_headers
!= NULL
)
3537 Elf_Internal_Shdr
*sec
;
3539 sec
= find_section (".dynamic");
3540 if (sec
== NULL
|| sec
->sh_size
== 0)
3542 error (_("no .dynamic section in the dynamic segment\n"));
3546 if (sec
->sh_type
== SHT_NOBITS
)
3549 dynamic_addr
= sec
->sh_offset
;
3550 dynamic_size
= sec
->sh_size
;
3552 if (dynamic_addr
< segment
->p_offset
3553 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3554 warn (_("the .dynamic section is not contained within the dynamic segment\n"));
3555 else if (dynamic_addr
> segment
->p_offset
)
3556 warn (_("the .dynamic section is not the first section in the dynamic segment.\n"));
3560 /* Otherwise, we can only assume that the .dynamic
3561 section is the first section in the DYNAMIC segment. */
3562 dynamic_addr
= segment
->p_offset
;
3563 dynamic_size
= segment
->p_filesz
;
3568 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3570 error (_("Unable to find program interpreter name\n"));
3574 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3576 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3577 error (_("Internal error: failed to create format string to display program interpreter\n"));
3579 program_interpreter
[0] = 0;
3580 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3581 error (_("Unable to read program interpreter name\n"));
3584 printf (_("\n [Requesting program interpreter: %s]"),
3585 program_interpreter
);
3591 putc ('\n', stdout
);
3594 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3596 printf (_("\n Section to Segment mapping:\n"));
3597 printf (_(" Segment Sections...\n"));
3599 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3602 Elf_Internal_Shdr
*section
;
3604 segment
= program_headers
+ i
;
3605 section
= section_headers
;
3607 printf (" %2.2d ", i
);
3609 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3611 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3612 printf ("%s ", SECTION_NAME (section
));
3623 /* Find the file offset corresponding to VMA by using the program headers. */
3626 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3628 Elf_Internal_Phdr
*seg
;
3630 if (! get_program_headers (file
))
3632 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3636 for (seg
= program_headers
;
3637 seg
< program_headers
+ elf_header
.e_phnum
;
3640 if (seg
->p_type
!= PT_LOAD
)
3643 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3644 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3645 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3648 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3655 get_32bit_section_headers (FILE *file
, unsigned int num
)
3657 Elf32_External_Shdr
*shdrs
;
3658 Elf_Internal_Shdr
*internal
;
3661 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3662 elf_header
.e_shentsize
, num
, _("section headers"));
3666 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3668 if (section_headers
== NULL
)
3670 error (_("Out of memory\n"));
3674 for (i
= 0, internal
= section_headers
;
3678 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3679 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3680 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3681 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3682 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3683 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3684 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3685 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3686 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3687 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3696 get_64bit_section_headers (FILE *file
, unsigned int num
)
3698 Elf64_External_Shdr
*shdrs
;
3699 Elf_Internal_Shdr
*internal
;
3702 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3703 elf_header
.e_shentsize
, num
, _("section headers"));
3707 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3709 if (section_headers
== NULL
)
3711 error (_("Out of memory\n"));
3715 for (i
= 0, internal
= section_headers
;
3719 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3720 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3721 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3722 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3723 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3724 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3725 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3726 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3727 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3728 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3736 static Elf_Internal_Sym
*
3737 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3739 unsigned long number
;
3740 Elf32_External_Sym
*esyms
;
3741 Elf_External_Sym_Shndx
*shndx
;
3742 Elf_Internal_Sym
*isyms
;
3743 Elf_Internal_Sym
*psym
;
3746 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3752 if (symtab_shndx_hdr
!= NULL
3753 && (symtab_shndx_hdr
->sh_link
3754 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3756 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3757 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3765 number
= section
->sh_size
/ section
->sh_entsize
;
3766 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3770 error (_("Out of memory\n"));
3777 for (j
= 0, psym
= isyms
;
3781 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3782 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3783 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3784 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3785 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3787 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3788 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3789 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3799 static Elf_Internal_Sym
*
3800 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3802 unsigned long number
;
3803 Elf64_External_Sym
*esyms
;
3804 Elf_External_Sym_Shndx
*shndx
;
3805 Elf_Internal_Sym
*isyms
;
3806 Elf_Internal_Sym
*psym
;
3809 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3815 if (symtab_shndx_hdr
!= NULL
3816 && (symtab_shndx_hdr
->sh_link
3817 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3819 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3820 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3828 number
= section
->sh_size
/ section
->sh_entsize
;
3829 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3833 error (_("Out of memory\n"));
3840 for (j
= 0, psym
= isyms
;
3844 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3845 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3846 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3847 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3848 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3850 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3851 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3852 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3863 get_elf_section_flags (bfd_vma sh_flags
)
3865 static char buff
[1024];
3867 int field_size
= is_32bit_elf
? 8 : 16;
3868 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3869 bfd_vma os_flags
= 0;
3870 bfd_vma proc_flags
= 0;
3871 bfd_vma unknown_flags
= 0;
3885 { "LINK ORDER", 10 },
3886 { "OS NONCONF", 10 },
3891 if (do_section_details
)
3893 sprintf (buff
, "[%*.*lx]: ",
3894 field_size
, field_size
, (unsigned long) sh_flags
);
3895 p
+= field_size
+ 4;
3902 flag
= sh_flags
& - sh_flags
;
3905 if (do_section_details
)
3909 case SHF_WRITE
: index
= 0; break;
3910 case SHF_ALLOC
: index
= 1; break;
3911 case SHF_EXECINSTR
: index
= 2; break;
3912 case SHF_MERGE
: index
= 3; break;
3913 case SHF_STRINGS
: index
= 4; break;
3914 case SHF_INFO_LINK
: index
= 5; break;
3915 case SHF_LINK_ORDER
: index
= 6; break;
3916 case SHF_OS_NONCONFORMING
: index
= 7; break;
3917 case SHF_GROUP
: index
= 8; break;
3918 case SHF_TLS
: index
= 9; break;
3927 if (p
!= buff
+ field_size
+ 4)
3929 if (size
< (10 + 2))
3936 size
-= flags
[index
].len
;
3937 p
= stpcpy (p
, flags
[index
].str
);
3939 else if (flag
& SHF_MASKOS
)
3941 else if (flag
& SHF_MASKPROC
)
3944 unknown_flags
|= flag
;
3950 case SHF_WRITE
: *p
= 'W'; break;
3951 case SHF_ALLOC
: *p
= 'A'; break;
3952 case SHF_EXECINSTR
: *p
= 'X'; break;
3953 case SHF_MERGE
: *p
= 'M'; break;
3954 case SHF_STRINGS
: *p
= 'S'; break;
3955 case SHF_INFO_LINK
: *p
= 'I'; break;
3956 case SHF_LINK_ORDER
: *p
= 'L'; break;
3957 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3958 case SHF_GROUP
: *p
= 'G'; break;
3959 case SHF_TLS
: *p
= 'T'; break;
3962 if (elf_header
.e_machine
== EM_X86_64
3963 && flag
== SHF_X86_64_LARGE
)
3965 else if (flag
& SHF_MASKOS
)
3968 sh_flags
&= ~ SHF_MASKOS
;
3970 else if (flag
& SHF_MASKPROC
)
3973 sh_flags
&= ~ SHF_MASKPROC
;
3983 if (do_section_details
)
3987 size
-= 5 + field_size
;
3988 if (p
!= buff
+ field_size
+ 4)
3996 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3997 (unsigned long) os_flags
);
3998 p
+= 5 + field_size
;
4002 size
-= 7 + field_size
;
4003 if (p
!= buff
+ field_size
+ 4)
4011 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4012 (unsigned long) proc_flags
);
4013 p
+= 7 + field_size
;
4017 size
-= 10 + field_size
;
4018 if (p
!= buff
+ field_size
+ 4)
4026 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4027 (unsigned long) unknown_flags
);
4028 p
+= 10 + field_size
;
4037 process_section_headers (FILE *file
)
4039 Elf_Internal_Shdr
*section
;
4042 section_headers
= NULL
;
4044 if (elf_header
.e_shnum
== 0)
4047 printf (_("\nThere are no sections in this file.\n"));
4052 if (do_sections
&& !do_header
)
4053 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4054 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4058 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4061 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4064 /* Read in the string table, so that we have names to display. */
4065 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4066 && SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
4068 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
4070 if (section
->sh_size
!= 0)
4072 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4073 1, section
->sh_size
, _("string table"));
4075 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4079 /* Scan the sections for the dynamic symbol table
4080 and dynamic string table and debug sections. */
4081 dynamic_symbols
= NULL
;
4082 dynamic_strings
= NULL
;
4083 dynamic_syminfo
= NULL
;
4084 symtab_shndx_hdr
= NULL
;
4086 eh_addr_size
= is_32bit_elf
? 4 : 8;
4087 switch (elf_header
.e_machine
)
4090 case EM_MIPS_RS3_LE
:
4091 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4092 FDE addresses. However, the ABI also has a semi-official ILP32
4093 variant for which the normal FDE address size rules apply.
4095 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4096 section, where XX is the size of longs in bits. Unfortunately,
4097 earlier compilers provided no way of distinguishing ILP32 objects
4098 from LP64 objects, so if there's any doubt, we should assume that
4099 the official LP64 form is being used. */
4100 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4101 && find_section (".gcc_compiled_long32") == NULL
)
4107 switch (elf_header
.e_flags
& EF_H8_MACH
)
4109 case E_H8_MACH_H8300
:
4110 case E_H8_MACH_H8300HN
:
4111 case E_H8_MACH_H8300SN
:
4112 case E_H8_MACH_H8300SXN
:
4115 case E_H8_MACH_H8300H
:
4116 case E_H8_MACH_H8300S
:
4117 case E_H8_MACH_H8300SX
:
4123 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4126 size_t expected_entsize \
4127 = is_32bit_elf ? size32 : size64; \
4128 if (section->sh_entsize != expected_entsize) \
4129 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4130 i, (unsigned long int) section->sh_entsize, \
4131 (unsigned long int) expected_entsize); \
4132 section->sh_entsize = expected_entsize; \
4135 #define CHECK_ENTSIZE(section, i, type) \
4136 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4137 sizeof (Elf64_External_##type))
4139 for (i
= 0, section
= section_headers
;
4140 i
< elf_header
.e_shnum
;
4143 char *name
= SECTION_NAME (section
);
4145 if (section
->sh_type
== SHT_DYNSYM
)
4147 if (dynamic_symbols
!= NULL
)
4149 error (_("File contains multiple dynamic symbol tables\n"));
4153 CHECK_ENTSIZE (section
, i
, Sym
);
4154 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4155 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4157 else if (section
->sh_type
== SHT_STRTAB
4158 && streq (name
, ".dynstr"))
4160 if (dynamic_strings
!= NULL
)
4162 error (_("File contains multiple dynamic string tables\n"));
4166 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4167 1, section
->sh_size
, _("dynamic strings"));
4168 dynamic_strings_length
= section
->sh_size
;
4170 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4172 if (symtab_shndx_hdr
!= NULL
)
4174 error (_("File contains multiple symtab shndx tables\n"));
4177 symtab_shndx_hdr
= section
;
4179 else if (section
->sh_type
== SHT_SYMTAB
)
4180 CHECK_ENTSIZE (section
, i
, Sym
);
4181 else if (section
->sh_type
== SHT_GROUP
)
4182 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4183 else if (section
->sh_type
== SHT_REL
)
4184 CHECK_ENTSIZE (section
, i
, Rel
);
4185 else if (section
->sh_type
== SHT_RELA
)
4186 CHECK_ENTSIZE (section
, i
, Rela
);
4187 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4188 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4189 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4190 || do_debug_loc
|| do_debug_ranges
)
4191 && const_strneq (name
, ".debug_"))
4196 || (do_debug_info
&& streq (name
, "info"))
4197 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4198 || (do_debug_lines
&& streq (name
, "line"))
4199 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4200 || (do_debug_aranges
&& streq (name
, "aranges"))
4201 || (do_debug_ranges
&& streq (name
, "ranges"))
4202 || (do_debug_frames
&& streq (name
, "frame"))
4203 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4204 || (do_debug_str
&& streq (name
, "str"))
4205 || (do_debug_loc
&& streq (name
, "loc"))
4207 request_dump_bynumber (i
, DEBUG_DUMP
);
4209 /* linkonce section to be combined with .debug_info at link time. */
4210 else if ((do_debugging
|| do_debug_info
)
4211 && const_strneq (name
, ".gnu.linkonce.wi."))
4212 request_dump_bynumber (i
, DEBUG_DUMP
);
4213 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4214 request_dump_bynumber (i
, DEBUG_DUMP
);
4220 if (elf_header
.e_shnum
> 1)
4221 printf (_("\nSection Headers:\n"));
4223 printf (_("\nSection Header:\n"));
4227 if (do_section_details
)
4229 printf (_(" [Nr] Name\n"));
4230 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4234 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4238 if (do_section_details
)
4240 printf (_(" [Nr] Name\n"));
4241 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4245 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4249 if (do_section_details
)
4251 printf (_(" [Nr] Name\n"));
4252 printf (_(" Type Address Offset Link\n"));
4253 printf (_(" Size EntSize Info Align\n"));
4257 printf (_(" [Nr] Name Type Address Offset\n"));
4258 printf (_(" Size EntSize Flags Link Info Align\n"));
4262 if (do_section_details
)
4263 printf (_(" Flags\n"));
4265 for (i
= 0, section
= section_headers
;
4266 i
< elf_header
.e_shnum
;
4269 if (do_section_details
)
4271 printf (" [%2u] %s\n",
4272 SECTION_HEADER_NUM (i
),
4273 SECTION_NAME (section
));
4274 if (is_32bit_elf
|| do_wide
)
4275 printf (" %-15.15s ",
4276 get_section_type_name (section
->sh_type
));
4279 printf (" [%2u] %-17.17s %-15.15s ",
4280 SECTION_HEADER_NUM (i
),
4281 SECTION_NAME (section
),
4282 get_section_type_name (section
->sh_type
));
4286 print_vma (section
->sh_addr
, LONG_HEX
);
4288 printf ( " %6.6lx %6.6lx %2.2lx",
4289 (unsigned long) section
->sh_offset
,
4290 (unsigned long) section
->sh_size
,
4291 (unsigned long) section
->sh_entsize
);
4293 if (do_section_details
)
4294 fputs (" ", stdout
);
4296 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4298 printf ("%2ld %3lu %2ld\n",
4299 (unsigned long) section
->sh_link
,
4300 (unsigned long) section
->sh_info
,
4301 (unsigned long) section
->sh_addralign
);
4305 print_vma (section
->sh_addr
, LONG_HEX
);
4307 if ((long) section
->sh_offset
== section
->sh_offset
)
4308 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4312 print_vma (section
->sh_offset
, LONG_HEX
);
4315 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4316 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4320 print_vma (section
->sh_size
, LONG_HEX
);
4323 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4324 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4328 print_vma (section
->sh_entsize
, LONG_HEX
);
4331 if (do_section_details
)
4332 fputs (" ", stdout
);
4334 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4336 printf ("%2ld %3lu ",
4337 (unsigned long) section
->sh_link
,
4338 (unsigned long) section
->sh_info
);
4340 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4341 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4344 print_vma (section
->sh_addralign
, DEC
);
4348 else if (do_section_details
)
4350 printf (" %-15.15s ",
4351 get_section_type_name (section
->sh_type
));
4352 print_vma (section
->sh_addr
, LONG_HEX
);
4353 if ((long) section
->sh_offset
== section
->sh_offset
)
4354 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4358 print_vma (section
->sh_offset
, LONG_HEX
);
4360 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4361 print_vma (section
->sh_size
, LONG_HEX
);
4363 print_vma (section
->sh_entsize
, LONG_HEX
);
4365 printf (" %-16lu %ld\n",
4366 (unsigned long) section
->sh_info
,
4367 (unsigned long) section
->sh_addralign
);
4372 print_vma (section
->sh_addr
, LONG_HEX
);
4373 if ((long) section
->sh_offset
== section
->sh_offset
)
4374 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4378 print_vma (section
->sh_offset
, LONG_HEX
);
4381 print_vma (section
->sh_size
, LONG_HEX
);
4383 print_vma (section
->sh_entsize
, LONG_HEX
);
4385 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4387 printf (" %2ld %3lu %ld\n",
4388 (unsigned long) section
->sh_link
,
4389 (unsigned long) section
->sh_info
,
4390 (unsigned long) section
->sh_addralign
);
4393 if (do_section_details
)
4394 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4397 if (!do_section_details
)
4398 printf (_("Key to Flags:\n\
4399 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4400 I (info), L (link order), G (group), x (unknown)\n\
4401 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4407 get_group_flags (unsigned int flags
)
4409 static char buff
[32];
4416 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4423 process_section_groups (FILE *file
)
4425 Elf_Internal_Shdr
*section
;
4427 struct group
*group
;
4428 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4429 Elf_Internal_Sym
*symtab
;
4433 /* Don't process section groups unless needed. */
4434 if (!do_unwind
&& !do_section_groups
)
4437 if (elf_header
.e_shnum
== 0)
4439 if (do_section_groups
)
4440 printf (_("\nThere are no sections in this file.\n"));
4445 if (section_headers
== NULL
)
4447 error (_("Section headers are not available!\n"));
4451 section_headers_groups
= calloc (elf_header
.e_shnum
,
4452 sizeof (struct group
*));
4454 if (section_headers_groups
== NULL
)
4456 error (_("Out of memory\n"));
4460 /* Scan the sections for the group section. */
4462 for (i
= 0, section
= section_headers
;
4463 i
< elf_header
.e_shnum
;
4465 if (section
->sh_type
== SHT_GROUP
)
4468 if (group_count
== 0)
4470 if (do_section_groups
)
4471 printf (_("\nThere are no section groups in this file.\n"));
4476 section_groups
= calloc (group_count
, sizeof (struct group
));
4478 if (section_groups
== NULL
)
4480 error (_("Out of memory\n"));
4489 for (i
= 0, section
= section_headers
, group
= section_groups
;
4490 i
< elf_header
.e_shnum
;
4493 if (section
->sh_type
== SHT_GROUP
)
4495 char *name
= SECTION_NAME (section
);
4497 unsigned char *start
, *indices
;
4498 unsigned int entry
, j
, size
;
4499 Elf_Internal_Shdr
*sec
;
4500 Elf_Internal_Sym
*sym
;
4502 /* Get the symbol table. */
4503 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4504 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4507 error (_("Bad sh_link in group section `%s'\n"), name
);
4511 if (symtab_sec
!= sec
)
4516 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4519 sym
= symtab
+ section
->sh_info
;
4521 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4523 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4526 error (_("Bad sh_info in group section `%s'\n"), name
);
4530 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4539 /* Get the string table. */
4540 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4541 >= elf_header
.e_shnum
)
4550 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4555 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4556 1, strtab_sec
->sh_size
,
4558 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4560 group_name
= sym
->st_name
< strtab_size
4561 ? strtab
+ sym
->st_name
: "<corrupt>";
4564 start
= get_data (NULL
, file
, section
->sh_offset
,
4565 1, section
->sh_size
, _("section data"));
4568 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4569 entry
= byte_get (indices
, 4);
4572 if (do_section_groups
)
4574 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4575 get_group_flags (entry
), i
, name
, group_name
, size
);
4577 printf (_(" [Index] Name\n"));
4580 group
->group_index
= i
;
4582 for (j
= 0; j
< size
; j
++)
4584 struct group_list
*g
;
4586 entry
= byte_get (indices
, 4);
4589 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4591 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4592 entry
, i
, elf_header
.e_shnum
- 1);
4595 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4597 error (_("invalid section [%5u] in group section [%5u]\n"),
4602 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4607 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4609 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4614 /* Intel C/C++ compiler may put section 0 in a
4615 section group. We just warn it the first time
4616 and ignore it afterwards. */
4617 static int warned
= 0;
4620 error (_("section 0 in group section [%5u]\n"),
4621 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4627 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4630 if (do_section_groups
)
4632 sec
= SECTION_HEADER (entry
);
4633 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4636 g
= xmalloc (sizeof (struct group_list
));
4637 g
->section_index
= entry
;
4638 g
->next
= group
->root
;
4662 } dynamic_relocations
[] =
4664 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4665 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4666 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4669 /* Process the reloc section. */
4672 process_relocs (FILE *file
)
4674 unsigned long rel_size
;
4675 unsigned long rel_offset
;
4681 if (do_using_dynamic
)
4685 int has_dynamic_reloc
;
4688 has_dynamic_reloc
= 0;
4690 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4692 is_rela
= dynamic_relocations
[i
].rela
;
4693 name
= dynamic_relocations
[i
].name
;
4694 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4695 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4697 has_dynamic_reloc
|= rel_size
;
4699 if (is_rela
== UNKNOWN
)
4701 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4702 switch (dynamic_info
[DT_PLTREL
])
4716 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4717 name
, rel_offset
, rel_size
);
4719 dump_relocations (file
,
4720 offset_from_vma (file
, rel_offset
, rel_size
),
4722 dynamic_symbols
, num_dynamic_syms
,
4723 dynamic_strings
, dynamic_strings_length
, is_rela
);
4727 if (! has_dynamic_reloc
)
4728 printf (_("\nThere are no dynamic relocations in this file.\n"));
4732 Elf_Internal_Shdr
*section
;
4736 for (i
= 0, section
= section_headers
;
4737 i
< elf_header
.e_shnum
;
4740 if ( section
->sh_type
!= SHT_RELA
4741 && section
->sh_type
!= SHT_REL
)
4744 rel_offset
= section
->sh_offset
;
4745 rel_size
= section
->sh_size
;
4749 Elf_Internal_Shdr
*strsec
;
4752 printf (_("\nRelocation section "));
4754 if (string_table
== NULL
)
4755 printf ("%d", section
->sh_name
);
4757 printf (_("'%s'"), SECTION_NAME (section
));
4759 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4760 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4762 is_rela
= section
->sh_type
== SHT_RELA
;
4764 if (section
->sh_link
4765 && SECTION_HEADER_INDEX (section
->sh_link
)
4766 < elf_header
.e_shnum
)
4768 Elf_Internal_Shdr
*symsec
;
4769 Elf_Internal_Sym
*symtab
;
4770 unsigned long nsyms
;
4771 unsigned long strtablen
= 0;
4772 char *strtab
= NULL
;
4774 symsec
= SECTION_HEADER (section
->sh_link
);
4775 if (symsec
->sh_type
!= SHT_SYMTAB
4776 && symsec
->sh_type
!= SHT_DYNSYM
)
4779 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4780 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4785 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4786 < elf_header
.e_shnum
)
4788 strsec
= SECTION_HEADER (symsec
->sh_link
);
4790 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4793 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4796 dump_relocations (file
, rel_offset
, rel_size
,
4797 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4803 dump_relocations (file
, rel_offset
, rel_size
,
4804 NULL
, 0, NULL
, 0, is_rela
);
4811 printf (_("\nThere are no relocations in this file.\n"));
4817 /* Process the unwind section. */
4819 #include "unwind-ia64.h"
4821 /* An absolute address consists of a section and an offset. If the
4822 section is NULL, the offset itself is the address, otherwise, the
4823 address equals to LOAD_ADDRESS(section) + offset. */
4827 unsigned short section
;
4831 #define ABSADDR(a) \
4833 ? section_headers [(a).section].sh_addr + (a).offset \
4836 struct ia64_unw_aux_info
4838 struct ia64_unw_table_entry
4840 struct absaddr start
;
4842 struct absaddr info
;
4844 *table
; /* Unwind table. */
4845 unsigned long table_len
; /* Length of unwind table. */
4846 unsigned char *info
; /* Unwind info. */
4847 unsigned long info_size
; /* Size of unwind info. */
4848 bfd_vma info_addr
; /* starting address of unwind info. */
4849 bfd_vma seg_base
; /* Starting address of segment. */
4850 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4851 unsigned long nsyms
; /* Number of symbols. */
4852 char *strtab
; /* The string table. */
4853 unsigned long strtab_size
; /* Size of string table. */
4857 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4858 unsigned long nsyms
,
4860 unsigned long strtab_size
,
4861 struct absaddr addr
,
4862 const char **symname
,
4865 bfd_vma dist
= 0x100000;
4866 Elf_Internal_Sym
*sym
, *best
= NULL
;
4869 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4871 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4872 && sym
->st_name
!= 0
4873 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4874 && addr
.offset
>= sym
->st_value
4875 && addr
.offset
- sym
->st_value
< dist
)
4878 dist
= addr
.offset
- sym
->st_value
;
4885 *symname
= (best
->st_name
>= strtab_size
4886 ? "<corrupt>" : strtab
+ best
->st_name
);
4891 *offset
= addr
.offset
;
4895 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4897 struct ia64_unw_table_entry
*tp
;
4900 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4904 const unsigned char *dp
;
4905 const unsigned char *head
;
4906 const char *procname
;
4908 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4909 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4911 fputs ("\n<", stdout
);
4915 fputs (procname
, stdout
);
4918 printf ("+%lx", (unsigned long) offset
);
4921 fputs (">: [", stdout
);
4922 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4923 fputc ('-', stdout
);
4924 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4925 printf ("], info at +0x%lx\n",
4926 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4928 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4929 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4931 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4932 (unsigned) UNW_VER (stamp
),
4933 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4934 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4935 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4936 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4938 if (UNW_VER (stamp
) != 1)
4940 printf ("\tUnknown version.\n");
4945 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4946 dp
= unw_decode (dp
, in_body
, & in_body
);
4951 slurp_ia64_unwind_table (FILE *file
,
4952 struct ia64_unw_aux_info
*aux
,
4953 Elf_Internal_Shdr
*sec
)
4955 unsigned long size
, nrelas
, i
;
4956 Elf_Internal_Phdr
*seg
;
4957 struct ia64_unw_table_entry
*tep
;
4958 Elf_Internal_Shdr
*relsec
;
4959 Elf_Internal_Rela
*rela
, *rp
;
4960 unsigned char *table
, *tp
;
4961 Elf_Internal_Sym
*sym
;
4962 const char *relname
;
4964 /* First, find the starting address of the segment that includes
4967 if (elf_header
.e_phnum
)
4969 if (! get_program_headers (file
))
4972 for (seg
= program_headers
;
4973 seg
< program_headers
+ elf_header
.e_phnum
;
4976 if (seg
->p_type
!= PT_LOAD
)
4979 if (sec
->sh_addr
>= seg
->p_vaddr
4980 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4982 aux
->seg_base
= seg
->p_vaddr
;
4988 /* Second, build the unwind table from the contents of the unwind section: */
4989 size
= sec
->sh_size
;
4990 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4994 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4996 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4998 tep
->start
.section
= SHN_UNDEF
;
4999 tep
->end
.section
= SHN_UNDEF
;
5000 tep
->info
.section
= SHN_UNDEF
;
5003 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5004 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5005 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5009 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5010 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5011 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5013 tep
->start
.offset
+= aux
->seg_base
;
5014 tep
->end
.offset
+= aux
->seg_base
;
5015 tep
->info
.offset
+= aux
->seg_base
;
5019 /* Third, apply any relocations to the unwind table: */
5021 for (relsec
= section_headers
;
5022 relsec
< section_headers
+ elf_header
.e_shnum
;
5025 if (relsec
->sh_type
!= SHT_RELA
5026 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5027 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5030 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5034 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5038 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5039 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5043 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5044 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5047 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5049 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5053 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5055 switch (rp
->r_offset
/eh_addr_size
% 3)
5058 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5059 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5062 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5063 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5066 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5067 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5077 aux
->table_len
= size
/ (3 * eh_addr_size
);
5082 ia64_process_unwind (FILE *file
)
5084 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5085 unsigned long i
, unwcount
= 0, unwstart
= 0;
5086 struct ia64_unw_aux_info aux
;
5088 memset (& aux
, 0, sizeof (aux
));
5090 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5092 if (sec
->sh_type
== SHT_SYMTAB
5093 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5095 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5096 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5098 strsec
= SECTION_HEADER (sec
->sh_link
);
5099 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5100 1, strsec
->sh_size
, _("string table"));
5101 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5103 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5108 printf (_("\nThere are no unwind sections in this file.\n"));
5110 while (unwcount
-- > 0)
5115 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5116 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5117 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5124 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5126 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5128 /* We need to find which section group it is in. */
5129 struct group_list
*g
= section_headers_groups
[i
]->root
;
5131 for (; g
!= NULL
; g
= g
->next
)
5133 sec
= SECTION_HEADER (g
->section_index
);
5135 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5140 i
= elf_header
.e_shnum
;
5142 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5144 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5145 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5146 suffix
= SECTION_NAME (unwsec
) + len
;
5147 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5149 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5150 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5155 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5156 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5157 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5158 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5160 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5161 suffix
= SECTION_NAME (unwsec
) + len
;
5162 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5164 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5165 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5169 if (i
== elf_header
.e_shnum
)
5171 printf (_("\nCould not find unwind info section for "));
5173 if (string_table
== NULL
)
5174 printf ("%d", unwsec
->sh_name
);
5176 printf (_("'%s'"), SECTION_NAME (unwsec
));
5180 aux
.info_size
= sec
->sh_size
;
5181 aux
.info_addr
= sec
->sh_addr
;
5182 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5185 printf (_("\nUnwind section "));
5187 if (string_table
== NULL
)
5188 printf ("%d", unwsec
->sh_name
);
5190 printf (_("'%s'"), SECTION_NAME (unwsec
));
5192 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5193 (unsigned long) unwsec
->sh_offset
,
5194 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5196 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5198 if (aux
.table_len
> 0)
5199 dump_ia64_unwind (& aux
);
5202 free ((char *) aux
.table
);
5204 free ((char *) aux
.info
);
5213 free ((char *) aux
.strtab
);
5218 struct hppa_unw_aux_info
5220 struct hppa_unw_table_entry
5222 struct absaddr start
;
5224 unsigned int Cannot_unwind
:1; /* 0 */
5225 unsigned int Millicode
:1; /* 1 */
5226 unsigned int Millicode_save_sr0
:1; /* 2 */
5227 unsigned int Region_description
:2; /* 3..4 */
5228 unsigned int reserved1
:1; /* 5 */
5229 unsigned int Entry_SR
:1; /* 6 */
5230 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5231 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5232 unsigned int Args_stored
:1; /* 16 */
5233 unsigned int Variable_Frame
:1; /* 17 */
5234 unsigned int Separate_Package_Body
:1; /* 18 */
5235 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5236 unsigned int Stack_Overflow_Check
:1; /* 20 */
5237 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5238 unsigned int Ada_Region
:1; /* 22 */
5239 unsigned int cxx_info
:1; /* 23 */
5240 unsigned int cxx_try_catch
:1; /* 24 */
5241 unsigned int sched_entry_seq
:1; /* 25 */
5242 unsigned int reserved2
:1; /* 26 */
5243 unsigned int Save_SP
:1; /* 27 */
5244 unsigned int Save_RP
:1; /* 28 */
5245 unsigned int Save_MRP_in_frame
:1; /* 29 */
5246 unsigned int extn_ptr_defined
:1; /* 30 */
5247 unsigned int Cleanup_defined
:1; /* 31 */
5249 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5250 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5251 unsigned int Large_frame
:1; /* 2 */
5252 unsigned int Pseudo_SP_Set
:1; /* 3 */
5253 unsigned int reserved4
:1; /* 4 */
5254 unsigned int Total_frame_size
:27; /* 5..31 */
5256 *table
; /* Unwind table. */
5257 unsigned long table_len
; /* Length of unwind table. */
5258 bfd_vma seg_base
; /* Starting address of segment. */
5259 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5260 unsigned long nsyms
; /* Number of symbols. */
5261 char *strtab
; /* The string table. */
5262 unsigned long strtab_size
; /* Size of string table. */
5266 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5268 struct hppa_unw_table_entry
*tp
;
5270 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5273 const char *procname
;
5275 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5276 aux
->strtab_size
, tp
->start
, &procname
,
5279 fputs ("\n<", stdout
);
5283 fputs (procname
, stdout
);
5286 printf ("+%lx", (unsigned long) offset
);
5289 fputs (">: [", stdout
);
5290 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5291 fputc ('-', stdout
);
5292 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5295 #define PF(_m) if (tp->_m) printf (#_m " ");
5296 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5299 PF(Millicode_save_sr0
);
5300 /* PV(Region_description); */
5306 PF(Separate_Package_Body
);
5307 PF(Frame_Extension_Millicode
);
5308 PF(Stack_Overflow_Check
);
5309 PF(Two_Instruction_SP_Increment
);
5313 PF(sched_entry_seq
);
5316 PF(Save_MRP_in_frame
);
5317 PF(extn_ptr_defined
);
5318 PF(Cleanup_defined
);
5319 PF(MPE_XL_interrupt_marker
);
5320 PF(HP_UX_interrupt_marker
);
5323 PV(Total_frame_size
);
5332 slurp_hppa_unwind_table (FILE *file
,
5333 struct hppa_unw_aux_info
*aux
,
5334 Elf_Internal_Shdr
*sec
)
5336 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5337 Elf_Internal_Phdr
*seg
;
5338 struct hppa_unw_table_entry
*tep
;
5339 Elf_Internal_Shdr
*relsec
;
5340 Elf_Internal_Rela
*rela
, *rp
;
5341 unsigned char *table
, *tp
;
5342 Elf_Internal_Sym
*sym
;
5343 const char *relname
;
5345 /* First, find the starting address of the segment that includes
5348 if (elf_header
.e_phnum
)
5350 if (! get_program_headers (file
))
5353 for (seg
= program_headers
;
5354 seg
< program_headers
+ elf_header
.e_phnum
;
5357 if (seg
->p_type
!= PT_LOAD
)
5360 if (sec
->sh_addr
>= seg
->p_vaddr
5361 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5363 aux
->seg_base
= seg
->p_vaddr
;
5369 /* Second, build the unwind table from the contents of the unwind
5371 size
= sec
->sh_size
;
5372 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5377 nentries
= size
/ unw_ent_size
;
5378 size
= unw_ent_size
* nentries
;
5380 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5382 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5384 unsigned int tmp1
, tmp2
;
5386 tep
->start
.section
= SHN_UNDEF
;
5387 tep
->end
.section
= SHN_UNDEF
;
5389 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5390 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5391 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5392 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5394 tep
->start
.offset
+= aux
->seg_base
;
5395 tep
->end
.offset
+= aux
->seg_base
;
5397 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5398 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5399 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5400 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5401 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5402 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5403 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5404 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5405 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5406 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5407 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5408 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5409 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5410 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5411 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5412 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5413 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5414 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5415 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5416 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5417 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5418 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5419 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5420 tep
->Cleanup_defined
= tmp1
& 0x1;
5422 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5423 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5424 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5425 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5426 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5427 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5431 /* Third, apply any relocations to the unwind table. */
5433 for (relsec
= section_headers
;
5434 relsec
< section_headers
+ elf_header
.e_shnum
;
5437 if (relsec
->sh_type
!= SHT_RELA
5438 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5439 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5442 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5446 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5450 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5451 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5455 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5456 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5459 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5460 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5462 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5466 i
= rp
->r_offset
/ unw_ent_size
;
5468 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5471 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5472 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5475 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5476 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5486 aux
->table_len
= nentries
;
5492 hppa_process_unwind (FILE *file
)
5494 struct hppa_unw_aux_info aux
;
5495 Elf_Internal_Shdr
*unwsec
= NULL
;
5496 Elf_Internal_Shdr
*strsec
;
5497 Elf_Internal_Shdr
*sec
;
5500 memset (& aux
, 0, sizeof (aux
));
5502 if (string_table
== NULL
)
5505 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5507 if (sec
->sh_type
== SHT_SYMTAB
5508 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5510 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5511 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5513 strsec
= SECTION_HEADER (sec
->sh_link
);
5514 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5515 1, strsec
->sh_size
, _("string table"));
5516 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5518 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5523 printf (_("\nThere are no unwind sections in this file.\n"));
5525 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5527 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5529 printf (_("\nUnwind section "));
5530 printf (_("'%s'"), SECTION_NAME (sec
));
5532 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5533 (unsigned long) sec
->sh_offset
,
5534 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5536 slurp_hppa_unwind_table (file
, &aux
, sec
);
5537 if (aux
.table_len
> 0)
5538 dump_hppa_unwind (&aux
);
5541 free ((char *) aux
.table
);
5549 free ((char *) aux
.strtab
);
5555 process_unwind (FILE *file
)
5557 struct unwind_handler
{
5559 int (*handler
)(FILE *file
);
5561 { EM_IA_64
, ia64_process_unwind
},
5562 { EM_PARISC
, hppa_process_unwind
},
5570 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5571 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5572 return handlers
[i
].handler (file
);
5574 printf (_("\nThere are no unwind sections in this file.\n"));
5579 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5581 switch (entry
->d_tag
)
5584 if (entry
->d_un
.d_val
== 0)
5588 static const char * opts
[] =
5590 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5591 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5592 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5593 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5598 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5599 if (entry
->d_un
.d_val
& (1 << cnt
))
5601 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5608 case DT_MIPS_IVERSION
:
5609 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5610 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5612 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5615 case DT_MIPS_TIME_STAMP
:
5620 time_t time
= entry
->d_un
.d_val
;
5621 tmp
= gmtime (&time
);
5622 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5623 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5624 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5625 printf ("Time Stamp: %s\n", timebuf
);
5629 case DT_MIPS_RLD_VERSION
:
5630 case DT_MIPS_LOCAL_GOTNO
:
5631 case DT_MIPS_CONFLICTNO
:
5632 case DT_MIPS_LIBLISTNO
:
5633 case DT_MIPS_SYMTABNO
:
5634 case DT_MIPS_UNREFEXTNO
:
5635 case DT_MIPS_HIPAGENO
:
5636 case DT_MIPS_DELTA_CLASS_NO
:
5637 case DT_MIPS_DELTA_INSTANCE_NO
:
5638 case DT_MIPS_DELTA_RELOC_NO
:
5639 case DT_MIPS_DELTA_SYM_NO
:
5640 case DT_MIPS_DELTA_CLASSSYM_NO
:
5641 case DT_MIPS_COMPACT_SIZE
:
5642 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5646 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5652 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5654 switch (entry
->d_tag
)
5656 case DT_HP_DLD_FLAGS
:
5665 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5666 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5667 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5668 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5669 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5670 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5671 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5672 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5673 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5674 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5675 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5676 { DT_HP_GST
, "HP_GST" },
5677 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5678 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5679 { DT_HP_NODELETE
, "HP_NODELETE" },
5680 { DT_HP_GROUP
, "HP_GROUP" },
5681 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5685 bfd_vma val
= entry
->d_un
.d_val
;
5687 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5688 if (val
& flags
[cnt
].bit
)
5692 fputs (flags
[cnt
].str
, stdout
);
5694 val
^= flags
[cnt
].bit
;
5697 if (val
!= 0 || first
)
5701 print_vma (val
, HEX
);
5707 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5714 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5716 switch (entry
->d_tag
)
5718 case DT_IA_64_PLT_RESERVE
:
5719 /* First 3 slots reserved. */
5720 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5722 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5726 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5733 get_32bit_dynamic_section (FILE *file
)
5735 Elf32_External_Dyn
*edyn
, *ext
;
5736 Elf_Internal_Dyn
*entry
;
5738 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5739 _("dynamic section"));
5743 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5744 might not have the luxury of section headers. Look for the DT_NULL
5745 terminator to determine the number of entries. */
5746 for (ext
= edyn
, dynamic_nent
= 0;
5747 (char *) ext
< (char *) edyn
+ dynamic_size
;
5751 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5755 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5756 if (dynamic_section
== NULL
)
5758 error (_("Out of memory\n"));
5763 for (ext
= edyn
, entry
= dynamic_section
;
5764 entry
< dynamic_section
+ dynamic_nent
;
5767 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5768 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5777 get_64bit_dynamic_section (FILE *file
)
5779 Elf64_External_Dyn
*edyn
, *ext
;
5780 Elf_Internal_Dyn
*entry
;
5782 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5783 _("dynamic section"));
5787 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5788 might not have the luxury of section headers. Look for the DT_NULL
5789 terminator to determine the number of entries. */
5790 for (ext
= edyn
, dynamic_nent
= 0;
5791 (char *) ext
< (char *) edyn
+ dynamic_size
;
5795 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5799 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5800 if (dynamic_section
== NULL
)
5802 error (_("Out of memory\n"));
5807 for (ext
= edyn
, entry
= dynamic_section
;
5808 entry
< dynamic_section
+ dynamic_nent
;
5811 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5812 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5821 print_dynamic_flags (bfd_vma flags
)
5829 flag
= flags
& - flags
;
5839 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5840 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5841 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5842 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5843 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5844 default: fputs ("unknown", stdout
); break;
5850 /* Parse and display the contents of the dynamic section. */
5853 process_dynamic_section (FILE *file
)
5855 Elf_Internal_Dyn
*entry
;
5857 if (dynamic_size
== 0)
5860 printf (_("\nThere is no dynamic section in this file.\n"));
5867 if (! get_32bit_dynamic_section (file
))
5870 else if (! get_64bit_dynamic_section (file
))
5873 /* Find the appropriate symbol table. */
5874 if (dynamic_symbols
== NULL
)
5876 for (entry
= dynamic_section
;
5877 entry
< dynamic_section
+ dynamic_nent
;
5880 Elf_Internal_Shdr section
;
5882 if (entry
->d_tag
!= DT_SYMTAB
)
5885 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5887 /* Since we do not know how big the symbol table is,
5888 we default to reading in the entire file (!) and
5889 processing that. This is overkill, I know, but it
5891 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5893 if (archive_file_offset
!= 0)
5894 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5897 if (fseek (file
, 0, SEEK_END
))
5898 error (_("Unable to seek to end of file!\n"));
5900 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5904 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5906 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5908 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5909 if (num_dynamic_syms
< 1)
5911 error (_("Unable to determine the number of symbols to load\n"));
5915 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5919 /* Similarly find a string table. */
5920 if (dynamic_strings
== NULL
)
5922 for (entry
= dynamic_section
;
5923 entry
< dynamic_section
+ dynamic_nent
;
5926 unsigned long offset
;
5929 if (entry
->d_tag
!= DT_STRTAB
)
5932 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5934 /* Since we do not know how big the string table is,
5935 we default to reading in the entire file (!) and
5936 processing that. This is overkill, I know, but it
5939 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5941 if (archive_file_offset
!= 0)
5942 str_tab_len
= archive_file_size
- offset
;
5945 if (fseek (file
, 0, SEEK_END
))
5946 error (_("Unable to seek to end of file\n"));
5947 str_tab_len
= ftell (file
) - offset
;
5950 if (str_tab_len
< 1)
5953 (_("Unable to determine the length of the dynamic string table\n"));
5957 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5958 _("dynamic string table"));
5959 dynamic_strings_length
= str_tab_len
;
5964 /* And find the syminfo section if available. */
5965 if (dynamic_syminfo
== NULL
)
5967 unsigned long syminsz
= 0;
5969 for (entry
= dynamic_section
;
5970 entry
< dynamic_section
+ dynamic_nent
;
5973 if (entry
->d_tag
== DT_SYMINENT
)
5975 /* Note: these braces are necessary to avoid a syntax
5976 error from the SunOS4 C compiler. */
5977 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5979 else if (entry
->d_tag
== DT_SYMINSZ
)
5980 syminsz
= entry
->d_un
.d_val
;
5981 else if (entry
->d_tag
== DT_SYMINFO
)
5982 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5986 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5988 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5989 Elf_Internal_Syminfo
*syminfo
;
5991 /* There is a syminfo section. Read the data. */
5992 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5993 syminsz
, _("symbol information"));
5997 dynamic_syminfo
= malloc (syminsz
);
5998 if (dynamic_syminfo
== NULL
)
6000 error (_("Out of memory\n"));
6004 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6005 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6006 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6007 ++syminfo
, ++extsym
)
6009 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6010 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6017 if (do_dynamic
&& dynamic_addr
)
6018 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6019 dynamic_addr
, dynamic_nent
);
6021 printf (_(" Tag Type Name/Value\n"));
6023 for (entry
= dynamic_section
;
6024 entry
< dynamic_section
+ dynamic_nent
;
6032 print_vma (entry
->d_tag
, FULL_HEX
);
6033 dtype
= get_dynamic_type (entry
->d_tag
);
6034 printf (" (%s)%*s", dtype
,
6035 ((is_32bit_elf
? 27 : 19)
6036 - (int) strlen (dtype
)),
6040 switch (entry
->d_tag
)
6044 print_dynamic_flags (entry
->d_un
.d_val
);
6054 switch (entry
->d_tag
)
6057 printf (_("Auxiliary library"));
6061 printf (_("Filter library"));
6065 printf (_("Configuration file"));
6069 printf (_("Dependency audit library"));
6073 printf (_("Audit library"));
6077 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6078 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6082 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6091 printf (_("Flags:"));
6093 if (entry
->d_un
.d_val
== 0)
6094 printf (_(" None\n"));
6097 unsigned long int val
= entry
->d_un
.d_val
;
6099 if (val
& DTF_1_PARINIT
)
6101 printf (" PARINIT");
6102 val
^= DTF_1_PARINIT
;
6104 if (val
& DTF_1_CONFEXP
)
6106 printf (" CONFEXP");
6107 val
^= DTF_1_CONFEXP
;
6110 printf (" %lx", val
);
6119 printf (_("Flags:"));
6121 if (entry
->d_un
.d_val
== 0)
6122 printf (_(" None\n"));
6125 unsigned long int val
= entry
->d_un
.d_val
;
6127 if (val
& DF_P1_LAZYLOAD
)
6129 printf (" LAZYLOAD");
6130 val
^= DF_P1_LAZYLOAD
;
6132 if (val
& DF_P1_GROUPPERM
)
6134 printf (" GROUPPERM");
6135 val
^= DF_P1_GROUPPERM
;
6138 printf (" %lx", val
);
6147 printf (_("Flags:"));
6148 if (entry
->d_un
.d_val
== 0)
6149 printf (_(" None\n"));
6152 unsigned long int val
= entry
->d_un
.d_val
;
6159 if (val
& DF_1_GLOBAL
)
6164 if (val
& DF_1_GROUP
)
6169 if (val
& DF_1_NODELETE
)
6171 printf (" NODELETE");
6172 val
^= DF_1_NODELETE
;
6174 if (val
& DF_1_LOADFLTR
)
6176 printf (" LOADFLTR");
6177 val
^= DF_1_LOADFLTR
;
6179 if (val
& DF_1_INITFIRST
)
6181 printf (" INITFIRST");
6182 val
^= DF_1_INITFIRST
;
6184 if (val
& DF_1_NOOPEN
)
6189 if (val
& DF_1_ORIGIN
)
6194 if (val
& DF_1_DIRECT
)
6199 if (val
& DF_1_TRANS
)
6204 if (val
& DF_1_INTERPOSE
)
6206 printf (" INTERPOSE");
6207 val
^= DF_1_INTERPOSE
;
6209 if (val
& DF_1_NODEFLIB
)
6211 printf (" NODEFLIB");
6212 val
^= DF_1_NODEFLIB
;
6214 if (val
& DF_1_NODUMP
)
6219 if (val
& DF_1_CONLFAT
)
6221 printf (" CONLFAT");
6222 val
^= DF_1_CONLFAT
;
6225 printf (" %lx", val
);
6232 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6234 puts (get_dynamic_type (entry
->d_un
.d_val
));
6254 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6260 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6261 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6267 switch (entry
->d_tag
)
6270 printf (_("Shared library: [%s]"), name
);
6272 if (streq (name
, program_interpreter
))
6273 printf (_(" program interpreter"));
6277 printf (_("Library soname: [%s]"), name
);
6281 printf (_("Library rpath: [%s]"), name
);
6285 printf (_("Library runpath: [%s]"), name
);
6289 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6294 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6307 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6311 case DT_INIT_ARRAYSZ
:
6312 case DT_FINI_ARRAYSZ
:
6313 case DT_GNU_CONFLICTSZ
:
6314 case DT_GNU_LIBLISTSZ
:
6317 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6318 printf (" (bytes)\n");
6328 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6341 if (entry
->d_tag
== DT_USED
6342 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6344 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6348 printf (_("Not needed object: [%s]\n"), name
);
6353 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6359 /* The value of this entry is ignored. */
6364 case DT_GNU_PRELINKED
:
6368 time_t time
= entry
->d_un
.d_val
;
6370 tmp
= gmtime (&time
);
6371 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6372 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6373 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6379 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6382 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6388 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6389 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6394 switch (elf_header
.e_machine
)
6397 case EM_MIPS_RS3_LE
:
6398 dynamic_section_mips_val (entry
);
6401 dynamic_section_parisc_val (entry
);
6404 dynamic_section_ia64_val (entry
);
6407 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6419 get_ver_flags (unsigned int flags
)
6421 static char buff
[32];
6428 if (flags
& VER_FLG_BASE
)
6429 strcat (buff
, "BASE ");
6431 if (flags
& VER_FLG_WEAK
)
6433 if (flags
& VER_FLG_BASE
)
6434 strcat (buff
, "| ");
6436 strcat (buff
, "WEAK ");
6439 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6440 strcat (buff
, "| <unknown>");
6445 /* Display the contents of the version sections. */
6447 process_version_sections (FILE *file
)
6449 Elf_Internal_Shdr
*section
;
6456 for (i
= 0, section
= section_headers
;
6457 i
< elf_header
.e_shnum
;
6460 switch (section
->sh_type
)
6462 case SHT_GNU_verdef
:
6464 Elf_External_Verdef
*edefs
;
6472 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6473 SECTION_NAME (section
), section
->sh_info
);
6475 printf (_(" Addr: 0x"));
6476 printf_vma (section
->sh_addr
);
6477 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6478 (unsigned long) section
->sh_offset
, section
->sh_link
,
6479 SECTION_HEADER_INDEX (section
->sh_link
)
6480 < elf_header
.e_shnum
6481 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6484 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6486 _("version definition section"));
6487 endbuf
= (char *) edefs
+ section
->sh_size
;
6491 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6494 Elf_External_Verdef
*edef
;
6495 Elf_Internal_Verdef ent
;
6496 Elf_External_Verdaux
*eaux
;
6497 Elf_Internal_Verdaux aux
;
6501 vstart
= ((char *) edefs
) + idx
;
6502 if (vstart
+ sizeof (*edef
) > endbuf
)
6505 edef
= (Elf_External_Verdef
*) vstart
;
6507 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6508 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6509 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6510 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6511 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6512 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6513 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6515 printf (_(" %#06x: Rev: %d Flags: %s"),
6516 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6518 printf (_(" Index: %d Cnt: %d "),
6519 ent
.vd_ndx
, ent
.vd_cnt
);
6521 vstart
+= ent
.vd_aux
;
6523 eaux
= (Elf_External_Verdaux
*) vstart
;
6525 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6526 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6528 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6529 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6531 printf (_("Name index: %ld\n"), aux
.vda_name
);
6533 isum
= idx
+ ent
.vd_aux
;
6535 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6537 isum
+= aux
.vda_next
;
6538 vstart
+= aux
.vda_next
;
6540 eaux
= (Elf_External_Verdaux
*) vstart
;
6541 if (vstart
+ sizeof (*eaux
) > endbuf
)
6544 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6545 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6547 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6548 printf (_(" %#06x: Parent %d: %s\n"),
6549 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6551 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6552 isum
, j
, aux
.vda_name
);
6555 printf (_(" Version def aux past end of section\n"));
6559 if (cnt
< section
->sh_info
)
6560 printf (_(" Version definition past end of section\n"));
6566 case SHT_GNU_verneed
:
6568 Elf_External_Verneed
*eneed
;
6575 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6576 SECTION_NAME (section
), section
->sh_info
);
6578 printf (_(" Addr: 0x"));
6579 printf_vma (section
->sh_addr
);
6580 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6581 (unsigned long) section
->sh_offset
, section
->sh_link
,
6582 SECTION_HEADER_INDEX (section
->sh_link
)
6583 < elf_header
.e_shnum
6584 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6587 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6589 _("version need section"));
6590 endbuf
= (char *) eneed
+ section
->sh_size
;
6594 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6596 Elf_External_Verneed
*entry
;
6597 Elf_Internal_Verneed ent
;
6602 vstart
= ((char *) eneed
) + idx
;
6603 if (vstart
+ sizeof (*entry
) > endbuf
)
6606 entry
= (Elf_External_Verneed
*) vstart
;
6608 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6609 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6610 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6611 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6612 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6614 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6616 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6617 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6619 printf (_(" File: %lx"), ent
.vn_file
);
6621 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6623 vstart
+= ent
.vn_aux
;
6625 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6627 Elf_External_Vernaux
*eaux
;
6628 Elf_Internal_Vernaux aux
;
6630 if (vstart
+ sizeof (*eaux
) > endbuf
)
6632 eaux
= (Elf_External_Vernaux
*) vstart
;
6634 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6635 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6636 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6637 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6638 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6640 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6641 printf (_(" %#06x: Name: %s"),
6642 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6644 printf (_(" %#06x: Name index: %lx"),
6645 isum
, aux
.vna_name
);
6647 printf (_(" Flags: %s Version: %d\n"),
6648 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6650 isum
+= aux
.vna_next
;
6651 vstart
+= aux
.vna_next
;
6654 printf (_(" Version need aux past end of section\n"));
6658 if (cnt
< section
->sh_info
)
6659 printf (_(" Version need past end of section\n"));
6665 case SHT_GNU_versym
:
6667 Elf_Internal_Shdr
*link_section
;
6670 unsigned char *edata
;
6671 unsigned short *data
;
6673 Elf_Internal_Sym
*symbols
;
6674 Elf_Internal_Shdr
*string_sec
;
6677 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6680 link_section
= SECTION_HEADER (section
->sh_link
);
6681 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6683 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6684 >= elf_header
.e_shnum
)
6689 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6691 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6693 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6694 string_sec
->sh_size
, _("version string table"));
6698 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6699 SECTION_NAME (section
), total
);
6701 printf (_(" Addr: "));
6702 printf_vma (section
->sh_addr
);
6703 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6704 (unsigned long) section
->sh_offset
, section
->sh_link
,
6705 SECTION_NAME (link_section
));
6707 off
= offset_from_vma (file
,
6708 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6709 total
* sizeof (short));
6710 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6711 _("version symbol data"));
6718 data
= cmalloc (total
, sizeof (short));
6720 for (cnt
= total
; cnt
--;)
6721 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6726 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6729 int check_def
, check_need
;
6732 printf (" %03x:", cnt
);
6734 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6735 switch (data
[cnt
+ j
])
6738 fputs (_(" 0 (*local*) "), stdout
);
6742 fputs (_(" 1 (*global*) "), stdout
);
6746 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6747 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6751 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6752 >= elf_header
.e_shnum
6753 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6756 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6763 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6765 Elf_Internal_Verneed ivn
;
6766 unsigned long offset
;
6768 offset
= offset_from_vma
6769 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6770 sizeof (Elf_External_Verneed
));
6774 Elf_Internal_Vernaux ivna
;
6775 Elf_External_Verneed evn
;
6776 Elf_External_Vernaux evna
;
6777 unsigned long a_off
;
6779 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6782 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6783 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6785 a_off
= offset
+ ivn
.vn_aux
;
6789 get_data (&evna
, file
, a_off
, sizeof (evna
),
6790 1, _("version need aux (2)"));
6792 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6793 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6795 a_off
+= ivna
.vna_next
;
6797 while (ivna
.vna_other
!= data
[cnt
+ j
]
6798 && ivna
.vna_next
!= 0);
6800 if (ivna
.vna_other
== data
[cnt
+ j
])
6802 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6804 if (ivna
.vna_name
>= string_sec
->sh_size
)
6805 name
= _("*invalid*");
6807 name
= strtab
+ ivna
.vna_name
;
6808 nn
+= printf ("(%s%-*s",
6810 12 - (int) strlen (name
),
6816 offset
+= ivn
.vn_next
;
6818 while (ivn
.vn_next
);
6821 if (check_def
&& data
[cnt
+ j
] != 0x8001
6822 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6824 Elf_Internal_Verdef ivd
;
6825 Elf_External_Verdef evd
;
6826 unsigned long offset
;
6828 offset
= offset_from_vma
6829 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6834 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6837 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6838 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6840 offset
+= ivd
.vd_next
;
6842 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6843 && ivd
.vd_next
!= 0);
6845 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6847 Elf_External_Verdaux evda
;
6848 Elf_Internal_Verdaux ivda
;
6850 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6852 get_data (&evda
, file
,
6853 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6855 _("version def aux"));
6857 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6859 if (ivda
.vda_name
>= string_sec
->sh_size
)
6860 name
= _("*invalid*");
6862 name
= strtab
+ ivda
.vda_name
;
6863 nn
+= printf ("(%s%-*s",
6865 12 - (int) strlen (name
),
6871 printf ("%*c", 18 - nn
, ' ');
6889 printf (_("\nNo version information found in this file.\n"));
6895 get_symbol_binding (unsigned int binding
)
6897 static char buff
[32];
6901 case STB_LOCAL
: return "LOCAL";
6902 case STB_GLOBAL
: return "GLOBAL";
6903 case STB_WEAK
: return "WEAK";
6905 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6906 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6908 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6909 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6911 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6917 get_symbol_type (unsigned int type
)
6919 static char buff
[32];
6923 case STT_NOTYPE
: return "NOTYPE";
6924 case STT_OBJECT
: return "OBJECT";
6925 case STT_FUNC
: return "FUNC";
6926 case STT_SECTION
: return "SECTION";
6927 case STT_FILE
: return "FILE";
6928 case STT_COMMON
: return "COMMON";
6929 case STT_TLS
: return "TLS";
6930 case STT_RELC
: return "RELC";
6931 case STT_SRELC
: return "SRELC";
6933 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6935 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6936 return "THUMB_FUNC";
6938 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6941 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6942 return "PARISC_MILLI";
6944 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6946 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6948 if (elf_header
.e_machine
== EM_PARISC
)
6950 if (type
== STT_HP_OPAQUE
)
6952 if (type
== STT_HP_STUB
)
6956 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6959 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6965 get_symbol_visibility (unsigned int visibility
)
6969 case STV_DEFAULT
: return "DEFAULT";
6970 case STV_INTERNAL
: return "INTERNAL";
6971 case STV_HIDDEN
: return "HIDDEN";
6972 case STV_PROTECTED
: return "PROTECTED";
6978 get_mips_symbol_other (unsigned int other
)
6982 case STO_OPTIONAL
: return "OPTIONAL";
6983 case STO_MIPS16
: return "MIPS16";
6984 default: return NULL
;
6989 get_symbol_other (unsigned int other
)
6991 const char * result
= NULL
;
6992 static char buff
[32];
6997 switch (elf_header
.e_machine
)
7000 result
= get_mips_symbol_other (other
);
7008 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7013 get_symbol_index_type (unsigned int type
)
7015 static char buff
[32];
7019 case SHN_UNDEF
: return "UND";
7020 case SHN_ABS
: return "ABS";
7021 case SHN_COMMON
: return "COM";
7023 if (type
== SHN_IA_64_ANSI_COMMON
7024 && elf_header
.e_machine
== EM_IA_64
7025 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7027 else if (elf_header
.e_machine
== EM_X86_64
7028 && type
== SHN_X86_64_LCOMMON
)
7030 else if (type
== SHN_MIPS_SCOMMON
7031 && elf_header
.e_machine
== EM_MIPS
)
7033 else if (type
== SHN_MIPS_SUNDEFINED
7034 && elf_header
.e_machine
== EM_MIPS
)
7036 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7037 sprintf (buff
, "PRC[0x%04x]", type
);
7038 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7039 sprintf (buff
, "OS [0x%04x]", type
);
7040 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
7041 sprintf (buff
, "RSV[0x%04x]", type
);
7043 sprintf (buff
, "%3d", type
);
7051 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7053 unsigned char *e_data
;
7056 e_data
= cmalloc (number
, ent_size
);
7060 error (_("Out of memory\n"));
7064 if (fread (e_data
, ent_size
, number
, file
) != number
)
7066 error (_("Unable to read in dynamic data\n"));
7070 i_data
= cmalloc (number
, sizeof (*i_data
));
7074 error (_("Out of memory\n"));
7080 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7088 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7090 Elf_Internal_Sym
*psym
;
7093 psym
= dynamic_symbols
+ si
;
7095 n
= print_vma (si
, DEC_5
);
7097 fputs (" " + n
, stdout
);
7098 printf (" %3lu: ", hn
);
7099 print_vma (psym
->st_value
, LONG_HEX
);
7101 print_vma (psym
->st_size
, DEC_5
);
7103 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7104 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7105 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7106 /* Check to see if any other bits in the st_other field are set.
7107 Note - displaying this information disrupts the layout of the
7108 table being generated, but for the moment this case is very
7110 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7111 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7112 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7113 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7114 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7116 printf (" <corrupt: %14ld>", psym
->st_name
);
7120 /* Dump the symbol table. */
7122 process_symbol_table (FILE *file
)
7124 Elf_Internal_Shdr
*section
;
7125 bfd_vma nbuckets
= 0;
7126 bfd_vma nchains
= 0;
7127 bfd_vma
*buckets
= NULL
;
7128 bfd_vma
*chains
= NULL
;
7129 bfd_vma ngnubuckets
= 0;
7130 bfd_vma
*gnubuckets
= NULL
;
7131 bfd_vma
*gnuchains
= NULL
;
7132 bfd_vma gnusymidx
= 0;
7134 if (! do_syms
&& !do_histogram
)
7137 if (dynamic_info
[DT_HASH
]
7139 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7141 unsigned char nb
[8];
7142 unsigned char nc
[8];
7143 int hash_ent_size
= 4;
7145 if ((elf_header
.e_machine
== EM_ALPHA
7146 || elf_header
.e_machine
== EM_S390
7147 || elf_header
.e_machine
== EM_S390_OLD
)
7148 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7152 (archive_file_offset
7153 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7154 sizeof nb
+ sizeof nc
)),
7157 error (_("Unable to seek to start of dynamic information\n"));
7161 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7163 error (_("Failed to read in number of buckets\n"));
7167 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7169 error (_("Failed to read in number of chains\n"));
7173 nbuckets
= byte_get (nb
, hash_ent_size
);
7174 nchains
= byte_get (nc
, hash_ent_size
);
7176 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7177 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7179 if (buckets
== NULL
|| chains
== NULL
)
7183 if (dynamic_info_DT_GNU_HASH
7185 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7187 unsigned char nb
[16];
7188 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7189 bfd_vma buckets_vma
;
7192 (archive_file_offset
7193 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7197 error (_("Unable to seek to start of dynamic information\n"));
7201 if (fread (nb
, 16, 1, file
) != 1)
7203 error (_("Failed to read in number of buckets\n"));
7207 ngnubuckets
= byte_get (nb
, 4);
7208 gnusymidx
= byte_get (nb
+ 4, 4);
7209 bitmaskwords
= byte_get (nb
+ 8, 4);
7210 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7212 buckets_vma
+= bitmaskwords
* 4;
7214 buckets_vma
+= bitmaskwords
* 8;
7217 (archive_file_offset
7218 + offset_from_vma (file
, buckets_vma
, 4)),
7221 error (_("Unable to seek to start of dynamic information\n"));
7225 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7227 if (gnubuckets
== NULL
)
7230 for (i
= 0; i
< ngnubuckets
; i
++)
7231 if (gnubuckets
[i
] != 0)
7233 if (gnubuckets
[i
] < gnusymidx
)
7236 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7237 maxchain
= gnubuckets
[i
];
7240 if (maxchain
== 0xffffffff)
7243 maxchain
-= gnusymidx
;
7246 (archive_file_offset
7247 + offset_from_vma (file
, buckets_vma
7248 + 4 * (ngnubuckets
+ maxchain
), 4)),
7251 error (_("Unable to seek to start of dynamic information\n"));
7257 if (fread (nb
, 4, 1, file
) != 1)
7259 error (_("Failed to determine last chain length\n"));
7263 if (maxchain
+ 1 == 0)
7268 while ((byte_get (nb
, 4) & 1) == 0);
7271 (archive_file_offset
7272 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7275 error (_("Unable to seek to start of dynamic information\n"));
7279 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7281 if (gnuchains
== NULL
)
7285 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7288 && dynamic_strings
!= NULL
)
7292 if (dynamic_info
[DT_HASH
])
7296 printf (_("\nSymbol table for image:\n"));
7298 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7300 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7302 for (hn
= 0; hn
< nbuckets
; hn
++)
7307 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7308 print_dynamic_symbol (si
, hn
);
7312 if (dynamic_info_DT_GNU_HASH
)
7314 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7316 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7318 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7320 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7321 if (gnubuckets
[hn
] != 0)
7323 bfd_vma si
= gnubuckets
[hn
];
7324 bfd_vma off
= si
- gnusymidx
;
7328 print_dynamic_symbol (si
, hn
);
7331 while ((gnuchains
[off
++] & 1) == 0);
7335 else if (do_syms
&& !do_using_dynamic
)
7339 for (i
= 0, section
= section_headers
;
7340 i
< elf_header
.e_shnum
;
7344 char *strtab
= NULL
;
7345 unsigned long int strtab_size
= 0;
7346 Elf_Internal_Sym
*symtab
;
7347 Elf_Internal_Sym
*psym
;
7350 if ( section
->sh_type
!= SHT_SYMTAB
7351 && section
->sh_type
!= SHT_DYNSYM
)
7354 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7355 SECTION_NAME (section
),
7356 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7358 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7360 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7362 symtab
= GET_ELF_SYMBOLS (file
, section
);
7366 if (section
->sh_link
== elf_header
.e_shstrndx
)
7368 strtab
= string_table
;
7369 strtab_size
= string_table_length
;
7371 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7373 Elf_Internal_Shdr
*string_sec
;
7375 string_sec
= SECTION_HEADER (section
->sh_link
);
7377 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7378 1, string_sec
->sh_size
, _("string table"));
7379 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7382 for (si
= 0, psym
= symtab
;
7383 si
< section
->sh_size
/ section
->sh_entsize
;
7386 printf ("%6d: ", si
);
7387 print_vma (psym
->st_value
, LONG_HEX
);
7389 print_vma (psym
->st_size
, DEC_5
);
7390 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7391 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7392 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7393 /* Check to see if any other bits in the st_other field are set.
7394 Note - displaying this information disrupts the layout of the
7395 table being generated, but for the moment this case is very rare. */
7396 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7397 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7398 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7399 print_symbol (25, psym
->st_name
< strtab_size
7400 ? strtab
+ psym
->st_name
: "<corrupt>");
7402 if (section
->sh_type
== SHT_DYNSYM
&&
7403 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7405 unsigned char data
[2];
7406 unsigned short vers_data
;
7407 unsigned long offset
;
7411 offset
= offset_from_vma
7412 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7413 sizeof data
+ si
* sizeof (vers_data
));
7415 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7416 sizeof (data
), 1, _("version data"));
7418 vers_data
= byte_get (data
, 2);
7420 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7421 < elf_header
.e_shnum
7422 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7425 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7427 if ((vers_data
& 0x8000) || vers_data
> 1)
7429 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7430 && (is_nobits
|| ! check_def
))
7432 Elf_External_Verneed evn
;
7433 Elf_Internal_Verneed ivn
;
7434 Elf_Internal_Vernaux ivna
;
7436 /* We must test both. */
7437 offset
= offset_from_vma
7438 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7443 unsigned long vna_off
;
7445 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7448 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7449 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7451 vna_off
= offset
+ ivn
.vn_aux
;
7455 Elf_External_Vernaux evna
;
7457 get_data (&evna
, file
, vna_off
,
7459 _("version need aux (3)"));
7461 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7462 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7463 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7465 vna_off
+= ivna
.vna_next
;
7467 while (ivna
.vna_other
!= vers_data
7468 && ivna
.vna_next
!= 0);
7470 if (ivna
.vna_other
== vers_data
)
7473 offset
+= ivn
.vn_next
;
7475 while (ivn
.vn_next
!= 0);
7477 if (ivna
.vna_other
== vers_data
)
7480 ivna
.vna_name
< strtab_size
7481 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7485 else if (! is_nobits
)
7486 error (_("bad dynamic symbol\n"));
7493 if (vers_data
!= 0x8001
7494 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7496 Elf_Internal_Verdef ivd
;
7497 Elf_Internal_Verdaux ivda
;
7498 Elf_External_Verdaux evda
;
7499 unsigned long offset
;
7501 offset
= offset_from_vma
7503 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7504 sizeof (Elf_External_Verdef
));
7508 Elf_External_Verdef evd
;
7510 get_data (&evd
, file
, offset
, sizeof (evd
),
7511 1, _("version def"));
7513 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7514 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7515 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7517 offset
+= ivd
.vd_next
;
7519 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7520 && ivd
.vd_next
!= 0);
7522 offset
-= ivd
.vd_next
;
7523 offset
+= ivd
.vd_aux
;
7525 get_data (&evda
, file
, offset
, sizeof (evda
),
7526 1, _("version def aux"));
7528 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7530 if (psym
->st_name
!= ivda
.vda_name
)
7531 printf ((vers_data
& 0x8000)
7533 ivda
.vda_name
< strtab_size
7534 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7544 if (strtab
!= string_table
)
7550 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7552 if (do_histogram
&& buckets
!= NULL
)
7554 unsigned long *lengths
;
7555 unsigned long *counts
;
7558 unsigned long maxlength
= 0;
7559 unsigned long nzero_counts
= 0;
7560 unsigned long nsyms
= 0;
7562 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7563 (unsigned long) nbuckets
);
7564 printf (_(" Length Number %% of total Coverage\n"));
7566 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7567 if (lengths
== NULL
)
7569 error (_("Out of memory\n"));
7572 for (hn
= 0; hn
< nbuckets
; ++hn
)
7574 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7577 if (maxlength
< ++lengths
[hn
])
7582 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7585 error (_("Out of memory\n"));
7589 for (hn
= 0; hn
< nbuckets
; ++hn
)
7590 ++counts
[lengths
[hn
]];
7595 printf (" 0 %-10lu (%5.1f%%)\n",
7596 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7597 for (i
= 1; i
<= maxlength
; ++i
)
7599 nzero_counts
+= counts
[i
] * i
;
7600 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7601 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7602 (nzero_counts
* 100.0) / nsyms
);
7610 if (buckets
!= NULL
)
7616 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7618 unsigned long *lengths
;
7619 unsigned long *counts
;
7621 unsigned long maxlength
= 0;
7622 unsigned long nzero_counts
= 0;
7623 unsigned long nsyms
= 0;
7625 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7626 if (lengths
== NULL
)
7628 error (_("Out of memory\n"));
7632 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7633 (unsigned long) ngnubuckets
);
7634 printf (_(" Length Number %% of total Coverage\n"));
7636 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7637 if (gnubuckets
[hn
] != 0)
7639 bfd_vma off
, length
= 1;
7641 for (off
= gnubuckets
[hn
] - gnusymidx
;
7642 (gnuchains
[off
] & 1) == 0; ++off
)
7644 lengths
[hn
] = length
;
7645 if (length
> maxlength
)
7650 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7653 error (_("Out of memory\n"));
7657 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7658 ++counts
[lengths
[hn
]];
7660 if (ngnubuckets
> 0)
7663 printf (" 0 %-10lu (%5.1f%%)\n",
7664 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7665 for (j
= 1; j
<= maxlength
; ++j
)
7667 nzero_counts
+= counts
[j
] * j
;
7668 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7669 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7670 (nzero_counts
* 100.0) / nsyms
);
7684 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7688 if (dynamic_syminfo
== NULL
7690 /* No syminfo, this is ok. */
7693 /* There better should be a dynamic symbol section. */
7694 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7698 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7699 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7701 printf (_(" Num: Name BoundTo Flags\n"));
7702 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7704 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7706 printf ("%4d: ", i
);
7707 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7708 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7710 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7713 switch (dynamic_syminfo
[i
].si_boundto
)
7715 case SYMINFO_BT_SELF
:
7716 fputs ("SELF ", stdout
);
7718 case SYMINFO_BT_PARENT
:
7719 fputs ("PARENT ", stdout
);
7722 if (dynamic_syminfo
[i
].si_boundto
> 0
7723 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7724 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7726 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7730 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7734 if (flags
& SYMINFO_FLG_DIRECT
)
7736 if (flags
& SYMINFO_FLG_PASSTHRU
)
7737 printf (" PASSTHRU");
7738 if (flags
& SYMINFO_FLG_COPY
)
7740 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7741 printf (" LAZYLOAD");
7749 #ifdef SUPPORT_DISASSEMBLY
7751 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7753 printf (_("\nAssembly dump of section %s\n"),
7754 SECTION_NAME (section
));
7756 /* XXX -- to be done --- XXX */
7763 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7765 Elf_Internal_Shdr
*relsec
;
7766 bfd_size_type num_bytes
;
7771 char *name
= SECTION_NAME (section
);
7772 bfd_boolean some_strings_shown
;
7774 num_bytes
= section
->sh_size
;
7776 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7778 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7782 addr
= section
->sh_addr
;
7784 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7789 printf (_("\nString dump of section '%s':\n"), name
);
7791 /* If the section being dumped has relocations against it the user might
7792 be expecting these relocations to have been applied. Check for this
7793 case and issue a warning message in order to avoid confusion.
7794 FIXME: Maybe we ought to have an option that dumps a section with
7796 for (relsec
= section_headers
;
7797 relsec
< section_headers
+ elf_header
.e_shnum
;
7800 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7801 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7802 || SECTION_HEADER (relsec
->sh_info
) != section
7803 || relsec
->sh_size
== 0
7804 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7807 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7812 end
= start
+ num_bytes
;
7813 some_strings_shown
= FALSE
;
7817 while (!ISPRINT (* data
))
7823 printf (" [%6tx] %s\n", data
- start
, data
);
7824 data
+= strlen (data
);
7825 some_strings_shown
= TRUE
;
7829 if (! some_strings_shown
)
7830 printf (_(" No strings found in this section."));
7840 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
7842 Elf_Internal_Shdr
*relsec
;
7843 bfd_size_type bytes
;
7845 unsigned char *data
;
7846 unsigned char *start
;
7848 bytes
= section
->sh_size
;
7850 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7852 printf (_("\nSection '%s' has no data to dump.\n"),
7853 SECTION_NAME (section
));
7857 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7859 addr
= section
->sh_addr
;
7861 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7866 /* If the section being dumped has relocations against it the user might
7867 be expecting these relocations to have been applied. Check for this
7868 case and issue a warning message in order to avoid confusion.
7869 FIXME: Maybe we ought to have an option that dumps a section with
7871 for (relsec
= section_headers
;
7872 relsec
< section_headers
+ elf_header
.e_shnum
;
7875 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7876 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7877 || SECTION_HEADER (relsec
->sh_info
) != section
7878 || relsec
->sh_size
== 0
7879 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7882 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7894 lbytes
= (bytes
> 16 ? 16 : bytes
);
7896 printf (" 0x%8.8lx ", (unsigned long) addr
);
7898 for (j
= 0; j
< 16; j
++)
7901 printf ("%2.2x", data
[j
]);
7909 for (j
= 0; j
< lbytes
; j
++)
7912 if (k
>= ' ' && k
< 0x7f)
7931 /* Return the number of bytes affected by a given reloc.
7932 This information is architecture and reloc dependent.
7933 Returns 4 by default, although this is not always correct.
7934 It should return 0 if a decision cannot be made.
7935 FIXME: This is not the correct way to solve this problem.
7936 The proper way is to have target specific reloc sizing functions
7937 created by the reloc-macros.h header, in the same way that it
7938 already creates the reloc naming functions. */
7941 get_reloc_size (Elf_Internal_Rela
* reloc
)
7943 switch (elf_header
.e_machine
)
7949 switch (ELF32_R_TYPE (reloc
->r_info
))
7951 /* PR gas/3800 - without this information we do not correctly
7952 decode the debug information generated by the h8300 assembler. */
7959 /* FIXME: We need to extend this switch statement to cope with other
7960 architecture's relocs. (When those relocs are used against debug
7961 sections, and when their size is not 4). But see the multiple
7962 inclusions of <elf/h8.h> for an example of the hoops that we need
7963 to jump through in order to obtain the reloc numbers. */
7968 /* Apply addends of RELA relocations. */
7971 debug_apply_rela_addends (void *file
,
7972 Elf_Internal_Shdr
*section
,
7973 unsigned char *start
)
7975 Elf_Internal_Shdr
*relsec
;
7976 unsigned char *end
= start
+ section
->sh_size
;
7978 if (!is_relocatable
)
7981 /* SH uses RELA but uses in place value instead of the addend field. */
7982 if (elf_header
.e_machine
== EM_SH
)
7985 for (relsec
= section_headers
;
7986 relsec
< section_headers
+ elf_header
.e_shnum
;
7989 unsigned long nrelas
;
7990 Elf_Internal_Rela
*rela
, *rp
;
7991 Elf_Internal_Shdr
*symsec
;
7992 Elf_Internal_Sym
*symtab
;
7993 Elf_Internal_Sym
*sym
;
7995 if (relsec
->sh_type
!= SHT_RELA
7996 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7997 || SECTION_HEADER (relsec
->sh_info
) != section
7998 || relsec
->sh_size
== 0
7999 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
8002 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8006 symsec
= SECTION_HEADER (relsec
->sh_link
);
8007 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8009 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8012 unsigned int reloc_size
;
8014 reloc_size
= get_reloc_size (rp
);
8015 if (reloc_size
== 0)
8017 warn (_("skipping relocation of unknown size against offset 0x%lx in section %s\n"),
8018 (unsigned long) rp
->r_offset
,
8019 SECTION_NAME (section
));
8023 loc
= start
+ rp
->r_offset
;
8024 if ((loc
+ reloc_size
) > end
)
8026 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8027 (unsigned long) rp
->r_offset
,
8028 SECTION_NAME (section
));
8034 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8036 if (ELF32_R_SYM (rp
->r_info
) != 0
8037 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
8038 /* Relocations against symbols without type can happen.
8039 Gcc -feliminate-dwarf2-dups may generate symbols
8040 without type for debug info. */
8041 && ELF32_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8042 /* Relocations against object symbols can happen,
8043 eg when referencing a global array. For an
8044 example of this see the _clz.o binary in libgcc.a. */
8045 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8047 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
8048 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
8049 SECTION_NAME (section
));
8055 /* In MIPS little-endian objects, r_info isn't really a
8056 64-bit little-endian value: it has a 32-bit little-endian
8057 symbol index followed by four individual byte fields.
8058 Reorder INFO accordingly. */
8059 if (elf_header
.e_machine
== EM_MIPS
8060 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
8061 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
8062 | ((rp
->r_info
>> 56) & 0xff)
8063 | ((rp
->r_info
>> 40) & 0xff00)
8064 | ((rp
->r_info
>> 24) & 0xff0000)
8065 | ((rp
->r_info
>> 8) & 0xff000000));
8067 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8069 if (ELF64_R_SYM (rp
->r_info
) != 0
8070 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
8071 && ELF64_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8072 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8074 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
8075 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
8076 SECTION_NAME (section
));
8081 byte_put (loc
, rp
->r_addend
, reloc_size
);
8092 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8094 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8095 Elf_Internal_Shdr
*sec
;
8098 /* If it is already loaded, do nothing. */
8099 if (section
->start
!= NULL
)
8102 /* Locate the debug section. */
8103 sec
= find_section (section
->name
);
8107 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8108 section
->address
= sec
->sh_addr
;
8109 section
->size
= sec
->sh_size
;
8110 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8113 if (debug_displays
[debug
].relocate
)
8114 debug_apply_rela_addends (file
, sec
, section
->start
);
8116 return section
->start
!= NULL
;
8120 free_debug_section (enum dwarf_section_display_enum debug
)
8122 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8124 if (section
->start
== NULL
)
8127 free ((char *) section
->start
);
8128 section
->start
= NULL
;
8129 section
->address
= 0;
8134 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8136 char *name
= SECTION_NAME (section
);
8137 bfd_size_type length
;
8139 enum dwarf_section_display_enum i
;
8141 length
= section
->sh_size
;
8144 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8148 if (const_strneq (name
, ".gnu.linkonce.wi."))
8149 name
= ".debug_info";
8151 /* See if we know how to display the contents of this section. */
8152 for (i
= 0; i
< max
; i
++)
8153 if (streq (debug_displays
[i
].section
.name
, name
))
8155 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8157 if (load_debug_section (i
, file
))
8159 result
&= debug_displays
[i
].display (sec
, file
);
8161 if (i
!= info
&& i
!= abbrev
)
8162 free_debug_section (i
);
8170 printf (_("Unrecognized debug section: %s\n"), name
);
8177 /* Set DUMP_SECTS for all sections where dumps were requested
8178 based on section name. */
8181 initialise_dumps_byname (void)
8183 struct dump_list_entry
*cur
;
8185 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8190 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8191 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8193 request_dump_bynumber (i
, cur
->type
);
8198 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8204 process_section_contents (FILE *file
)
8206 Elf_Internal_Shdr
*section
;
8212 initialise_dumps_byname ();
8214 for (i
= 0, section
= section_headers
;
8215 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8218 #ifdef SUPPORT_DISASSEMBLY
8219 if (dump_sects
[i
] & DISASS_DUMP
)
8220 disassemble_section (section
, file
);
8222 if (dump_sects
[i
] & HEX_DUMP
)
8223 dump_section_as_bytes (section
, file
);
8225 if (dump_sects
[i
] & DEBUG_DUMP
)
8226 display_debug_section (section
, file
);
8228 if (dump_sects
[i
] & STRING_DUMP
)
8229 dump_section_as_strings (section
, file
);
8232 /* Check to see if the user requested a
8233 dump of a section that does not exist. */
8234 while (i
++ < num_dump_sects
)
8236 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8240 process_mips_fpe_exception (int mask
)
8245 if (mask
& OEX_FPU_INEX
)
8246 fputs ("INEX", stdout
), first
= 0;
8247 if (mask
& OEX_FPU_UFLO
)
8248 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8249 if (mask
& OEX_FPU_OFLO
)
8250 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8251 if (mask
& OEX_FPU_DIV0
)
8252 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8253 if (mask
& OEX_FPU_INVAL
)
8254 printf ("%sINVAL", first
? "" : "|");
8257 fputs ("0", stdout
);
8260 /* ARM EABI attributes section. */
8265 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8268 } arm_attr_public_tag
;
8270 static const char *arm_attr_tag_CPU_arch
[] =
8271 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8273 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8274 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8275 {"No", "Thumb-1", "Thumb-2"};
8276 /* FIXME: VFPv3 encoding was extrapolated! */
8277 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8278 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8279 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8280 static const char *arm_attr_tag_ABI_PCS_config
[] =
8281 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8282 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8283 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8284 {"V6", "SB", "TLS", "Unused"};
8285 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8286 {"Absolute", "PC-relative", "SB-relative", "None"};
8287 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8288 {"Absolute", "PC-relative", "None"};
8289 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8290 {"None", "direct", "GOT-indirect"};
8291 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8292 {"None", "??? 1", "2", "??? 3", "4"};
8293 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8294 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8295 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8296 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8297 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8298 {"Unused", "Finite", "RTABI", "IEEE 754"};
8299 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8300 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8301 {"No", "Yes, except leaf SP", "Yes"};
8302 static const char *arm_attr_tag_ABI_enum_size
[] =
8303 {"Unused", "small", "int", "forced to int"};
8304 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8305 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8306 static const char *arm_attr_tag_ABI_VFP_args
[] =
8307 {"AAPCS", "VFP registers", "custom"};
8308 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8309 {"AAPCS", "WMMX registers", "custom"};
8310 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8311 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8312 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8313 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8314 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8315 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8317 #define LOOKUP(id, name) \
8318 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8319 static arm_attr_public_tag arm_attr_public_tags
[] =
8321 {4, "CPU_raw_name", 1, NULL
},
8322 {5, "CPU_name", 1, NULL
},
8323 LOOKUP(6, CPU_arch
),
8324 {7, "CPU_arch_profile", 0, NULL
},
8325 LOOKUP(8, ARM_ISA_use
),
8326 LOOKUP(9, THUMB_ISA_use
),
8327 LOOKUP(10, VFP_arch
),
8328 LOOKUP(11, WMMX_arch
),
8329 LOOKUP(12, NEON_arch
),
8330 LOOKUP(13, ABI_PCS_config
),
8331 LOOKUP(14, ABI_PCS_R9_use
),
8332 LOOKUP(15, ABI_PCS_RW_data
),
8333 LOOKUP(16, ABI_PCS_RO_DATA
),
8334 LOOKUP(17, ABI_PCS_GOT_use
),
8335 LOOKUP(18, ABI_PCS_wchar_t
),
8336 LOOKUP(19, ABI_FP_rounding
),
8337 LOOKUP(20, ABI_FP_denormal
),
8338 LOOKUP(21, ABI_FP_exceptions
),
8339 LOOKUP(22, ABI_FP_user_exceptions
),
8340 LOOKUP(23, ABI_FP_number_model
),
8341 LOOKUP(24, ABI_align8_needed
),
8342 LOOKUP(25, ABI_align8_preserved
),
8343 LOOKUP(26, ABI_enum_size
),
8344 LOOKUP(27, ABI_HardFP_use
),
8345 LOOKUP(28, ABI_VFP_args
),
8346 LOOKUP(29, ABI_WMMX_args
),
8347 LOOKUP(30, ABI_optimization_goals
),
8348 LOOKUP(31, ABI_FP_optimization_goals
),
8349 {32, "compatibility", 0, NULL
}
8353 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8356 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8370 val
|= ((unsigned int)c
& 0x7f) << shift
;
8379 static unsigned char *
8380 display_arm_attribute (unsigned char *p
)
8385 arm_attr_public_tag
*attr
;
8389 tag
= read_uleb128 (p
, &len
);
8392 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8394 if (arm_attr_public_tags
[i
].tag
== tag
)
8396 attr
= &arm_attr_public_tags
[i
];
8403 printf (" Tag_%s: ", attr
->name
);
8409 case 7: /* Tag_CPU_arch_profile. */
8410 val
= read_uleb128 (p
, &len
);
8414 case 0: printf ("None\n"); break;
8415 case 'A': printf ("Application\n"); break;
8416 case 'R': printf ("Realtime\n"); break;
8417 case 'M': printf ("Microcontroller\n"); break;
8418 default: printf ("??? (%d)\n", val
); break;
8422 case 32: /* Tag_compatibility. */
8423 val
= read_uleb128 (p
, &len
);
8425 printf ("flag = %d, vendor = %s\n", val
, p
);
8426 p
+= strlen((char *)p
) + 1;
8440 assert (attr
->type
& 0x80);
8441 val
= read_uleb128 (p
, &len
);
8443 type
= attr
->type
& 0x7f;
8445 printf ("??? (%d)\n", val
);
8447 printf ("%s\n", attr
->table
[val
]);
8454 type
= 1; /* String. */
8456 type
= 2; /* uleb128. */
8457 printf (" Tag_unknown_%d: ", tag
);
8462 printf ("\"%s\"\n", p
);
8463 p
+= strlen((char *)p
) + 1;
8467 val
= read_uleb128 (p
, &len
);
8469 printf ("%d (0x%x)\n", val
, val
);
8475 static unsigned char *
8476 display_gnu_attribute (unsigned char * p
,
8477 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8484 tag
= read_uleb128 (p
, &len
);
8487 /* Tag_compatibility is the only generic GNU attribute defined at
8491 val
= read_uleb128 (p
, &len
);
8493 printf ("flag = %d, vendor = %s\n", val
, p
);
8494 p
+= strlen ((char *) p
) + 1;
8498 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8499 return display_proc_gnu_attribute (p
, tag
);
8502 type
= 1; /* String. */
8504 type
= 2; /* uleb128. */
8505 printf (" Tag_unknown_%d: ", tag
);
8509 printf ("\"%s\"\n", p
);
8510 p
+= strlen ((char *) p
) + 1;
8514 val
= read_uleb128 (p
, &len
);
8516 printf ("%d (0x%x)\n", val
, val
);
8522 static unsigned char *
8523 display_power_gnu_attribute (unsigned char *p
, int tag
)
8529 if (tag
== Tag_GNU_Power_ABI_FP
)
8531 val
= read_uleb128 (p
, &len
);
8533 printf (" Tag_GNU_Power_ABI_FP: ");
8538 printf ("Hard or soft float\n");
8541 printf ("Hard float\n");
8544 printf ("Soft float\n");
8547 printf ("??? (%d)\n", val
);
8554 type
= 1; /* String. */
8556 type
= 2; /* uleb128. */
8557 printf (" Tag_unknown_%d: ", tag
);
8561 printf ("\"%s\"\n", p
);
8562 p
+= strlen ((char *) p
) + 1;
8566 val
= read_uleb128 (p
, &len
);
8568 printf ("%d (0x%x)\n", val
, val
);
8574 static unsigned char *
8575 display_mips_gnu_attribute (unsigned char *p
, int tag
)
8581 if (tag
== Tag_GNU_MIPS_ABI_FP
)
8583 val
= read_uleb128 (p
, &len
);
8585 printf (" Tag_GNU_MIPS_ABI_FP: ");
8590 printf ("Hard or soft float\n");
8593 printf ("Hard float (-mdouble-float)\n");
8596 printf ("Hard float (-msingle-float)\n");
8599 printf ("Soft float\n");
8602 printf ("??? (%d)\n", val
);
8609 type
= 1; /* String. */
8611 type
= 2; /* uleb128. */
8612 printf (" Tag_unknown_%d: ", tag
);
8616 printf ("\"%s\"\n", p
);
8617 p
+= strlen ((char *) p
) + 1;
8621 val
= read_uleb128 (p
, &len
);
8623 printf ("%d (0x%x)\n", val
, val
);
8630 process_attributes (FILE * file
,
8631 const char * public_name
,
8632 unsigned int proc_type
,
8633 unsigned char * (* display_pub_attribute
) (unsigned char *),
8634 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8636 Elf_Internal_Shdr
*sect
;
8637 unsigned char *contents
;
8640 bfd_vma section_len
;
8644 /* Find the section header so that we get the size. */
8645 for (i
= 0, sect
= section_headers
;
8646 i
< elf_header
.e_shnum
;
8649 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
8652 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
8654 if (contents
== NULL
)
8660 len
= sect
->sh_size
- 1;
8666 bfd_boolean public_section
;
8667 bfd_boolean gnu_section
;
8669 section_len
= byte_get (p
, 4);
8672 if (section_len
> len
)
8674 printf (_("ERROR: Bad section length (%d > %d)\n"),
8675 (int) section_len
, (int) len
);
8680 printf ("Attribute Section: %s\n", p
);
8682 if (public_name
&& streq ((char *) p
, public_name
))
8683 public_section
= TRUE
;
8685 public_section
= FALSE
;
8687 if (streq ((char *) p
, "gnu"))
8690 gnu_section
= FALSE
;
8692 namelen
= strlen ((char *) p
) + 1;
8694 section_len
-= namelen
+ 4;
8696 while (section_len
> 0)
8702 size
= byte_get (p
, 4);
8703 if (size
> section_len
)
8705 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8706 (int) size
, (int) section_len
);
8710 section_len
-= size
;
8717 printf ("File Attributes\n");
8720 printf ("Section Attributes:");
8723 printf ("Symbol Attributes:");
8729 val
= read_uleb128 (p
, &i
);
8733 printf (" %d", val
);
8738 printf ("Unknown tag: %d\n", tag
);
8739 public_section
= FALSE
;
8746 p
= display_pub_attribute (p
);
8748 else if (gnu_section
)
8751 p
= display_gnu_attribute (p
,
8752 display_proc_gnu_attribute
);
8756 /* ??? Do something sensible, like dump hex. */
8757 printf (" Unknown section contexts\n");
8764 printf (_("Unknown format '%c'\n"), *p
);
8772 process_arm_specific (FILE *file
)
8774 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
8775 display_arm_attribute
, NULL
);
8779 process_power_specific (FILE *file
)
8781 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
8782 display_power_gnu_attribute
);
8786 process_mips_specific (FILE *file
)
8788 Elf_Internal_Dyn
*entry
;
8789 size_t liblist_offset
= 0;
8790 size_t liblistno
= 0;
8791 size_t conflictsno
= 0;
8792 size_t options_offset
= 0;
8793 size_t conflicts_offset
= 0;
8795 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
8796 display_mips_gnu_attribute
);
8798 /* We have a lot of special sections. Thanks SGI! */
8799 if (dynamic_section
== NULL
)
8800 /* No information available. */
8803 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
8804 switch (entry
->d_tag
)
8806 case DT_MIPS_LIBLIST
:
8808 = offset_from_vma (file
, entry
->d_un
.d_val
,
8809 liblistno
* sizeof (Elf32_External_Lib
));
8811 case DT_MIPS_LIBLISTNO
:
8812 liblistno
= entry
->d_un
.d_val
;
8814 case DT_MIPS_OPTIONS
:
8815 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8817 case DT_MIPS_CONFLICT
:
8819 = offset_from_vma (file
, entry
->d_un
.d_val
,
8820 conflictsno
* sizeof (Elf32_External_Conflict
));
8822 case DT_MIPS_CONFLICTNO
:
8823 conflictsno
= entry
->d_un
.d_val
;
8829 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8831 Elf32_External_Lib
*elib
;
8834 elib
= get_data (NULL
, file
, liblist_offset
,
8835 liblistno
, sizeof (Elf32_External_Lib
),
8839 printf ("\nSection '.liblist' contains %lu entries:\n",
8840 (unsigned long) liblistno
);
8841 fputs (" Library Time Stamp Checksum Version Flags\n",
8844 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8851 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8852 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8853 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8854 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8855 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8857 tmp
= gmtime (&time
);
8858 snprintf (timebuf
, sizeof (timebuf
),
8859 "%04u-%02u-%02uT%02u:%02u:%02u",
8860 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8861 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8863 printf ("%3lu: ", (unsigned long) cnt
);
8864 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
8865 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
8867 printf ("<corrupt: %9ld>", liblist
.l_name
);
8868 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8871 if (liblist
.l_flags
== 0)
8882 { " EXACT_MATCH", LL_EXACT_MATCH
},
8883 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8884 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8885 { " EXPORTS", LL_EXPORTS
},
8886 { " DELAY_LOAD", LL_DELAY_LOAD
},
8887 { " DELTA", LL_DELTA
}
8889 int flags
= liblist
.l_flags
;
8892 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
8893 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8895 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8896 flags
^= l_flags_vals
[fcnt
].bit
;
8899 printf (" %#x", (unsigned int) flags
);
8909 if (options_offset
!= 0)
8911 Elf_External_Options
*eopt
;
8912 Elf_Internal_Shdr
*sect
= section_headers
;
8913 Elf_Internal_Options
*iopt
;
8914 Elf_Internal_Options
*option
;
8918 /* Find the section header so that we get the size. */
8919 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8922 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8926 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8929 error (_("Out of memory\n"));
8936 while (offset
< sect
->sh_size
)
8938 Elf_External_Options
*eoption
;
8940 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8942 option
->kind
= BYTE_GET (eoption
->kind
);
8943 option
->size
= BYTE_GET (eoption
->size
);
8944 option
->section
= BYTE_GET (eoption
->section
);
8945 option
->info
= BYTE_GET (eoption
->info
);
8947 offset
+= option
->size
;
8953 printf (_("\nSection '%s' contains %d entries:\n"),
8954 SECTION_NAME (sect
), cnt
);
8962 switch (option
->kind
)
8965 /* This shouldn't happen. */
8966 printf (" NULL %d %lx", option
->section
, option
->info
);
8969 printf (" REGINFO ");
8970 if (elf_header
.e_machine
== EM_MIPS
)
8973 Elf32_External_RegInfo
*ereg
;
8974 Elf32_RegInfo reginfo
;
8976 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8977 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8978 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8979 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8980 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8981 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8982 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8984 printf ("GPR %08lx GP 0x%lx\n",
8986 (unsigned long) reginfo
.ri_gp_value
);
8987 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8988 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8989 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8994 Elf64_External_RegInfo
*ereg
;
8995 Elf64_Internal_RegInfo reginfo
;
8997 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8998 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8999 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9000 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9001 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9002 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9003 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9005 printf ("GPR %08lx GP 0x",
9006 reginfo
.ri_gprmask
);
9007 printf_vma (reginfo
.ri_gp_value
);
9010 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9011 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9012 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9016 case ODK_EXCEPTIONS
:
9017 fputs (" EXCEPTIONS fpe_min(", stdout
);
9018 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9019 fputs (") fpe_max(", stdout
);
9020 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9021 fputs (")", stdout
);
9023 if (option
->info
& OEX_PAGE0
)
9024 fputs (" PAGE0", stdout
);
9025 if (option
->info
& OEX_SMM
)
9026 fputs (" SMM", stdout
);
9027 if (option
->info
& OEX_FPDBUG
)
9028 fputs (" FPDBUG", stdout
);
9029 if (option
->info
& OEX_DISMISS
)
9030 fputs (" DISMISS", stdout
);
9033 fputs (" PAD ", stdout
);
9034 if (option
->info
& OPAD_PREFIX
)
9035 fputs (" PREFIX", stdout
);
9036 if (option
->info
& OPAD_POSTFIX
)
9037 fputs (" POSTFIX", stdout
);
9038 if (option
->info
& OPAD_SYMBOL
)
9039 fputs (" SYMBOL", stdout
);
9042 fputs (" HWPATCH ", stdout
);
9043 if (option
->info
& OHW_R4KEOP
)
9044 fputs (" R4KEOP", stdout
);
9045 if (option
->info
& OHW_R8KPFETCH
)
9046 fputs (" R8KPFETCH", stdout
);
9047 if (option
->info
& OHW_R5KEOP
)
9048 fputs (" R5KEOP", stdout
);
9049 if (option
->info
& OHW_R5KCVTL
)
9050 fputs (" R5KCVTL", stdout
);
9053 fputs (" FILL ", stdout
);
9054 /* XXX Print content of info word? */
9057 fputs (" TAGS ", stdout
);
9058 /* XXX Print content of info word? */
9061 fputs (" HWAND ", stdout
);
9062 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9063 fputs (" R4KEOP_CHECKED", stdout
);
9064 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9065 fputs (" R4KEOP_CLEAN", stdout
);
9068 fputs (" HWOR ", stdout
);
9069 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9070 fputs (" R4KEOP_CHECKED", stdout
);
9071 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9072 fputs (" R4KEOP_CLEAN", stdout
);
9075 printf (" GP_GROUP %#06lx self-contained %#06lx",
9076 option
->info
& OGP_GROUP
,
9077 (option
->info
& OGP_SELF
) >> 16);
9080 printf (" IDENT %#06lx self-contained %#06lx",
9081 option
->info
& OGP_GROUP
,
9082 (option
->info
& OGP_SELF
) >> 16);
9085 /* This shouldn't happen. */
9086 printf (" %3d ??? %d %lx",
9087 option
->kind
, option
->section
, option
->info
);
9091 len
= sizeof (*eopt
);
9092 while (len
< option
->size
)
9093 if (((char *) option
)[len
] >= ' '
9094 && ((char *) option
)[len
] < 0x7f)
9095 printf ("%c", ((char *) option
)[len
++]);
9097 printf ("\\%03o", ((char *) option
)[len
++]);
9099 fputs ("\n", stdout
);
9107 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9109 Elf32_Conflict
*iconf
;
9112 if (dynamic_symbols
== NULL
)
9114 error (_("conflict list found without a dynamic symbol table\n"));
9118 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9121 error (_("Out of memory\n"));
9127 Elf32_External_Conflict
*econf32
;
9129 econf32
= get_data (NULL
, file
, conflicts_offset
,
9130 conflictsno
, sizeof (*econf32
), _("conflict"));
9134 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9135 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9141 Elf64_External_Conflict
*econf64
;
9143 econf64
= get_data (NULL
, file
, conflicts_offset
,
9144 conflictsno
, sizeof (*econf64
), _("conflict"));
9148 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9149 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9154 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9155 (unsigned long) conflictsno
);
9156 puts (_(" Num: Index Value Name"));
9158 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9160 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9162 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9163 print_vma (psym
->st_value
, FULL_HEX
);
9165 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9166 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9168 printf ("<corrupt: %14ld>", psym
->st_name
);
9179 process_gnu_liblist (FILE *file
)
9181 Elf_Internal_Shdr
*section
, *string_sec
;
9182 Elf32_External_Lib
*elib
;
9191 for (i
= 0, section
= section_headers
;
9192 i
< elf_header
.e_shnum
;
9195 switch (section
->sh_type
)
9197 case SHT_GNU_LIBLIST
:
9198 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
9201 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9206 string_sec
= SECTION_HEADER (section
->sh_link
);
9208 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9209 string_sec
->sh_size
, _("liblist string table"));
9210 strtab_size
= string_sec
->sh_size
;
9213 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9219 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9220 SECTION_NAME (section
),
9221 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9223 puts (" Library Time Stamp Checksum Version Flags");
9225 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9233 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9234 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9235 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9236 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9237 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9239 tmp
= gmtime (&time
);
9240 snprintf (timebuf
, sizeof (timebuf
),
9241 "%04u-%02u-%02uT%02u:%02u:%02u",
9242 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9243 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9245 printf ("%3lu: ", (unsigned long) cnt
);
9247 printf ("%-20s", liblist
.l_name
< strtab_size
9248 ? strtab
+ liblist
.l_name
: "<corrupt>");
9250 printf ("%-20.20s", liblist
.l_name
< strtab_size
9251 ? strtab
+ liblist
.l_name
: "<corrupt>");
9252 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9253 liblist
.l_version
, liblist
.l_flags
);
9264 get_note_type (unsigned e_type
)
9266 static char buff
[64];
9268 if (elf_header
.e_type
== ET_CORE
)
9272 return _("NT_AUXV (auxiliary vector)");
9274 return _("NT_PRSTATUS (prstatus structure)");
9276 return _("NT_FPREGSET (floating point registers)");
9278 return _("NT_PRPSINFO (prpsinfo structure)");
9280 return _("NT_TASKSTRUCT (task structure)");
9282 return _("NT_PRXFPREG (user_xfpregs structure)");
9284 return _("NT_PSTATUS (pstatus structure)");
9286 return _("NT_FPREGS (floating point registers)");
9288 return _("NT_PSINFO (psinfo structure)");
9290 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9292 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9293 case NT_WIN32PSTATUS
:
9294 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9302 return _("NT_VERSION (version)");
9304 return _("NT_ARCH (architecture)");
9309 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9314 get_gnu_elf_note_type (unsigned e_type
)
9316 static char buff
[64];
9320 case NT_GNU_ABI_TAG
:
9321 return _("NT_GNU_ABI_TAG (ABI version tag)");
9323 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9324 case NT_GNU_BUILD_ID
:
9325 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9330 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9335 get_netbsd_elfcore_note_type (unsigned e_type
)
9337 static char buff
[64];
9339 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9341 /* NetBSD core "procinfo" structure. */
9342 return _("NetBSD procinfo structure");
9345 /* As of Jan 2002 there are no other machine-independent notes
9346 defined for NetBSD core files. If the note type is less
9347 than the start of the machine-dependent note types, we don't
9350 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9352 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9356 switch (elf_header
.e_machine
)
9358 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9359 and PT_GETFPREGS == mach+2. */
9364 case EM_SPARC32PLUS
:
9368 case NT_NETBSDCORE_FIRSTMACH
+0:
9369 return _("PT_GETREGS (reg structure)");
9370 case NT_NETBSDCORE_FIRSTMACH
+2:
9371 return _("PT_GETFPREGS (fpreg structure)");
9377 /* On all other arch's, PT_GETREGS == mach+1 and
9378 PT_GETFPREGS == mach+3. */
9382 case NT_NETBSDCORE_FIRSTMACH
+1:
9383 return _("PT_GETREGS (reg structure)");
9384 case NT_NETBSDCORE_FIRSTMACH
+3:
9385 return _("PT_GETFPREGS (fpreg structure)");
9391 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
9392 e_type
- NT_NETBSDCORE_FIRSTMACH
);
9396 /* Note that by the ELF standard, the name field is already null byte
9397 terminated, and namesz includes the terminating null byte.
9398 I.E. the value of namesz for the name "FSF" is 4.
9400 If the value of namesz is zero, there is no name present. */
9402 process_note (Elf_Internal_Note
*pnote
)
9404 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
9407 if (pnote
->namesz
== 0)
9408 /* If there is no note name, then use the default set of
9409 note type strings. */
9410 nt
= get_note_type (pnote
->type
);
9412 else if (const_strneq (pnote
->namedata
, "GNU"))
9413 /* GNU-specific object file notes. */
9414 nt
= get_gnu_elf_note_type (pnote
->type
);
9416 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
9417 /* NetBSD-specific core file notes. */
9418 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9420 else if (strneq (pnote
->namedata
, "SPU/", 4))
9422 /* SPU-specific core file notes. */
9423 nt
= pnote
->namedata
+ 4;
9428 /* Don't recognize this note name; just use the default set of
9429 note type strings. */
9430 nt
= get_note_type (pnote
->type
);
9432 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
9438 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
9440 Elf_External_Note
*pnotes
;
9441 Elf_External_Note
*external
;
9447 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
9453 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9454 (unsigned long) offset
, (unsigned long) length
);
9455 printf (_(" Owner\t\tData size\tDescription\n"));
9457 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9459 Elf_External_Note
*next
;
9460 Elf_Internal_Note inote
;
9463 inote
.type
= BYTE_GET (external
->type
);
9464 inote
.namesz
= BYTE_GET (external
->namesz
);
9465 inote
.namedata
= external
->name
;
9466 inote
.descsz
= BYTE_GET (external
->descsz
);
9467 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9468 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9470 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9472 if (((char *) next
) > (((char *) pnotes
) + length
))
9474 warn (_("corrupt note found at offset %lx into core notes\n"),
9475 (long)((char *)external
- (char *)pnotes
));
9476 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
9477 inote
.type
, inote
.namesz
, inote
.descsz
);
9483 /* Verify that name is null terminated. It appears that at least
9484 one version of Linux (RedHat 6.0) generates corefiles that don't
9485 comply with the ELF spec by failing to include the null byte in
9487 if (inote
.namedata
[inote
.namesz
] != '\0')
9489 temp
= malloc (inote
.namesz
+ 1);
9493 error (_("Out of memory\n"));
9498 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9499 temp
[inote
.namesz
] = 0;
9501 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9502 inote
.namedata
= temp
;
9505 res
&= process_note (& inote
);
9520 process_corefile_note_segments (FILE *file
)
9522 Elf_Internal_Phdr
*segment
;
9526 if (! get_program_headers (file
))
9529 for (i
= 0, segment
= program_headers
;
9530 i
< elf_header
.e_phnum
;
9533 if (segment
->p_type
== PT_NOTE
)
9534 res
&= process_corefile_note_segment (file
,
9535 (bfd_vma
) segment
->p_offset
,
9536 (bfd_vma
) segment
->p_filesz
);
9543 process_note_sections (FILE *file
)
9545 Elf_Internal_Shdr
*section
;
9549 for (i
= 0, section
= section_headers
;
9550 i
< elf_header
.e_shnum
;
9552 if (section
->sh_type
== SHT_NOTE
)
9553 res
&= process_corefile_note_segment (file
,
9554 (bfd_vma
) section
->sh_offset
,
9555 (bfd_vma
) section
->sh_size
);
9561 process_notes (FILE *file
)
9563 /* If we have not been asked to display the notes then do nothing. */
9567 if (elf_header
.e_type
!= ET_CORE
)
9568 return process_note_sections (file
);
9570 /* No program headers means no NOTE segment. */
9571 if (elf_header
.e_phnum
> 0)
9572 return process_corefile_note_segments (file
);
9574 printf (_("No note segments present in the core file.\n"));
9579 process_arch_specific (FILE *file
)
9584 switch (elf_header
.e_machine
)
9587 return process_arm_specific (file
);
9589 case EM_MIPS_RS3_LE
:
9590 return process_mips_specific (file
);
9593 return process_power_specific (file
);
9602 get_file_header (FILE *file
)
9604 /* Read in the identity array. */
9605 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9608 /* Determine how to read the rest of the header. */
9609 switch (elf_header
.e_ident
[EI_DATA
])
9611 default: /* fall through */
9612 case ELFDATANONE
: /* fall through */
9614 byte_get
= byte_get_little_endian
;
9615 byte_put
= byte_put_little_endian
;
9618 byte_get
= byte_get_big_endian
;
9619 byte_put
= byte_put_big_endian
;
9623 /* For now we only support 32 bit and 64 bit ELF files. */
9624 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9626 /* Read in the rest of the header. */
9629 Elf32_External_Ehdr ehdr32
;
9631 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9634 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9635 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9636 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9637 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9638 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9639 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9640 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9641 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9642 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9643 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9644 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9645 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9646 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9650 Elf64_External_Ehdr ehdr64
;
9652 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9653 we will not be able to cope with the 64bit data found in
9654 64 ELF files. Detect this now and abort before we start
9655 overwriting things. */
9656 if (sizeof (bfd_vma
) < 8)
9658 error (_("This instance of readelf has been built without support for a\n\
9659 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9663 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9666 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9667 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9668 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9669 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
9670 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
9671 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
9672 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9673 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9674 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9675 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9676 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9677 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9678 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9681 if (elf_header
.e_shoff
)
9683 /* There may be some extensions in the first section header. Don't
9684 bomb if we can't read it. */
9686 get_32bit_section_headers (file
, 1);
9688 get_64bit_section_headers (file
, 1);
9691 is_relocatable
= elf_header
.e_type
== ET_REL
;
9696 /* Process one ELF object file according to the command line options.
9697 This file may actually be stored in an archive. The file is
9698 positioned at the start of the ELF object. */
9701 process_object (char *file_name
, FILE *file
)
9705 if (! get_file_header (file
))
9707 error (_("%s: Failed to read file header\n"), file_name
);
9711 /* Initialise per file variables. */
9712 for (i
= ARRAY_SIZE (version_info
); i
--;)
9713 version_info
[i
] = 0;
9715 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
9716 dynamic_info
[i
] = 0;
9718 /* Process the file. */
9720 printf (_("\nFile: %s\n"), file_name
);
9722 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9723 Note we do this even if cmdline_dump_sects is empty because we
9724 must make sure that the dump_sets array is zeroed out before each
9725 object file is processed. */
9726 if (num_dump_sects
> num_cmdline_dump_sects
)
9727 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
9729 if (num_cmdline_dump_sects
> 0)
9731 if (num_dump_sects
== 0)
9732 /* A sneaky way of allocating the dump_sects array. */
9733 request_dump_bynumber (num_cmdline_dump_sects
, 0);
9735 assert (num_dump_sects
>= num_cmdline_dump_sects
);
9736 memcpy (dump_sects
, cmdline_dump_sects
,
9737 num_cmdline_dump_sects
* sizeof (* dump_sects
));
9740 if (! process_file_header ())
9743 if (! process_section_headers (file
))
9745 /* Without loaded section headers we cannot process lots of
9747 do_unwind
= do_version
= do_dump
= do_arch
= 0;
9749 if (! do_using_dynamic
)
9750 do_syms
= do_reloc
= 0;
9753 if (! process_section_groups (file
))
9755 /* Without loaded section groups we cannot process unwind. */
9759 if (process_program_headers (file
))
9760 process_dynamic_section (file
);
9762 process_relocs (file
);
9764 process_unwind (file
);
9766 process_symbol_table (file
);
9768 process_syminfo (file
);
9770 process_version_sections (file
);
9772 process_section_contents (file
);
9774 process_notes (file
);
9776 process_gnu_liblist (file
);
9778 process_arch_specific (file
);
9780 if (program_headers
)
9782 free (program_headers
);
9783 program_headers
= NULL
;
9786 if (section_headers
)
9788 free (section_headers
);
9789 section_headers
= NULL
;
9794 free (string_table
);
9795 string_table
= NULL
;
9796 string_table_length
= 0;
9799 if (dynamic_strings
)
9801 free (dynamic_strings
);
9802 dynamic_strings
= NULL
;
9803 dynamic_strings_length
= 0;
9806 if (dynamic_symbols
)
9808 free (dynamic_symbols
);
9809 dynamic_symbols
= NULL
;
9810 num_dynamic_syms
= 0;
9813 if (dynamic_syminfo
)
9815 free (dynamic_syminfo
);
9816 dynamic_syminfo
= NULL
;
9819 if (section_headers_groups
)
9821 free (section_headers_groups
);
9822 section_headers_groups
= NULL
;
9827 struct group_list
*g
, *next
;
9829 for (i
= 0; i
< group_count
; i
++)
9831 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
9838 free (section_groups
);
9839 section_groups
= NULL
;
9842 free_debug_memory ();
9847 /* Process an ELF archive.
9848 On entry the file is positioned just after the ARMAG string. */
9851 process_archive (char *file_name
, FILE *file
)
9853 struct ar_hdr arhdr
;
9856 unsigned long index_num
= 0;
9857 unsigned long *index_array
= NULL
;
9858 char *sym_table
= NULL
;
9859 unsigned long sym_size
= 0;
9860 char *longnames
= NULL
;
9861 unsigned long longnames_size
= 0;
9862 size_t file_name_size
;
9867 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9868 if (got
!= sizeof arhdr
)
9873 error (_("%s: failed to read archive header\n"), file_name
);
9877 /* See if this is the archive symbol table. */
9878 if (const_strneq (arhdr
.ar_name
, "/ ")
9879 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
9881 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9882 size
= size
+ (size
& 1);
9884 if (do_archive_index
)
9887 /* A buffer used to hold numbers read in from an archive index.
9888 These are always 4 bytes long and stored in big-endian format. */
9889 #define SIZEOF_AR_INDEX_NUMBERS 4
9890 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
9891 unsigned char * index_buffer
;
9893 /* Check the size of the archive index. */
9894 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
9896 error (_("%s: the archive index is empty\n"), file_name
);
9900 /* Read the numer of entries in the archive index. */
9901 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
9902 if (got
!= sizeof (integer_buffer
))
9904 error (_("%s: failed to read archive index\n"), file_name
);
9907 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
9908 size
-= SIZEOF_AR_INDEX_NUMBERS
;
9910 /* Read in the archive index. */
9911 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
9913 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
9914 file_name
, index_num
);
9917 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
9918 if (index_buffer
== NULL
)
9920 error (_("Out of memory whilst trying to read archive symbol index\n"));
9923 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
9924 if (got
!= index_num
)
9926 free (index_buffer
);
9927 error (_("%s: failed to read archive index\n"), file_name
);
9931 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
9933 /* Convert the index numbers into the host's numeric format. */
9934 index_array
= malloc (index_num
* sizeof (* index_array
));
9935 if (index_array
== NULL
)
9937 free (index_buffer
);
9938 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
9942 for (i
= 0; i
< index_num
; i
++)
9943 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
9944 SIZEOF_AR_INDEX_NUMBERS
);
9945 free (index_buffer
);
9947 /* The remaining space in the header is taken up by the symbol table. */
9950 error (_("%s: the archive has an index but no symbols\n"), file_name
);
9954 sym_table
= malloc (size
);
9956 if (sym_table
== NULL
)
9958 error (_("Out of memory whilst trying to read archive index symbol table\n"));
9962 got
= fread (sym_table
, 1, size
, file
);
9965 error (_("%s: failed to read archive index symbol table\n"), file_name
);
9972 if (fseek (file
, size
, SEEK_CUR
) != 0)
9974 error (_("%s: failed to skip archive symbol table\n"), file_name
);
9979 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
9980 if (got
!= sizeof arhdr
)
9988 error (_("%s: failed to read archive header following archive index\n"), file_name
);
9993 else if (do_archive_index
)
9994 printf (_("%s has no archive index\n"), file_name
);
9996 if (const_strneq (arhdr
.ar_name
, "// "))
9998 /* This is the archive string table holding long member
10001 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10002 longnames
= malloc (longnames_size
);
10003 if (longnames
== NULL
)
10005 error (_("Out of memory reading long symbol names in archive\n"));
10010 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10013 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10018 if ((longnames_size
& 1) != 0)
10021 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10022 if (got
!= sizeof arhdr
)
10028 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10035 if (do_archive_index
)
10037 if (sym_table
== NULL
)
10038 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10041 unsigned int i
, j
, k
, l
;
10043 unsigned long current_pos
;
10045 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10046 file_name
, index_num
, sym_size
);
10047 current_pos
= ftell (file
);
10049 for (i
= l
= 0; i
< index_num
; i
++)
10051 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10053 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10055 error (_("%s: failed to seek to next file name\n"), file_name
);
10059 got
= fread (elf_name
, 1, 16, file
);
10062 error (_("%s: failed to read file name\n"), file_name
);
10067 if (elf_name
[0] == '/')
10069 /* We have a long name. */
10070 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10071 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10073 longnames
[j
] = '\0';
10074 printf (_("Binary %s contains:\n"), longnames
+ k
);
10075 longnames
[j
] = '/';
10080 while ((elf_name
[j
] != '/') && (j
< 16))
10082 elf_name
[j
] = '\0';
10083 printf(_("Binary %s contains:\n"), elf_name
);
10088 error (_("%s: end of the symbol table reached before the end of the index\n"),
10092 printf ("\t%s\n", sym_table
+ l
);
10093 l
+= strlen (sym_table
+ l
) + 1;
10097 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10100 free (index_array
);
10101 index_array
= NULL
;
10104 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10106 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10111 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10112 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10113 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10114 && !do_section_groups
)
10115 return 0; /* Archive index only. */
10118 file_name_size
= strlen (file_name
);
10127 if (arhdr
.ar_name
[0] == '/')
10131 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10132 if (off
>= longnames_size
)
10134 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10139 name
= longnames
+ off
;
10140 nameend
= memchr (name
, '/', longnames_size
- off
);
10144 name
= arhdr
.ar_name
;
10145 nameend
= memchr (name
, '/', 16);
10148 if (nameend
== NULL
)
10150 error (_("%s: bad archive file name\n"), file_name
);
10155 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10156 if (namealc
== NULL
)
10158 error (_("Out of memory\n"));
10163 memcpy (namealc
, file_name
, file_name_size
);
10164 namealc
[file_name_size
] = '(';
10165 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10166 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10167 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10169 archive_file_offset
= ftell (file
);
10170 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10172 ret
|= process_object (namealc
, file
);
10177 (archive_file_offset
10178 + archive_file_size
10179 + (archive_file_size
& 1)),
10182 error (_("%s: failed to seek to next archive header\n"), file_name
);
10187 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10188 if (got
!= sizeof arhdr
)
10193 error (_("%s: failed to read archive header\n"), file_name
);
10200 if (index_array
!= NULL
)
10201 free (index_array
);
10202 if (sym_table
!= NULL
)
10204 if (longnames
!= NULL
)
10211 process_file (char *file_name
)
10214 struct stat statbuf
;
10215 char armag
[SARMAG
];
10218 if (stat (file_name
, &statbuf
) < 0)
10220 if (errno
== ENOENT
)
10221 error (_("'%s': No such file\n"), file_name
);
10223 error (_("Could not locate '%s'. System error message: %s\n"),
10224 file_name
, strerror (errno
));
10228 if (! S_ISREG (statbuf
.st_mode
))
10230 error (_("'%s' is not an ordinary file\n"), file_name
);
10234 file
= fopen (file_name
, "rb");
10237 error (_("Input file '%s' is not readable.\n"), file_name
);
10241 if (fread (armag
, SARMAG
, 1, file
) != 1)
10243 error (_("%s: Failed to read file's magic number\n"), file_name
);
10248 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10249 ret
= process_archive (file_name
, file
);
10252 if (do_archive_index
)
10253 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10257 archive_file_size
= archive_file_offset
= 0;
10258 ret
= process_object (file_name
, file
);
10266 #ifdef SUPPORT_DISASSEMBLY
10267 /* Needed by the i386 disassembler. For extra credit, someone could
10268 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10272 print_address (unsigned int addr
, FILE *outfile
)
10274 fprintf (outfile
,"0x%8.8x", addr
);
10277 /* Needed by the i386 disassembler. */
10279 db_task_printsym (unsigned int addr
)
10281 print_address (addr
, stderr
);
10286 main (int argc
, char **argv
)
10290 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10291 setlocale (LC_MESSAGES
, "");
10293 #if defined (HAVE_SETLOCALE)
10294 setlocale (LC_CTYPE
, "");
10296 bindtextdomain (PACKAGE
, LOCALEDIR
);
10297 textdomain (PACKAGE
);
10299 expandargv (&argc
, &argv
);
10301 parse_args (argc
, argv
);
10303 if (num_dump_sects
> 0)
10305 /* Make a copy of the dump_sects array. */
10306 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10307 if (cmdline_dump_sects
== NULL
)
10308 error (_("Out of memory allocating dump request table.\n"));
10311 memcpy (cmdline_dump_sects
, dump_sects
,
10312 num_dump_sects
* sizeof (* dump_sects
));
10313 num_cmdline_dump_sects
= num_dump_sects
;
10317 if (optind
< (argc
- 1))
10321 while (optind
< argc
)
10322 err
|= process_file (argv
[optind
++]);
10324 if (dump_sects
!= NULL
)
10326 if (cmdline_dump_sects
!= NULL
)
10327 free (cmdline_dump_sects
);