1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 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. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
64 /* The following headers use the elf/reloc-macros.h file to
65 automatically generate relocation recognition functions
66 such as elf_mips_reloc_type() */
68 #define RELOC_MACROS_GEN_FUNC
70 #include "elf/alpha.h"
92 #include "elf/m68hc11.h"
93 #include "elf/mcore.h"
96 #include "elf/mn10200.h"
97 #include "elf/mn10300.h"
99 #include "elf/msp430.h"
100 #include "elf/or32.h"
103 #include "elf/ppc64.h"
104 #include "elf/s390.h"
106 #include "elf/sparc.h"
107 #include "elf/v850.h"
109 #include "elf/x86-64.h"
110 #include "elf/xstormy16.h"
112 #include "elf/iq2000.h"
113 #include "elf/xtensa.h"
119 #include "libiberty.h"
121 char *program_name
= "readelf";
122 static long archive_file_offset
;
123 static unsigned long archive_file_size
;
124 static unsigned long dynamic_addr
;
125 static bfd_size_type dynamic_size
;
126 static unsigned int dynamic_nent
;
127 static char *dynamic_strings
;
128 static unsigned long dynamic_strings_length
;
129 static char *string_table
;
130 static unsigned long string_table_length
;
131 static unsigned long num_dynamic_syms
;
132 static Elf_Internal_Sym
*dynamic_symbols
;
133 static Elf_Internal_Syminfo
*dynamic_syminfo
;
134 static unsigned long dynamic_syminfo_offset
;
135 static unsigned int dynamic_syminfo_nent
;
136 static char program_interpreter
[64];
137 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
138 static bfd_vma version_info
[16];
139 static Elf_Internal_Ehdr elf_header
;
140 static Elf_Internal_Shdr
*section_headers
;
141 static Elf_Internal_Phdr
*program_headers
;
142 static Elf_Internal_Dyn
*dynamic_section
;
143 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
144 static int show_name
;
145 static int do_dynamic
;
148 static int do_sections
;
149 static int do_section_groups
;
150 static int do_section_details
;
151 static int do_segments
;
152 static int do_unwind
;
153 static int do_using_dynamic
;
154 static int do_header
;
156 static int do_version
;
158 static int do_histogram
;
159 static int do_debugging
;
162 static int is_32bit_elf
;
166 struct group_list
*next
;
167 unsigned int section_index
;
172 struct group_list
*root
;
173 unsigned int group_index
;
176 static size_t group_count
;
177 static struct group
*section_groups
;
178 static struct group
**section_headers_groups
;
180 /* A linked list of the section names for which dumps were requested
182 struct dump_list_entry
186 struct dump_list_entry
*next
;
188 static struct dump_list_entry
*dump_sects_byname
;
190 /* A dynamic array of flags indicating for which sections a hex dump
191 has been requested (via the -x switch) and/or a disassembly dump
192 (via the -i switch). */
193 char *cmdline_dump_sects
= NULL
;
194 unsigned num_cmdline_dump_sects
= 0;
196 /* A dynamic array of flags indicating for which sections a dump of
197 some kind has been requested. It is reset on a per-object file
198 basis and then initialised from the cmdline_dump_sects array,
199 the results of interpreting the -w switch, and the
200 dump_sects_byname list. */
201 char *dump_sects
= NULL
;
202 unsigned int num_dump_sects
= 0;
204 #define HEX_DUMP (1 << 0)
205 #define DISASS_DUMP (1 << 1)
206 #define DEBUG_DUMP (1 << 2)
208 /* How to print a vma value. */
209 typedef enum print_mode
221 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
225 #define SECTION_NAME(X) \
226 ((X) == NULL ? "<none>" \
227 : string_table == NULL ? "<no-name>" \
228 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
229 : string_table + (X)->sh_name))
231 /* Given st_shndx I, map to section_headers index. */
232 #define SECTION_HEADER_INDEX(I) \
233 ((I) < SHN_LORESERVE \
235 : ((I) <= SHN_HIRESERVE \
237 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
239 /* Reverse of the above. */
240 #define SECTION_HEADER_NUM(N) \
241 ((N) < SHN_LORESERVE \
243 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
245 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
247 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
249 #define BYTE_GET(field) byte_get (field, sizeof (field))
251 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
253 #define GET_ELF_SYMBOLS(file, section) \
254 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
255 : get_64bit_elf_symbols (file, section))
257 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
258 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
259 already been called and verified that the string exists. */
260 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
262 /* This is just a bit of syntatic sugar. */
263 #define streq(a,b) (strcmp ((a), (b)) == 0)
264 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
267 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
272 if (size
== 0 || nmemb
== 0)
275 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
277 error (_("Unable to seek to 0x%lx for %s\n"),
278 archive_file_offset
+ offset
, reason
);
285 /* Check for overflow. */
286 if (nmemb
< (~(size_t) 0 - 1) / size
)
287 /* + 1 so that we can '\0' terminate invalid string table sections. */
288 mvar
= malloc (size
* nmemb
+ 1);
292 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
293 (unsigned long)(size
* nmemb
), reason
);
297 ((char *) mvar
)[size
* nmemb
] = '\0';
300 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
302 error (_("Unable to read in 0x%lx bytes of %s\n"),
303 (unsigned long)(size
* nmemb
), reason
);
313 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
318 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
319 field
[6] = ((value
>> 24) >> 24) & 0xff;
320 field
[5] = ((value
>> 24) >> 16) & 0xff;
321 field
[4] = ((value
>> 24) >> 8) & 0xff;
324 field
[3] = (value
>> 24) & 0xff;
325 field
[2] = (value
>> 16) & 0xff;
328 field
[1] = (value
>> 8) & 0xff;
331 field
[0] = value
& 0xff;
335 error (_("Unhandled data length: %d\n"), size
);
340 #if defined BFD64 && !BFD_HOST_64BIT_LONG
342 print_dec_vma (bfd_vma vma
, int is_signed
)
348 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
357 *bufp
++ = '0' + vma
% 10;
369 print_hex_vma (bfd_vma vma
)
377 char digit
= '0' + (vma
& 0x0f);
379 digit
+= 'a' - '0' - 10;
392 /* Print a VMA value. */
394 print_vma (bfd_vma vma
, print_mode mode
)
403 return printf ("0x%8.8lx", (unsigned long) vma
);
406 return printf ("%8.8lx", (unsigned long) vma
);
410 return printf ("%5ld", (long) vma
);
414 return printf ("0x%lx", (unsigned long) vma
);
417 return printf ("%lx", (unsigned long) vma
);
420 return printf ("%ld", (unsigned long) vma
);
423 return printf ("%lu", (unsigned long) vma
);
446 #if BFD_HOST_64BIT_LONG
447 return nc
+ printf ("%lx", vma
);
449 return nc
+ print_hex_vma (vma
);
453 #if BFD_HOST_64BIT_LONG
454 return printf ("%ld", vma
);
456 return print_dec_vma (vma
, 1);
460 #if BFD_HOST_64BIT_LONG
462 return printf ("%5ld", vma
);
464 return printf ("%#lx", vma
);
467 return printf ("%5ld", _bfd_int64_low (vma
));
469 return print_hex_vma (vma
);
473 #if BFD_HOST_64BIT_LONG
474 return printf ("%lu", vma
);
476 return print_dec_vma (vma
, 0);
484 /* Display a symbol on stdout. If do_wide is not true then
485 format the symbol to be at most WIDTH characters,
486 truncating as necessary. If WIDTH is negative then
487 format the string to be exactly - WIDTH characters,
488 truncating or padding as necessary. */
491 print_symbol (int width
, const char *symbol
)
494 printf ("%s", symbol
);
496 printf ("%-*.*s", width
, width
, symbol
);
498 printf ("%-.*s", width
, symbol
);
502 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
507 field
[7] = value
& 0xff;
508 field
[6] = (value
>> 8) & 0xff;
509 field
[5] = (value
>> 16) & 0xff;
510 field
[4] = (value
>> 24) & 0xff;
515 field
[3] = value
& 0xff;
516 field
[2] = (value
>> 8) & 0xff;
520 field
[1] = value
& 0xff;
524 field
[0] = value
& 0xff;
528 error (_("Unhandled data length: %d\n"), size
);
533 /* Return a pointer to section NAME, or NULL if no such section exists. */
535 static Elf_Internal_Shdr
*
536 find_section (const char *name
)
540 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
541 if (streq (SECTION_NAME (section_headers
+ i
), name
))
542 return section_headers
+ i
;
547 /* Guess the relocation size commonly used by the specific machines. */
550 guess_is_rela (unsigned long e_machine
)
554 /* Targets that use REL relocations. */
569 /* Targets that use RELA relocations. */
584 case EM_CYGNUS_MN10200
:
586 case EM_CYGNUS_MN10300
:
617 case EM_ALTERA_NIOS2
:
638 warn (_("Don't know about relocations on this machine architecture\n"));
644 slurp_rela_relocs (FILE *file
,
645 unsigned long rel_offset
,
646 unsigned long rel_size
,
647 Elf_Internal_Rela
**relasp
,
648 unsigned long *nrelasp
)
650 Elf_Internal_Rela
*relas
;
651 unsigned long nrelas
;
656 Elf32_External_Rela
*erelas
;
658 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
662 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
664 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
669 error (_("out of memory parsing relocs"));
673 for (i
= 0; i
< nrelas
; i
++)
675 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
676 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
677 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
684 Elf64_External_Rela
*erelas
;
686 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
690 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
692 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
697 error (_("out of memory parsing relocs"));
701 for (i
= 0; i
< nrelas
; i
++)
703 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
704 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
705 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
716 slurp_rel_relocs (FILE *file
,
717 unsigned long rel_offset
,
718 unsigned long rel_size
,
719 Elf_Internal_Rela
**relsp
,
720 unsigned long *nrelsp
)
722 Elf_Internal_Rela
*rels
;
728 Elf32_External_Rel
*erels
;
730 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
734 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
736 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
741 error (_("out of memory parsing relocs"));
745 for (i
= 0; i
< nrels
; i
++)
747 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
748 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
749 rels
[i
].r_addend
= 0;
756 Elf64_External_Rel
*erels
;
758 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
762 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
764 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
769 error (_("out of memory parsing relocs"));
773 for (i
= 0; i
< nrels
; i
++)
775 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
776 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
777 rels
[i
].r_addend
= 0;
787 /* Display the contents of the relocation data found at the specified
791 dump_relocations (FILE *file
,
792 unsigned long rel_offset
,
793 unsigned long rel_size
,
794 Elf_Internal_Sym
*symtab
,
797 unsigned long strtablen
,
801 Elf_Internal_Rela
*rels
;
804 if (is_rela
== UNKNOWN
)
805 is_rela
= guess_is_rela (elf_header
.e_machine
);
809 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
814 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
823 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
825 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
830 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
832 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
840 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
842 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
847 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
849 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
853 for (i
= 0; i
< rel_size
; i
++)
856 const char *rtype2
= NULL
;
857 const char *rtype3
= NULL
;
860 bfd_vma symtab_index
;
865 offset
= rels
[i
].r_offset
;
866 info
= rels
[i
].r_info
;
870 type
= ELF32_R_TYPE (info
);
871 symtab_index
= ELF32_R_SYM (info
);
875 /* The #ifdef BFD64 below is to prevent a compile time warning.
876 We know that if we do not have a 64 bit data type that we
877 will never execute this code anyway. */
879 if (elf_header
.e_machine
== EM_MIPS
)
881 /* In little-endian objects, r_info isn't really a 64-bit
882 little-endian value: it has a 32-bit little-endian
883 symbol index followed by four individual byte fields.
884 Reorder INFO accordingly. */
885 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
886 info
= (((info
& 0xffffffff) << 32)
887 | ((info
>> 56) & 0xff)
888 | ((info
>> 40) & 0xff00)
889 | ((info
>> 24) & 0xff0000)
890 | ((info
>> 8) & 0xff000000));
891 type
= ELF64_MIPS_R_TYPE (info
);
892 type2
= ELF64_MIPS_R_TYPE2 (info
);
893 type3
= ELF64_MIPS_R_TYPE3 (info
);
895 else if (elf_header
.e_machine
== EM_SPARCV9
)
896 type
= ELF64_R_TYPE_ID (info
);
898 type
= ELF64_R_TYPE (info
);
900 symtab_index
= ELF64_R_SYM (info
);
906 #ifdef _bfd_int64_low
907 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
909 printf ("%8.8lx %8.8lx ", offset
, info
);
914 #ifdef _bfd_int64_low
916 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
917 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
918 _bfd_int64_high (offset
),
919 _bfd_int64_low (offset
),
920 _bfd_int64_high (info
),
921 _bfd_int64_low (info
));
924 ? "%16.16lx %16.16lx "
925 : "%12.12lx %12.12lx ",
930 switch (elf_header
.e_machine
)
938 rtype
= elf_m32r_reloc_type (type
);
943 rtype
= elf_i386_reloc_type (type
);
948 rtype
= elf_m68hc11_reloc_type (type
);
952 rtype
= elf_m68k_reloc_type (type
);
956 rtype
= elf_i960_reloc_type (type
);
961 rtype
= elf_avr_reloc_type (type
);
968 rtype
= elf_sparc_reloc_type (type
);
973 rtype
= v850_reloc_type (type
);
978 rtype
= elf_d10v_reloc_type (type
);
983 rtype
= elf_d30v_reloc_type (type
);
987 rtype
= elf_dlx_reloc_type (type
);
991 rtype
= elf_sh_reloc_type (type
);
995 case EM_CYGNUS_MN10300
:
996 rtype
= elf_mn10300_reloc_type (type
);
1000 case EM_CYGNUS_MN10200
:
1001 rtype
= elf_mn10200_reloc_type (type
);
1005 case EM_CYGNUS_FR30
:
1006 rtype
= elf_fr30_reloc_type (type
);
1010 rtype
= elf_frv_reloc_type (type
);
1014 rtype
= elf_mcore_reloc_type (type
);
1018 rtype
= elf_mmix_reloc_type (type
);
1023 rtype
= elf_msp430_reloc_type (type
);
1027 rtype
= elf_ppc_reloc_type (type
);
1031 rtype
= elf_ppc64_reloc_type (type
);
1035 case EM_MIPS_RS3_LE
:
1036 rtype
= elf_mips_reloc_type (type
);
1039 rtype2
= elf_mips_reloc_type (type2
);
1040 rtype3
= elf_mips_reloc_type (type3
);
1045 rtype
= elf_alpha_reloc_type (type
);
1049 rtype
= elf_arm_reloc_type (type
);
1053 rtype
= elf_arc_reloc_type (type
);
1057 rtype
= elf_hppa_reloc_type (type
);
1063 rtype
= elf_h8_reloc_type (type
);
1068 rtype
= elf_or32_reloc_type (type
);
1073 rtype
= elf_pj_reloc_type (type
);
1076 rtype
= elf_ia64_reloc_type (type
);
1080 rtype
= elf_cris_reloc_type (type
);
1084 rtype
= elf_i860_reloc_type (type
);
1088 rtype
= elf_x86_64_reloc_type (type
);
1092 rtype
= i370_reloc_type (type
);
1097 rtype
= elf_s390_reloc_type (type
);
1101 rtype
= elf_xstormy16_reloc_type (type
);
1105 rtype
= elf_crx_reloc_type (type
);
1109 rtype
= elf_vax_reloc_type (type
);
1114 rtype
= elf_ip2k_reloc_type (type
);
1118 rtype
= elf_iq2000_reloc_type (type
);
1123 rtype
= elf_xtensa_reloc_type (type
);
1127 rtype
= elf_m32c_reloc_type (type
);
1131 rtype
= elf_mt_reloc_type (type
);
1135 rtype
= elf_bfin_reloc_type (type
);
1141 #ifdef _bfd_int64_low
1142 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1144 printf (_("unrecognized: %-7lx"), type
);
1147 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1149 if (elf_header
.e_machine
== EM_ALPHA
1150 && streq (rtype
, "R_ALPHA_LITUSE")
1153 switch (rels
[i
].r_addend
)
1155 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1156 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1157 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1158 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1159 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1160 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1161 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1162 default: rtype
= NULL
;
1165 printf (" (%s)", rtype
);
1169 printf (_("<unknown addend: %lx>"),
1170 (unsigned long) rels
[i
].r_addend
);
1173 else if (symtab_index
)
1175 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1176 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1179 Elf_Internal_Sym
*psym
;
1181 psym
= symtab
+ symtab_index
;
1184 print_vma (psym
->st_value
, LONG_HEX
);
1185 printf (is_32bit_elf
? " " : " ");
1187 if (psym
->st_name
== 0)
1189 const char *sec_name
= "<null>";
1192 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1194 bfd_vma sec_index
= (bfd_vma
) -1;
1196 if (psym
->st_shndx
< SHN_LORESERVE
)
1197 sec_index
= psym
->st_shndx
;
1198 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1199 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1202 if (sec_index
!= (bfd_vma
) -1)
1203 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1204 else if (psym
->st_shndx
== SHN_ABS
)
1206 else if (psym
->st_shndx
== SHN_COMMON
)
1207 sec_name
= "COMMON";
1208 else if (elf_header
.e_machine
== EM_X86_64
1209 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1210 sec_name
= "LARGE_COMMON";
1211 else if (elf_header
.e_machine
== EM_IA_64
1212 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1213 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1214 sec_name
= "ANSI_COM";
1217 sprintf (name_buf
, "<section 0x%x>",
1218 (unsigned int) psym
->st_shndx
);
1219 sec_name
= name_buf
;
1222 print_symbol (22, sec_name
);
1224 else if (strtab
== NULL
)
1225 printf (_("<string table index: %3ld>"), psym
->st_name
);
1226 else if (psym
->st_name
>= strtablen
)
1227 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1229 print_symbol (22, strtab
+ psym
->st_name
);
1232 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1237 printf ("%*c", is_32bit_elf
?
1238 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1239 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1242 if (elf_header
.e_machine
== EM_SPARCV9
&& streq (rtype
, "R_SPARC_OLO10"))
1243 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1247 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1249 printf (" Type2: ");
1252 #ifdef _bfd_int64_low
1253 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1255 printf (_("unrecognized: %-7lx"), type2
);
1258 printf ("%-17.17s", rtype2
);
1260 printf ("\n Type3: ");
1263 #ifdef _bfd_int64_low
1264 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1266 printf (_("unrecognized: %-7lx"), type3
);
1269 printf ("%-17.17s", rtype3
);
1281 get_mips_dynamic_type (unsigned long type
)
1285 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1286 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1287 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1288 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1289 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1290 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1291 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1292 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1293 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1294 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1295 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1296 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1297 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1298 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1299 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1300 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1301 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1302 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1303 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1304 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1305 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1306 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1307 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1308 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1309 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1310 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1311 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1312 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1313 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1314 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1315 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1316 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1317 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1318 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1319 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1320 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1321 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1322 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1323 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1324 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1325 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1326 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1327 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1334 get_sparc64_dynamic_type (unsigned long type
)
1338 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1345 get_ppc_dynamic_type (unsigned long type
)
1349 case DT_PPC_GOT
: return "PPC_GOT";
1356 get_ppc64_dynamic_type (unsigned long type
)
1360 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1361 case DT_PPC64_OPD
: return "PPC64_OPD";
1362 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1369 get_parisc_dynamic_type (unsigned long type
)
1373 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1374 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1375 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1376 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1377 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1378 case DT_HP_PREINIT
: return "HP_PREINIT";
1379 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1380 case DT_HP_NEEDED
: return "HP_NEEDED";
1381 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1382 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1383 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1384 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1385 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1386 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1387 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1388 case DT_HP_FILTERED
: return "HP_FILTERED";
1389 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1390 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1391 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1392 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1393 case DT_PLT
: return "PLT";
1394 case DT_PLT_SIZE
: return "PLT_SIZE";
1395 case DT_DLT
: return "DLT";
1396 case DT_DLT_SIZE
: return "DLT_SIZE";
1403 get_ia64_dynamic_type (unsigned long type
)
1407 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1414 get_alpha_dynamic_type (unsigned long type
)
1418 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1425 get_dynamic_type (unsigned long type
)
1427 static char buff
[64];
1431 case DT_NULL
: return "NULL";
1432 case DT_NEEDED
: return "NEEDED";
1433 case DT_PLTRELSZ
: return "PLTRELSZ";
1434 case DT_PLTGOT
: return "PLTGOT";
1435 case DT_HASH
: return "HASH";
1436 case DT_STRTAB
: return "STRTAB";
1437 case DT_SYMTAB
: return "SYMTAB";
1438 case DT_RELA
: return "RELA";
1439 case DT_RELASZ
: return "RELASZ";
1440 case DT_RELAENT
: return "RELAENT";
1441 case DT_STRSZ
: return "STRSZ";
1442 case DT_SYMENT
: return "SYMENT";
1443 case DT_INIT
: return "INIT";
1444 case DT_FINI
: return "FINI";
1445 case DT_SONAME
: return "SONAME";
1446 case DT_RPATH
: return "RPATH";
1447 case DT_SYMBOLIC
: return "SYMBOLIC";
1448 case DT_REL
: return "REL";
1449 case DT_RELSZ
: return "RELSZ";
1450 case DT_RELENT
: return "RELENT";
1451 case DT_PLTREL
: return "PLTREL";
1452 case DT_DEBUG
: return "DEBUG";
1453 case DT_TEXTREL
: return "TEXTREL";
1454 case DT_JMPREL
: return "JMPREL";
1455 case DT_BIND_NOW
: return "BIND_NOW";
1456 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1457 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1458 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1459 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1460 case DT_RUNPATH
: return "RUNPATH";
1461 case DT_FLAGS
: return "FLAGS";
1463 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1464 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1466 case DT_CHECKSUM
: return "CHECKSUM";
1467 case DT_PLTPADSZ
: return "PLTPADSZ";
1468 case DT_MOVEENT
: return "MOVEENT";
1469 case DT_MOVESZ
: return "MOVESZ";
1470 case DT_FEATURE
: return "FEATURE";
1471 case DT_POSFLAG_1
: return "POSFLAG_1";
1472 case DT_SYMINSZ
: return "SYMINSZ";
1473 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1475 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1476 case DT_CONFIG
: return "CONFIG";
1477 case DT_DEPAUDIT
: return "DEPAUDIT";
1478 case DT_AUDIT
: return "AUDIT";
1479 case DT_PLTPAD
: return "PLTPAD";
1480 case DT_MOVETAB
: return "MOVETAB";
1481 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1483 case DT_VERSYM
: return "VERSYM";
1485 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1486 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1487 case DT_RELACOUNT
: return "RELACOUNT";
1488 case DT_RELCOUNT
: return "RELCOUNT";
1489 case DT_FLAGS_1
: return "FLAGS_1";
1490 case DT_VERDEF
: return "VERDEF";
1491 case DT_VERDEFNUM
: return "VERDEFNUM";
1492 case DT_VERNEED
: return "VERNEED";
1493 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1495 case DT_AUXILIARY
: return "AUXILIARY";
1496 case DT_USED
: return "USED";
1497 case DT_FILTER
: return "FILTER";
1499 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1500 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1501 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1502 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1503 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1506 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1510 switch (elf_header
.e_machine
)
1513 case EM_MIPS_RS3_LE
:
1514 result
= get_mips_dynamic_type (type
);
1517 result
= get_sparc64_dynamic_type (type
);
1520 result
= get_ppc_dynamic_type (type
);
1523 result
= get_ppc64_dynamic_type (type
);
1526 result
= get_ia64_dynamic_type (type
);
1529 result
= get_alpha_dynamic_type (type
);
1539 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1541 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1542 || (elf_header
.e_machine
== EM_PARISC
1543 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1547 switch (elf_header
.e_machine
)
1550 result
= get_parisc_dynamic_type (type
);
1560 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1564 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1571 get_file_type (unsigned e_type
)
1573 static char buff
[32];
1577 case ET_NONE
: return _("NONE (None)");
1578 case ET_REL
: return _("REL (Relocatable file)");
1579 case ET_EXEC
: return _("EXEC (Executable file)");
1580 case ET_DYN
: return _("DYN (Shared object file)");
1581 case ET_CORE
: return _("CORE (Core file)");
1584 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1585 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1586 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1587 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1589 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1595 get_machine_name (unsigned e_machine
)
1597 static char buff
[64]; /* XXX */
1601 case EM_NONE
: return _("None");
1602 case EM_M32
: return "WE32100";
1603 case EM_SPARC
: return "Sparc";
1604 case EM_386
: return "Intel 80386";
1605 case EM_68K
: return "MC68000";
1606 case EM_88K
: return "MC88000";
1607 case EM_486
: return "Intel 80486";
1608 case EM_860
: return "Intel 80860";
1609 case EM_MIPS
: return "MIPS R3000";
1610 case EM_S370
: return "IBM System/370";
1611 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1612 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1613 case EM_PARISC
: return "HPPA";
1614 case EM_PPC_OLD
: return "Power PC (old)";
1615 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1616 case EM_960
: return "Intel 90860";
1617 case EM_PPC
: return "PowerPC";
1618 case EM_PPC64
: return "PowerPC64";
1619 case EM_V800
: return "NEC V800";
1620 case EM_FR20
: return "Fujitsu FR20";
1621 case EM_RH32
: return "TRW RH32";
1622 case EM_MCORE
: return "MCORE";
1623 case EM_ARM
: return "ARM";
1624 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1625 case EM_SH
: return "Renesas / SuperH SH";
1626 case EM_SPARCV9
: return "Sparc v9";
1627 case EM_TRICORE
: return "Siemens Tricore";
1628 case EM_ARC
: return "ARC";
1629 case EM_H8_300
: return "Renesas H8/300";
1630 case EM_H8_300H
: return "Renesas H8/300H";
1631 case EM_H8S
: return "Renesas H8S";
1632 case EM_H8_500
: return "Renesas H8/500";
1633 case EM_IA_64
: return "Intel IA-64";
1634 case EM_MIPS_X
: return "Stanford MIPS-X";
1635 case EM_COLDFIRE
: return "Motorola Coldfire";
1636 case EM_68HC12
: return "Motorola M68HC12";
1637 case EM_ALPHA
: return "Alpha";
1638 case EM_CYGNUS_D10V
:
1639 case EM_D10V
: return "d10v";
1640 case EM_CYGNUS_D30V
:
1641 case EM_D30V
: return "d30v";
1642 case EM_CYGNUS_M32R
:
1643 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1644 case EM_CYGNUS_V850
:
1645 case EM_V850
: return "NEC v850";
1646 case EM_CYGNUS_MN10300
:
1647 case EM_MN10300
: return "mn10300";
1648 case EM_CYGNUS_MN10200
:
1649 case EM_MN10200
: return "mn10200";
1650 case EM_CYGNUS_FR30
:
1651 case EM_FR30
: return "Fujitsu FR30";
1652 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1654 case EM_PJ
: return "picoJava";
1655 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1656 case EM_PCP
: return "Siemens PCP";
1657 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1658 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1659 case EM_STARCORE
: return "Motorola Star*Core processor";
1660 case EM_ME16
: return "Toyota ME16 processor";
1661 case EM_ST100
: return "STMicroelectronics ST100 processor";
1662 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1663 case EM_FX66
: return "Siemens FX66 microcontroller";
1664 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1665 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1666 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1667 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1668 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1669 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1670 case EM_SVX
: return "Silicon Graphics SVx";
1671 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1672 case EM_VAX
: return "Digital VAX";
1674 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1675 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1676 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1677 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1678 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1679 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1680 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1681 case EM_PRISM
: return "Vitesse Prism";
1682 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1684 case EM_S390
: return "IBM S/390";
1685 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1687 case EM_OR32
: return "OpenRISC";
1688 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1689 case EM_DLX
: return "OpenDLX";
1691 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1692 case EM_IQ2000
: return "Vitesse IQ2000";
1694 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1695 case EM_M32C
: return "Renesas M32c";
1696 case EM_MT
: return "Morpho Techologies MT processor";
1697 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1698 case EM_NIOS32
: return "Altera Nios";
1699 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1700 case EM_XC16X
: return "Infineon Technologies xc16x";
1702 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1708 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1713 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1714 e_flags
&= ~ EF_ARM_EABIMASK
;
1716 /* Handle "generic" ARM flags. */
1717 if (e_flags
& EF_ARM_RELEXEC
)
1719 strcat (buf
, ", relocatable executable");
1720 e_flags
&= ~ EF_ARM_RELEXEC
;
1723 if (e_flags
& EF_ARM_HASENTRY
)
1725 strcat (buf
, ", has entry point");
1726 e_flags
&= ~ EF_ARM_HASENTRY
;
1729 /* Now handle EABI specific flags. */
1733 strcat (buf
, ", <unrecognized EABI>");
1738 case EF_ARM_EABI_VER1
:
1739 strcat (buf
, ", Version1 EABI");
1744 /* Process flags one bit at a time. */
1745 flag
= e_flags
& - e_flags
;
1750 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1751 strcat (buf
, ", sorted symbol tables");
1761 case EF_ARM_EABI_VER2
:
1762 strcat (buf
, ", Version2 EABI");
1767 /* Process flags one bit at a time. */
1768 flag
= e_flags
& - e_flags
;
1773 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1774 strcat (buf
, ", sorted symbol tables");
1777 case EF_ARM_DYNSYMSUSESEGIDX
:
1778 strcat (buf
, ", dynamic symbols use segment index");
1781 case EF_ARM_MAPSYMSFIRST
:
1782 strcat (buf
, ", mapping symbols precede others");
1792 case EF_ARM_EABI_VER3
:
1793 strcat (buf
, ", Version3 EABI");
1796 case EF_ARM_EABI_VER4
:
1797 strcat (buf
, ", Version4 EABI");
1800 case EF_ARM_EABI_VER5
:
1801 strcat (buf
, ", Version5 EABI");
1807 /* Process flags one bit at a time. */
1808 flag
= e_flags
& - e_flags
;
1814 strcat (buf
, ", BE8");
1818 strcat (buf
, ", LE8");
1828 case EF_ARM_EABI_UNKNOWN
:
1829 strcat (buf
, ", GNU EABI");
1834 /* Process flags one bit at a time. */
1835 flag
= e_flags
& - e_flags
;
1840 case EF_ARM_INTERWORK
:
1841 strcat (buf
, ", interworking enabled");
1844 case EF_ARM_APCS_26
:
1845 strcat (buf
, ", uses APCS/26");
1848 case EF_ARM_APCS_FLOAT
:
1849 strcat (buf
, ", uses APCS/float");
1853 strcat (buf
, ", position independent");
1857 strcat (buf
, ", 8 bit structure alignment");
1860 case EF_ARM_NEW_ABI
:
1861 strcat (buf
, ", uses new ABI");
1864 case EF_ARM_OLD_ABI
:
1865 strcat (buf
, ", uses old ABI");
1868 case EF_ARM_SOFT_FLOAT
:
1869 strcat (buf
, ", software FP");
1872 case EF_ARM_VFP_FLOAT
:
1873 strcat (buf
, ", VFP");
1876 case EF_ARM_MAVERICK_FLOAT
:
1877 strcat (buf
, ", Maverick FP");
1888 strcat (buf
,", <unknown>");
1892 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1894 static char buf
[1024];
1906 decode_ARM_machine_flags (e_flags
, buf
);
1910 switch (e_flags
& EF_FRV_CPU_MASK
)
1912 case EF_FRV_CPU_GENERIC
:
1916 strcat (buf
, ", fr???");
1919 case EF_FRV_CPU_FR300
:
1920 strcat (buf
, ", fr300");
1923 case EF_FRV_CPU_FR400
:
1924 strcat (buf
, ", fr400");
1926 case EF_FRV_CPU_FR405
:
1927 strcat (buf
, ", fr405");
1930 case EF_FRV_CPU_FR450
:
1931 strcat (buf
, ", fr450");
1934 case EF_FRV_CPU_FR500
:
1935 strcat (buf
, ", fr500");
1937 case EF_FRV_CPU_FR550
:
1938 strcat (buf
, ", fr550");
1941 case EF_FRV_CPU_SIMPLE
:
1942 strcat (buf
, ", simple");
1944 case EF_FRV_CPU_TOMCAT
:
1945 strcat (buf
, ", tomcat");
1951 if (e_flags
& EF_M68K_CPU32
)
1952 strcat (buf
, ", cpu32");
1953 if (e_flags
& EF_M68K_M68000
)
1954 strcat (buf
, ", m68000");
1955 if (e_flags
& EF_M68K_ISA_MASK
)
1957 char const *isa
= _("unknown");
1958 char const *mac
= _("unknown mac");
1959 char const *additional
= NULL
;
1961 switch (e_flags
& EF_M68K_ISA_MASK
)
1963 case EF_M68K_ISA_A_NODIV
:
1965 additional
= ", nodiv";
1970 case EF_M68K_ISA_A_PLUS
:
1973 case EF_M68K_ISA_B_NOUSP
:
1975 additional
= ", nousp";
1981 strcat (buf
, ", cf, isa ");
1984 strcat (buf
, additional
);
1985 if (e_flags
& EF_M68K_FLOAT
)
1986 strcat (buf
, ", float");
1987 switch (e_flags
& EF_M68K_MAC_MASK
)
2008 if (e_flags
& EF_PPC_EMB
)
2009 strcat (buf
, ", emb");
2011 if (e_flags
& EF_PPC_RELOCATABLE
)
2012 strcat (buf
, ", relocatable");
2014 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2015 strcat (buf
, ", relocatable-lib");
2019 case EM_CYGNUS_V850
:
2020 switch (e_flags
& EF_V850_ARCH
)
2023 strcat (buf
, ", v850e1");
2026 strcat (buf
, ", v850e");
2029 strcat (buf
, ", v850");
2032 strcat (buf
, ", unknown v850 architecture variant");
2038 case EM_CYGNUS_M32R
:
2039 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2040 strcat (buf
, ", m32r");
2045 case EM_MIPS_RS3_LE
:
2046 if (e_flags
& EF_MIPS_NOREORDER
)
2047 strcat (buf
, ", noreorder");
2049 if (e_flags
& EF_MIPS_PIC
)
2050 strcat (buf
, ", pic");
2052 if (e_flags
& EF_MIPS_CPIC
)
2053 strcat (buf
, ", cpic");
2055 if (e_flags
& EF_MIPS_UCODE
)
2056 strcat (buf
, ", ugen_reserved");
2058 if (e_flags
& EF_MIPS_ABI2
)
2059 strcat (buf
, ", abi2");
2061 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2062 strcat (buf
, ", odk first");
2064 if (e_flags
& EF_MIPS_32BITMODE
)
2065 strcat (buf
, ", 32bitmode");
2067 switch ((e_flags
& EF_MIPS_MACH
))
2069 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2070 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2071 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2072 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2073 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2074 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2075 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2076 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2077 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2078 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2080 /* We simply ignore the field in this case to avoid confusion:
2081 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2084 default: strcat (buf
, ", unknown CPU"); break;
2087 switch ((e_flags
& EF_MIPS_ABI
))
2089 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2090 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2091 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2092 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2094 /* We simply ignore the field in this case to avoid confusion:
2095 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2096 This means it is likely to be an o32 file, but not for
2099 default: strcat (buf
, ", unknown ABI"); break;
2102 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2103 strcat (buf
, ", mdmx");
2105 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2106 strcat (buf
, ", mips16");
2108 switch ((e_flags
& EF_MIPS_ARCH
))
2110 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2111 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2112 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2113 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2114 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2115 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2116 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2117 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2118 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2119 default: strcat (buf
, ", unknown ISA"); break;
2125 switch ((e_flags
& EF_SH_MACH_MASK
))
2127 case EF_SH1
: strcat (buf
, ", sh1"); break;
2128 case EF_SH2
: strcat (buf
, ", sh2"); break;
2129 case EF_SH3
: strcat (buf
, ", sh3"); break;
2130 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2131 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2132 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2133 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2134 case EF_SH4
: strcat (buf
, ", sh4"); break;
2135 case EF_SH5
: strcat (buf
, ", sh5"); break;
2136 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2137 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2138 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2139 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2140 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2141 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2142 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2143 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2144 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2145 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2146 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2147 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2148 default: strcat (buf
, ", unknown ISA"); break;
2154 if (e_flags
& EF_SPARC_32PLUS
)
2155 strcat (buf
, ", v8+");
2157 if (e_flags
& EF_SPARC_SUN_US1
)
2158 strcat (buf
, ", ultrasparcI");
2160 if (e_flags
& EF_SPARC_SUN_US3
)
2161 strcat (buf
, ", ultrasparcIII");
2163 if (e_flags
& EF_SPARC_HAL_R1
)
2164 strcat (buf
, ", halr1");
2166 if (e_flags
& EF_SPARC_LEDATA
)
2167 strcat (buf
, ", ledata");
2169 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2170 strcat (buf
, ", tso");
2172 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2173 strcat (buf
, ", pso");
2175 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2176 strcat (buf
, ", rmo");
2180 switch (e_flags
& EF_PARISC_ARCH
)
2182 case EFA_PARISC_1_0
:
2183 strcpy (buf
, ", PA-RISC 1.0");
2185 case EFA_PARISC_1_1
:
2186 strcpy (buf
, ", PA-RISC 1.1");
2188 case EFA_PARISC_2_0
:
2189 strcpy (buf
, ", PA-RISC 2.0");
2194 if (e_flags
& EF_PARISC_TRAPNIL
)
2195 strcat (buf
, ", trapnil");
2196 if (e_flags
& EF_PARISC_EXT
)
2197 strcat (buf
, ", ext");
2198 if (e_flags
& EF_PARISC_LSB
)
2199 strcat (buf
, ", lsb");
2200 if (e_flags
& EF_PARISC_WIDE
)
2201 strcat (buf
, ", wide");
2202 if (e_flags
& EF_PARISC_NO_KABP
)
2203 strcat (buf
, ", no kabp");
2204 if (e_flags
& EF_PARISC_LAZYSWAP
)
2205 strcat (buf
, ", lazyswap");
2210 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2211 strcat (buf
, ", new calling convention");
2213 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2214 strcat (buf
, ", gnu calling convention");
2218 if ((e_flags
& EF_IA_64_ABI64
))
2219 strcat (buf
, ", 64-bit");
2221 strcat (buf
, ", 32-bit");
2222 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2223 strcat (buf
, ", reduced fp model");
2224 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2225 strcat (buf
, ", no function descriptors, constant gp");
2226 else if ((e_flags
& EF_IA_64_CONS_GP
))
2227 strcat (buf
, ", constant gp");
2228 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2229 strcat (buf
, ", absolute");
2233 if ((e_flags
& EF_VAX_NONPIC
))
2234 strcat (buf
, ", non-PIC");
2235 if ((e_flags
& EF_VAX_DFLOAT
))
2236 strcat (buf
, ", D-Float");
2237 if ((e_flags
& EF_VAX_GFLOAT
))
2238 strcat (buf
, ", G-Float");
2247 get_osabi_name (unsigned int osabi
)
2249 static char buff
[32];
2253 case ELFOSABI_NONE
: return "UNIX - System V";
2254 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2255 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2256 case ELFOSABI_LINUX
: return "UNIX - Linux";
2257 case ELFOSABI_HURD
: return "GNU/Hurd";
2258 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2259 case ELFOSABI_AIX
: return "UNIX - AIX";
2260 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2261 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2262 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2263 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2264 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2265 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2266 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2267 case ELFOSABI_AROS
: return "Amiga Research OS";
2268 case ELFOSABI_STANDALONE
: return _("Standalone App");
2269 case ELFOSABI_ARM
: return "ARM";
2271 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2277 get_arm_segment_type (unsigned long type
)
2291 get_mips_segment_type (unsigned long type
)
2295 case PT_MIPS_REGINFO
:
2297 case PT_MIPS_RTPROC
:
2299 case PT_MIPS_OPTIONS
:
2309 get_parisc_segment_type (unsigned long type
)
2313 case PT_HP_TLS
: return "HP_TLS";
2314 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2315 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2316 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2317 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2318 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2319 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2320 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2321 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2322 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2323 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2324 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2325 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2326 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2327 case PT_HP_STACK
: return "HP_STACK";
2328 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2329 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2330 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2331 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2340 get_ia64_segment_type (unsigned long type
)
2344 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2345 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2346 case PT_HP_TLS
: return "HP_TLS";
2347 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2348 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2349 case PT_IA_64_HP_STACK
: return "HP_STACK";
2358 get_segment_type (unsigned long p_type
)
2360 static char buff
[32];
2364 case PT_NULL
: return "NULL";
2365 case PT_LOAD
: return "LOAD";
2366 case PT_DYNAMIC
: return "DYNAMIC";
2367 case PT_INTERP
: return "INTERP";
2368 case PT_NOTE
: return "NOTE";
2369 case PT_SHLIB
: return "SHLIB";
2370 case PT_PHDR
: return "PHDR";
2371 case PT_TLS
: return "TLS";
2373 case PT_GNU_EH_FRAME
:
2374 return "GNU_EH_FRAME";
2375 case PT_GNU_STACK
: return "GNU_STACK";
2376 case PT_GNU_RELRO
: return "GNU_RELRO";
2379 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2383 switch (elf_header
.e_machine
)
2386 result
= get_arm_segment_type (p_type
);
2389 case EM_MIPS_RS3_LE
:
2390 result
= get_mips_segment_type (p_type
);
2393 result
= get_parisc_segment_type (p_type
);
2396 result
= get_ia64_segment_type (p_type
);
2406 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2408 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2412 switch (elf_header
.e_machine
)
2415 result
= get_parisc_segment_type (p_type
);
2418 result
= get_ia64_segment_type (p_type
);
2428 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2431 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2438 get_mips_section_type_name (unsigned int sh_type
)
2442 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2443 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2444 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2445 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2446 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2447 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2448 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2449 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2450 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2451 case SHT_MIPS_RELD
: return "MIPS_RELD";
2452 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2453 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2454 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2455 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2456 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2457 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2458 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2459 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2460 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2461 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2462 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2463 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2464 case SHT_MIPS_LINE
: return "MIPS_LINE";
2465 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2466 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2467 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2468 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2469 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2470 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2471 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2472 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2473 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2474 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2475 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2476 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2477 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2478 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2479 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2480 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2488 get_parisc_section_type_name (unsigned int sh_type
)
2492 case SHT_PARISC_EXT
: return "PARISC_EXT";
2493 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2494 case SHT_PARISC_DOC
: return "PARISC_DOC";
2495 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2496 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2497 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2498 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2506 get_ia64_section_type_name (unsigned int sh_type
)
2508 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2509 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2510 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2514 case SHT_IA_64_EXT
: return "IA_64_EXT";
2515 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2516 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2524 get_x86_64_section_type_name (unsigned int sh_type
)
2528 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2536 get_arm_section_type_name (unsigned int sh_type
)
2542 case SHT_ARM_PREEMPTMAP
:
2543 return "ARM_PREEMPTMAP";
2544 case SHT_ARM_ATTRIBUTES
:
2545 return "ARM_ATTRIBUTES";
2553 get_section_type_name (unsigned int sh_type
)
2555 static char buff
[32];
2559 case SHT_NULL
: return "NULL";
2560 case SHT_PROGBITS
: return "PROGBITS";
2561 case SHT_SYMTAB
: return "SYMTAB";
2562 case SHT_STRTAB
: return "STRTAB";
2563 case SHT_RELA
: return "RELA";
2564 case SHT_HASH
: return "HASH";
2565 case SHT_DYNAMIC
: return "DYNAMIC";
2566 case SHT_NOTE
: return "NOTE";
2567 case SHT_NOBITS
: return "NOBITS";
2568 case SHT_REL
: return "REL";
2569 case SHT_SHLIB
: return "SHLIB";
2570 case SHT_DYNSYM
: return "DYNSYM";
2571 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2572 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2573 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2574 case SHT_GROUP
: return "GROUP";
2575 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2576 case SHT_GNU_verdef
: return "VERDEF";
2577 case SHT_GNU_verneed
: return "VERNEED";
2578 case SHT_GNU_versym
: return "VERSYM";
2579 case 0x6ffffff0: return "VERSYM";
2580 case 0x6ffffffc: return "VERDEF";
2581 case 0x7ffffffd: return "AUXILIARY";
2582 case 0x7fffffff: return "FILTER";
2583 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2586 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2590 switch (elf_header
.e_machine
)
2593 case EM_MIPS_RS3_LE
:
2594 result
= get_mips_section_type_name (sh_type
);
2597 result
= get_parisc_section_type_name (sh_type
);
2600 result
= get_ia64_section_type_name (sh_type
);
2603 result
= get_x86_64_section_type_name (sh_type
);
2606 result
= get_arm_section_type_name (sh_type
);
2616 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2618 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2619 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2620 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2621 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2623 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2629 #define OPTION_DEBUG_DUMP 512
2631 static struct option options
[] =
2633 {"all", no_argument
, 0, 'a'},
2634 {"file-header", no_argument
, 0, 'h'},
2635 {"program-headers", no_argument
, 0, 'l'},
2636 {"headers", no_argument
, 0, 'e'},
2637 {"histogram", no_argument
, 0, 'I'},
2638 {"segments", no_argument
, 0, 'l'},
2639 {"sections", no_argument
, 0, 'S'},
2640 {"section-headers", no_argument
, 0, 'S'},
2641 {"section-groups", no_argument
, 0, 'g'},
2642 {"section-details", no_argument
, 0, 't'},
2643 {"full-section-name",no_argument
, 0, 'N'},
2644 {"symbols", no_argument
, 0, 's'},
2645 {"syms", no_argument
, 0, 's'},
2646 {"relocs", no_argument
, 0, 'r'},
2647 {"notes", no_argument
, 0, 'n'},
2648 {"dynamic", no_argument
, 0, 'd'},
2649 {"arch-specific", no_argument
, 0, 'A'},
2650 {"version-info", no_argument
, 0, 'V'},
2651 {"use-dynamic", no_argument
, 0, 'D'},
2652 {"hex-dump", required_argument
, 0, 'x'},
2653 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2654 {"unwind", no_argument
, 0, 'u'},
2655 #ifdef SUPPORT_DISASSEMBLY
2656 {"instruction-dump", required_argument
, 0, 'i'},
2659 {"version", no_argument
, 0, 'v'},
2660 {"wide", no_argument
, 0, 'W'},
2661 {"help", no_argument
, 0, 'H'},
2662 {0, no_argument
, 0, 0}
2668 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2669 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2670 fprintf (stdout
, _(" Options are:\n\
2671 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2672 -h --file-header Display the ELF file header\n\
2673 -l --program-headers Display the program headers\n\
2674 --segments An alias for --program-headers\n\
2675 -S --section-headers Display the sections' header\n\
2676 --sections An alias for --section-headers\n\
2677 -g --section-groups Display the section groups\n\
2678 -t --section-details Display the section details\n\
2679 -e --headers Equivalent to: -h -l -S\n\
2680 -s --syms Display the symbol table\n\
2681 --symbols An alias for --syms\n\
2682 -n --notes Display the core notes (if present)\n\
2683 -r --relocs Display the relocations (if present)\n\
2684 -u --unwind Display the unwind info (if present)\n\
2685 -d --dynamic Display the dynamic section (if present)\n\
2686 -V --version-info Display the version sections (if present)\n\
2687 -A --arch-specific Display architecture specific information (if any).\n\
2688 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2689 -x --hex-dump=<number> Dump the contents of section <number>\n\
2690 -w[liaprmfFsoR] or\n\
2691 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2692 Display the contents of DWARF2 debug sections\n"));
2693 #ifdef SUPPORT_DISASSEMBLY
2694 fprintf (stdout
, _("\
2695 -i --instruction-dump=<number>\n\
2696 Disassemble the contents of section <number>\n"));
2698 fprintf (stdout
, _("\
2699 -I --histogram Display histogram of bucket list lengths\n\
2700 -W --wide Allow output width to exceed 80 characters\n\
2701 @<file> Read options from <file>\n\
2702 -H --help Display this information\n\
2703 -v --version Display the version number of readelf\n"));
2704 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2709 /* Record the fact that the user wants the contents of section number
2710 SECTION to be displayed using the method(s) encoded as flags bits
2711 in TYPE. Note, TYPE can be zero if we are creating the array for
2715 request_dump (unsigned int section
, int type
)
2717 if (section
>= num_dump_sects
)
2719 char *new_dump_sects
;
2721 new_dump_sects
= calloc (section
+ 1, 1);
2723 if (new_dump_sects
== NULL
)
2724 error (_("Out of memory allocating dump request table."));
2727 /* Copy current flag settings. */
2728 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2732 dump_sects
= new_dump_sects
;
2733 num_dump_sects
= section
+ 1;
2738 dump_sects
[section
] |= type
;
2743 /* Request a dump by section name. */
2746 request_dump_byname (const char *section
, int type
)
2748 struct dump_list_entry
*new_request
;
2750 new_request
= malloc (sizeof (struct dump_list_entry
));
2752 error (_("Out of memory allocating dump request table."));
2754 new_request
->name
= strdup (section
);
2755 if (!new_request
->name
)
2756 error (_("Out of memory allocating dump request table."));
2758 new_request
->type
= type
;
2760 new_request
->next
= dump_sects_byname
;
2761 dump_sects_byname
= new_request
;
2765 parse_args (int argc
, char **argv
)
2772 while ((c
= getopt_long
2773 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2794 do_section_groups
++;
2802 do_section_groups
++;
2807 do_section_details
++;
2849 section
= strtoul (optarg
, & cp
, 0);
2850 if (! *cp
&& section
>= 0)
2851 request_dump (section
, HEX_DUMP
);
2853 request_dump_byname (optarg
, HEX_DUMP
);
2861 unsigned int index
= 0;
2865 while (optarg
[index
])
2866 switch (optarg
[index
++])
2875 do_debug_abbrevs
= 1;
2885 do_debug_pubnames
= 1;
2889 do_debug_aranges
= 1;
2893 do_debug_ranges
= 1;
2897 do_debug_frames_interp
= 1;
2899 do_debug_frames
= 1;
2904 do_debug_macinfo
= 1;
2918 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2923 case OPTION_DEBUG_DUMP
:
2931 const char * option
;
2934 debug_dump_long_opts
;
2936 debug_dump_long_opts opts_table
[] =
2938 /* Please keep this table alpha- sorted. */
2939 { "Ranges", & do_debug_ranges
},
2940 { "abbrev", & do_debug_abbrevs
},
2941 { "aranges", & do_debug_aranges
},
2942 { "frames", & do_debug_frames
},
2943 { "frames-interp", & do_debug_frames_interp
},
2944 { "info", & do_debug_info
},
2945 { "line", & do_debug_lines
},
2946 { "loc", & do_debug_loc
},
2947 { "macro", & do_debug_macinfo
},
2948 { "pubnames", & do_debug_pubnames
},
2949 /* This entry is for compatability
2950 with earlier versions of readelf. */
2951 { "ranges", & do_debug_aranges
},
2952 { "str", & do_debug_str
},
2963 debug_dump_long_opts
* entry
;
2965 for (entry
= opts_table
; entry
->option
; entry
++)
2967 size_t len
= strlen (entry
->option
);
2969 if (strneq (p
, entry
->option
, len
)
2970 && (p
[len
] == ',' || p
[len
] == '\0'))
2972 * entry
->variable
= 1;
2974 /* The --debug-dump=frames-interp option also
2975 enables the --debug-dump=frames option. */
2976 if (do_debug_frames_interp
)
2977 do_debug_frames
= 1;
2984 if (entry
->option
== NULL
)
2986 warn (_("Unrecognized debug option '%s'\n"), p
);
2987 p
= strchr (p
, ',');
2997 #ifdef SUPPORT_DISASSEMBLY
3000 section
= strtoul (optarg
, & cp
, 0);
3001 if (! *cp
&& section
>= 0)
3003 request_dump (section
, DISASS_DUMP
);
3009 print_version (program_name
);
3018 #ifdef SUPPORT_DISASSEMBLY
3021 /* xgettext:c-format */
3022 error (_("Invalid option '-%c'\n"), c
);
3029 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3030 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3031 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3032 && !do_section_groups
)
3036 warn (_("Nothing to do.\n"));
3042 get_elf_class (unsigned int elf_class
)
3044 static char buff
[32];
3048 case ELFCLASSNONE
: return _("none");
3049 case ELFCLASS32
: return "ELF32";
3050 case ELFCLASS64
: return "ELF64";
3052 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3058 get_data_encoding (unsigned int encoding
)
3060 static char buff
[32];
3064 case ELFDATANONE
: return _("none");
3065 case ELFDATA2LSB
: return _("2's complement, little endian");
3066 case ELFDATA2MSB
: return _("2's complement, big endian");
3068 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3073 /* Decode the data held in 'elf_header'. */
3076 process_file_header (void)
3078 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3079 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3080 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3081 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3084 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3092 printf (_("ELF Header:\n"));
3093 printf (_(" Magic: "));
3094 for (i
= 0; i
< EI_NIDENT
; i
++)
3095 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3097 printf (_(" Class: %s\n"),
3098 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3099 printf (_(" Data: %s\n"),
3100 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3101 printf (_(" Version: %d %s\n"),
3102 elf_header
.e_ident
[EI_VERSION
],
3103 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3105 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3108 printf (_(" OS/ABI: %s\n"),
3109 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3110 printf (_(" ABI Version: %d\n"),
3111 elf_header
.e_ident
[EI_ABIVERSION
]);
3112 printf (_(" Type: %s\n"),
3113 get_file_type (elf_header
.e_type
));
3114 printf (_(" Machine: %s\n"),
3115 get_machine_name (elf_header
.e_machine
));
3116 printf (_(" Version: 0x%lx\n"),
3117 (unsigned long) elf_header
.e_version
);
3119 printf (_(" Entry point address: "));
3120 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3121 printf (_("\n Start of program headers: "));
3122 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3123 printf (_(" (bytes into file)\n Start of section headers: "));
3124 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3125 printf (_(" (bytes into file)\n"));
3127 printf (_(" Flags: 0x%lx%s\n"),
3128 (unsigned long) elf_header
.e_flags
,
3129 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3130 printf (_(" Size of this header: %ld (bytes)\n"),
3131 (long) elf_header
.e_ehsize
);
3132 printf (_(" Size of program headers: %ld (bytes)\n"),
3133 (long) elf_header
.e_phentsize
);
3134 printf (_(" Number of program headers: %ld\n"),
3135 (long) elf_header
.e_phnum
);
3136 printf (_(" Size of section headers: %ld (bytes)\n"),
3137 (long) elf_header
.e_shentsize
);
3138 printf (_(" Number of section headers: %ld"),
3139 (long) elf_header
.e_shnum
);
3140 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3141 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3142 putc ('\n', stdout
);
3143 printf (_(" Section header string table index: %ld"),
3144 (long) elf_header
.e_shstrndx
);
3145 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3146 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3147 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3148 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3149 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3150 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3151 printf (" <corrupt: out of range>");
3152 putc ('\n', stdout
);
3155 if (section_headers
!= NULL
)
3157 if (elf_header
.e_shnum
== 0)
3158 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3159 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3160 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3161 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3162 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3163 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3164 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3165 elf_header
.e_shstrndx
= SHN_UNDEF
;
3166 free (section_headers
);
3167 section_headers
= NULL
;
3175 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3177 Elf32_External_Phdr
*phdrs
;
3178 Elf32_External_Phdr
*external
;
3179 Elf_Internal_Phdr
*internal
;
3182 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3183 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3184 _("program headers"));
3188 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3189 i
< elf_header
.e_phnum
;
3190 i
++, internal
++, external
++)
3192 internal
->p_type
= BYTE_GET (external
->p_type
);
3193 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3194 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3195 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3196 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3197 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3198 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3199 internal
->p_align
= BYTE_GET (external
->p_align
);
3208 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3210 Elf64_External_Phdr
*phdrs
;
3211 Elf64_External_Phdr
*external
;
3212 Elf_Internal_Phdr
*internal
;
3215 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3216 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3217 _("program headers"));
3221 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3222 i
< elf_header
.e_phnum
;
3223 i
++, internal
++, external
++)
3225 internal
->p_type
= BYTE_GET (external
->p_type
);
3226 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3227 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3228 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3229 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3230 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3231 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3232 internal
->p_align
= BYTE_GET (external
->p_align
);
3240 /* Returns 1 if the program headers were read into `program_headers'. */
3243 get_program_headers (FILE *file
)
3245 Elf_Internal_Phdr
*phdrs
;
3247 /* Check cache of prior read. */
3248 if (program_headers
!= NULL
)
3251 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3255 error (_("Out of memory\n"));
3260 ? get_32bit_program_headers (file
, phdrs
)
3261 : get_64bit_program_headers (file
, phdrs
))
3263 program_headers
= phdrs
;
3271 /* Returns 1 if the program headers were loaded. */
3274 process_program_headers (FILE *file
)
3276 Elf_Internal_Phdr
*segment
;
3279 if (elf_header
.e_phnum
== 0)
3282 printf (_("\nThere are no program headers in this file.\n"));
3286 if (do_segments
&& !do_header
)
3288 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3289 printf (_("Entry point "));
3290 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3291 printf (_("\nThere are %d program headers, starting at offset "),
3292 elf_header
.e_phnum
);
3293 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3297 if (! get_program_headers (file
))
3302 if (elf_header
.e_phnum
> 1)
3303 printf (_("\nProgram Headers:\n"));
3305 printf (_("\nProgram Headers:\n"));
3309 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3312 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3316 (_(" Type Offset VirtAddr PhysAddr\n"));
3318 (_(" FileSiz MemSiz Flags Align\n"));
3325 for (i
= 0, segment
= program_headers
;
3326 i
< elf_header
.e_phnum
;
3331 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3335 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3336 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3337 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3338 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3339 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3341 (segment
->p_flags
& PF_R
? 'R' : ' '),
3342 (segment
->p_flags
& PF_W
? 'W' : ' '),
3343 (segment
->p_flags
& PF_X
? 'E' : ' '));
3344 printf ("%#lx", (unsigned long) segment
->p_align
);
3348 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3349 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3352 print_vma (segment
->p_offset
, FULL_HEX
);
3356 print_vma (segment
->p_vaddr
, FULL_HEX
);
3358 print_vma (segment
->p_paddr
, FULL_HEX
);
3361 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3362 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3365 print_vma (segment
->p_filesz
, FULL_HEX
);
3369 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3370 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3373 print_vma (segment
->p_offset
, FULL_HEX
);
3377 (segment
->p_flags
& PF_R
? 'R' : ' '),
3378 (segment
->p_flags
& PF_W
? 'W' : ' '),
3379 (segment
->p_flags
& PF_X
? 'E' : ' '));
3381 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3382 printf ("%#lx", (unsigned long) segment
->p_align
);
3385 print_vma (segment
->p_align
, PREFIX_HEX
);
3390 print_vma (segment
->p_offset
, FULL_HEX
);
3392 print_vma (segment
->p_vaddr
, FULL_HEX
);
3394 print_vma (segment
->p_paddr
, FULL_HEX
);
3396 print_vma (segment
->p_filesz
, FULL_HEX
);
3398 print_vma (segment
->p_memsz
, FULL_HEX
);
3400 (segment
->p_flags
& PF_R
? 'R' : ' '),
3401 (segment
->p_flags
& PF_W
? 'W' : ' '),
3402 (segment
->p_flags
& PF_X
? 'E' : ' '));
3403 print_vma (segment
->p_align
, HEX
);
3407 switch (segment
->p_type
)
3411 error (_("more than one dynamic segment\n"));
3413 /* Try to locate the .dynamic section. If there is
3414 a section header table, we can easily locate it. */
3415 if (section_headers
!= NULL
)
3417 Elf_Internal_Shdr
*sec
;
3419 sec
= find_section (".dynamic");
3420 if (sec
== NULL
|| sec
->sh_size
== 0)
3422 error (_("no .dynamic section in the dynamic segment"));
3426 dynamic_addr
= sec
->sh_offset
;
3427 dynamic_size
= sec
->sh_size
;
3429 if (dynamic_addr
< segment
->p_offset
3430 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3431 warn (_("the .dynamic section is not contained within the dynamic segment"));
3432 else if (dynamic_addr
> segment
->p_offset
)
3433 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3437 /* Otherwise, we can only assume that the .dynamic
3438 section is the first section in the DYNAMIC segment. */
3439 dynamic_addr
= segment
->p_offset
;
3440 dynamic_size
= segment
->p_filesz
;
3445 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3447 error (_("Unable to find program interpreter name\n"));
3450 program_interpreter
[0] = 0;
3451 fscanf (file
, "%63s", program_interpreter
);
3454 printf (_("\n [Requesting program interpreter: %s]"),
3455 program_interpreter
);
3461 putc ('\n', stdout
);
3464 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3466 printf (_("\n Section to Segment mapping:\n"));
3467 printf (_(" Segment Sections...\n"));
3469 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3472 Elf_Internal_Shdr
*section
;
3474 segment
= program_headers
+ i
;
3475 section
= section_headers
;
3477 printf (" %2.2d ", i
);
3479 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3481 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3482 printf ("%s ", SECTION_NAME (section
));
3493 /* Find the file offset corresponding to VMA by using the program headers. */
3496 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3498 Elf_Internal_Phdr
*seg
;
3500 if (! get_program_headers (file
))
3502 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3506 for (seg
= program_headers
;
3507 seg
< program_headers
+ elf_header
.e_phnum
;
3510 if (seg
->p_type
!= PT_LOAD
)
3513 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3514 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3515 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3518 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3525 get_32bit_section_headers (FILE *file
, unsigned int num
)
3527 Elf32_External_Shdr
*shdrs
;
3528 Elf_Internal_Shdr
*internal
;
3531 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3532 elf_header
.e_shentsize
, num
, _("section headers"));
3536 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3538 if (section_headers
== NULL
)
3540 error (_("Out of memory\n"));
3544 for (i
= 0, internal
= section_headers
;
3548 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3549 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3550 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3551 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3552 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3553 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3554 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3555 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3556 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3557 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3566 get_64bit_section_headers (FILE *file
, unsigned int num
)
3568 Elf64_External_Shdr
*shdrs
;
3569 Elf_Internal_Shdr
*internal
;
3572 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3573 elf_header
.e_shentsize
, num
, _("section headers"));
3577 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3579 if (section_headers
== NULL
)
3581 error (_("Out of memory\n"));
3585 for (i
= 0, internal
= section_headers
;
3589 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3590 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3591 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3592 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3593 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3594 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3595 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3596 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3597 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3598 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3606 static Elf_Internal_Sym
*
3607 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3609 unsigned long number
;
3610 Elf32_External_Sym
*esyms
;
3611 Elf_External_Sym_Shndx
*shndx
;
3612 Elf_Internal_Sym
*isyms
;
3613 Elf_Internal_Sym
*psym
;
3616 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3622 if (symtab_shndx_hdr
!= NULL
3623 && (symtab_shndx_hdr
->sh_link
3624 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3626 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3627 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3635 number
= section
->sh_size
/ section
->sh_entsize
;
3636 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3640 error (_("Out of memory\n"));
3647 for (j
= 0, psym
= isyms
;
3651 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3652 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3653 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3654 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3655 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3657 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3658 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3659 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3669 static Elf_Internal_Sym
*
3670 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3672 unsigned long number
;
3673 Elf64_External_Sym
*esyms
;
3674 Elf_External_Sym_Shndx
*shndx
;
3675 Elf_Internal_Sym
*isyms
;
3676 Elf_Internal_Sym
*psym
;
3679 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3685 if (symtab_shndx_hdr
!= NULL
3686 && (symtab_shndx_hdr
->sh_link
3687 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3689 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3690 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3698 number
= section
->sh_size
/ section
->sh_entsize
;
3699 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3703 error (_("Out of memory\n"));
3710 for (j
= 0, psym
= isyms
;
3714 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3715 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3716 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3717 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3718 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3720 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3721 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3722 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3733 get_elf_section_flags (bfd_vma sh_flags
)
3735 static char buff
[1024];
3737 int field_size
= is_32bit_elf
? 8 : 16;
3738 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3739 bfd_vma os_flags
= 0;
3740 bfd_vma proc_flags
= 0;
3741 bfd_vma unknown_flags
= 0;
3755 { "LINK ORDER", 10 },
3756 { "OS NONCONF", 10 },
3761 if (do_section_details
)
3763 sprintf (buff
, "[%*.*lx]: ",
3764 field_size
, field_size
, (unsigned long) sh_flags
);
3765 p
+= field_size
+ 4;
3772 flag
= sh_flags
& - sh_flags
;
3775 if (do_section_details
)
3779 case SHF_WRITE
: index
= 0; break;
3780 case SHF_ALLOC
: index
= 1; break;
3781 case SHF_EXECINSTR
: index
= 2; break;
3782 case SHF_MERGE
: index
= 3; break;
3783 case SHF_STRINGS
: index
= 4; break;
3784 case SHF_INFO_LINK
: index
= 5; break;
3785 case SHF_LINK_ORDER
: index
= 6; break;
3786 case SHF_OS_NONCONFORMING
: index
= 7; break;
3787 case SHF_GROUP
: index
= 8; break;
3788 case SHF_TLS
: index
= 9; break;
3797 if (p
!= buff
+ field_size
+ 4)
3799 if (size
< (10 + 2))
3806 size
-= flags
[index
].len
;
3807 p
= stpcpy (p
, flags
[index
].str
);
3809 else if (flag
& SHF_MASKOS
)
3811 else if (flag
& SHF_MASKPROC
)
3814 unknown_flags
|= flag
;
3820 case SHF_WRITE
: *p
= 'W'; break;
3821 case SHF_ALLOC
: *p
= 'A'; break;
3822 case SHF_EXECINSTR
: *p
= 'X'; break;
3823 case SHF_MERGE
: *p
= 'M'; break;
3824 case SHF_STRINGS
: *p
= 'S'; break;
3825 case SHF_INFO_LINK
: *p
= 'I'; break;
3826 case SHF_LINK_ORDER
: *p
= 'L'; break;
3827 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3828 case SHF_GROUP
: *p
= 'G'; break;
3829 case SHF_TLS
: *p
= 'T'; break;
3832 if (elf_header
.e_machine
== EM_X86_64
3833 && flag
== SHF_X86_64_LARGE
)
3835 else if (flag
& SHF_MASKOS
)
3838 sh_flags
&= ~ SHF_MASKOS
;
3840 else if (flag
& SHF_MASKPROC
)
3843 sh_flags
&= ~ SHF_MASKPROC
;
3853 if (do_section_details
)
3857 size
-= 5 + field_size
;
3858 if (p
!= buff
+ field_size
+ 4)
3866 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3867 (unsigned long) os_flags
);
3868 p
+= 5 + field_size
;
3872 size
-= 7 + field_size
;
3873 if (p
!= buff
+ field_size
+ 4)
3881 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3882 (unsigned long) proc_flags
);
3883 p
+= 7 + field_size
;
3887 size
-= 10 + field_size
;
3888 if (p
!= buff
+ field_size
+ 4)
3896 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3897 (unsigned long) unknown_flags
);
3898 p
+= 10 + field_size
;
3907 process_section_headers (FILE *file
)
3909 Elf_Internal_Shdr
*section
;
3912 section_headers
= NULL
;
3914 if (elf_header
.e_shnum
== 0)
3917 printf (_("\nThere are no sections in this file.\n"));
3922 if (do_sections
&& !do_header
)
3923 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3924 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3928 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3931 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3934 /* Read in the string table, so that we have names to display. */
3935 if (elf_header
.e_shstrndx
!= SHN_UNDEF
3936 && SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3938 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3940 if (section
->sh_size
!= 0)
3942 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3943 1, section
->sh_size
, _("string table"));
3945 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
3949 /* Scan the sections for the dynamic symbol table
3950 and dynamic string table and debug sections. */
3951 dynamic_symbols
= NULL
;
3952 dynamic_strings
= NULL
;
3953 dynamic_syminfo
= NULL
;
3954 symtab_shndx_hdr
= NULL
;
3956 eh_addr_size
= is_32bit_elf
? 4 : 8;
3957 switch (elf_header
.e_machine
)
3960 case EM_MIPS_RS3_LE
:
3961 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3962 FDE addresses. However, the ABI also has a semi-official ILP32
3963 variant for which the normal FDE address size rules apply.
3965 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3966 section, where XX is the size of longs in bits. Unfortunately,
3967 earlier compilers provided no way of distinguishing ILP32 objects
3968 from LP64 objects, so if there's any doubt, we should assume that
3969 the official LP64 form is being used. */
3970 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3971 && find_section (".gcc_compiled_long32") == NULL
)
3977 switch (elf_header
.e_flags
& EF_H8_MACH
)
3979 case E_H8_MACH_H8300
:
3980 case E_H8_MACH_H8300HN
:
3981 case E_H8_MACH_H8300SN
:
3982 case E_H8_MACH_H8300SXN
:
3985 case E_H8_MACH_H8300H
:
3986 case E_H8_MACH_H8300S
:
3987 case E_H8_MACH_H8300SX
:
3993 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3996 size_t expected_entsize \
3997 = is_32bit_elf ? size32 : size64; \
3998 if (section->sh_entsize != expected_entsize) \
3999 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4000 i, (unsigned long int) section->sh_entsize, \
4001 (unsigned long int) expected_entsize); \
4002 section->sh_entsize = expected_entsize; \
4005 #define CHECK_ENTSIZE(section, i, type) \
4006 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4007 sizeof (Elf64_External_##type))
4009 for (i
= 0, section
= section_headers
;
4010 i
< elf_header
.e_shnum
;
4013 char *name
= SECTION_NAME (section
);
4015 if (section
->sh_type
== SHT_DYNSYM
)
4017 if (dynamic_symbols
!= NULL
)
4019 error (_("File contains multiple dynamic symbol tables\n"));
4023 CHECK_ENTSIZE (section
, i
, Sym
);
4024 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4025 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4027 else if (section
->sh_type
== SHT_STRTAB
4028 && streq (name
, ".dynstr"))
4030 if (dynamic_strings
!= NULL
)
4032 error (_("File contains multiple dynamic string tables\n"));
4036 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4037 1, section
->sh_size
, _("dynamic strings"));
4038 dynamic_strings_length
= section
->sh_size
;
4040 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4042 if (symtab_shndx_hdr
!= NULL
)
4044 error (_("File contains multiple symtab shndx tables\n"));
4047 symtab_shndx_hdr
= section
;
4049 else if (section
->sh_type
== SHT_SYMTAB
)
4050 CHECK_ENTSIZE (section
, i
, Sym
);
4051 else if (section
->sh_type
== SHT_GROUP
)
4052 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4053 else if (section
->sh_type
== SHT_REL
)
4054 CHECK_ENTSIZE (section
, i
, Rel
);
4055 else if (section
->sh_type
== SHT_RELA
)
4056 CHECK_ENTSIZE (section
, i
, Rela
);
4057 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4058 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4059 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4060 || do_debug_loc
|| do_debug_ranges
)
4061 && strneq (name
, ".debug_", 7))
4066 || (do_debug_info
&& streq (name
, "info"))
4067 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4068 || (do_debug_lines
&& streq (name
, "line"))
4069 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4070 || (do_debug_aranges
&& streq (name
, "aranges"))
4071 || (do_debug_ranges
&& streq (name
, "ranges"))
4072 || (do_debug_frames
&& streq (name
, "frame"))
4073 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4074 || (do_debug_str
&& streq (name
, "str"))
4075 || (do_debug_loc
&& streq (name
, "loc"))
4077 request_dump (i
, DEBUG_DUMP
);
4079 /* linkonce section to be combined with .debug_info at link time. */
4080 else if ((do_debugging
|| do_debug_info
)
4081 && strneq (name
, ".gnu.linkonce.wi.", 17))
4082 request_dump (i
, DEBUG_DUMP
);
4083 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4084 request_dump (i
, DEBUG_DUMP
);
4090 if (elf_header
.e_shnum
> 1)
4091 printf (_("\nSection Headers:\n"));
4093 printf (_("\nSection Header:\n"));
4097 if (do_section_details
)
4099 printf (_(" [Nr] Name\n"));
4100 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4104 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4108 if (do_section_details
)
4110 printf (_(" [Nr] Name\n"));
4111 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4115 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4119 if (do_section_details
)
4121 printf (_(" [Nr] Name\n"));
4122 printf (_(" Type Address Offset Link\n"));
4123 printf (_(" Size EntSize Info Align\n"));
4127 printf (_(" [Nr] Name Type Address Offset\n"));
4128 printf (_(" Size EntSize Flags Link Info Align\n"));
4132 if (do_section_details
)
4133 printf (_(" Flags\n"));
4135 for (i
= 0, section
= section_headers
;
4136 i
< elf_header
.e_shnum
;
4139 if (do_section_details
)
4141 printf (" [%2u] %s\n",
4142 SECTION_HEADER_NUM (i
),
4143 SECTION_NAME (section
));
4144 if (is_32bit_elf
|| do_wide
)
4145 printf (" %-15.15s ",
4146 get_section_type_name (section
->sh_type
));
4149 printf (" [%2u] %-17.17s %-15.15s ",
4150 SECTION_HEADER_NUM (i
),
4151 SECTION_NAME (section
),
4152 get_section_type_name (section
->sh_type
));
4156 print_vma (section
->sh_addr
, LONG_HEX
);
4158 printf ( " %6.6lx %6.6lx %2.2lx",
4159 (unsigned long) section
->sh_offset
,
4160 (unsigned long) section
->sh_size
,
4161 (unsigned long) section
->sh_entsize
);
4163 if (do_section_details
)
4164 fputs (" ", stdout
);
4166 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4168 printf ("%2ld %3lu %2ld\n",
4169 (unsigned long) section
->sh_link
,
4170 (unsigned long) section
->sh_info
,
4171 (unsigned long) section
->sh_addralign
);
4175 print_vma (section
->sh_addr
, LONG_HEX
);
4177 if ((long) section
->sh_offset
== section
->sh_offset
)
4178 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4182 print_vma (section
->sh_offset
, LONG_HEX
);
4185 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4186 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4190 print_vma (section
->sh_size
, LONG_HEX
);
4193 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4194 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4198 print_vma (section
->sh_entsize
, LONG_HEX
);
4201 if (do_section_details
)
4202 fputs (" ", stdout
);
4204 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4206 printf ("%2ld %3lu ",
4207 (unsigned long) section
->sh_link
,
4208 (unsigned long) section
->sh_info
);
4210 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4211 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4214 print_vma (section
->sh_addralign
, DEC
);
4218 else if (do_section_details
)
4220 printf (" %-15.15s ",
4221 get_section_type_name (section
->sh_type
));
4222 print_vma (section
->sh_addr
, LONG_HEX
);
4223 if ((long) section
->sh_offset
== section
->sh_offset
)
4224 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4228 print_vma (section
->sh_offset
, LONG_HEX
);
4230 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4231 print_vma (section
->sh_size
, LONG_HEX
);
4233 print_vma (section
->sh_entsize
, LONG_HEX
);
4235 printf (" %-16lu %ld\n",
4236 (unsigned long) section
->sh_info
,
4237 (unsigned long) section
->sh_addralign
);
4242 print_vma (section
->sh_addr
, LONG_HEX
);
4243 if ((long) section
->sh_offset
== section
->sh_offset
)
4244 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4248 print_vma (section
->sh_offset
, LONG_HEX
);
4251 print_vma (section
->sh_size
, LONG_HEX
);
4253 print_vma (section
->sh_entsize
, LONG_HEX
);
4255 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4257 printf (" %2ld %3lu %ld\n",
4258 (unsigned long) section
->sh_link
,
4259 (unsigned long) section
->sh_info
,
4260 (unsigned long) section
->sh_addralign
);
4263 if (do_section_details
)
4264 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4267 if (!do_section_details
)
4268 printf (_("Key to Flags:\n\
4269 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4270 I (info), L (link order), G (group), x (unknown)\n\
4271 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4277 get_group_flags (unsigned int flags
)
4279 static char buff
[32];
4286 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4293 process_section_groups (FILE *file
)
4295 Elf_Internal_Shdr
*section
;
4297 struct group
*group
;
4298 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4299 Elf_Internal_Sym
*symtab
;
4303 /* Don't process section groups unless needed. */
4304 if (!do_unwind
&& !do_section_groups
)
4307 if (elf_header
.e_shnum
== 0)
4309 if (do_section_groups
)
4310 printf (_("\nThere are no sections in this file.\n"));
4315 if (section_headers
== NULL
)
4317 error (_("Section headers are not available!\n"));
4321 section_headers_groups
= calloc (elf_header
.e_shnum
,
4322 sizeof (struct group
*));
4324 if (section_headers_groups
== NULL
)
4326 error (_("Out of memory\n"));
4330 /* Scan the sections for the group section. */
4332 for (i
= 0, section
= section_headers
;
4333 i
< elf_header
.e_shnum
;
4335 if (section
->sh_type
== SHT_GROUP
)
4338 if (group_count
== 0)
4340 if (do_section_groups
)
4341 printf (_("\nThere are no section groups in this file.\n"));
4346 section_groups
= calloc (group_count
, sizeof (struct group
));
4348 if (section_groups
== NULL
)
4350 error (_("Out of memory\n"));
4359 for (i
= 0, section
= section_headers
, group
= section_groups
;
4360 i
< elf_header
.e_shnum
;
4363 if (section
->sh_type
== SHT_GROUP
)
4365 char *name
= SECTION_NAME (section
);
4367 unsigned char *start
, *indices
;
4368 unsigned int entry
, j
, size
;
4369 Elf_Internal_Shdr
*sec
;
4370 Elf_Internal_Sym
*sym
;
4372 /* Get the symbol table. */
4373 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4374 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4377 error (_("Bad sh_link in group section `%s'\n"), name
);
4381 if (symtab_sec
!= sec
)
4386 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4389 sym
= symtab
+ section
->sh_info
;
4391 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4393 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4396 error (_("Bad sh_info in group section `%s'\n"), name
);
4400 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4409 /* Get the string table. */
4410 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4411 >= elf_header
.e_shnum
)
4420 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4425 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4426 1, strtab_sec
->sh_size
,
4428 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4430 group_name
= sym
->st_name
< strtab_size
4431 ? strtab
+ sym
->st_name
: "<corrupt>";
4434 start
= get_data (NULL
, file
, section
->sh_offset
,
4435 1, section
->sh_size
, _("section data"));
4438 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4439 entry
= byte_get (indices
, 4);
4442 if (do_section_groups
)
4444 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4445 get_group_flags (entry
), i
, name
, group_name
, size
);
4447 printf (_(" [Index] Name\n"));
4450 group
->group_index
= i
;
4452 for (j
= 0; j
< size
; j
++)
4454 struct group_list
*g
;
4456 entry
= byte_get (indices
, 4);
4459 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4461 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4462 entry
, i
, elf_header
.e_shnum
- 1);
4465 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4467 error (_("invalid section [%5u] in group section [%5u]\n"),
4472 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4477 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4479 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4484 /* Intel C/C++ compiler may put section 0 in a
4485 section group. We just warn it the first time
4486 and ignore it afterwards. */
4487 static int warned
= 0;
4490 error (_("section 0 in group section [%5u]\n"),
4491 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4497 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4500 if (do_section_groups
)
4502 sec
= SECTION_HEADER (entry
);
4503 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4506 g
= xmalloc (sizeof (struct group_list
));
4507 g
->section_index
= entry
;
4508 g
->next
= group
->root
;
4532 } dynamic_relocations
[] =
4534 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4535 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4536 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4539 /* Process the reloc section. */
4542 process_relocs (FILE *file
)
4544 unsigned long rel_size
;
4545 unsigned long rel_offset
;
4551 if (do_using_dynamic
)
4555 int has_dynamic_reloc
;
4558 has_dynamic_reloc
= 0;
4560 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4562 is_rela
= dynamic_relocations
[i
].rela
;
4563 name
= dynamic_relocations
[i
].name
;
4564 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4565 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4567 has_dynamic_reloc
|= rel_size
;
4569 if (is_rela
== UNKNOWN
)
4571 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4572 switch (dynamic_info
[DT_PLTREL
])
4586 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4587 name
, rel_offset
, rel_size
);
4589 dump_relocations (file
,
4590 offset_from_vma (file
, rel_offset
, rel_size
),
4592 dynamic_symbols
, num_dynamic_syms
,
4593 dynamic_strings
, dynamic_strings_length
, is_rela
);
4597 if (! has_dynamic_reloc
)
4598 printf (_("\nThere are no dynamic relocations in this file.\n"));
4602 Elf_Internal_Shdr
*section
;
4606 for (i
= 0, section
= section_headers
;
4607 i
< elf_header
.e_shnum
;
4610 if ( section
->sh_type
!= SHT_RELA
4611 && section
->sh_type
!= SHT_REL
)
4614 rel_offset
= section
->sh_offset
;
4615 rel_size
= section
->sh_size
;
4619 Elf_Internal_Shdr
*strsec
;
4622 printf (_("\nRelocation section "));
4624 if (string_table
== NULL
)
4625 printf ("%d", section
->sh_name
);
4627 printf (_("'%s'"), SECTION_NAME (section
));
4629 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4630 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4632 is_rela
= section
->sh_type
== SHT_RELA
;
4634 if (section
->sh_link
4635 && SECTION_HEADER_INDEX (section
->sh_link
)
4636 < elf_header
.e_shnum
)
4638 Elf_Internal_Shdr
*symsec
;
4639 Elf_Internal_Sym
*symtab
;
4640 unsigned long nsyms
;
4641 unsigned long strtablen
= 0;
4642 char *strtab
= NULL
;
4644 symsec
= SECTION_HEADER (section
->sh_link
);
4645 if (symsec
->sh_type
!= SHT_SYMTAB
4646 && symsec
->sh_type
!= SHT_DYNSYM
)
4649 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4650 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4655 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4656 < elf_header
.e_shnum
)
4658 strsec
= SECTION_HEADER (symsec
->sh_link
);
4660 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4663 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4666 dump_relocations (file
, rel_offset
, rel_size
,
4667 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4673 dump_relocations (file
, rel_offset
, rel_size
,
4674 NULL
, 0, NULL
, 0, is_rela
);
4681 printf (_("\nThere are no relocations in this file.\n"));
4687 /* Process the unwind section. */
4689 #include "unwind-ia64.h"
4691 /* An absolute address consists of a section and an offset. If the
4692 section is NULL, the offset itself is the address, otherwise, the
4693 address equals to LOAD_ADDRESS(section) + offset. */
4697 unsigned short section
;
4701 #define ABSADDR(a) \
4703 ? section_headers [(a).section].sh_addr + (a).offset \
4706 struct ia64_unw_aux_info
4708 struct ia64_unw_table_entry
4710 struct absaddr start
;
4712 struct absaddr info
;
4714 *table
; /* Unwind table. */
4715 unsigned long table_len
; /* Length of unwind table. */
4716 unsigned char *info
; /* Unwind info. */
4717 unsigned long info_size
; /* Size of unwind info. */
4718 bfd_vma info_addr
; /* starting address of unwind info. */
4719 bfd_vma seg_base
; /* Starting address of segment. */
4720 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4721 unsigned long nsyms
; /* Number of symbols. */
4722 char *strtab
; /* The string table. */
4723 unsigned long strtab_size
; /* Size of string table. */
4727 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4728 unsigned long nsyms
,
4730 unsigned long strtab_size
,
4731 struct absaddr addr
,
4732 const char **symname
,
4735 bfd_vma dist
= 0x100000;
4736 Elf_Internal_Sym
*sym
, *best
= NULL
;
4739 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4741 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4742 && sym
->st_name
!= 0
4743 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4744 && addr
.offset
>= sym
->st_value
4745 && addr
.offset
- sym
->st_value
< dist
)
4748 dist
= addr
.offset
- sym
->st_value
;
4755 *symname
= (best
->st_name
>= strtab_size
4756 ? "<corrupt>" : strtab
+ best
->st_name
);
4761 *offset
= addr
.offset
;
4765 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4767 struct ia64_unw_table_entry
*tp
;
4770 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4774 const unsigned char *dp
;
4775 const unsigned char *head
;
4776 const char *procname
;
4778 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4779 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4781 fputs ("\n<", stdout
);
4785 fputs (procname
, stdout
);
4788 printf ("+%lx", (unsigned long) offset
);
4791 fputs (">: [", stdout
);
4792 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4793 fputc ('-', stdout
);
4794 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4795 printf ("], info at +0x%lx\n",
4796 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4798 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4799 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4801 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4802 (unsigned) UNW_VER (stamp
),
4803 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4804 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4805 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4806 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4808 if (UNW_VER (stamp
) != 1)
4810 printf ("\tUnknown version.\n");
4815 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4816 dp
= unw_decode (dp
, in_body
, & in_body
);
4821 slurp_ia64_unwind_table (FILE *file
,
4822 struct ia64_unw_aux_info
*aux
,
4823 Elf_Internal_Shdr
*sec
)
4825 unsigned long size
, nrelas
, i
;
4826 Elf_Internal_Phdr
*seg
;
4827 struct ia64_unw_table_entry
*tep
;
4828 Elf_Internal_Shdr
*relsec
;
4829 Elf_Internal_Rela
*rela
, *rp
;
4830 unsigned char *table
, *tp
;
4831 Elf_Internal_Sym
*sym
;
4832 const char *relname
;
4834 /* First, find the starting address of the segment that includes
4837 if (elf_header
.e_phnum
)
4839 if (! get_program_headers (file
))
4842 for (seg
= program_headers
;
4843 seg
< program_headers
+ elf_header
.e_phnum
;
4846 if (seg
->p_type
!= PT_LOAD
)
4849 if (sec
->sh_addr
>= seg
->p_vaddr
4850 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4852 aux
->seg_base
= seg
->p_vaddr
;
4858 /* Second, build the unwind table from the contents of the unwind section: */
4859 size
= sec
->sh_size
;
4860 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4864 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4866 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4868 tep
->start
.section
= SHN_UNDEF
;
4869 tep
->end
.section
= SHN_UNDEF
;
4870 tep
->info
.section
= SHN_UNDEF
;
4873 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4874 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4875 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4879 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4880 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4881 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4883 tep
->start
.offset
+= aux
->seg_base
;
4884 tep
->end
.offset
+= aux
->seg_base
;
4885 tep
->info
.offset
+= aux
->seg_base
;
4889 /* Third, apply any relocations to the unwind table: */
4891 for (relsec
= section_headers
;
4892 relsec
< section_headers
+ elf_header
.e_shnum
;
4895 if (relsec
->sh_type
!= SHT_RELA
4896 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4897 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4900 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4904 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4908 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4909 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4913 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4914 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4917 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4919 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4923 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4925 switch (rp
->r_offset
/eh_addr_size
% 3)
4928 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4929 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4932 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4933 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4936 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4937 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4947 aux
->table_len
= size
/ (3 * eh_addr_size
);
4952 ia64_process_unwind (FILE *file
)
4954 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4955 unsigned long i
, unwcount
= 0, unwstart
= 0;
4956 struct ia64_unw_aux_info aux
;
4958 memset (& aux
, 0, sizeof (aux
));
4960 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4962 if (sec
->sh_type
== SHT_SYMTAB
4963 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
4965 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4966 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4968 strsec
= SECTION_HEADER (sec
->sh_link
);
4969 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4970 1, strsec
->sh_size
, _("string table"));
4971 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
4973 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4978 printf (_("\nThere are no unwind sections in this file.\n"));
4980 while (unwcount
-- > 0)
4985 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4986 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4987 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4994 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4996 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4998 /* We need to find which section group it is in. */
4999 struct group_list
*g
= section_headers_groups
[i
]->root
;
5001 for (; g
!= NULL
; g
= g
->next
)
5003 sec
= SECTION_HEADER (g
->section_index
);
5005 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5010 i
= elf_header
.e_shnum
;
5012 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5014 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5015 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5016 suffix
= SECTION_NAME (unwsec
) + len
;
5017 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5019 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5020 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5025 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5026 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5027 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5028 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5030 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5031 suffix
= SECTION_NAME (unwsec
) + len
;
5032 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5034 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5035 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5039 if (i
== elf_header
.e_shnum
)
5041 printf (_("\nCould not find unwind info section for "));
5043 if (string_table
== NULL
)
5044 printf ("%d", unwsec
->sh_name
);
5046 printf (_("'%s'"), SECTION_NAME (unwsec
));
5050 aux
.info_size
= sec
->sh_size
;
5051 aux
.info_addr
= sec
->sh_addr
;
5052 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5055 printf (_("\nUnwind section "));
5057 if (string_table
== NULL
)
5058 printf ("%d", unwsec
->sh_name
);
5060 printf (_("'%s'"), SECTION_NAME (unwsec
));
5062 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5063 (unsigned long) unwsec
->sh_offset
,
5064 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5066 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5068 if (aux
.table_len
> 0)
5069 dump_ia64_unwind (& aux
);
5072 free ((char *) aux
.table
);
5074 free ((char *) aux
.info
);
5083 free ((char *) aux
.strtab
);
5088 struct hppa_unw_aux_info
5090 struct hppa_unw_table_entry
5092 struct absaddr start
;
5094 unsigned int Cannot_unwind
:1; /* 0 */
5095 unsigned int Millicode
:1; /* 1 */
5096 unsigned int Millicode_save_sr0
:1; /* 2 */
5097 unsigned int Region_description
:2; /* 3..4 */
5098 unsigned int reserved1
:1; /* 5 */
5099 unsigned int Entry_SR
:1; /* 6 */
5100 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5101 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5102 unsigned int Args_stored
:1; /* 16 */
5103 unsigned int Variable_Frame
:1; /* 17 */
5104 unsigned int Separate_Package_Body
:1; /* 18 */
5105 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5106 unsigned int Stack_Overflow_Check
:1; /* 20 */
5107 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5108 unsigned int Ada_Region
:1; /* 22 */
5109 unsigned int cxx_info
:1; /* 23 */
5110 unsigned int cxx_try_catch
:1; /* 24 */
5111 unsigned int sched_entry_seq
:1; /* 25 */
5112 unsigned int reserved2
:1; /* 26 */
5113 unsigned int Save_SP
:1; /* 27 */
5114 unsigned int Save_RP
:1; /* 28 */
5115 unsigned int Save_MRP_in_frame
:1; /* 29 */
5116 unsigned int extn_ptr_defined
:1; /* 30 */
5117 unsigned int Cleanup_defined
:1; /* 31 */
5119 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5120 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5121 unsigned int Large_frame
:1; /* 2 */
5122 unsigned int Pseudo_SP_Set
:1; /* 3 */
5123 unsigned int reserved4
:1; /* 4 */
5124 unsigned int Total_frame_size
:27; /* 5..31 */
5126 *table
; /* Unwind table. */
5127 unsigned long table_len
; /* Length of unwind table. */
5128 bfd_vma seg_base
; /* Starting address of segment. */
5129 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5130 unsigned long nsyms
; /* Number of symbols. */
5131 char *strtab
; /* The string table. */
5132 unsigned long strtab_size
; /* Size of string table. */
5136 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5138 struct hppa_unw_table_entry
*tp
;
5140 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5143 const char *procname
;
5145 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5146 aux
->strtab_size
, tp
->start
, &procname
,
5149 fputs ("\n<", stdout
);
5153 fputs (procname
, stdout
);
5156 printf ("+%lx", (unsigned long) offset
);
5159 fputs (">: [", stdout
);
5160 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5161 fputc ('-', stdout
);
5162 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5165 #define PF(_m) if (tp->_m) printf (#_m " ");
5166 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5169 PF(Millicode_save_sr0
);
5170 /* PV(Region_description); */
5176 PF(Separate_Package_Body
);
5177 PF(Frame_Extension_Millicode
);
5178 PF(Stack_Overflow_Check
);
5179 PF(Two_Instruction_SP_Increment
);
5183 PF(sched_entry_seq
);
5186 PF(Save_MRP_in_frame
);
5187 PF(extn_ptr_defined
);
5188 PF(Cleanup_defined
);
5189 PF(MPE_XL_interrupt_marker
);
5190 PF(HP_UX_interrupt_marker
);
5193 PV(Total_frame_size
);
5202 slurp_hppa_unwind_table (FILE *file
,
5203 struct hppa_unw_aux_info
*aux
,
5204 Elf_Internal_Shdr
*sec
)
5206 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5207 Elf_Internal_Phdr
*seg
;
5208 struct hppa_unw_table_entry
*tep
;
5209 Elf_Internal_Shdr
*relsec
;
5210 Elf_Internal_Rela
*rela
, *rp
;
5211 unsigned char *table
, *tp
;
5212 Elf_Internal_Sym
*sym
;
5213 const char *relname
;
5215 /* First, find the starting address of the segment that includes
5218 if (elf_header
.e_phnum
)
5220 if (! get_program_headers (file
))
5223 for (seg
= program_headers
;
5224 seg
< program_headers
+ elf_header
.e_phnum
;
5227 if (seg
->p_type
!= PT_LOAD
)
5230 if (sec
->sh_addr
>= seg
->p_vaddr
5231 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5233 aux
->seg_base
= seg
->p_vaddr
;
5239 /* Second, build the unwind table from the contents of the unwind
5241 size
= sec
->sh_size
;
5242 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5247 nentries
= size
/ unw_ent_size
;
5248 size
= unw_ent_size
* nentries
;
5250 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5252 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5254 unsigned int tmp1
, tmp2
;
5256 tep
->start
.section
= SHN_UNDEF
;
5257 tep
->end
.section
= SHN_UNDEF
;
5259 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5260 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5261 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5262 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5264 tep
->start
.offset
+= aux
->seg_base
;
5265 tep
->end
.offset
+= aux
->seg_base
;
5267 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5268 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5269 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5270 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5271 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5272 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5273 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5274 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5275 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5276 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5277 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5278 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5279 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5280 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5281 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5282 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5283 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5284 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5285 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5286 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5287 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5288 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5289 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5290 tep
->Cleanup_defined
= tmp1
& 0x1;
5292 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5293 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5294 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5295 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5296 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5297 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5301 /* Third, apply any relocations to the unwind table. */
5303 for (relsec
= section_headers
;
5304 relsec
< section_headers
+ elf_header
.e_shnum
;
5307 if (relsec
->sh_type
!= SHT_RELA
5308 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5309 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5312 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5316 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5320 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5321 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5325 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5326 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5329 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5330 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5332 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5336 i
= rp
->r_offset
/ unw_ent_size
;
5338 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5341 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5342 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5345 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5346 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5356 aux
->table_len
= nentries
;
5362 hppa_process_unwind (FILE *file
)
5364 struct hppa_unw_aux_info aux
;
5365 Elf_Internal_Shdr
*unwsec
= NULL
;
5366 Elf_Internal_Shdr
*strsec
;
5367 Elf_Internal_Shdr
*sec
;
5370 memset (& aux
, 0, sizeof (aux
));
5372 if (string_table
== NULL
)
5375 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5377 if (sec
->sh_type
== SHT_SYMTAB
5378 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5380 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5381 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5383 strsec
= SECTION_HEADER (sec
->sh_link
);
5384 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5385 1, strsec
->sh_size
, _("string table"));
5386 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5388 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5393 printf (_("\nThere are no unwind sections in this file.\n"));
5395 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5397 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5399 printf (_("\nUnwind section "));
5400 printf (_("'%s'"), SECTION_NAME (sec
));
5402 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5403 (unsigned long) sec
->sh_offset
,
5404 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5406 slurp_hppa_unwind_table (file
, &aux
, sec
);
5407 if (aux
.table_len
> 0)
5408 dump_hppa_unwind (&aux
);
5411 free ((char *) aux
.table
);
5419 free ((char *) aux
.strtab
);
5425 process_unwind (FILE *file
)
5427 struct unwind_handler
{
5429 int (*handler
)(FILE *file
);
5431 { EM_IA_64
, ia64_process_unwind
},
5432 { EM_PARISC
, hppa_process_unwind
},
5440 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5441 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5442 return handlers
[i
].handler (file
);
5444 printf (_("\nThere are no unwind sections in this file.\n"));
5449 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5451 switch (entry
->d_tag
)
5454 if (entry
->d_un
.d_val
== 0)
5458 static const char * opts
[] =
5460 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5461 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5462 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5463 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5468 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5469 if (entry
->d_un
.d_val
& (1 << cnt
))
5471 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5478 case DT_MIPS_IVERSION
:
5479 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5480 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5482 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5485 case DT_MIPS_TIME_STAMP
:
5490 time_t time
= entry
->d_un
.d_val
;
5491 tmp
= gmtime (&time
);
5492 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5493 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5494 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5495 printf ("Time Stamp: %s\n", timebuf
);
5499 case DT_MIPS_RLD_VERSION
:
5500 case DT_MIPS_LOCAL_GOTNO
:
5501 case DT_MIPS_CONFLICTNO
:
5502 case DT_MIPS_LIBLISTNO
:
5503 case DT_MIPS_SYMTABNO
:
5504 case DT_MIPS_UNREFEXTNO
:
5505 case DT_MIPS_HIPAGENO
:
5506 case DT_MIPS_DELTA_CLASS_NO
:
5507 case DT_MIPS_DELTA_INSTANCE_NO
:
5508 case DT_MIPS_DELTA_RELOC_NO
:
5509 case DT_MIPS_DELTA_SYM_NO
:
5510 case DT_MIPS_DELTA_CLASSSYM_NO
:
5511 case DT_MIPS_COMPACT_SIZE
:
5512 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5516 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5522 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5524 switch (entry
->d_tag
)
5526 case DT_HP_DLD_FLAGS
:
5535 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5536 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5537 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5538 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5539 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5540 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5541 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5542 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5543 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5544 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5545 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5546 { DT_HP_GST
, "HP_GST" },
5547 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5548 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5549 { DT_HP_NODELETE
, "HP_NODELETE" },
5550 { DT_HP_GROUP
, "HP_GROUP" },
5551 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5555 bfd_vma val
= entry
->d_un
.d_val
;
5557 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5558 if (val
& flags
[cnt
].bit
)
5562 fputs (flags
[cnt
].str
, stdout
);
5564 val
^= flags
[cnt
].bit
;
5567 if (val
!= 0 || first
)
5571 print_vma (val
, HEX
);
5577 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5584 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5586 switch (entry
->d_tag
)
5588 case DT_IA_64_PLT_RESERVE
:
5589 /* First 3 slots reserved. */
5590 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5592 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5596 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5603 get_32bit_dynamic_section (FILE *file
)
5605 Elf32_External_Dyn
*edyn
, *ext
;
5606 Elf_Internal_Dyn
*entry
;
5608 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5609 _("dynamic section"));
5613 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5614 might not have the luxury of section headers. Look for the DT_NULL
5615 terminator to determine the number of entries. */
5616 for (ext
= edyn
, dynamic_nent
= 0;
5617 (char *) ext
< (char *) edyn
+ dynamic_size
;
5621 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5625 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5626 if (dynamic_section
== NULL
)
5628 error (_("Out of memory\n"));
5633 for (ext
= edyn
, entry
= dynamic_section
;
5634 entry
< dynamic_section
+ dynamic_nent
;
5637 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5638 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5647 get_64bit_dynamic_section (FILE *file
)
5649 Elf64_External_Dyn
*edyn
, *ext
;
5650 Elf_Internal_Dyn
*entry
;
5652 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5653 _("dynamic section"));
5657 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5658 might not have the luxury of section headers. Look for the DT_NULL
5659 terminator to determine the number of entries. */
5660 for (ext
= edyn
, dynamic_nent
= 0;
5661 (char *) ext
< (char *) edyn
+ dynamic_size
;
5665 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5669 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5670 if (dynamic_section
== NULL
)
5672 error (_("Out of memory\n"));
5677 for (ext
= edyn
, entry
= dynamic_section
;
5678 entry
< dynamic_section
+ dynamic_nent
;
5681 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5682 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5691 print_dynamic_flags (bfd_vma flags
)
5699 flag
= flags
& - flags
;
5709 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5710 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5711 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5712 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5713 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5714 default: fputs ("unknown", stdout
); break;
5720 /* Parse and display the contents of the dynamic section. */
5723 process_dynamic_section (FILE *file
)
5725 Elf_Internal_Dyn
*entry
;
5727 if (dynamic_size
== 0)
5730 printf (_("\nThere is no dynamic section in this file.\n"));
5737 if (! get_32bit_dynamic_section (file
))
5740 else if (! get_64bit_dynamic_section (file
))
5743 /* Find the appropriate symbol table. */
5744 if (dynamic_symbols
== NULL
)
5746 for (entry
= dynamic_section
;
5747 entry
< dynamic_section
+ dynamic_nent
;
5750 Elf_Internal_Shdr section
;
5752 if (entry
->d_tag
!= DT_SYMTAB
)
5755 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5757 /* Since we do not know how big the symbol table is,
5758 we default to reading in the entire file (!) and
5759 processing that. This is overkill, I know, but it
5761 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5763 if (archive_file_offset
!= 0)
5764 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5767 if (fseek (file
, 0, SEEK_END
))
5768 error (_("Unable to seek to end of file!"));
5770 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5774 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5776 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5778 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5779 if (num_dynamic_syms
< 1)
5781 error (_("Unable to determine the number of symbols to load\n"));
5785 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5789 /* Similarly find a string table. */
5790 if (dynamic_strings
== NULL
)
5792 for (entry
= dynamic_section
;
5793 entry
< dynamic_section
+ dynamic_nent
;
5796 unsigned long offset
;
5799 if (entry
->d_tag
!= DT_STRTAB
)
5802 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5804 /* Since we do not know how big the string table is,
5805 we default to reading in the entire file (!) and
5806 processing that. This is overkill, I know, but it
5809 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5811 if (archive_file_offset
!= 0)
5812 str_tab_len
= archive_file_size
- offset
;
5815 if (fseek (file
, 0, SEEK_END
))
5816 error (_("Unable to seek to end of file\n"));
5817 str_tab_len
= ftell (file
) - offset
;
5820 if (str_tab_len
< 1)
5823 (_("Unable to determine the length of the dynamic string table\n"));
5827 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5828 _("dynamic string table"));
5829 dynamic_strings_length
= str_tab_len
;
5834 /* And find the syminfo section if available. */
5835 if (dynamic_syminfo
== NULL
)
5837 unsigned long syminsz
= 0;
5839 for (entry
= dynamic_section
;
5840 entry
< dynamic_section
+ dynamic_nent
;
5843 if (entry
->d_tag
== DT_SYMINENT
)
5845 /* Note: these braces are necessary to avoid a syntax
5846 error from the SunOS4 C compiler. */
5847 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5849 else if (entry
->d_tag
== DT_SYMINSZ
)
5850 syminsz
= entry
->d_un
.d_val
;
5851 else if (entry
->d_tag
== DT_SYMINFO
)
5852 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5856 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5858 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5859 Elf_Internal_Syminfo
*syminfo
;
5861 /* There is a syminfo section. Read the data. */
5862 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5863 syminsz
, _("symbol information"));
5867 dynamic_syminfo
= malloc (syminsz
);
5868 if (dynamic_syminfo
== NULL
)
5870 error (_("Out of memory\n"));
5874 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5875 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5876 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5877 ++syminfo
, ++extsym
)
5879 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5880 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5887 if (do_dynamic
&& dynamic_addr
)
5888 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5889 dynamic_addr
, dynamic_nent
);
5891 printf (_(" Tag Type Name/Value\n"));
5893 for (entry
= dynamic_section
;
5894 entry
< dynamic_section
+ dynamic_nent
;
5902 print_vma (entry
->d_tag
, FULL_HEX
);
5903 dtype
= get_dynamic_type (entry
->d_tag
);
5904 printf (" (%s)%*s", dtype
,
5905 ((is_32bit_elf
? 27 : 19)
5906 - (int) strlen (dtype
)),
5910 switch (entry
->d_tag
)
5914 print_dynamic_flags (entry
->d_un
.d_val
);
5924 switch (entry
->d_tag
)
5927 printf (_("Auxiliary library"));
5931 printf (_("Filter library"));
5935 printf (_("Configuration file"));
5939 printf (_("Dependency audit library"));
5943 printf (_("Audit library"));
5947 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5948 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5952 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5961 printf (_("Flags:"));
5963 if (entry
->d_un
.d_val
== 0)
5964 printf (_(" None\n"));
5967 unsigned long int val
= entry
->d_un
.d_val
;
5969 if (val
& DTF_1_PARINIT
)
5971 printf (" PARINIT");
5972 val
^= DTF_1_PARINIT
;
5974 if (val
& DTF_1_CONFEXP
)
5976 printf (" CONFEXP");
5977 val
^= DTF_1_CONFEXP
;
5980 printf (" %lx", val
);
5989 printf (_("Flags:"));
5991 if (entry
->d_un
.d_val
== 0)
5992 printf (_(" None\n"));
5995 unsigned long int val
= entry
->d_un
.d_val
;
5997 if (val
& DF_P1_LAZYLOAD
)
5999 printf (" LAZYLOAD");
6000 val
^= DF_P1_LAZYLOAD
;
6002 if (val
& DF_P1_GROUPPERM
)
6004 printf (" GROUPPERM");
6005 val
^= DF_P1_GROUPPERM
;
6008 printf (" %lx", val
);
6017 printf (_("Flags:"));
6018 if (entry
->d_un
.d_val
== 0)
6019 printf (_(" None\n"));
6022 unsigned long int val
= entry
->d_un
.d_val
;
6029 if (val
& DF_1_GLOBAL
)
6034 if (val
& DF_1_GROUP
)
6039 if (val
& DF_1_NODELETE
)
6041 printf (" NODELETE");
6042 val
^= DF_1_NODELETE
;
6044 if (val
& DF_1_LOADFLTR
)
6046 printf (" LOADFLTR");
6047 val
^= DF_1_LOADFLTR
;
6049 if (val
& DF_1_INITFIRST
)
6051 printf (" INITFIRST");
6052 val
^= DF_1_INITFIRST
;
6054 if (val
& DF_1_NOOPEN
)
6059 if (val
& DF_1_ORIGIN
)
6064 if (val
& DF_1_DIRECT
)
6069 if (val
& DF_1_TRANS
)
6074 if (val
& DF_1_INTERPOSE
)
6076 printf (" INTERPOSE");
6077 val
^= DF_1_INTERPOSE
;
6079 if (val
& DF_1_NODEFLIB
)
6081 printf (" NODEFLIB");
6082 val
^= DF_1_NODEFLIB
;
6084 if (val
& DF_1_NODUMP
)
6089 if (val
& DF_1_CONLFAT
)
6091 printf (" CONLFAT");
6092 val
^= DF_1_CONLFAT
;
6095 printf (" %lx", val
);
6102 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6104 puts (get_dynamic_type (entry
->d_un
.d_val
));
6124 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6130 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6131 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6137 switch (entry
->d_tag
)
6140 printf (_("Shared library: [%s]"), name
);
6142 if (streq (name
, program_interpreter
))
6143 printf (_(" program interpreter"));
6147 printf (_("Library soname: [%s]"), name
);
6151 printf (_("Library rpath: [%s]"), name
);
6155 printf (_("Library runpath: [%s]"), name
);
6159 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6164 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6177 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6181 case DT_INIT_ARRAYSZ
:
6182 case DT_FINI_ARRAYSZ
:
6183 case DT_GNU_CONFLICTSZ
:
6184 case DT_GNU_LIBLISTSZ
:
6187 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6188 printf (" (bytes)\n");
6198 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6211 if (entry
->d_tag
== DT_USED
6212 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6214 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6218 printf (_("Not needed object: [%s]\n"), name
);
6223 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6229 /* The value of this entry is ignored. */
6234 case DT_GNU_PRELINKED
:
6238 time_t time
= entry
->d_un
.d_val
;
6240 tmp
= gmtime (&time
);
6241 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6242 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6243 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6249 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6250 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6255 switch (elf_header
.e_machine
)
6258 case EM_MIPS_RS3_LE
:
6259 dynamic_section_mips_val (entry
);
6262 dynamic_section_parisc_val (entry
);
6265 dynamic_section_ia64_val (entry
);
6268 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6280 get_ver_flags (unsigned int flags
)
6282 static char buff
[32];
6289 if (flags
& VER_FLG_BASE
)
6290 strcat (buff
, "BASE ");
6292 if (flags
& VER_FLG_WEAK
)
6294 if (flags
& VER_FLG_BASE
)
6295 strcat (buff
, "| ");
6297 strcat (buff
, "WEAK ");
6300 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6301 strcat (buff
, "| <unknown>");
6306 /* Display the contents of the version sections. */
6308 process_version_sections (FILE *file
)
6310 Elf_Internal_Shdr
*section
;
6317 for (i
= 0, section
= section_headers
;
6318 i
< elf_header
.e_shnum
;
6321 switch (section
->sh_type
)
6323 case SHT_GNU_verdef
:
6325 Elf_External_Verdef
*edefs
;
6332 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6333 SECTION_NAME (section
), section
->sh_info
);
6335 printf (_(" Addr: 0x"));
6336 printf_vma (section
->sh_addr
);
6337 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6338 (unsigned long) section
->sh_offset
, section
->sh_link
,
6339 SECTION_HEADER_INDEX (section
->sh_link
)
6340 < elf_header
.e_shnum
6341 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6344 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6346 _("version definition section"));
6350 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6353 Elf_External_Verdef
*edef
;
6354 Elf_Internal_Verdef ent
;
6355 Elf_External_Verdaux
*eaux
;
6356 Elf_Internal_Verdaux aux
;
6360 vstart
= ((char *) edefs
) + idx
;
6362 edef
= (Elf_External_Verdef
*) vstart
;
6364 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6365 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6366 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6367 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6368 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6369 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6370 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6372 printf (_(" %#06x: Rev: %d Flags: %s"),
6373 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6375 printf (_(" Index: %d Cnt: %d "),
6376 ent
.vd_ndx
, ent
.vd_cnt
);
6378 vstart
+= ent
.vd_aux
;
6380 eaux
= (Elf_External_Verdaux
*) vstart
;
6382 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6383 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6385 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6386 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6388 printf (_("Name index: %ld\n"), aux
.vda_name
);
6390 isum
= idx
+ ent
.vd_aux
;
6392 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6394 isum
+= aux
.vda_next
;
6395 vstart
+= aux
.vda_next
;
6397 eaux
= (Elf_External_Verdaux
*) vstart
;
6399 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6400 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6402 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6403 printf (_(" %#06x: Parent %d: %s\n"),
6404 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6406 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6407 isum
, j
, aux
.vda_name
);
6417 case SHT_GNU_verneed
:
6419 Elf_External_Verneed
*eneed
;
6425 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6426 SECTION_NAME (section
), section
->sh_info
);
6428 printf (_(" Addr: 0x"));
6429 printf_vma (section
->sh_addr
);
6430 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6431 (unsigned long) section
->sh_offset
, section
->sh_link
,
6432 SECTION_HEADER_INDEX (section
->sh_link
)
6433 < elf_header
.e_shnum
6434 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6437 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6439 _("version need section"));
6443 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6445 Elf_External_Verneed
*entry
;
6446 Elf_Internal_Verneed ent
;
6451 vstart
= ((char *) eneed
) + idx
;
6453 entry
= (Elf_External_Verneed
*) vstart
;
6455 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6456 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6457 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6458 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6459 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6461 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6463 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6464 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6466 printf (_(" File: %lx"), ent
.vn_file
);
6468 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6470 vstart
+= ent
.vn_aux
;
6472 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6474 Elf_External_Vernaux
*eaux
;
6475 Elf_Internal_Vernaux aux
;
6477 eaux
= (Elf_External_Vernaux
*) vstart
;
6479 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6480 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6481 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6482 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6483 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6485 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6486 printf (_(" %#06x: Name: %s"),
6487 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6489 printf (_(" %#06x: Name index: %lx"),
6490 isum
, aux
.vna_name
);
6492 printf (_(" Flags: %s Version: %d\n"),
6493 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6495 isum
+= aux
.vna_next
;
6496 vstart
+= aux
.vna_next
;
6506 case SHT_GNU_versym
:
6508 Elf_Internal_Shdr
*link_section
;
6511 unsigned char *edata
;
6512 unsigned short *data
;
6514 Elf_Internal_Sym
*symbols
;
6515 Elf_Internal_Shdr
*string_sec
;
6518 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6521 link_section
= SECTION_HEADER (section
->sh_link
);
6522 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6524 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6525 >= elf_header
.e_shnum
)
6530 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6532 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6534 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6535 string_sec
->sh_size
, _("version string table"));
6539 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6540 SECTION_NAME (section
), total
);
6542 printf (_(" Addr: "));
6543 printf_vma (section
->sh_addr
);
6544 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6545 (unsigned long) section
->sh_offset
, section
->sh_link
,
6546 SECTION_NAME (link_section
));
6548 off
= offset_from_vma (file
,
6549 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6550 total
* sizeof (short));
6551 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6552 _("version symbol data"));
6559 data
= cmalloc (total
, sizeof (short));
6561 for (cnt
= total
; cnt
--;)
6562 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6567 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6570 int check_def
, check_need
;
6573 printf (" %03x:", cnt
);
6575 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6576 switch (data
[cnt
+ j
])
6579 fputs (_(" 0 (*local*) "), stdout
);
6583 fputs (_(" 1 (*global*) "), stdout
);
6587 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6588 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6592 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6593 >= elf_header
.e_shnum
6594 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6597 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6604 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6606 Elf_Internal_Verneed ivn
;
6607 unsigned long offset
;
6609 offset
= offset_from_vma
6610 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6611 sizeof (Elf_External_Verneed
));
6615 Elf_Internal_Vernaux ivna
;
6616 Elf_External_Verneed evn
;
6617 Elf_External_Vernaux evna
;
6618 unsigned long a_off
;
6620 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6623 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6624 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6626 a_off
= offset
+ ivn
.vn_aux
;
6630 get_data (&evna
, file
, a_off
, sizeof (evna
),
6631 1, _("version need aux (2)"));
6633 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6634 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6636 a_off
+= ivna
.vna_next
;
6638 while (ivna
.vna_other
!= data
[cnt
+ j
]
6639 && ivna
.vna_next
!= 0);
6641 if (ivna
.vna_other
== data
[cnt
+ j
])
6643 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6645 name
= strtab
+ ivna
.vna_name
;
6646 nn
+= printf ("(%s%-*s",
6648 12 - (int) strlen (name
),
6654 offset
+= ivn
.vn_next
;
6656 while (ivn
.vn_next
);
6659 if (check_def
&& data
[cnt
+ j
] != 0x8001
6660 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6662 Elf_Internal_Verdef ivd
;
6663 Elf_External_Verdef evd
;
6664 unsigned long offset
;
6666 offset
= offset_from_vma
6667 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6672 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6675 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6676 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6678 offset
+= ivd
.vd_next
;
6680 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6681 && ivd
.vd_next
!= 0);
6683 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6685 Elf_External_Verdaux evda
;
6686 Elf_Internal_Verdaux ivda
;
6688 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6690 get_data (&evda
, file
,
6691 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6693 _("version def aux"));
6695 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6697 name
= strtab
+ ivda
.vda_name
;
6698 nn
+= printf ("(%s%-*s",
6700 12 - (int) strlen (name
),
6706 printf ("%*c", 18 - nn
, ' ');
6724 printf (_("\nNo version information found in this file.\n"));
6730 get_symbol_binding (unsigned int binding
)
6732 static char buff
[32];
6736 case STB_LOCAL
: return "LOCAL";
6737 case STB_GLOBAL
: return "GLOBAL";
6738 case STB_WEAK
: return "WEAK";
6740 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6741 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6743 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6744 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6746 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6752 get_symbol_type (unsigned int type
)
6754 static char buff
[32];
6758 case STT_NOTYPE
: return "NOTYPE";
6759 case STT_OBJECT
: return "OBJECT";
6760 case STT_FUNC
: return "FUNC";
6761 case STT_SECTION
: return "SECTION";
6762 case STT_FILE
: return "FILE";
6763 case STT_COMMON
: return "COMMON";
6764 case STT_TLS
: return "TLS";
6766 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6768 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6769 return "THUMB_FUNC";
6771 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6774 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6775 return "PARISC_MILLI";
6777 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6779 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6781 if (elf_header
.e_machine
== EM_PARISC
)
6783 if (type
== STT_HP_OPAQUE
)
6785 if (type
== STT_HP_STUB
)
6789 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6792 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6798 get_symbol_visibility (unsigned int visibility
)
6802 case STV_DEFAULT
: return "DEFAULT";
6803 case STV_INTERNAL
: return "INTERNAL";
6804 case STV_HIDDEN
: return "HIDDEN";
6805 case STV_PROTECTED
: return "PROTECTED";
6811 get_mips_symbol_other (unsigned int other
)
6815 case STO_OPTIONAL
: return "OPTIONAL";
6816 case STO_MIPS16
: return "MIPS16";
6817 default: return NULL
;
6822 get_symbol_other (unsigned int other
)
6824 const char * result
= NULL
;
6825 static char buff
[32];
6830 switch (elf_header
.e_machine
)
6833 result
= get_mips_symbol_other (other
);
6841 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6846 get_symbol_index_type (unsigned int type
)
6848 static char buff
[32];
6852 case SHN_UNDEF
: return "UND";
6853 case SHN_ABS
: return "ABS";
6854 case SHN_COMMON
: return "COM";
6856 if (type
== SHN_IA_64_ANSI_COMMON
6857 && elf_header
.e_machine
== EM_IA_64
6858 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6860 else if (elf_header
.e_machine
== EM_X86_64
6861 && type
== SHN_X86_64_LCOMMON
)
6863 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6864 sprintf (buff
, "PRC[0x%04x]", type
);
6865 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6866 sprintf (buff
, "OS [0x%04x]", type
);
6867 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6868 sprintf (buff
, "RSV[0x%04x]", type
);
6870 sprintf (buff
, "%3d", type
);
6878 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6880 unsigned char *e_data
;
6883 e_data
= cmalloc (number
, ent_size
);
6887 error (_("Out of memory\n"));
6891 if (fread (e_data
, ent_size
, number
, file
) != number
)
6893 error (_("Unable to read in dynamic data\n"));
6897 i_data
= cmalloc (number
, sizeof (*i_data
));
6901 error (_("Out of memory\n"));
6907 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6914 /* Dump the symbol table. */
6916 process_symbol_table (FILE *file
)
6918 Elf_Internal_Shdr
*section
;
6919 bfd_vma nbuckets
= 0;
6920 bfd_vma nchains
= 0;
6921 bfd_vma
*buckets
= NULL
;
6922 bfd_vma
*chains
= NULL
;
6924 if (! do_syms
&& !do_histogram
)
6927 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6930 unsigned char nb
[8];
6931 unsigned char nc
[8];
6932 int hash_ent_size
= 4;
6934 if ((elf_header
.e_machine
== EM_ALPHA
6935 || elf_header
.e_machine
== EM_S390
6936 || elf_header
.e_machine
== EM_S390_OLD
)
6937 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6941 (archive_file_offset
6942 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6943 sizeof nb
+ sizeof nc
)),
6946 error (_("Unable to seek to start of dynamic information"));
6950 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6952 error (_("Failed to read in number of buckets\n"));
6956 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6958 error (_("Failed to read in number of chains\n"));
6962 nbuckets
= byte_get (nb
, hash_ent_size
);
6963 nchains
= byte_get (nc
, hash_ent_size
);
6965 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6966 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6968 if (buckets
== NULL
|| chains
== NULL
)
6973 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6978 printf (_("\nSymbol table for image:\n"));
6980 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6982 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6984 for (hn
= 0; hn
< nbuckets
; hn
++)
6989 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6991 Elf_Internal_Sym
*psym
;
6994 psym
= dynamic_symbols
+ si
;
6996 n
= print_vma (si
, DEC_5
);
6998 fputs (" " + n
, stdout
);
6999 printf (" %3lu: ", hn
);
7000 print_vma (psym
->st_value
, LONG_HEX
);
7002 print_vma (psym
->st_size
, DEC_5
);
7004 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7005 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7006 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7007 /* Check to see if any other bits in the st_other field are set.
7008 Note - displaying this information disrupts the layout of the
7009 table being generated, but for the moment this case is very rare. */
7010 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7011 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7012 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7013 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7014 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7016 printf (" <corrupt: %14ld>", psym
->st_name
);
7021 else if (do_syms
&& !do_using_dynamic
)
7025 for (i
= 0, section
= section_headers
;
7026 i
< elf_header
.e_shnum
;
7030 char *strtab
= NULL
;
7031 unsigned long int strtab_size
= 0;
7032 Elf_Internal_Sym
*symtab
;
7033 Elf_Internal_Sym
*psym
;
7036 if ( section
->sh_type
!= SHT_SYMTAB
7037 && section
->sh_type
!= SHT_DYNSYM
)
7040 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7041 SECTION_NAME (section
),
7042 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7044 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7046 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7048 symtab
= GET_ELF_SYMBOLS (file
, section
);
7052 if (section
->sh_link
== elf_header
.e_shstrndx
)
7054 strtab
= string_table
;
7055 strtab_size
= string_table_length
;
7057 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7059 Elf_Internal_Shdr
*string_sec
;
7061 string_sec
= SECTION_HEADER (section
->sh_link
);
7063 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7064 1, string_sec
->sh_size
, _("string table"));
7065 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7068 for (si
= 0, psym
= symtab
;
7069 si
< section
->sh_size
/ section
->sh_entsize
;
7072 printf ("%6d: ", si
);
7073 print_vma (psym
->st_value
, LONG_HEX
);
7075 print_vma (psym
->st_size
, DEC_5
);
7076 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7077 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7078 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7079 /* Check to see if any other bits in the st_other field are set.
7080 Note - displaying this information disrupts the layout of the
7081 table being generated, but for the moment this case is very rare. */
7082 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7083 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7084 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7085 print_symbol (25, psym
->st_name
< strtab_size
7086 ? strtab
+ psym
->st_name
: "<corrupt>");
7088 if (section
->sh_type
== SHT_DYNSYM
&&
7089 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7091 unsigned char data
[2];
7092 unsigned short vers_data
;
7093 unsigned long offset
;
7097 offset
= offset_from_vma
7098 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7099 sizeof data
+ si
* sizeof (vers_data
));
7101 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7102 sizeof (data
), 1, _("version data"));
7104 vers_data
= byte_get (data
, 2);
7106 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7107 < elf_header
.e_shnum
7108 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7111 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7113 if ((vers_data
& 0x8000) || vers_data
> 1)
7115 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7116 && (is_nobits
|| ! check_def
))
7118 Elf_External_Verneed evn
;
7119 Elf_Internal_Verneed ivn
;
7120 Elf_Internal_Vernaux ivna
;
7122 /* We must test both. */
7123 offset
= offset_from_vma
7124 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7129 unsigned long vna_off
;
7131 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7134 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7135 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7137 vna_off
= offset
+ ivn
.vn_aux
;
7141 Elf_External_Vernaux evna
;
7143 get_data (&evna
, file
, vna_off
,
7145 _("version need aux (3)"));
7147 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7148 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7149 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7151 vna_off
+= ivna
.vna_next
;
7153 while (ivna
.vna_other
!= vers_data
7154 && ivna
.vna_next
!= 0);
7156 if (ivna
.vna_other
== vers_data
)
7159 offset
+= ivn
.vn_next
;
7161 while (ivn
.vn_next
!= 0);
7163 if (ivna
.vna_other
== vers_data
)
7166 ivna
.vna_name
< strtab_size
7167 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7171 else if (! is_nobits
)
7172 error (_("bad dynamic symbol"));
7179 if (vers_data
!= 0x8001
7180 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7182 Elf_Internal_Verdef ivd
;
7183 Elf_Internal_Verdaux ivda
;
7184 Elf_External_Verdaux evda
;
7185 unsigned long offset
;
7187 offset
= offset_from_vma
7189 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7190 sizeof (Elf_External_Verdef
));
7194 Elf_External_Verdef evd
;
7196 get_data (&evd
, file
, offset
, sizeof (evd
),
7197 1, _("version def"));
7199 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7200 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7201 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7203 offset
+= ivd
.vd_next
;
7205 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7206 && ivd
.vd_next
!= 0);
7208 offset
-= ivd
.vd_next
;
7209 offset
+= ivd
.vd_aux
;
7211 get_data (&evda
, file
, offset
, sizeof (evda
),
7212 1, _("version def aux"));
7214 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7216 if (psym
->st_name
!= ivda
.vda_name
)
7217 printf ((vers_data
& 0x8000)
7219 ivda
.vda_name
< strtab_size
7220 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7230 if (strtab
!= string_table
)
7236 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7238 if (do_histogram
&& buckets
!= NULL
)
7240 unsigned long *lengths
;
7241 unsigned long *counts
;
7244 unsigned long maxlength
= 0;
7245 unsigned long nzero_counts
= 0;
7246 unsigned long nsyms
= 0;
7248 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7249 (unsigned long) nbuckets
);
7250 printf (_(" Length Number %% of total Coverage\n"));
7252 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7253 if (lengths
== NULL
)
7255 error (_("Out of memory"));
7258 for (hn
= 0; hn
< nbuckets
; ++hn
)
7260 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7263 if (maxlength
< ++lengths
[hn
])
7268 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7271 error (_("Out of memory"));
7275 for (hn
= 0; hn
< nbuckets
; ++hn
)
7276 ++counts
[lengths
[hn
]];
7281 printf (" 0 %-10lu (%5.1f%%)\n",
7282 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7283 for (i
= 1; i
<= maxlength
; ++i
)
7285 nzero_counts
+= counts
[i
] * i
;
7286 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7287 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7288 (nzero_counts
* 100.0) / nsyms
);
7296 if (buckets
!= NULL
)
7306 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7310 if (dynamic_syminfo
== NULL
7312 /* No syminfo, this is ok. */
7315 /* There better should be a dynamic symbol section. */
7316 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7320 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7321 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7323 printf (_(" Num: Name BoundTo Flags\n"));
7324 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7326 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7328 printf ("%4d: ", i
);
7329 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7330 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7332 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7335 switch (dynamic_syminfo
[i
].si_boundto
)
7337 case SYMINFO_BT_SELF
:
7338 fputs ("SELF ", stdout
);
7340 case SYMINFO_BT_PARENT
:
7341 fputs ("PARENT ", stdout
);
7344 if (dynamic_syminfo
[i
].si_boundto
> 0
7345 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7346 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7348 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7352 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7356 if (flags
& SYMINFO_FLG_DIRECT
)
7358 if (flags
& SYMINFO_FLG_PASSTHRU
)
7359 printf (" PASSTHRU");
7360 if (flags
& SYMINFO_FLG_COPY
)
7362 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7363 printf (" LAZYLOAD");
7371 #ifdef SUPPORT_DISASSEMBLY
7373 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7375 printf (_("\nAssembly dump of section %s\n"),
7376 SECTION_NAME (section
));
7378 /* XXX -- to be done --- XXX */
7385 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7387 bfd_size_type bytes
;
7389 unsigned char *data
;
7390 unsigned char *start
;
7392 bytes
= section
->sh_size
;
7394 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7396 printf (_("\nSection '%s' has no data to dump.\n"),
7397 SECTION_NAME (section
));
7401 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7403 addr
= section
->sh_addr
;
7405 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7418 lbytes
= (bytes
> 16 ? 16 : bytes
);
7420 printf (" 0x%8.8lx ", (unsigned long) addr
);
7422 switch (elf_header
.e_ident
[EI_DATA
])
7426 for (j
= 15; j
>= 0; j
--)
7429 printf ("%2.2x", data
[j
]);
7439 for (j
= 0; j
< 16; j
++)
7442 printf ("%2.2x", data
[j
]);
7452 for (j
= 0; j
< lbytes
; j
++)
7455 if (k
>= ' ' && k
< 0x7f)
7473 /* Apply addends of RELA relocations. */
7476 debug_apply_rela_addends (void *file
,
7477 Elf_Internal_Shdr
*section
,
7478 unsigned char *start
)
7480 Elf_Internal_Shdr
*relsec
;
7481 unsigned char *end
= start
+ section
->sh_size
;
7482 /* FIXME: The relocation field size is relocation type dependent. */
7483 unsigned int reloc_size
= 4;
7485 if (!is_relocatable
)
7488 if (section
->sh_size
< reloc_size
)
7491 for (relsec
= section_headers
;
7492 relsec
< section_headers
+ elf_header
.e_shnum
;
7495 unsigned long nrelas
;
7496 Elf_Internal_Rela
*rela
, *rp
;
7497 Elf_Internal_Shdr
*symsec
;
7498 Elf_Internal_Sym
*symtab
;
7499 Elf_Internal_Sym
*sym
;
7501 if (relsec
->sh_type
!= SHT_RELA
7502 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7503 || SECTION_HEADER (relsec
->sh_info
) != section
7504 || relsec
->sh_size
== 0
7505 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7508 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7512 symsec
= SECTION_HEADER (relsec
->sh_link
);
7513 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7515 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7519 loc
= start
+ rp
->r_offset
;
7520 if ((loc
+ reloc_size
) > end
)
7522 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7523 (unsigned long) rp
->r_offset
,
7524 SECTION_NAME (section
));
7530 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7532 if (ELF32_R_SYM (rp
->r_info
) != 0
7533 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7534 /* Relocations against object symbols can happen,
7535 eg when referencing a global array. For an
7536 example of this see the _clz.o binary in libgcc.a. */
7537 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7539 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7540 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7541 SECTION_NAME (section
));
7547 /* In MIPS little-endian objects, r_info isn't really a
7548 64-bit little-endian value: it has a 32-bit little-endian
7549 symbol index followed by four individual byte fields.
7550 Reorder INFO accordingly. */
7551 if (elf_header
.e_machine
== EM_MIPS
7552 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7553 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7554 | ((rp
->r_info
>> 56) & 0xff)
7555 | ((rp
->r_info
>> 40) & 0xff00)
7556 | ((rp
->r_info
>> 24) & 0xff0000)
7557 | ((rp
->r_info
>> 8) & 0xff000000));
7559 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7561 if (ELF64_R_SYM (rp
->r_info
) != 0
7562 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7563 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7565 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7566 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7567 SECTION_NAME (section
));
7572 byte_put (loc
, rp
->r_addend
, reloc_size
);
7583 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
7585 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7586 Elf_Internal_Shdr
*sec
;
7589 /* If it is already loaded, do nothing. */
7590 if (section
->start
!= NULL
)
7593 /* Locate the debug section. */
7594 sec
= find_section (section
->name
);
7598 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
7599 section
->address
= sec
->sh_addr
;
7600 section
->size
= sec
->sh_size
;
7601 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7604 if (debug_displays
[debug
].relocate
)
7605 debug_apply_rela_addends (file
, sec
, section
->start
);
7607 return section
->start
!= NULL
;
7611 free_debug_section (enum dwarf_section_display_enum debug
)
7613 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7615 if (section
->start
== NULL
)
7618 free ((char *) section
->start
);
7619 section
->start
= NULL
;
7620 section
->address
= 0;
7625 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
7627 char *name
= SECTION_NAME (section
);
7628 bfd_size_type length
;
7630 enum dwarf_section_display_enum i
;
7632 length
= section
->sh_size
;
7635 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7639 if (strneq (name
, ".gnu.linkonce.wi.", 17))
7640 name
= ".debug_info";
7642 /* See if we know how to display the contents of this section. */
7643 for (i
= 0; i
< max
; i
++)
7644 if (streq (debug_displays
[i
].section
.name
, name
))
7646 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
7648 if (load_debug_section (i
, file
))
7650 result
&= debug_displays
[i
].display (sec
, file
);
7652 if (i
!= info
&& i
!= abbrev
)
7653 free_debug_section (i
);
7661 printf (_("Unrecognized debug section: %s\n"), name
);
7668 /* Set DUMP_SECTS for all sections where dumps were requested
7669 based on section name. */
7672 initialise_dumps_byname (void)
7674 struct dump_list_entry
*cur
;
7676 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
7681 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
7682 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
7684 request_dump (i
, cur
->type
);
7689 warn (_("Section '%s' was not dumped because it does not exist!\n"),
7695 process_section_contents (FILE *file
)
7697 Elf_Internal_Shdr
*section
;
7703 initialise_dumps_byname ();
7705 for (i
= 0, section
= section_headers
;
7706 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7709 #ifdef SUPPORT_DISASSEMBLY
7710 if (dump_sects
[i
] & DISASS_DUMP
)
7711 disassemble_section (section
, file
);
7713 if (dump_sects
[i
] & HEX_DUMP
)
7714 dump_section (section
, file
);
7716 if (dump_sects
[i
] & DEBUG_DUMP
)
7717 display_debug_section (section
, file
);
7720 /* Check to see if the user requested a
7721 dump of a section that does not exist. */
7722 while (i
++ < num_dump_sects
)
7724 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
7728 process_mips_fpe_exception (int mask
)
7733 if (mask
& OEX_FPU_INEX
)
7734 fputs ("INEX", stdout
), first
= 0;
7735 if (mask
& OEX_FPU_UFLO
)
7736 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7737 if (mask
& OEX_FPU_OFLO
)
7738 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7739 if (mask
& OEX_FPU_DIV0
)
7740 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7741 if (mask
& OEX_FPU_INVAL
)
7742 printf ("%sINVAL", first
? "" : "|");
7745 fputs ("0", stdout
);
7748 /* ARM EABI attributes section. */
7753 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
7756 } arm_attr_public_tag
;
7758 static const char *arm_attr_tag_CPU_arch
[] =
7759 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
7761 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
7762 static const char *arm_attr_tag_THUMB_ISA_use
[] =
7763 {"No", "Thumb-1", "Thumb-2"};
7764 /* FIXME: VFPv3 encoding was extrapolated! */
7765 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
7766 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
7767 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
7768 static const char *arm_attr_tag_ABI_PCS_config
[] =
7769 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
7770 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
7771 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
7772 {"V6", "SB", "TLS", "Unused"};
7773 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
7774 {"Absolute", "PC-relative", "SB-relative", "None"};
7775 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
7776 {"Absolute", "PC-relative", "None"};
7777 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
7778 {"None", "direct", "GOT-indirect"};
7779 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
7780 {"None", "??? 1", "2", "??? 3", "4"};
7781 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
7782 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
7783 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
7784 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
7785 static const char *arm_attr_tag_ABI_FP_number_model
[] =
7786 {"Unused", "Finite", "RTABI", "IEEE 754"};
7787 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
7788 static const char *arm_attr_tag_ABI_align8_preserved
[] =
7789 {"No", "Yes, except leaf SP", "Yes"};
7790 static const char *arm_attr_tag_ABI_enum_size
[] =
7791 {"Unused", "small", "int", "forced to int"};
7792 static const char *arm_attr_tag_ABI_HardFP_use
[] =
7793 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
7794 static const char *arm_attr_tag_ABI_VFP_args
[] =
7795 {"AAPCS", "VFP registers", "custom"};
7796 static const char *arm_attr_tag_ABI_WMMX_args
[] =
7797 {"AAPCS", "WMMX registers", "custom"};
7798 static const char *arm_attr_tag_ABI_optimization_goals
[] =
7799 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7800 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
7801 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
7802 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7803 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
7805 #define LOOKUP(id, name) \
7806 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
7807 static arm_attr_public_tag arm_attr_public_tags
[] =
7809 {4, "CPU_raw_name", 1, NULL
},
7810 {5, "CPU_name", 1, NULL
},
7811 LOOKUP(6, CPU_arch
),
7812 {7, "CPU_arch_profile", 0, NULL
},
7813 LOOKUP(8, ARM_ISA_use
),
7814 LOOKUP(9, THUMB_ISA_use
),
7815 LOOKUP(10, VFP_arch
),
7816 LOOKUP(11, WMMX_arch
),
7817 LOOKUP(12, NEON_arch
),
7818 LOOKUP(13, ABI_PCS_config
),
7819 LOOKUP(14, ABI_PCS_R9_use
),
7820 LOOKUP(15, ABI_PCS_RW_data
),
7821 LOOKUP(16, ABI_PCS_RO_DATA
),
7822 LOOKUP(17, ABI_PCS_GOT_use
),
7823 LOOKUP(18, ABI_PCS_wchar_t
),
7824 LOOKUP(19, ABI_FP_rounding
),
7825 LOOKUP(20, ABI_FP_denormal
),
7826 LOOKUP(21, ABI_FP_exceptions
),
7827 LOOKUP(22, ABI_FP_user_exceptions
),
7828 LOOKUP(23, ABI_FP_number_model
),
7829 LOOKUP(24, ABI_align8_needed
),
7830 LOOKUP(25, ABI_align8_preserved
),
7831 LOOKUP(26, ABI_enum_size
),
7832 LOOKUP(27, ABI_HardFP_use
),
7833 LOOKUP(28, ABI_VFP_args
),
7834 LOOKUP(29, ABI_WMMX_args
),
7835 LOOKUP(30, ABI_optimization_goals
),
7836 LOOKUP(31, ABI_FP_optimization_goals
),
7837 {32, "compatibility", 0, NULL
}
7841 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
7844 read_uleb128 (unsigned char *p
, unsigned int *plen
)
7858 val
|= ((unsigned int)c
& 0x7f) << shift
;
7867 static unsigned char *
7868 display_arm_attribute (unsigned char *p
)
7873 arm_attr_public_tag
*attr
;
7877 tag
= read_uleb128 (p
, &len
);
7880 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
7882 if (arm_attr_public_tags
[i
].tag
== tag
)
7884 attr
= &arm_attr_public_tags
[i
];
7891 printf (" Tag_%s: ", attr
->name
);
7897 case 7: /* Tag_CPU_arch_profile. */
7898 val
= read_uleb128 (p
, &len
);
7902 case 0: printf ("None\n"); break;
7903 case 'A': printf ("Application\n"); break;
7904 case 'R': printf ("Realtime\n"); break;
7905 case 'M': printf ("Microcontroller\n"); break;
7906 default: printf ("??? (%d)\n", val
); break;
7910 case 32: /* Tag_compatibility. */
7911 val
= read_uleb128 (p
, &len
);
7913 printf ("flag = %d, vendor = %s\n", val
, p
);
7914 p
+= strlen((char *)p
) + 1;
7928 assert (attr
->type
& 0x80);
7929 val
= read_uleb128 (p
, &len
);
7931 type
= attr
->type
& 0x7f;
7933 printf ("??? (%d)\n", val
);
7935 printf ("%s\n", attr
->table
[val
]);
7942 type
= 1; /* String. */
7944 type
= 2; /* uleb128. */
7945 printf (" Tag_unknown_%d: ", tag
);
7950 printf ("\"%s\"\n", p
);
7951 p
+= strlen((char *)p
) + 1;
7955 val
= read_uleb128 (p
, &len
);
7957 printf ("%d (0x%x)\n", val
, val
);
7964 process_arm_specific (FILE *file
)
7966 Elf_Internal_Shdr
*sect
;
7967 unsigned char *contents
;
7970 bfd_vma section_len
;
7974 /* Find the section header so that we get the size. */
7975 for (i
= 0, sect
= section_headers
;
7976 i
< elf_header
.e_shnum
;
7979 if (sect
->sh_type
!= SHT_ARM_ATTRIBUTES
)
7982 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
7990 len
= sect
->sh_size
- 1;
7995 bfd_boolean public_section
;
7997 section_len
= byte_get (p
, 4);
7999 if (section_len
> len
)
8001 printf (_("ERROR: Bad section length (%d > %d)\n"),
8002 (int)section_len
, (int)len
);
8006 printf ("Attribute Section: %s\n", p
);
8007 if (strcmp ((char *)p
, "aeabi") == 0)
8008 public_section
= TRUE
;
8010 public_section
= FALSE
;
8011 namelen
= strlen ((char *)p
) + 1;
8013 section_len
-= namelen
+ 4;
8014 while (section_len
> 0)
8019 size
= byte_get (p
, 4);
8020 if (size
> section_len
)
8022 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8023 (int)size
, (int)section_len
);
8026 section_len
-= size
;
8032 printf ("File Attributes\n");
8035 printf ("Section Attributes:");
8038 printf ("Symbol Attributes:");
8043 val
= read_uleb128 (p
, &i
);
8047 printf (" %d", val
);
8052 printf ("Unknown tag: %d\n", tag
);
8053 public_section
= FALSE
;
8059 p
= display_arm_attribute(p
);
8063 /* ??? Do something sensible, like dump hex. */
8064 printf (" Unknown section contexts\n");
8072 printf (_("Unknown format '%c'\n"), *p
);
8081 process_mips_specific (FILE *file
)
8083 Elf_Internal_Dyn
*entry
;
8084 size_t liblist_offset
= 0;
8085 size_t liblistno
= 0;
8086 size_t conflictsno
= 0;
8087 size_t options_offset
= 0;
8088 size_t conflicts_offset
= 0;
8090 /* We have a lot of special sections. Thanks SGI! */
8091 if (dynamic_section
== NULL
)
8092 /* No information available. */
8095 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
8096 switch (entry
->d_tag
)
8098 case DT_MIPS_LIBLIST
:
8100 = offset_from_vma (file
, entry
->d_un
.d_val
,
8101 liblistno
* sizeof (Elf32_External_Lib
));
8103 case DT_MIPS_LIBLISTNO
:
8104 liblistno
= entry
->d_un
.d_val
;
8106 case DT_MIPS_OPTIONS
:
8107 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8109 case DT_MIPS_CONFLICT
:
8111 = offset_from_vma (file
, entry
->d_un
.d_val
,
8112 conflictsno
* sizeof (Elf32_External_Conflict
));
8114 case DT_MIPS_CONFLICTNO
:
8115 conflictsno
= entry
->d_un
.d_val
;
8121 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8123 Elf32_External_Lib
*elib
;
8126 elib
= get_data (NULL
, file
, liblist_offset
,
8127 liblistno
, sizeof (Elf32_External_Lib
),
8131 printf ("\nSection '.liblist' contains %lu entries:\n",
8132 (unsigned long) liblistno
);
8133 fputs (" Library Time Stamp Checksum Version Flags\n",
8136 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8143 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8144 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8145 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8146 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8147 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8149 tmp
= gmtime (&time
);
8150 snprintf (timebuf
, sizeof (timebuf
),
8151 "%04u-%02u-%02uT%02u:%02u:%02u",
8152 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8153 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8155 printf ("%3lu: ", (unsigned long) cnt
);
8156 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
8157 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
8159 printf ("<corrupt: %9ld>", liblist
.l_name
);
8160 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8163 if (liblist
.l_flags
== 0)
8174 { " EXACT_MATCH", LL_EXACT_MATCH
},
8175 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8176 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8177 { " EXPORTS", LL_EXPORTS
},
8178 { " DELAY_LOAD", LL_DELAY_LOAD
},
8179 { " DELTA", LL_DELTA
}
8181 int flags
= liblist
.l_flags
;
8185 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
8187 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8189 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8190 flags
^= l_flags_vals
[fcnt
].bit
;
8193 printf (" %#x", (unsigned int) flags
);
8203 if (options_offset
!= 0)
8205 Elf_External_Options
*eopt
;
8206 Elf_Internal_Shdr
*sect
= section_headers
;
8207 Elf_Internal_Options
*iopt
;
8208 Elf_Internal_Options
*option
;
8212 /* Find the section header so that we get the size. */
8213 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8216 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8220 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8223 error (_("Out of memory"));
8230 while (offset
< sect
->sh_size
)
8232 Elf_External_Options
*eoption
;
8234 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8236 option
->kind
= BYTE_GET (eoption
->kind
);
8237 option
->size
= BYTE_GET (eoption
->size
);
8238 option
->section
= BYTE_GET (eoption
->section
);
8239 option
->info
= BYTE_GET (eoption
->info
);
8241 offset
+= option
->size
;
8247 printf (_("\nSection '%s' contains %d entries:\n"),
8248 SECTION_NAME (sect
), cnt
);
8256 switch (option
->kind
)
8259 /* This shouldn't happen. */
8260 printf (" NULL %d %lx", option
->section
, option
->info
);
8263 printf (" REGINFO ");
8264 if (elf_header
.e_machine
== EM_MIPS
)
8267 Elf32_External_RegInfo
*ereg
;
8268 Elf32_RegInfo reginfo
;
8270 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8271 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8272 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8273 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8274 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8275 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8276 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8278 printf ("GPR %08lx GP 0x%lx\n",
8280 (unsigned long) reginfo
.ri_gp_value
);
8281 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8282 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8283 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8288 Elf64_External_RegInfo
*ereg
;
8289 Elf64_Internal_RegInfo reginfo
;
8291 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8292 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8293 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8294 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8295 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8296 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8297 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8299 printf ("GPR %08lx GP 0x",
8300 reginfo
.ri_gprmask
);
8301 printf_vma (reginfo
.ri_gp_value
);
8304 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8305 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8306 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8310 case ODK_EXCEPTIONS
:
8311 fputs (" EXCEPTIONS fpe_min(", stdout
);
8312 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8313 fputs (") fpe_max(", stdout
);
8314 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8315 fputs (")", stdout
);
8317 if (option
->info
& OEX_PAGE0
)
8318 fputs (" PAGE0", stdout
);
8319 if (option
->info
& OEX_SMM
)
8320 fputs (" SMM", stdout
);
8321 if (option
->info
& OEX_FPDBUG
)
8322 fputs (" FPDBUG", stdout
);
8323 if (option
->info
& OEX_DISMISS
)
8324 fputs (" DISMISS", stdout
);
8327 fputs (" PAD ", stdout
);
8328 if (option
->info
& OPAD_PREFIX
)
8329 fputs (" PREFIX", stdout
);
8330 if (option
->info
& OPAD_POSTFIX
)
8331 fputs (" POSTFIX", stdout
);
8332 if (option
->info
& OPAD_SYMBOL
)
8333 fputs (" SYMBOL", stdout
);
8336 fputs (" HWPATCH ", stdout
);
8337 if (option
->info
& OHW_R4KEOP
)
8338 fputs (" R4KEOP", stdout
);
8339 if (option
->info
& OHW_R8KPFETCH
)
8340 fputs (" R8KPFETCH", stdout
);
8341 if (option
->info
& OHW_R5KEOP
)
8342 fputs (" R5KEOP", stdout
);
8343 if (option
->info
& OHW_R5KCVTL
)
8344 fputs (" R5KCVTL", stdout
);
8347 fputs (" FILL ", stdout
);
8348 /* XXX Print content of info word? */
8351 fputs (" TAGS ", stdout
);
8352 /* XXX Print content of info word? */
8355 fputs (" HWAND ", stdout
);
8356 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8357 fputs (" R4KEOP_CHECKED", stdout
);
8358 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8359 fputs (" R4KEOP_CLEAN", stdout
);
8362 fputs (" HWOR ", stdout
);
8363 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8364 fputs (" R4KEOP_CHECKED", stdout
);
8365 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8366 fputs (" R4KEOP_CLEAN", stdout
);
8369 printf (" GP_GROUP %#06lx self-contained %#06lx",
8370 option
->info
& OGP_GROUP
,
8371 (option
->info
& OGP_SELF
) >> 16);
8374 printf (" IDENT %#06lx self-contained %#06lx",
8375 option
->info
& OGP_GROUP
,
8376 (option
->info
& OGP_SELF
) >> 16);
8379 /* This shouldn't happen. */
8380 printf (" %3d ??? %d %lx",
8381 option
->kind
, option
->section
, option
->info
);
8385 len
= sizeof (*eopt
);
8386 while (len
< option
->size
)
8387 if (((char *) option
)[len
] >= ' '
8388 && ((char *) option
)[len
] < 0x7f)
8389 printf ("%c", ((char *) option
)[len
++]);
8391 printf ("\\%03o", ((char *) option
)[len
++]);
8393 fputs ("\n", stdout
);
8401 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8403 Elf32_Conflict
*iconf
;
8406 if (dynamic_symbols
== NULL
)
8408 error (_("conflict list found without a dynamic symbol table"));
8412 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
8415 error (_("Out of memory"));
8421 Elf32_External_Conflict
*econf32
;
8423 econf32
= get_data (NULL
, file
, conflicts_offset
,
8424 conflictsno
, sizeof (*econf32
), _("conflict"));
8428 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8429 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8435 Elf64_External_Conflict
*econf64
;
8437 econf64
= get_data (NULL
, file
, conflicts_offset
,
8438 conflictsno
, sizeof (*econf64
), _("conflict"));
8442 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8443 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8448 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8449 (unsigned long) conflictsno
);
8450 puts (_(" Num: Index Value Name"));
8452 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8454 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
8456 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8457 print_vma (psym
->st_value
, FULL_HEX
);
8459 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8460 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8462 printf ("<corrupt: %14ld>", psym
->st_name
);
8473 process_gnu_liblist (FILE *file
)
8475 Elf_Internal_Shdr
*section
, *string_sec
;
8476 Elf32_External_Lib
*elib
;
8485 for (i
= 0, section
= section_headers
;
8486 i
< elf_header
.e_shnum
;
8489 switch (section
->sh_type
)
8491 case SHT_GNU_LIBLIST
:
8492 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
8495 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
8500 string_sec
= SECTION_HEADER (section
->sh_link
);
8502 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8503 string_sec
->sh_size
, _("liblist string table"));
8504 strtab_size
= string_sec
->sh_size
;
8507 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
8513 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8514 SECTION_NAME (section
),
8515 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
8517 puts (" Library Time Stamp Checksum Version Flags");
8519 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
8527 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8528 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8529 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8530 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8531 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8533 tmp
= gmtime (&time
);
8534 snprintf (timebuf
, sizeof (timebuf
),
8535 "%04u-%02u-%02uT%02u:%02u:%02u",
8536 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8537 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8539 printf ("%3lu: ", (unsigned long) cnt
);
8541 printf ("%-20s", liblist
.l_name
< strtab_size
8542 ? strtab
+ liblist
.l_name
: "<corrupt>");
8544 printf ("%-20.20s", liblist
.l_name
< strtab_size
8545 ? strtab
+ liblist
.l_name
: "<corrupt>");
8546 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
8547 liblist
.l_version
, liblist
.l_flags
);
8558 get_note_type (unsigned e_type
)
8560 static char buff
[64];
8562 if (elf_header
.e_type
== ET_CORE
)
8566 return _("NT_AUXV (auxiliary vector)");
8568 return _("NT_PRSTATUS (prstatus structure)");
8570 return _("NT_FPREGSET (floating point registers)");
8572 return _("NT_PRPSINFO (prpsinfo structure)");
8574 return _("NT_TASKSTRUCT (task structure)");
8576 return _("NT_PRXFPREG (user_xfpregs structure)");
8578 return _("NT_PSTATUS (pstatus structure)");
8580 return _("NT_FPREGS (floating point registers)");
8582 return _("NT_PSINFO (psinfo structure)");
8584 return _("NT_LWPSTATUS (lwpstatus_t structure)");
8586 return _("NT_LWPSINFO (lwpsinfo_t structure)");
8587 case NT_WIN32PSTATUS
:
8588 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8596 return _("NT_VERSION (version)");
8598 return _("NT_ARCH (architecture)");
8603 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8608 get_netbsd_elfcore_note_type (unsigned e_type
)
8610 static char buff
[64];
8612 if (e_type
== NT_NETBSDCORE_PROCINFO
)
8614 /* NetBSD core "procinfo" structure. */
8615 return _("NetBSD procinfo structure");
8618 /* As of Jan 2002 there are no other machine-independent notes
8619 defined for NetBSD core files. If the note type is less
8620 than the start of the machine-dependent note types, we don't
8623 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
8625 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8629 switch (elf_header
.e_machine
)
8631 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8632 and PT_GETFPREGS == mach+2. */
8637 case EM_SPARC32PLUS
:
8641 case NT_NETBSDCORE_FIRSTMACH
+0:
8642 return _("PT_GETREGS (reg structure)");
8643 case NT_NETBSDCORE_FIRSTMACH
+2:
8644 return _("PT_GETFPREGS (fpreg structure)");
8650 /* On all other arch's, PT_GETREGS == mach+1 and
8651 PT_GETFPREGS == mach+3. */
8655 case NT_NETBSDCORE_FIRSTMACH
+1:
8656 return _("PT_GETREGS (reg structure)");
8657 case NT_NETBSDCORE_FIRSTMACH
+3:
8658 return _("PT_GETFPREGS (fpreg structure)");
8664 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
8665 e_type
- NT_NETBSDCORE_FIRSTMACH
);
8669 /* Note that by the ELF standard, the name field is already null byte
8670 terminated, and namesz includes the terminating null byte.
8671 I.E. the value of namesz for the name "FSF" is 4.
8673 If the value of namesz is zero, there is no name present. */
8675 process_note (Elf_Internal_Note
*pnote
)
8679 if (pnote
->namesz
== 0)
8680 /* If there is no note name, then use the default set of
8681 note type strings. */
8682 nt
= get_note_type (pnote
->type
);
8684 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
8685 /* NetBSD-specific core file notes. */
8686 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
8689 /* Don't recognize this note name; just use the default set of
8690 note type strings. */
8691 nt
= get_note_type (pnote
->type
);
8693 printf (" %s\t\t0x%08lx\t%s\n",
8694 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8701 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
8703 Elf_External_Note
*pnotes
;
8704 Elf_External_Note
*external
;
8710 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
8716 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8717 (unsigned long) offset
, (unsigned long) length
);
8718 printf (_(" Owner\t\tData size\tDescription\n"));
8720 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8722 Elf_External_Note
*next
;
8723 Elf_Internal_Note inote
;
8726 inote
.type
= BYTE_GET (external
->type
);
8727 inote
.namesz
= BYTE_GET (external
->namesz
);
8728 inote
.namedata
= external
->name
;
8729 inote
.descsz
= BYTE_GET (external
->descsz
);
8730 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8731 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8733 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8735 if (((char *) next
) > (((char *) pnotes
) + length
))
8737 warn (_("corrupt note found at offset %lx into core notes\n"),
8738 (long)((char *)external
- (char *)pnotes
));
8739 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8740 inote
.type
, inote
.namesz
, inote
.descsz
);
8746 /* Verify that name is null terminated. It appears that at least
8747 one version of Linux (RedHat 6.0) generates corefiles that don't
8748 comply with the ELF spec by failing to include the null byte in
8750 if (inote
.namedata
[inote
.namesz
] != '\0')
8752 temp
= malloc (inote
.namesz
+ 1);
8756 error (_("Out of memory\n"));
8761 strncpy (temp
, inote
.namedata
, inote
.namesz
);
8762 temp
[inote
.namesz
] = 0;
8764 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8765 inote
.namedata
= temp
;
8768 res
&= process_note (& inote
);
8783 process_corefile_note_segments (FILE *file
)
8785 Elf_Internal_Phdr
*segment
;
8789 if (! get_program_headers (file
))
8792 for (i
= 0, segment
= program_headers
;
8793 i
< elf_header
.e_phnum
;
8796 if (segment
->p_type
== PT_NOTE
)
8797 res
&= process_corefile_note_segment (file
,
8798 (bfd_vma
) segment
->p_offset
,
8799 (bfd_vma
) segment
->p_filesz
);
8806 process_note_sections (FILE *file
)
8808 Elf_Internal_Shdr
*section
;
8812 for (i
= 0, section
= section_headers
;
8813 i
< elf_header
.e_shnum
;
8815 if (section
->sh_type
== SHT_NOTE
)
8816 res
&= process_corefile_note_segment (file
,
8817 (bfd_vma
) section
->sh_offset
,
8818 (bfd_vma
) section
->sh_size
);
8824 process_notes (FILE *file
)
8826 /* If we have not been asked to display the notes then do nothing. */
8830 if (elf_header
.e_type
!= ET_CORE
)
8831 return process_note_sections (file
);
8833 /* No program headers means no NOTE segment. */
8834 if (elf_header
.e_phnum
> 0)
8835 return process_corefile_note_segments (file
);
8837 printf (_("No note segments present in the core file.\n"));
8842 process_arch_specific (FILE *file
)
8847 switch (elf_header
.e_machine
)
8850 return process_arm_specific (file
);
8852 case EM_MIPS_RS3_LE
:
8853 return process_mips_specific (file
);
8862 get_file_header (FILE *file
)
8864 /* Read in the identity array. */
8865 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
8868 /* Determine how to read the rest of the header. */
8869 switch (elf_header
.e_ident
[EI_DATA
])
8871 default: /* fall through */
8872 case ELFDATANONE
: /* fall through */
8874 byte_get
= byte_get_little_endian
;
8875 byte_put
= byte_put_little_endian
;
8878 byte_get
= byte_get_big_endian
;
8879 byte_put
= byte_put_big_endian
;
8883 /* For now we only support 32 bit and 64 bit ELF files. */
8884 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
8886 /* Read in the rest of the header. */
8889 Elf32_External_Ehdr ehdr32
;
8891 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
8894 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
8895 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
8896 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
8897 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
8898 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
8899 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
8900 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
8901 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
8902 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
8903 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
8904 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
8905 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
8906 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
8910 Elf64_External_Ehdr ehdr64
;
8912 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8913 we will not be able to cope with the 64bit data found in
8914 64 ELF files. Detect this now and abort before we start
8915 overwriting things. */
8916 if (sizeof (bfd_vma
) < 8)
8918 error (_("This instance of readelf has been built without support for a\n\
8919 64 bit data type and so it cannot read 64 bit ELF files.\n"));
8923 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
8926 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
8927 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
8928 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
8929 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
8930 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
8931 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
8932 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
8933 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
8934 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
8935 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
8936 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
8937 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
8938 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
8941 if (elf_header
.e_shoff
)
8943 /* There may be some extensions in the first section header. Don't
8944 bomb if we can't read it. */
8946 get_32bit_section_headers (file
, 1);
8948 get_64bit_section_headers (file
, 1);
8951 is_relocatable
= elf_header
.e_type
== ET_REL
;
8956 /* Process one ELF object file according to the command line options.
8957 This file may actually be stored in an archive. The file is
8958 positioned at the start of the ELF object. */
8961 process_object (char *file_name
, FILE *file
)
8965 if (! get_file_header (file
))
8967 error (_("%s: Failed to read file header\n"), file_name
);
8971 /* Initialise per file variables. */
8972 for (i
= NUM_ELEM (version_info
); i
--;)
8973 version_info
[i
] = 0;
8975 for (i
= NUM_ELEM (dynamic_info
); i
--;)
8976 dynamic_info
[i
] = 0;
8978 /* Process the file. */
8980 printf (_("\nFile: %s\n"), file_name
);
8982 /* Initialise the dump_sects array from the cmdline_dump_sects array.
8983 Note we do this even if cmdline_dump_sects is empty because we
8984 must make sure that the dump_sets array is zeroed out before each
8985 object file is processed. */
8986 if (num_dump_sects
> num_cmdline_dump_sects
)
8987 memset (dump_sects
, 0, num_dump_sects
);
8989 if (num_cmdline_dump_sects
> 0)
8991 if (num_dump_sects
== 0)
8992 /* A sneaky way of allocating the dump_sects array. */
8993 request_dump (num_cmdline_dump_sects
, 0);
8995 assert (num_dump_sects
>= num_cmdline_dump_sects
);
8996 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
8999 if (! process_file_header ())
9002 if (! process_section_headers (file
))
9004 /* Without loaded section headers we cannot process lots of
9006 do_unwind
= do_version
= do_dump
= do_arch
= 0;
9008 if (! do_using_dynamic
)
9009 do_syms
= do_reloc
= 0;
9012 if (! process_section_groups (file
))
9014 /* Without loaded section groups we cannot process unwind. */
9018 if (process_program_headers (file
))
9019 process_dynamic_section (file
);
9021 process_relocs (file
);
9023 process_unwind (file
);
9025 process_symbol_table (file
);
9027 process_syminfo (file
);
9029 process_version_sections (file
);
9031 process_section_contents (file
);
9033 process_notes (file
);
9035 process_gnu_liblist (file
);
9037 process_arch_specific (file
);
9039 if (program_headers
)
9041 free (program_headers
);
9042 program_headers
= NULL
;
9045 if (section_headers
)
9047 free (section_headers
);
9048 section_headers
= NULL
;
9053 free (string_table
);
9054 string_table
= NULL
;
9055 string_table_length
= 0;
9058 if (dynamic_strings
)
9060 free (dynamic_strings
);
9061 dynamic_strings
= NULL
;
9062 dynamic_strings_length
= 0;
9065 if (dynamic_symbols
)
9067 free (dynamic_symbols
);
9068 dynamic_symbols
= NULL
;
9069 num_dynamic_syms
= 0;
9072 if (dynamic_syminfo
)
9074 free (dynamic_syminfo
);
9075 dynamic_syminfo
= NULL
;
9078 if (section_headers_groups
)
9080 free (section_headers_groups
);
9081 section_headers_groups
= NULL
;
9086 struct group_list
*g
, *next
;
9088 for (i
= 0; i
< group_count
; i
++)
9090 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
9097 free (section_groups
);
9098 section_groups
= NULL
;
9101 free_debug_memory ();
9106 /* Process an ELF archive. The file is positioned just after the
9110 process_archive (char *file_name
, FILE *file
)
9112 struct ar_hdr arhdr
;
9115 char *longnames
= NULL
;
9116 unsigned long longnames_size
= 0;
9117 size_t file_name_size
;
9122 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9123 if (got
!= sizeof arhdr
)
9128 error (_("%s: failed to read archive header\n"), file_name
);
9132 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
9134 /* This is the archive symbol table. Skip it.
9135 FIXME: We should have an option to dump it. */
9136 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9137 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
9139 error (_("%s: failed to skip archive symbol table\n"), file_name
);
9143 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9144 if (got
!= sizeof arhdr
)
9149 error (_("%s: failed to read archive header\n"), file_name
);
9154 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
9156 /* This is the archive string table holding long member
9159 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9161 longnames
= malloc (longnames_size
);
9162 if (longnames
== NULL
)
9164 error (_("Out of memory\n"));
9168 if (fread (longnames
, longnames_size
, 1, file
) != 1)
9171 error (_("%s: failed to read string table\n"), file_name
);
9175 if ((longnames_size
& 1) != 0)
9178 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9179 if (got
!= sizeof arhdr
)
9186 error (_("%s: failed to read archive header\n"), file_name
);
9191 file_name_size
= strlen (file_name
);
9200 if (arhdr
.ar_name
[0] == '/')
9204 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
9205 if (off
>= longnames_size
)
9207 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
9212 name
= longnames
+ off
;
9213 nameend
= memchr (name
, '/', longnames_size
- off
);
9217 name
= arhdr
.ar_name
;
9218 nameend
= memchr (name
, '/', 16);
9221 if (nameend
== NULL
)
9223 error (_("%s: bad archive file name\n"), file_name
);
9228 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
9229 if (namealc
== NULL
)
9231 error (_("Out of memory\n"));
9236 memcpy (namealc
, file_name
, file_name_size
);
9237 namealc
[file_name_size
] = '(';
9238 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
9239 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
9240 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
9242 archive_file_offset
= ftell (file
);
9243 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9245 ret
|= process_object (namealc
, file
);
9250 (archive_file_offset
9252 + (archive_file_size
& 1)),
9255 error (_("%s: failed to seek to next archive header\n"), file_name
);
9260 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9261 if (got
!= sizeof arhdr
)
9266 error (_("%s: failed to read archive header\n"), file_name
);
9279 process_file (char *file_name
)
9282 struct stat statbuf
;
9286 if (stat (file_name
, &statbuf
) < 0)
9288 if (errno
== ENOENT
)
9289 error (_("'%s': No such file\n"), file_name
);
9291 error (_("Could not locate '%s'. System error message: %s\n"),
9292 file_name
, strerror (errno
));
9296 if (! S_ISREG (statbuf
.st_mode
))
9298 error (_("'%s' is not an ordinary file\n"), file_name
);
9302 file
= fopen (file_name
, "rb");
9305 error (_("Input file '%s' is not readable.\n"), file_name
);
9309 if (fread (armag
, SARMAG
, 1, file
) != 1)
9311 error (_("%s: Failed to read file header\n"), file_name
);
9316 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
9317 ret
= process_archive (file_name
, file
);
9321 archive_file_size
= archive_file_offset
= 0;
9322 ret
= process_object (file_name
, file
);
9330 #ifdef SUPPORT_DISASSEMBLY
9331 /* Needed by the i386 disassembler. For extra credit, someone could
9332 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9336 print_address (unsigned int addr
, FILE *outfile
)
9338 fprintf (outfile
,"0x%8.8x", addr
);
9341 /* Needed by the i386 disassembler. */
9343 db_task_printsym (unsigned int addr
)
9345 print_address (addr
, stderr
);
9350 main (int argc
, char **argv
)
9354 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9355 setlocale (LC_MESSAGES
, "");
9357 #if defined (HAVE_SETLOCALE)
9358 setlocale (LC_CTYPE
, "");
9360 bindtextdomain (PACKAGE
, LOCALEDIR
);
9361 textdomain (PACKAGE
);
9363 expandargv (&argc
, &argv
);
9365 parse_args (argc
, argv
);
9367 if (num_dump_sects
> 0)
9369 /* Make a copy of the dump_sects array. */
9370 cmdline_dump_sects
= malloc (num_dump_sects
);
9371 if (cmdline_dump_sects
== NULL
)
9372 error (_("Out of memory allocating dump request table."));
9375 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
9376 num_cmdline_dump_sects
= num_dump_sects
;
9380 if (optind
< (argc
- 1))
9384 while (optind
< argc
)
9385 err
|= process_file (argv
[optind
++]);
9387 if (dump_sects
!= NULL
)
9389 if (cmdline_dump_sects
!= NULL
)
9390 free (cmdline_dump_sects
);