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) ((X) == NULL ? "<none>" : \
226 ((X)->sh_name >= string_table_length \
227 ? "<corrupt>" : string_table + (X)->sh_name))
229 /* Given st_shndx I, map to section_headers index. */
230 #define SECTION_HEADER_INDEX(I) \
231 ((I) < SHN_LORESERVE \
233 : ((I) <= SHN_HIRESERVE \
235 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
237 /* Reverse of the above. */
238 #define SECTION_HEADER_NUM(N) \
239 ((N) < SHN_LORESERVE \
241 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
243 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
245 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
247 #define BYTE_GET(field) byte_get (field, sizeof (field))
249 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
251 #define GET_ELF_SYMBOLS(file, section) \
252 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
253 : get_64bit_elf_symbols (file, section))
255 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
256 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
257 already been called and verified that the string exists. */
258 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
260 /* This is just a bit of syntatic sugar. */
261 #define streq(a,b) (strcmp ((a), (b)) == 0)
262 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
265 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
270 if (size
== 0 || nmemb
== 0)
273 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
275 error (_("Unable to seek to 0x%lx for %s\n"),
276 archive_file_offset
+ offset
, reason
);
283 /* Check for overflow. */
284 if (nmemb
< (~(size_t) 0 - 1) / size
)
285 /* + 1 so that we can '\0' terminate invalid string table sections. */
286 mvar
= malloc (size
* nmemb
+ 1);
290 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
291 (unsigned long)(size
* nmemb
), reason
);
295 ((char *) mvar
)[size
* nmemb
] = '\0';
298 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
300 error (_("Unable to read in 0x%lx bytes of %s\n"),
301 (unsigned long)(size
* nmemb
), reason
);
311 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
316 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
317 field
[6] = ((value
>> 24) >> 24) & 0xff;
318 field
[5] = ((value
>> 24) >> 16) & 0xff;
319 field
[4] = ((value
>> 24) >> 8) & 0xff;
322 field
[3] = (value
>> 24) & 0xff;
323 field
[2] = (value
>> 16) & 0xff;
326 field
[1] = (value
>> 8) & 0xff;
329 field
[0] = value
& 0xff;
333 error (_("Unhandled data length: %d\n"), size
);
338 #if defined BFD64 && !BFD_HOST_64BIT_LONG
340 print_dec_vma (bfd_vma vma
, int is_signed
)
346 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
355 *bufp
++ = '0' + vma
% 10;
367 print_hex_vma (bfd_vma vma
)
375 char digit
= '0' + (vma
& 0x0f);
377 digit
+= 'a' - '0' - 10;
390 /* Print a VMA value. */
392 print_vma (bfd_vma vma
, print_mode mode
)
401 return printf ("0x%8.8lx", (unsigned long) vma
);
404 return printf ("%8.8lx", (unsigned long) vma
);
408 return printf ("%5ld", (long) vma
);
412 return printf ("0x%lx", (unsigned long) vma
);
415 return printf ("%lx", (unsigned long) vma
);
418 return printf ("%ld", (unsigned long) vma
);
421 return printf ("%lu", (unsigned long) vma
);
444 #if BFD_HOST_64BIT_LONG
445 return nc
+ printf ("%lx", vma
);
447 return nc
+ print_hex_vma (vma
);
451 #if BFD_HOST_64BIT_LONG
452 return printf ("%ld", vma
);
454 return print_dec_vma (vma
, 1);
458 #if BFD_HOST_64BIT_LONG
460 return printf ("%5ld", vma
);
462 return printf ("%#lx", vma
);
465 return printf ("%5ld", _bfd_int64_low (vma
));
467 return print_hex_vma (vma
);
471 #if BFD_HOST_64BIT_LONG
472 return printf ("%lu", vma
);
474 return print_dec_vma (vma
, 0);
482 /* Display a symbol on stdout. If do_wide is not true then
483 format the symbol to be at most WIDTH characters,
484 truncating as necessary. If WIDTH is negative then
485 format the string to be exactly - WIDTH characters,
486 truncating or padding as necessary. */
489 print_symbol (int width
, const char *symbol
)
492 printf ("%s", symbol
);
494 printf ("%-*.*s", width
, width
, symbol
);
496 printf ("%-.*s", width
, symbol
);
500 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
505 field
[7] = value
& 0xff;
506 field
[6] = (value
>> 8) & 0xff;
507 field
[5] = (value
>> 16) & 0xff;
508 field
[4] = (value
>> 24) & 0xff;
513 field
[3] = value
& 0xff;
514 field
[2] = (value
>> 8) & 0xff;
518 field
[1] = value
& 0xff;
522 field
[0] = value
& 0xff;
526 error (_("Unhandled data length: %d\n"), size
);
531 /* Return a pointer to section NAME, or NULL if no such section exists. */
533 static Elf_Internal_Shdr
*
534 find_section (const char *name
)
538 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
539 if (streq (SECTION_NAME (section_headers
+ i
), name
))
540 return section_headers
+ i
;
545 /* Guess the relocation size commonly used by the specific machines. */
548 guess_is_rela (unsigned long e_machine
)
552 /* Targets that use REL relocations. */
567 /* Targets that use RELA relocations. */
582 case EM_CYGNUS_MN10200
:
584 case EM_CYGNUS_MN10300
:
615 case EM_ALTERA_NIOS2
:
636 warn (_("Don't know about relocations on this machine architecture\n"));
642 slurp_rela_relocs (FILE *file
,
643 unsigned long rel_offset
,
644 unsigned long rel_size
,
645 Elf_Internal_Rela
**relasp
,
646 unsigned long *nrelasp
)
648 Elf_Internal_Rela
*relas
;
649 unsigned long nrelas
;
654 Elf32_External_Rela
*erelas
;
656 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
660 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
662 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
667 error (_("out of memory parsing relocs"));
671 for (i
= 0; i
< nrelas
; i
++)
673 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
674 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
675 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
682 Elf64_External_Rela
*erelas
;
684 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
688 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
690 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
695 error (_("out of memory parsing relocs"));
699 for (i
= 0; i
< nrelas
; i
++)
701 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
702 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
703 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
714 slurp_rel_relocs (FILE *file
,
715 unsigned long rel_offset
,
716 unsigned long rel_size
,
717 Elf_Internal_Rela
**relsp
,
718 unsigned long *nrelsp
)
720 Elf_Internal_Rela
*rels
;
726 Elf32_External_Rel
*erels
;
728 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
732 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
734 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
739 error (_("out of memory parsing relocs"));
743 for (i
= 0; i
< nrels
; i
++)
745 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
746 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
747 rels
[i
].r_addend
= 0;
754 Elf64_External_Rel
*erels
;
756 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
760 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
762 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
767 error (_("out of memory parsing relocs"));
771 for (i
= 0; i
< nrels
; i
++)
773 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
774 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
775 rels
[i
].r_addend
= 0;
785 /* Display the contents of the relocation data found at the specified
789 dump_relocations (FILE *file
,
790 unsigned long rel_offset
,
791 unsigned long rel_size
,
792 Elf_Internal_Sym
*symtab
,
795 unsigned long strtablen
,
799 Elf_Internal_Rela
*rels
;
802 if (is_rela
== UNKNOWN
)
803 is_rela
= guess_is_rela (elf_header
.e_machine
);
807 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
812 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
821 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
823 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
828 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
830 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
838 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
840 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
845 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
847 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
851 for (i
= 0; i
< rel_size
; i
++)
854 const char *rtype2
= NULL
;
855 const char *rtype3
= NULL
;
858 bfd_vma symtab_index
;
863 offset
= rels
[i
].r_offset
;
864 info
= rels
[i
].r_info
;
868 type
= ELF32_R_TYPE (info
);
869 symtab_index
= ELF32_R_SYM (info
);
873 /* The #ifdef BFD64 below is to prevent a compile time warning.
874 We know that if we do not have a 64 bit data type that we
875 will never execute this code anyway. */
877 if (elf_header
.e_machine
== EM_MIPS
)
879 /* In little-endian objects, r_info isn't really a 64-bit
880 little-endian value: it has a 32-bit little-endian
881 symbol index followed by four individual byte fields.
882 Reorder INFO accordingly. */
883 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
884 info
= (((info
& 0xffffffff) << 32)
885 | ((info
>> 56) & 0xff)
886 | ((info
>> 40) & 0xff00)
887 | ((info
>> 24) & 0xff0000)
888 | ((info
>> 8) & 0xff000000));
889 type
= ELF64_MIPS_R_TYPE (info
);
890 type2
= ELF64_MIPS_R_TYPE2 (info
);
891 type3
= ELF64_MIPS_R_TYPE3 (info
);
893 else if (elf_header
.e_machine
== EM_SPARCV9
)
894 type
= ELF64_R_TYPE_ID (info
);
896 type
= ELF64_R_TYPE (info
);
898 symtab_index
= ELF64_R_SYM (info
);
904 #ifdef _bfd_int64_low
905 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
907 printf ("%8.8lx %8.8lx ", offset
, info
);
912 #ifdef _bfd_int64_low
914 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
915 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
916 _bfd_int64_high (offset
),
917 _bfd_int64_low (offset
),
918 _bfd_int64_high (info
),
919 _bfd_int64_low (info
));
922 ? "%16.16lx %16.16lx "
923 : "%12.12lx %12.12lx ",
928 switch (elf_header
.e_machine
)
936 rtype
= elf_m32r_reloc_type (type
);
941 rtype
= elf_i386_reloc_type (type
);
946 rtype
= elf_m68hc11_reloc_type (type
);
950 rtype
= elf_m68k_reloc_type (type
);
954 rtype
= elf_i960_reloc_type (type
);
959 rtype
= elf_avr_reloc_type (type
);
966 rtype
= elf_sparc_reloc_type (type
);
971 rtype
= v850_reloc_type (type
);
976 rtype
= elf_d10v_reloc_type (type
);
981 rtype
= elf_d30v_reloc_type (type
);
985 rtype
= elf_dlx_reloc_type (type
);
989 rtype
= elf_sh_reloc_type (type
);
993 case EM_CYGNUS_MN10300
:
994 rtype
= elf_mn10300_reloc_type (type
);
998 case EM_CYGNUS_MN10200
:
999 rtype
= elf_mn10200_reloc_type (type
);
1003 case EM_CYGNUS_FR30
:
1004 rtype
= elf_fr30_reloc_type (type
);
1008 rtype
= elf_frv_reloc_type (type
);
1012 rtype
= elf_mcore_reloc_type (type
);
1016 rtype
= elf_mmix_reloc_type (type
);
1021 rtype
= elf_msp430_reloc_type (type
);
1025 rtype
= elf_ppc_reloc_type (type
);
1029 rtype
= elf_ppc64_reloc_type (type
);
1033 case EM_MIPS_RS3_LE
:
1034 rtype
= elf_mips_reloc_type (type
);
1037 rtype2
= elf_mips_reloc_type (type2
);
1038 rtype3
= elf_mips_reloc_type (type3
);
1043 rtype
= elf_alpha_reloc_type (type
);
1047 rtype
= elf_arm_reloc_type (type
);
1051 rtype
= elf_arc_reloc_type (type
);
1055 rtype
= elf_hppa_reloc_type (type
);
1061 rtype
= elf_h8_reloc_type (type
);
1066 rtype
= elf_or32_reloc_type (type
);
1071 rtype
= elf_pj_reloc_type (type
);
1074 rtype
= elf_ia64_reloc_type (type
);
1078 rtype
= elf_cris_reloc_type (type
);
1082 rtype
= elf_i860_reloc_type (type
);
1086 rtype
= elf_x86_64_reloc_type (type
);
1090 rtype
= i370_reloc_type (type
);
1095 rtype
= elf_s390_reloc_type (type
);
1099 rtype
= elf_xstormy16_reloc_type (type
);
1103 rtype
= elf_crx_reloc_type (type
);
1107 rtype
= elf_vax_reloc_type (type
);
1112 rtype
= elf_ip2k_reloc_type (type
);
1116 rtype
= elf_iq2000_reloc_type (type
);
1121 rtype
= elf_xtensa_reloc_type (type
);
1125 rtype
= elf_m32c_reloc_type (type
);
1129 rtype
= elf_mt_reloc_type (type
);
1133 rtype
= elf_bfin_reloc_type (type
);
1139 #ifdef _bfd_int64_low
1140 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1142 printf (_("unrecognized: %-7lx"), type
);
1145 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1147 if (elf_header
.e_machine
== EM_ALPHA
1148 && streq (rtype
, "R_ALPHA_LITUSE")
1151 switch (rels
[i
].r_addend
)
1153 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1154 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1155 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1156 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1157 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1158 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1159 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1160 default: rtype
= NULL
;
1163 printf (" (%s)", rtype
);
1167 printf (_("<unknown addend: %lx>"),
1168 (unsigned long) rels
[i
].r_addend
);
1171 else if (symtab_index
)
1173 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1174 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1177 Elf_Internal_Sym
*psym
;
1179 psym
= symtab
+ symtab_index
;
1182 print_vma (psym
->st_value
, LONG_HEX
);
1183 printf (is_32bit_elf
? " " : " ");
1185 if (psym
->st_name
== 0)
1187 const char *sec_name
= "<null>";
1190 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1192 bfd_vma sec_index
= (bfd_vma
) -1;
1194 if (psym
->st_shndx
< SHN_LORESERVE
)
1195 sec_index
= psym
->st_shndx
;
1196 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1197 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1200 if (sec_index
!= (bfd_vma
) -1)
1201 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1202 else if (psym
->st_shndx
== SHN_ABS
)
1204 else if (psym
->st_shndx
== SHN_COMMON
)
1205 sec_name
= "COMMON";
1206 else if (elf_header
.e_machine
== EM_X86_64
1207 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1208 sec_name
= "LARGE_COMMON";
1209 else if (elf_header
.e_machine
== EM_IA_64
1210 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1211 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1212 sec_name
= "ANSI_COM";
1215 sprintf (name_buf
, "<section 0x%x>",
1216 (unsigned int) psym
->st_shndx
);
1217 sec_name
= name_buf
;
1220 print_symbol (22, sec_name
);
1222 else if (strtab
== NULL
)
1223 printf (_("<string table index: %3ld>"), psym
->st_name
);
1224 else if (psym
->st_name
>= strtablen
)
1225 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1227 print_symbol (22, strtab
+ psym
->st_name
);
1230 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1235 printf ("%*c", is_32bit_elf
?
1236 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1237 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1240 if (elf_header
.e_machine
== EM_SPARCV9
&& streq (rtype
, "R_SPARC_OLO10"))
1241 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1245 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1247 printf (" Type2: ");
1250 #ifdef _bfd_int64_low
1251 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1253 printf (_("unrecognized: %-7lx"), type2
);
1256 printf ("%-17.17s", rtype2
);
1258 printf ("\n Type3: ");
1261 #ifdef _bfd_int64_low
1262 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1264 printf (_("unrecognized: %-7lx"), type3
);
1267 printf ("%-17.17s", rtype3
);
1279 get_mips_dynamic_type (unsigned long type
)
1283 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1284 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1285 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1286 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1287 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1288 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1289 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1290 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1291 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1292 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1293 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1294 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1295 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1296 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1297 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1298 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1299 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1300 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1301 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1302 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1303 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1304 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1305 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1306 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1307 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1308 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1309 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1310 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1311 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1312 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1313 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1314 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1315 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1316 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1317 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1318 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1319 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1320 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1321 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1322 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1323 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1324 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1325 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1332 get_sparc64_dynamic_type (unsigned long type
)
1336 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1343 get_ppc_dynamic_type (unsigned long type
)
1347 case DT_PPC_GOT
: return "PPC_GOT";
1354 get_ppc64_dynamic_type (unsigned long type
)
1358 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1359 case DT_PPC64_OPD
: return "PPC64_OPD";
1360 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1367 get_parisc_dynamic_type (unsigned long type
)
1371 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1372 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1373 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1374 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1375 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1376 case DT_HP_PREINIT
: return "HP_PREINIT";
1377 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1378 case DT_HP_NEEDED
: return "HP_NEEDED";
1379 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1380 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1381 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1382 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1383 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1384 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1385 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1386 case DT_HP_FILTERED
: return "HP_FILTERED";
1387 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1388 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1389 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1390 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1391 case DT_PLT
: return "PLT";
1392 case DT_PLT_SIZE
: return "PLT_SIZE";
1393 case DT_DLT
: return "DLT";
1394 case DT_DLT_SIZE
: return "DLT_SIZE";
1401 get_ia64_dynamic_type (unsigned long type
)
1405 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1412 get_alpha_dynamic_type (unsigned long type
)
1416 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1423 get_dynamic_type (unsigned long type
)
1425 static char buff
[64];
1429 case DT_NULL
: return "NULL";
1430 case DT_NEEDED
: return "NEEDED";
1431 case DT_PLTRELSZ
: return "PLTRELSZ";
1432 case DT_PLTGOT
: return "PLTGOT";
1433 case DT_HASH
: return "HASH";
1434 case DT_STRTAB
: return "STRTAB";
1435 case DT_SYMTAB
: return "SYMTAB";
1436 case DT_RELA
: return "RELA";
1437 case DT_RELASZ
: return "RELASZ";
1438 case DT_RELAENT
: return "RELAENT";
1439 case DT_STRSZ
: return "STRSZ";
1440 case DT_SYMENT
: return "SYMENT";
1441 case DT_INIT
: return "INIT";
1442 case DT_FINI
: return "FINI";
1443 case DT_SONAME
: return "SONAME";
1444 case DT_RPATH
: return "RPATH";
1445 case DT_SYMBOLIC
: return "SYMBOLIC";
1446 case DT_REL
: return "REL";
1447 case DT_RELSZ
: return "RELSZ";
1448 case DT_RELENT
: return "RELENT";
1449 case DT_PLTREL
: return "PLTREL";
1450 case DT_DEBUG
: return "DEBUG";
1451 case DT_TEXTREL
: return "TEXTREL";
1452 case DT_JMPREL
: return "JMPREL";
1453 case DT_BIND_NOW
: return "BIND_NOW";
1454 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1455 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1456 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1457 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1458 case DT_RUNPATH
: return "RUNPATH";
1459 case DT_FLAGS
: return "FLAGS";
1461 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1462 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1464 case DT_CHECKSUM
: return "CHECKSUM";
1465 case DT_PLTPADSZ
: return "PLTPADSZ";
1466 case DT_MOVEENT
: return "MOVEENT";
1467 case DT_MOVESZ
: return "MOVESZ";
1468 case DT_FEATURE
: return "FEATURE";
1469 case DT_POSFLAG_1
: return "POSFLAG_1";
1470 case DT_SYMINSZ
: return "SYMINSZ";
1471 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1473 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1474 case DT_CONFIG
: return "CONFIG";
1475 case DT_DEPAUDIT
: return "DEPAUDIT";
1476 case DT_AUDIT
: return "AUDIT";
1477 case DT_PLTPAD
: return "PLTPAD";
1478 case DT_MOVETAB
: return "MOVETAB";
1479 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1481 case DT_VERSYM
: return "VERSYM";
1483 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1484 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1485 case DT_RELACOUNT
: return "RELACOUNT";
1486 case DT_RELCOUNT
: return "RELCOUNT";
1487 case DT_FLAGS_1
: return "FLAGS_1";
1488 case DT_VERDEF
: return "VERDEF";
1489 case DT_VERDEFNUM
: return "VERDEFNUM";
1490 case DT_VERNEED
: return "VERNEED";
1491 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1493 case DT_AUXILIARY
: return "AUXILIARY";
1494 case DT_USED
: return "USED";
1495 case DT_FILTER
: return "FILTER";
1497 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1498 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1499 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1500 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1501 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1504 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1508 switch (elf_header
.e_machine
)
1511 case EM_MIPS_RS3_LE
:
1512 result
= get_mips_dynamic_type (type
);
1515 result
= get_sparc64_dynamic_type (type
);
1518 result
= get_ppc_dynamic_type (type
);
1521 result
= get_ppc64_dynamic_type (type
);
1524 result
= get_ia64_dynamic_type (type
);
1527 result
= get_alpha_dynamic_type (type
);
1537 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1539 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1540 || (elf_header
.e_machine
== EM_PARISC
1541 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1545 switch (elf_header
.e_machine
)
1548 result
= get_parisc_dynamic_type (type
);
1558 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1562 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1569 get_file_type (unsigned e_type
)
1571 static char buff
[32];
1575 case ET_NONE
: return _("NONE (None)");
1576 case ET_REL
: return _("REL (Relocatable file)");
1577 case ET_EXEC
: return _("EXEC (Executable file)");
1578 case ET_DYN
: return _("DYN (Shared object file)");
1579 case ET_CORE
: return _("CORE (Core file)");
1582 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1583 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1584 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1585 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1587 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1593 get_machine_name (unsigned e_machine
)
1595 static char buff
[64]; /* XXX */
1599 case EM_NONE
: return _("None");
1600 case EM_M32
: return "WE32100";
1601 case EM_SPARC
: return "Sparc";
1602 case EM_386
: return "Intel 80386";
1603 case EM_68K
: return "MC68000";
1604 case EM_88K
: return "MC88000";
1605 case EM_486
: return "Intel 80486";
1606 case EM_860
: return "Intel 80860";
1607 case EM_MIPS
: return "MIPS R3000";
1608 case EM_S370
: return "IBM System/370";
1609 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1610 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1611 case EM_PARISC
: return "HPPA";
1612 case EM_PPC_OLD
: return "Power PC (old)";
1613 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1614 case EM_960
: return "Intel 90860";
1615 case EM_PPC
: return "PowerPC";
1616 case EM_PPC64
: return "PowerPC64";
1617 case EM_V800
: return "NEC V800";
1618 case EM_FR20
: return "Fujitsu FR20";
1619 case EM_RH32
: return "TRW RH32";
1620 case EM_MCORE
: return "MCORE";
1621 case EM_ARM
: return "ARM";
1622 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1623 case EM_SH
: return "Renesas / SuperH SH";
1624 case EM_SPARCV9
: return "Sparc v9";
1625 case EM_TRICORE
: return "Siemens Tricore";
1626 case EM_ARC
: return "ARC";
1627 case EM_H8_300
: return "Renesas H8/300";
1628 case EM_H8_300H
: return "Renesas H8/300H";
1629 case EM_H8S
: return "Renesas H8S";
1630 case EM_H8_500
: return "Renesas H8/500";
1631 case EM_IA_64
: return "Intel IA-64";
1632 case EM_MIPS_X
: return "Stanford MIPS-X";
1633 case EM_COLDFIRE
: return "Motorola Coldfire";
1634 case EM_68HC12
: return "Motorola M68HC12";
1635 case EM_ALPHA
: return "Alpha";
1636 case EM_CYGNUS_D10V
:
1637 case EM_D10V
: return "d10v";
1638 case EM_CYGNUS_D30V
:
1639 case EM_D30V
: return "d30v";
1640 case EM_CYGNUS_M32R
:
1641 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1642 case EM_CYGNUS_V850
:
1643 case EM_V850
: return "NEC v850";
1644 case EM_CYGNUS_MN10300
:
1645 case EM_MN10300
: return "mn10300";
1646 case EM_CYGNUS_MN10200
:
1647 case EM_MN10200
: return "mn10200";
1648 case EM_CYGNUS_FR30
:
1649 case EM_FR30
: return "Fujitsu FR30";
1650 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1652 case EM_PJ
: return "picoJava";
1653 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1654 case EM_PCP
: return "Siemens PCP";
1655 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1656 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1657 case EM_STARCORE
: return "Motorola Star*Core processor";
1658 case EM_ME16
: return "Toyota ME16 processor";
1659 case EM_ST100
: return "STMicroelectronics ST100 processor";
1660 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1661 case EM_FX66
: return "Siemens FX66 microcontroller";
1662 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1663 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1664 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1665 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1666 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1667 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1668 case EM_SVX
: return "Silicon Graphics SVx";
1669 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1670 case EM_VAX
: return "Digital VAX";
1672 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1673 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1674 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1675 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1676 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1677 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1678 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1679 case EM_PRISM
: return "Vitesse Prism";
1680 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1682 case EM_S390
: return "IBM S/390";
1683 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1685 case EM_OR32
: return "OpenRISC";
1686 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1687 case EM_DLX
: return "OpenDLX";
1689 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1690 case EM_IQ2000
: return "Vitesse IQ2000";
1692 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1693 case EM_M32C
: return "Renesas M32c";
1694 case EM_MT
: return "Morpho Techologies MT processor";
1695 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1696 case EM_NIOS32
: return "Altera Nios";
1697 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1699 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1705 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1710 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1711 e_flags
&= ~ EF_ARM_EABIMASK
;
1713 /* Handle "generic" ARM flags. */
1714 if (e_flags
& EF_ARM_RELEXEC
)
1716 strcat (buf
, ", relocatable executable");
1717 e_flags
&= ~ EF_ARM_RELEXEC
;
1720 if (e_flags
& EF_ARM_HASENTRY
)
1722 strcat (buf
, ", has entry point");
1723 e_flags
&= ~ EF_ARM_HASENTRY
;
1726 /* Now handle EABI specific flags. */
1730 strcat (buf
, ", <unrecognized EABI>");
1735 case EF_ARM_EABI_VER1
:
1736 strcat (buf
, ", Version1 EABI");
1741 /* Process flags one bit at a time. */
1742 flag
= e_flags
& - e_flags
;
1747 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1748 strcat (buf
, ", sorted symbol tables");
1758 case EF_ARM_EABI_VER2
:
1759 strcat (buf
, ", Version2 EABI");
1764 /* Process flags one bit at a time. */
1765 flag
= e_flags
& - e_flags
;
1770 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1771 strcat (buf
, ", sorted symbol tables");
1774 case EF_ARM_DYNSYMSUSESEGIDX
:
1775 strcat (buf
, ", dynamic symbols use segment index");
1778 case EF_ARM_MAPSYMSFIRST
:
1779 strcat (buf
, ", mapping symbols precede others");
1789 case EF_ARM_EABI_VER3
:
1790 strcat (buf
, ", Version3 EABI");
1793 case EF_ARM_EABI_VER4
:
1794 strcat (buf
, ", Version4 EABI");
1799 /* Process flags one bit at a time. */
1800 flag
= e_flags
& - e_flags
;
1806 strcat (buf
, ", BE8");
1810 strcat (buf
, ", LE8");
1820 case EF_ARM_EABI_UNKNOWN
:
1821 strcat (buf
, ", GNU EABI");
1826 /* Process flags one bit at a time. */
1827 flag
= e_flags
& - e_flags
;
1832 case EF_ARM_INTERWORK
:
1833 strcat (buf
, ", interworking enabled");
1836 case EF_ARM_APCS_26
:
1837 strcat (buf
, ", uses APCS/26");
1840 case EF_ARM_APCS_FLOAT
:
1841 strcat (buf
, ", uses APCS/float");
1845 strcat (buf
, ", position independent");
1849 strcat (buf
, ", 8 bit structure alignment");
1852 case EF_ARM_NEW_ABI
:
1853 strcat (buf
, ", uses new ABI");
1856 case EF_ARM_OLD_ABI
:
1857 strcat (buf
, ", uses old ABI");
1860 case EF_ARM_SOFT_FLOAT
:
1861 strcat (buf
, ", software FP");
1864 case EF_ARM_VFP_FLOAT
:
1865 strcat (buf
, ", VFP");
1868 case EF_ARM_MAVERICK_FLOAT
:
1869 strcat (buf
, ", Maverick FP");
1880 strcat (buf
,", <unknown>");
1884 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1886 static char buf
[1024];
1898 decode_ARM_machine_flags (e_flags
, buf
);
1902 switch (e_flags
& EF_FRV_CPU_MASK
)
1904 case EF_FRV_CPU_GENERIC
:
1908 strcat (buf
, ", fr???");
1911 case EF_FRV_CPU_FR300
:
1912 strcat (buf
, ", fr300");
1915 case EF_FRV_CPU_FR400
:
1916 strcat (buf
, ", fr400");
1918 case EF_FRV_CPU_FR405
:
1919 strcat (buf
, ", fr405");
1922 case EF_FRV_CPU_FR450
:
1923 strcat (buf
, ", fr450");
1926 case EF_FRV_CPU_FR500
:
1927 strcat (buf
, ", fr500");
1929 case EF_FRV_CPU_FR550
:
1930 strcat (buf
, ", fr550");
1933 case EF_FRV_CPU_SIMPLE
:
1934 strcat (buf
, ", simple");
1936 case EF_FRV_CPU_TOMCAT
:
1937 strcat (buf
, ", tomcat");
1943 if (e_flags
& EF_M68K_CPU32
)
1944 strcat (buf
, ", cpu32");
1945 if (e_flags
& EF_M68K_M68000
)
1946 strcat (buf
, ", m68000");
1947 if (e_flags
& EF_M68K_ISA_MASK
)
1949 char const *isa
= _("unknown");
1950 char const *mac
= _("unknown mac");
1952 switch (e_flags
& EF_M68K_ISA_MASK
)
1957 case EF_M68K_ISA_A_PLUS
:
1964 strcat (buf
, ", cf, isa ");
1966 if (e_flags
& EF_M68K_HW_DIV
)
1967 strcat (buf
, ", hwdiv");
1968 switch (e_flags
& EF_M68K_MAC_MASK
)
1985 if (e_flags
& EF_M68K_USP
)
1986 strcat (buf
, ", usp");
1987 if (e_flags
& EF_M68K_FLOAT
)
1988 strcat (buf
, ", float");
1993 if (e_flags
& EF_PPC_EMB
)
1994 strcat (buf
, ", emb");
1996 if (e_flags
& EF_PPC_RELOCATABLE
)
1997 strcat (buf
, ", relocatable");
1999 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2000 strcat (buf
, ", relocatable-lib");
2004 case EM_CYGNUS_V850
:
2005 switch (e_flags
& EF_V850_ARCH
)
2008 strcat (buf
, ", v850e1");
2011 strcat (buf
, ", v850e");
2014 strcat (buf
, ", v850");
2017 strcat (buf
, ", unknown v850 architecture variant");
2023 case EM_CYGNUS_M32R
:
2024 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2025 strcat (buf
, ", m32r");
2030 case EM_MIPS_RS3_LE
:
2031 if (e_flags
& EF_MIPS_NOREORDER
)
2032 strcat (buf
, ", noreorder");
2034 if (e_flags
& EF_MIPS_PIC
)
2035 strcat (buf
, ", pic");
2037 if (e_flags
& EF_MIPS_CPIC
)
2038 strcat (buf
, ", cpic");
2040 if (e_flags
& EF_MIPS_UCODE
)
2041 strcat (buf
, ", ugen_reserved");
2043 if (e_flags
& EF_MIPS_ABI2
)
2044 strcat (buf
, ", abi2");
2046 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2047 strcat (buf
, ", odk first");
2049 if (e_flags
& EF_MIPS_32BITMODE
)
2050 strcat (buf
, ", 32bitmode");
2052 switch ((e_flags
& EF_MIPS_MACH
))
2054 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2055 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2056 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2057 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2058 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2059 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2060 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2061 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2062 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2063 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2065 /* We simply ignore the field in this case to avoid confusion:
2066 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2069 default: strcat (buf
, ", unknown CPU"); break;
2072 switch ((e_flags
& EF_MIPS_ABI
))
2074 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2075 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2076 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2077 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2079 /* We simply ignore the field in this case to avoid confusion:
2080 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2081 This means it is likely to be an o32 file, but not for
2084 default: strcat (buf
, ", unknown ABI"); break;
2087 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2088 strcat (buf
, ", mdmx");
2090 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2091 strcat (buf
, ", mips16");
2093 switch ((e_flags
& EF_MIPS_ARCH
))
2095 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2096 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2097 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2098 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2099 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2100 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2101 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2102 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2103 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2104 default: strcat (buf
, ", unknown ISA"); break;
2110 switch ((e_flags
& EF_SH_MACH_MASK
))
2112 case EF_SH1
: strcat (buf
, ", sh1"); break;
2113 case EF_SH2
: strcat (buf
, ", sh2"); break;
2114 case EF_SH3
: strcat (buf
, ", sh3"); break;
2115 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2116 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2117 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2118 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2119 case EF_SH4
: strcat (buf
, ", sh4"); break;
2120 case EF_SH5
: strcat (buf
, ", sh5"); break;
2121 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2122 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2123 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2124 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2125 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2126 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2127 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2128 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2129 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2130 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2131 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2132 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2133 default: strcat (buf
, ", unknown ISA"); break;
2139 if (e_flags
& EF_SPARC_32PLUS
)
2140 strcat (buf
, ", v8+");
2142 if (e_flags
& EF_SPARC_SUN_US1
)
2143 strcat (buf
, ", ultrasparcI");
2145 if (e_flags
& EF_SPARC_SUN_US3
)
2146 strcat (buf
, ", ultrasparcIII");
2148 if (e_flags
& EF_SPARC_HAL_R1
)
2149 strcat (buf
, ", halr1");
2151 if (e_flags
& EF_SPARC_LEDATA
)
2152 strcat (buf
, ", ledata");
2154 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2155 strcat (buf
, ", tso");
2157 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2158 strcat (buf
, ", pso");
2160 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2161 strcat (buf
, ", rmo");
2165 switch (e_flags
& EF_PARISC_ARCH
)
2167 case EFA_PARISC_1_0
:
2168 strcpy (buf
, ", PA-RISC 1.0");
2170 case EFA_PARISC_1_1
:
2171 strcpy (buf
, ", PA-RISC 1.1");
2173 case EFA_PARISC_2_0
:
2174 strcpy (buf
, ", PA-RISC 2.0");
2179 if (e_flags
& EF_PARISC_TRAPNIL
)
2180 strcat (buf
, ", trapnil");
2181 if (e_flags
& EF_PARISC_EXT
)
2182 strcat (buf
, ", ext");
2183 if (e_flags
& EF_PARISC_LSB
)
2184 strcat (buf
, ", lsb");
2185 if (e_flags
& EF_PARISC_WIDE
)
2186 strcat (buf
, ", wide");
2187 if (e_flags
& EF_PARISC_NO_KABP
)
2188 strcat (buf
, ", no kabp");
2189 if (e_flags
& EF_PARISC_LAZYSWAP
)
2190 strcat (buf
, ", lazyswap");
2195 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2196 strcat (buf
, ", new calling convention");
2198 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2199 strcat (buf
, ", gnu calling convention");
2203 if ((e_flags
& EF_IA_64_ABI64
))
2204 strcat (buf
, ", 64-bit");
2206 strcat (buf
, ", 32-bit");
2207 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2208 strcat (buf
, ", reduced fp model");
2209 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2210 strcat (buf
, ", no function descriptors, constant gp");
2211 else if ((e_flags
& EF_IA_64_CONS_GP
))
2212 strcat (buf
, ", constant gp");
2213 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2214 strcat (buf
, ", absolute");
2218 if ((e_flags
& EF_VAX_NONPIC
))
2219 strcat (buf
, ", non-PIC");
2220 if ((e_flags
& EF_VAX_DFLOAT
))
2221 strcat (buf
, ", D-Float");
2222 if ((e_flags
& EF_VAX_GFLOAT
))
2223 strcat (buf
, ", G-Float");
2232 get_osabi_name (unsigned int osabi
)
2234 static char buff
[32];
2238 case ELFOSABI_NONE
: return "UNIX - System V";
2239 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2240 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2241 case ELFOSABI_LINUX
: return "UNIX - Linux";
2242 case ELFOSABI_HURD
: return "GNU/Hurd";
2243 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2244 case ELFOSABI_AIX
: return "UNIX - AIX";
2245 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2246 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2247 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2248 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2249 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2250 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2251 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2252 case ELFOSABI_AROS
: return "Amiga Research OS";
2253 case ELFOSABI_STANDALONE
: return _("Standalone App");
2254 case ELFOSABI_ARM
: return "ARM";
2256 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2262 get_arm_segment_type (unsigned long type
)
2276 get_mips_segment_type (unsigned long type
)
2280 case PT_MIPS_REGINFO
:
2282 case PT_MIPS_RTPROC
:
2284 case PT_MIPS_OPTIONS
:
2294 get_parisc_segment_type (unsigned long type
)
2298 case PT_HP_TLS
: return "HP_TLS";
2299 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2300 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2301 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2302 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2303 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2304 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2305 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2306 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2307 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2308 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2309 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2310 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2311 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2312 case PT_HP_STACK
: return "HP_STACK";
2313 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2314 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2315 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2316 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2325 get_ia64_segment_type (unsigned long type
)
2329 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2330 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2331 case PT_HP_TLS
: return "HP_TLS";
2332 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2333 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2334 case PT_IA_64_HP_STACK
: return "HP_STACK";
2343 get_segment_type (unsigned long p_type
)
2345 static char buff
[32];
2349 case PT_NULL
: return "NULL";
2350 case PT_LOAD
: return "LOAD";
2351 case PT_DYNAMIC
: return "DYNAMIC";
2352 case PT_INTERP
: return "INTERP";
2353 case PT_NOTE
: return "NOTE";
2354 case PT_SHLIB
: return "SHLIB";
2355 case PT_PHDR
: return "PHDR";
2356 case PT_TLS
: return "TLS";
2358 case PT_GNU_EH_FRAME
:
2359 return "GNU_EH_FRAME";
2360 case PT_GNU_STACK
: return "GNU_STACK";
2361 case PT_GNU_RELRO
: return "GNU_RELRO";
2364 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2368 switch (elf_header
.e_machine
)
2371 result
= get_arm_segment_type (p_type
);
2374 case EM_MIPS_RS3_LE
:
2375 result
= get_mips_segment_type (p_type
);
2378 result
= get_parisc_segment_type (p_type
);
2381 result
= get_ia64_segment_type (p_type
);
2391 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2393 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2397 switch (elf_header
.e_machine
)
2400 result
= get_parisc_segment_type (p_type
);
2403 result
= get_ia64_segment_type (p_type
);
2413 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2416 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2423 get_mips_section_type_name (unsigned int sh_type
)
2427 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2428 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2429 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2430 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2431 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2432 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2433 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2434 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2435 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2436 case SHT_MIPS_RELD
: return "MIPS_RELD";
2437 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2438 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2439 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2440 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2441 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2442 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2443 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2444 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2445 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2446 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2447 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2448 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2449 case SHT_MIPS_LINE
: return "MIPS_LINE";
2450 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2451 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2452 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2453 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2454 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2455 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2456 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2457 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2458 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2459 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2460 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2461 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2462 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2463 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2464 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2465 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2473 get_parisc_section_type_name (unsigned int sh_type
)
2477 case SHT_PARISC_EXT
: return "PARISC_EXT";
2478 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2479 case SHT_PARISC_DOC
: return "PARISC_DOC";
2480 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2481 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2482 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2483 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2491 get_ia64_section_type_name (unsigned int sh_type
)
2493 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2494 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2495 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2499 case SHT_IA_64_EXT
: return "IA_64_EXT";
2500 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2501 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2509 get_x86_64_section_type_name (unsigned int sh_type
)
2513 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2521 get_arm_section_type_name (unsigned int sh_type
)
2527 case SHT_ARM_PREEMPTMAP
:
2528 return "ARM_PREEMPTMAP";
2529 case SHT_ARM_ATTRIBUTES
:
2530 return "ARM_ATTRIBUTES";
2538 get_section_type_name (unsigned int sh_type
)
2540 static char buff
[32];
2544 case SHT_NULL
: return "NULL";
2545 case SHT_PROGBITS
: return "PROGBITS";
2546 case SHT_SYMTAB
: return "SYMTAB";
2547 case SHT_STRTAB
: return "STRTAB";
2548 case SHT_RELA
: return "RELA";
2549 case SHT_HASH
: return "HASH";
2550 case SHT_DYNAMIC
: return "DYNAMIC";
2551 case SHT_NOTE
: return "NOTE";
2552 case SHT_NOBITS
: return "NOBITS";
2553 case SHT_REL
: return "REL";
2554 case SHT_SHLIB
: return "SHLIB";
2555 case SHT_DYNSYM
: return "DYNSYM";
2556 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2557 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2558 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2559 case SHT_GROUP
: return "GROUP";
2560 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2561 case SHT_GNU_verdef
: return "VERDEF";
2562 case SHT_GNU_verneed
: return "VERNEED";
2563 case SHT_GNU_versym
: return "VERSYM";
2564 case 0x6ffffff0: return "VERSYM";
2565 case 0x6ffffffc: return "VERDEF";
2566 case 0x7ffffffd: return "AUXILIARY";
2567 case 0x7fffffff: return "FILTER";
2568 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2571 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2575 switch (elf_header
.e_machine
)
2578 case EM_MIPS_RS3_LE
:
2579 result
= get_mips_section_type_name (sh_type
);
2582 result
= get_parisc_section_type_name (sh_type
);
2585 result
= get_ia64_section_type_name (sh_type
);
2588 result
= get_x86_64_section_type_name (sh_type
);
2591 result
= get_arm_section_type_name (sh_type
);
2601 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2603 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2604 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2605 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2606 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2608 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2614 #define OPTION_DEBUG_DUMP 512
2616 static struct option options
[] =
2618 {"all", no_argument
, 0, 'a'},
2619 {"file-header", no_argument
, 0, 'h'},
2620 {"program-headers", no_argument
, 0, 'l'},
2621 {"headers", no_argument
, 0, 'e'},
2622 {"histogram", no_argument
, 0, 'I'},
2623 {"segments", no_argument
, 0, 'l'},
2624 {"sections", no_argument
, 0, 'S'},
2625 {"section-headers", no_argument
, 0, 'S'},
2626 {"section-groups", no_argument
, 0, 'g'},
2627 {"section-details", no_argument
, 0, 't'},
2628 {"full-section-name",no_argument
, 0, 'N'},
2629 {"symbols", no_argument
, 0, 's'},
2630 {"syms", no_argument
, 0, 's'},
2631 {"relocs", no_argument
, 0, 'r'},
2632 {"notes", no_argument
, 0, 'n'},
2633 {"dynamic", no_argument
, 0, 'd'},
2634 {"arch-specific", no_argument
, 0, 'A'},
2635 {"version-info", no_argument
, 0, 'V'},
2636 {"use-dynamic", no_argument
, 0, 'D'},
2637 {"hex-dump", required_argument
, 0, 'x'},
2638 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2639 {"unwind", no_argument
, 0, 'u'},
2640 #ifdef SUPPORT_DISASSEMBLY
2641 {"instruction-dump", required_argument
, 0, 'i'},
2644 {"version", no_argument
, 0, 'v'},
2645 {"wide", no_argument
, 0, 'W'},
2646 {"help", no_argument
, 0, 'H'},
2647 {0, no_argument
, 0, 0}
2653 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2654 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2655 fprintf (stdout
, _(" Options are:\n\
2656 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2657 -h --file-header Display the ELF file header\n\
2658 -l --program-headers Display the program headers\n\
2659 --segments An alias for --program-headers\n\
2660 -S --section-headers Display the sections' header\n\
2661 --sections An alias for --section-headers\n\
2662 -g --section-groups Display the section groups\n\
2663 -t --section-details Display the section details\n\
2664 -e --headers Equivalent to: -h -l -S\n\
2665 -s --syms Display the symbol table\n\
2666 --symbols An alias for --syms\n\
2667 -n --notes Display the core notes (if present)\n\
2668 -r --relocs Display the relocations (if present)\n\
2669 -u --unwind Display the unwind info (if present)\n\
2670 -d --dynamic Display the dynamic section (if present)\n\
2671 -V --version-info Display the version sections (if present)\n\
2672 -A --arch-specific Display architecture specific information (if any).\n\
2673 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2674 -x --hex-dump=<number> Dump the contents of section <number>\n\
2675 -w[liaprmfFsoR] or\n\
2676 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2677 Display the contents of DWARF2 debug sections\n"));
2678 #ifdef SUPPORT_DISASSEMBLY
2679 fprintf (stdout
, _("\
2680 -i --instruction-dump=<number>\n\
2681 Disassemble the contents of section <number>\n"));
2683 fprintf (stdout
, _("\
2684 -I --histogram Display histogram of bucket list lengths\n\
2685 -W --wide Allow output width to exceed 80 characters\n\
2686 @<file> Read options from <file>\n\
2687 -H --help Display this information\n\
2688 -v --version Display the version number of readelf\n"));
2689 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2694 /* Record the fact that the user wants the contents of section number
2695 SECTION to be displayed using the method(s) encoded as flags bits
2696 in TYPE. Note, TYPE can be zero if we are creating the array for
2700 request_dump (unsigned int section
, int type
)
2702 if (section
>= num_dump_sects
)
2704 char *new_dump_sects
;
2706 new_dump_sects
= calloc (section
+ 1, 1);
2708 if (new_dump_sects
== NULL
)
2709 error (_("Out of memory allocating dump request table."));
2712 /* Copy current flag settings. */
2713 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2717 dump_sects
= new_dump_sects
;
2718 num_dump_sects
= section
+ 1;
2723 dump_sects
[section
] |= type
;
2728 /* Request a dump by section name. */
2731 request_dump_byname (const char *section
, int type
)
2733 struct dump_list_entry
*new_request
;
2735 new_request
= malloc (sizeof (struct dump_list_entry
));
2737 error (_("Out of memory allocating dump request table."));
2739 new_request
->name
= strdup (section
);
2740 if (!new_request
->name
)
2741 error (_("Out of memory allocating dump request table."));
2743 new_request
->type
= type
;
2745 new_request
->next
= dump_sects_byname
;
2746 dump_sects_byname
= new_request
;
2750 parse_args (int argc
, char **argv
)
2757 while ((c
= getopt_long
2758 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2779 do_section_groups
++;
2787 do_section_groups
++;
2792 do_section_details
++;
2834 section
= strtoul (optarg
, & cp
, 0);
2835 if (! *cp
&& section
>= 0)
2836 request_dump (section
, HEX_DUMP
);
2838 request_dump_byname (optarg
, HEX_DUMP
);
2846 unsigned int index
= 0;
2850 while (optarg
[index
])
2851 switch (optarg
[index
++])
2860 do_debug_abbrevs
= 1;
2870 do_debug_pubnames
= 1;
2874 do_debug_aranges
= 1;
2878 do_debug_ranges
= 1;
2882 do_debug_frames_interp
= 1;
2884 do_debug_frames
= 1;
2889 do_debug_macinfo
= 1;
2903 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2908 case OPTION_DEBUG_DUMP
:
2916 const char * option
;
2919 debug_dump_long_opts
;
2921 debug_dump_long_opts opts_table
[] =
2923 /* Please keep this table alpha- sorted. */
2924 { "Ranges", & do_debug_ranges
},
2925 { "abbrev", & do_debug_abbrevs
},
2926 { "aranges", & do_debug_aranges
},
2927 { "frames", & do_debug_frames
},
2928 { "frames-interp", & do_debug_frames_interp
},
2929 { "info", & do_debug_info
},
2930 { "line", & do_debug_lines
},
2931 { "loc", & do_debug_loc
},
2932 { "macro", & do_debug_macinfo
},
2933 { "pubnames", & do_debug_pubnames
},
2934 /* This entry is for compatability
2935 with earlier versions of readelf. */
2936 { "ranges", & do_debug_aranges
},
2937 { "str", & do_debug_str
},
2948 debug_dump_long_opts
* entry
;
2950 for (entry
= opts_table
; entry
->option
; entry
++)
2952 size_t len
= strlen (entry
->option
);
2954 if (strneq (p
, entry
->option
, len
)
2955 && (p
[len
] == ',' || p
[len
] == '\0'))
2957 * entry
->variable
= 1;
2959 /* The --debug-dump=frames-interp option also
2960 enables the --debug-dump=frames option. */
2961 if (do_debug_frames_interp
)
2962 do_debug_frames
= 1;
2969 if (entry
->option
== NULL
)
2971 warn (_("Unrecognized debug option '%s'\n"), p
);
2972 p
= strchr (p
, ',');
2982 #ifdef SUPPORT_DISASSEMBLY
2985 section
= strtoul (optarg
, & cp
, 0);
2986 if (! *cp
&& section
>= 0)
2988 request_dump (section
, DISASS_DUMP
);
2994 print_version (program_name
);
3003 #ifdef SUPPORT_DISASSEMBLY
3006 /* xgettext:c-format */
3007 error (_("Invalid option '-%c'\n"), c
);
3014 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3015 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3016 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3017 && !do_section_groups
)
3021 warn (_("Nothing to do.\n"));
3027 get_elf_class (unsigned int elf_class
)
3029 static char buff
[32];
3033 case ELFCLASSNONE
: return _("none");
3034 case ELFCLASS32
: return "ELF32";
3035 case ELFCLASS64
: return "ELF64";
3037 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3043 get_data_encoding (unsigned int encoding
)
3045 static char buff
[32];
3049 case ELFDATANONE
: return _("none");
3050 case ELFDATA2LSB
: return _("2's complement, little endian");
3051 case ELFDATA2MSB
: return _("2's complement, big endian");
3053 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3058 /* Decode the data held in 'elf_header'. */
3061 process_file_header (void)
3063 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3064 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3065 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3066 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3069 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3077 printf (_("ELF Header:\n"));
3078 printf (_(" Magic: "));
3079 for (i
= 0; i
< EI_NIDENT
; i
++)
3080 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3082 printf (_(" Class: %s\n"),
3083 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3084 printf (_(" Data: %s\n"),
3085 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3086 printf (_(" Version: %d %s\n"),
3087 elf_header
.e_ident
[EI_VERSION
],
3088 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3090 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3093 printf (_(" OS/ABI: %s\n"),
3094 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3095 printf (_(" ABI Version: %d\n"),
3096 elf_header
.e_ident
[EI_ABIVERSION
]);
3097 printf (_(" Type: %s\n"),
3098 get_file_type (elf_header
.e_type
));
3099 printf (_(" Machine: %s\n"),
3100 get_machine_name (elf_header
.e_machine
));
3101 printf (_(" Version: 0x%lx\n"),
3102 (unsigned long) elf_header
.e_version
);
3104 printf (_(" Entry point address: "));
3105 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3106 printf (_("\n Start of program headers: "));
3107 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3108 printf (_(" (bytes into file)\n Start of section headers: "));
3109 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3110 printf (_(" (bytes into file)\n"));
3112 printf (_(" Flags: 0x%lx%s\n"),
3113 (unsigned long) elf_header
.e_flags
,
3114 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3115 printf (_(" Size of this header: %ld (bytes)\n"),
3116 (long) elf_header
.e_ehsize
);
3117 printf (_(" Size of program headers: %ld (bytes)\n"),
3118 (long) elf_header
.e_phentsize
);
3119 printf (_(" Number of program headers: %ld\n"),
3120 (long) elf_header
.e_phnum
);
3121 printf (_(" Size of section headers: %ld (bytes)\n"),
3122 (long) elf_header
.e_shentsize
);
3123 printf (_(" Number of section headers: %ld"),
3124 (long) elf_header
.e_shnum
);
3125 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3126 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3127 putc ('\n', stdout
);
3128 printf (_(" Section header string table index: %ld"),
3129 (long) elf_header
.e_shstrndx
);
3130 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3131 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3132 putc ('\n', stdout
);
3135 if (section_headers
!= NULL
)
3137 if (elf_header
.e_shnum
== 0)
3138 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3139 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3140 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3141 free (section_headers
);
3142 section_headers
= NULL
;
3150 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3152 Elf32_External_Phdr
*phdrs
;
3153 Elf32_External_Phdr
*external
;
3154 Elf_Internal_Phdr
*internal
;
3157 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3158 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3159 _("program headers"));
3163 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3164 i
< elf_header
.e_phnum
;
3165 i
++, internal
++, external
++)
3167 internal
->p_type
= BYTE_GET (external
->p_type
);
3168 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3169 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3170 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3171 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3172 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3173 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3174 internal
->p_align
= BYTE_GET (external
->p_align
);
3183 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3185 Elf64_External_Phdr
*phdrs
;
3186 Elf64_External_Phdr
*external
;
3187 Elf_Internal_Phdr
*internal
;
3190 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3191 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3192 _("program headers"));
3196 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3197 i
< elf_header
.e_phnum
;
3198 i
++, internal
++, external
++)
3200 internal
->p_type
= BYTE_GET (external
->p_type
);
3201 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3202 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3203 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3204 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3205 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3206 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3207 internal
->p_align
= BYTE_GET (external
->p_align
);
3215 /* Returns 1 if the program headers were read into `program_headers'. */
3218 get_program_headers (FILE *file
)
3220 Elf_Internal_Phdr
*phdrs
;
3222 /* Check cache of prior read. */
3223 if (program_headers
!= NULL
)
3226 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3230 error (_("Out of memory\n"));
3235 ? get_32bit_program_headers (file
, phdrs
)
3236 : get_64bit_program_headers (file
, phdrs
))
3238 program_headers
= phdrs
;
3246 /* Returns 1 if the program headers were loaded. */
3249 process_program_headers (FILE *file
)
3251 Elf_Internal_Phdr
*segment
;
3254 if (elf_header
.e_phnum
== 0)
3257 printf (_("\nThere are no program headers in this file.\n"));
3261 if (do_segments
&& !do_header
)
3263 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3264 printf (_("Entry point "));
3265 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3266 printf (_("\nThere are %d program headers, starting at offset "),
3267 elf_header
.e_phnum
);
3268 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3272 if (! get_program_headers (file
))
3277 if (elf_header
.e_phnum
> 1)
3278 printf (_("\nProgram Headers:\n"));
3280 printf (_("\nProgram Headers:\n"));
3284 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3287 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3291 (_(" Type Offset VirtAddr PhysAddr\n"));
3293 (_(" FileSiz MemSiz Flags Align\n"));
3300 for (i
= 0, segment
= program_headers
;
3301 i
< elf_header
.e_phnum
;
3306 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3310 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3311 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3312 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3313 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3314 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3316 (segment
->p_flags
& PF_R
? 'R' : ' '),
3317 (segment
->p_flags
& PF_W
? 'W' : ' '),
3318 (segment
->p_flags
& PF_X
? 'E' : ' '));
3319 printf ("%#lx", (unsigned long) segment
->p_align
);
3323 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3324 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3327 print_vma (segment
->p_offset
, FULL_HEX
);
3331 print_vma (segment
->p_vaddr
, FULL_HEX
);
3333 print_vma (segment
->p_paddr
, FULL_HEX
);
3336 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3337 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3340 print_vma (segment
->p_filesz
, FULL_HEX
);
3344 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3345 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3348 print_vma (segment
->p_offset
, FULL_HEX
);
3352 (segment
->p_flags
& PF_R
? 'R' : ' '),
3353 (segment
->p_flags
& PF_W
? 'W' : ' '),
3354 (segment
->p_flags
& PF_X
? 'E' : ' '));
3356 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3357 printf ("%#lx", (unsigned long) segment
->p_align
);
3360 print_vma (segment
->p_align
, PREFIX_HEX
);
3365 print_vma (segment
->p_offset
, FULL_HEX
);
3367 print_vma (segment
->p_vaddr
, FULL_HEX
);
3369 print_vma (segment
->p_paddr
, FULL_HEX
);
3371 print_vma (segment
->p_filesz
, FULL_HEX
);
3373 print_vma (segment
->p_memsz
, FULL_HEX
);
3375 (segment
->p_flags
& PF_R
? 'R' : ' '),
3376 (segment
->p_flags
& PF_W
? 'W' : ' '),
3377 (segment
->p_flags
& PF_X
? 'E' : ' '));
3378 print_vma (segment
->p_align
, HEX
);
3382 switch (segment
->p_type
)
3386 error (_("more than one dynamic segment\n"));
3388 /* Try to locate the .dynamic section. If there is
3389 a section header table, we can easily locate it. */
3390 if (section_headers
!= NULL
)
3392 Elf_Internal_Shdr
*sec
;
3394 sec
= find_section (".dynamic");
3395 if (sec
== NULL
|| sec
->sh_size
== 0)
3397 error (_("no .dynamic section in the dynamic segment"));
3401 dynamic_addr
= sec
->sh_offset
;
3402 dynamic_size
= sec
->sh_size
;
3404 if (dynamic_addr
< segment
->p_offset
3405 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3406 warn (_("the .dynamic section is not contained within the dynamic segment"));
3407 else if (dynamic_addr
> segment
->p_offset
)
3408 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3412 /* Otherwise, we can only assume that the .dynamic
3413 section is the first section in the DYNAMIC segment. */
3414 dynamic_addr
= segment
->p_offset
;
3415 dynamic_size
= segment
->p_filesz
;
3420 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3422 error (_("Unable to find program interpreter name\n"));
3425 program_interpreter
[0] = 0;
3426 fscanf (file
, "%63s", program_interpreter
);
3429 printf (_("\n [Requesting program interpreter: %s]"),
3430 program_interpreter
);
3436 putc ('\n', stdout
);
3439 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3441 printf (_("\n Section to Segment mapping:\n"));
3442 printf (_(" Segment Sections...\n"));
3444 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3447 Elf_Internal_Shdr
*section
;
3449 segment
= program_headers
+ i
;
3450 section
= section_headers
;
3452 printf (" %2.2d ", i
);
3454 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3456 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3457 printf ("%s ", SECTION_NAME (section
));
3468 /* Find the file offset corresponding to VMA by using the program headers. */
3471 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3473 Elf_Internal_Phdr
*seg
;
3475 if (! get_program_headers (file
))
3477 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3481 for (seg
= program_headers
;
3482 seg
< program_headers
+ elf_header
.e_phnum
;
3485 if (seg
->p_type
!= PT_LOAD
)
3488 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3489 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3490 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3493 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3500 get_32bit_section_headers (FILE *file
, unsigned int num
)
3502 Elf32_External_Shdr
*shdrs
;
3503 Elf_Internal_Shdr
*internal
;
3506 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3507 elf_header
.e_shentsize
, num
, _("section headers"));
3511 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3513 if (section_headers
== NULL
)
3515 error (_("Out of memory\n"));
3519 for (i
= 0, internal
= section_headers
;
3523 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3524 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3525 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3526 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3527 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3528 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3529 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3530 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3531 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3532 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3541 get_64bit_section_headers (FILE *file
, unsigned int num
)
3543 Elf64_External_Shdr
*shdrs
;
3544 Elf_Internal_Shdr
*internal
;
3547 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3548 elf_header
.e_shentsize
, num
, _("section headers"));
3552 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3554 if (section_headers
== NULL
)
3556 error (_("Out of memory\n"));
3560 for (i
= 0, internal
= section_headers
;
3564 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3565 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3566 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3567 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3568 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3569 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3570 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3571 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3572 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3573 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3581 static Elf_Internal_Sym
*
3582 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3584 unsigned long number
;
3585 Elf32_External_Sym
*esyms
;
3586 Elf_External_Sym_Shndx
*shndx
;
3587 Elf_Internal_Sym
*isyms
;
3588 Elf_Internal_Sym
*psym
;
3591 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3597 if (symtab_shndx_hdr
!= NULL
3598 && (symtab_shndx_hdr
->sh_link
3599 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3601 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3602 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3610 number
= section
->sh_size
/ section
->sh_entsize
;
3611 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3615 error (_("Out of memory\n"));
3622 for (j
= 0, psym
= isyms
;
3626 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3627 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3628 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3629 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3630 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3632 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3633 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3634 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3644 static Elf_Internal_Sym
*
3645 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3647 unsigned long number
;
3648 Elf64_External_Sym
*esyms
;
3649 Elf_External_Sym_Shndx
*shndx
;
3650 Elf_Internal_Sym
*isyms
;
3651 Elf_Internal_Sym
*psym
;
3654 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3660 if (symtab_shndx_hdr
!= NULL
3661 && (symtab_shndx_hdr
->sh_link
3662 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3664 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3665 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3673 number
= section
->sh_size
/ section
->sh_entsize
;
3674 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3678 error (_("Out of memory\n"));
3685 for (j
= 0, psym
= isyms
;
3689 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3690 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3691 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3692 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3693 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3695 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3696 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3697 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3708 get_elf_section_flags (bfd_vma sh_flags
)
3710 static char buff
[1024];
3712 int field_size
= is_32bit_elf
? 8 : 16;
3713 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3714 bfd_vma os_flags
= 0;
3715 bfd_vma proc_flags
= 0;
3716 bfd_vma unknown_flags
= 0;
3730 { "LINK ORDER", 10 },
3731 { "OS NONCONF", 10 },
3736 if (do_section_details
)
3738 sprintf (buff
, "[%*.*lx]: ",
3739 field_size
, field_size
, (unsigned long) sh_flags
);
3740 p
+= field_size
+ 4;
3747 flag
= sh_flags
& - sh_flags
;
3750 if (do_section_details
)
3754 case SHF_WRITE
: index
= 0; break;
3755 case SHF_ALLOC
: index
= 1; break;
3756 case SHF_EXECINSTR
: index
= 2; break;
3757 case SHF_MERGE
: index
= 3; break;
3758 case SHF_STRINGS
: index
= 4; break;
3759 case SHF_INFO_LINK
: index
= 5; break;
3760 case SHF_LINK_ORDER
: index
= 6; break;
3761 case SHF_OS_NONCONFORMING
: index
= 7; break;
3762 case SHF_GROUP
: index
= 8; break;
3763 case SHF_TLS
: index
= 9; break;
3772 if (p
!= buff
+ field_size
+ 4)
3774 if (size
< (10 + 2))
3781 size
-= flags
[index
].len
;
3782 p
= stpcpy (p
, flags
[index
].str
);
3784 else if (flag
& SHF_MASKOS
)
3786 else if (flag
& SHF_MASKPROC
)
3789 unknown_flags
|= flag
;
3795 case SHF_WRITE
: *p
= 'W'; break;
3796 case SHF_ALLOC
: *p
= 'A'; break;
3797 case SHF_EXECINSTR
: *p
= 'X'; break;
3798 case SHF_MERGE
: *p
= 'M'; break;
3799 case SHF_STRINGS
: *p
= 'S'; break;
3800 case SHF_INFO_LINK
: *p
= 'I'; break;
3801 case SHF_LINK_ORDER
: *p
= 'L'; break;
3802 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3803 case SHF_GROUP
: *p
= 'G'; break;
3804 case SHF_TLS
: *p
= 'T'; break;
3807 if (elf_header
.e_machine
== EM_X86_64
3808 && flag
== SHF_X86_64_LARGE
)
3810 else if (flag
& SHF_MASKOS
)
3813 sh_flags
&= ~ SHF_MASKOS
;
3815 else if (flag
& SHF_MASKPROC
)
3818 sh_flags
&= ~ SHF_MASKPROC
;
3828 if (do_section_details
)
3832 size
-= 5 + field_size
;
3833 if (p
!= buff
+ field_size
+ 4)
3841 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3842 (unsigned long) os_flags
);
3843 p
+= 5 + field_size
;
3847 size
-= 7 + field_size
;
3848 if (p
!= buff
+ field_size
+ 4)
3856 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3857 (unsigned long) proc_flags
);
3858 p
+= 7 + field_size
;
3862 size
-= 10 + field_size
;
3863 if (p
!= buff
+ field_size
+ 4)
3871 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3872 (unsigned long) unknown_flags
);
3873 p
+= 10 + field_size
;
3882 process_section_headers (FILE *file
)
3884 Elf_Internal_Shdr
*section
;
3887 section_headers
= NULL
;
3889 if (elf_header
.e_shnum
== 0)
3892 printf (_("\nThere are no sections in this file.\n"));
3897 if (do_sections
&& !do_header
)
3898 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3899 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3903 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3906 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3909 /* Read in the string table, so that we have names to display. */
3910 if (SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3912 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3914 if (section
->sh_size
!= 0)
3916 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3917 1, section
->sh_size
, _("string table"));
3919 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
3923 /* Scan the sections for the dynamic symbol table
3924 and dynamic string table and debug sections. */
3925 dynamic_symbols
= NULL
;
3926 dynamic_strings
= NULL
;
3927 dynamic_syminfo
= NULL
;
3928 symtab_shndx_hdr
= NULL
;
3930 eh_addr_size
= is_32bit_elf
? 4 : 8;
3931 switch (elf_header
.e_machine
)
3934 case EM_MIPS_RS3_LE
:
3935 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3936 FDE addresses. However, the ABI also has a semi-official ILP32
3937 variant for which the normal FDE address size rules apply.
3939 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3940 section, where XX is the size of longs in bits. Unfortunately,
3941 earlier compilers provided no way of distinguishing ILP32 objects
3942 from LP64 objects, so if there's any doubt, we should assume that
3943 the official LP64 form is being used. */
3944 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3945 && find_section (".gcc_compiled_long32") == NULL
)
3950 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3953 size_t expected_entsize \
3954 = is_32bit_elf ? size32 : size64; \
3955 if (section->sh_entsize != expected_entsize) \
3956 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
3957 i, (unsigned long int) section->sh_entsize, \
3958 (unsigned long int) expected_entsize); \
3959 section->sh_entsize = expected_entsize; \
3962 #define CHECK_ENTSIZE(section, i, type) \
3963 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
3964 sizeof (Elf64_External_##type))
3966 for (i
= 0, section
= section_headers
;
3967 i
< elf_header
.e_shnum
;
3970 char *name
= SECTION_NAME (section
);
3972 if (section
->sh_type
== SHT_DYNSYM
)
3974 if (dynamic_symbols
!= NULL
)
3976 error (_("File contains multiple dynamic symbol tables\n"));
3980 CHECK_ENTSIZE (section
, i
, Sym
);
3981 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3982 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3984 else if (section
->sh_type
== SHT_STRTAB
3985 && streq (name
, ".dynstr"))
3987 if (dynamic_strings
!= NULL
)
3989 error (_("File contains multiple dynamic string tables\n"));
3993 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3994 1, section
->sh_size
, _("dynamic strings"));
3995 dynamic_strings_length
= section
->sh_size
;
3997 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3999 if (symtab_shndx_hdr
!= NULL
)
4001 error (_("File contains multiple symtab shndx tables\n"));
4004 symtab_shndx_hdr
= section
;
4006 else if (section
->sh_type
== SHT_SYMTAB
)
4007 CHECK_ENTSIZE (section
, i
, Sym
);
4008 else if (section
->sh_type
== SHT_GROUP
)
4009 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4010 else if (section
->sh_type
== SHT_REL
)
4011 CHECK_ENTSIZE (section
, i
, Rel
);
4012 else if (section
->sh_type
== SHT_RELA
)
4013 CHECK_ENTSIZE (section
, i
, Rela
);
4014 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4015 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4016 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4017 || do_debug_loc
|| do_debug_ranges
)
4018 && strneq (name
, ".debug_", 7))
4023 || (do_debug_info
&& streq (name
, "info"))
4024 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4025 || (do_debug_lines
&& streq (name
, "line"))
4026 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4027 || (do_debug_aranges
&& streq (name
, "aranges"))
4028 || (do_debug_ranges
&& streq (name
, "ranges"))
4029 || (do_debug_frames
&& streq (name
, "frame"))
4030 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4031 || (do_debug_str
&& streq (name
, "str"))
4032 || (do_debug_loc
&& streq (name
, "loc"))
4034 request_dump (i
, DEBUG_DUMP
);
4036 /* linkonce section to be combined with .debug_info at link time. */
4037 else if ((do_debugging
|| do_debug_info
)
4038 && strneq (name
, ".gnu.linkonce.wi.", 17))
4039 request_dump (i
, DEBUG_DUMP
);
4040 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4041 request_dump (i
, DEBUG_DUMP
);
4047 if (elf_header
.e_shnum
> 1)
4048 printf (_("\nSection Headers:\n"));
4050 printf (_("\nSection Header:\n"));
4054 if (do_section_details
)
4056 printf (_(" [Nr] Name\n"));
4057 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4061 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4065 if (do_section_details
)
4067 printf (_(" [Nr] Name\n"));
4068 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4072 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4076 if (do_section_details
)
4078 printf (_(" [Nr] Name\n"));
4079 printf (_(" Type Address Offset Link\n"));
4080 printf (_(" Size EntSize Info Align\n"));
4084 printf (_(" [Nr] Name Type Address Offset\n"));
4085 printf (_(" Size EntSize Flags Link Info Align\n"));
4089 if (do_section_details
)
4090 printf (_(" Flags\n"));
4092 for (i
= 0, section
= section_headers
;
4093 i
< elf_header
.e_shnum
;
4096 if (do_section_details
)
4098 printf (" [%2u] %s\n",
4099 SECTION_HEADER_NUM (i
),
4100 SECTION_NAME (section
));
4101 if (is_32bit_elf
|| do_wide
)
4102 printf (" %-15.15s ",
4103 get_section_type_name (section
->sh_type
));
4106 printf (" [%2u] %-17.17s %-15.15s ",
4107 SECTION_HEADER_NUM (i
),
4108 SECTION_NAME (section
),
4109 get_section_type_name (section
->sh_type
));
4113 print_vma (section
->sh_addr
, LONG_HEX
);
4115 printf ( " %6.6lx %6.6lx %2.2lx",
4116 (unsigned long) section
->sh_offset
,
4117 (unsigned long) section
->sh_size
,
4118 (unsigned long) section
->sh_entsize
);
4120 if (do_section_details
)
4121 fputs (" ", stdout
);
4123 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4125 printf ("%2ld %3lu %2ld\n",
4126 (unsigned long) section
->sh_link
,
4127 (unsigned long) section
->sh_info
,
4128 (unsigned long) section
->sh_addralign
);
4132 print_vma (section
->sh_addr
, LONG_HEX
);
4134 if ((long) section
->sh_offset
== section
->sh_offset
)
4135 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4139 print_vma (section
->sh_offset
, LONG_HEX
);
4142 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4143 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4147 print_vma (section
->sh_size
, LONG_HEX
);
4150 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4151 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4155 print_vma (section
->sh_entsize
, LONG_HEX
);
4158 if (do_section_details
)
4159 fputs (" ", stdout
);
4161 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4163 printf ("%2ld %3lu ",
4164 (unsigned long) section
->sh_link
,
4165 (unsigned long) section
->sh_info
);
4167 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4168 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4171 print_vma (section
->sh_addralign
, DEC
);
4175 else if (do_section_details
)
4177 printf (" %-15.15s ",
4178 get_section_type_name (section
->sh_type
));
4179 print_vma (section
->sh_addr
, LONG_HEX
);
4180 if ((long) section
->sh_offset
== section
->sh_offset
)
4181 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4185 print_vma (section
->sh_offset
, LONG_HEX
);
4187 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4188 print_vma (section
->sh_size
, LONG_HEX
);
4190 print_vma (section
->sh_entsize
, LONG_HEX
);
4192 printf (" %-16lu %ld\n",
4193 (unsigned long) section
->sh_info
,
4194 (unsigned long) section
->sh_addralign
);
4199 print_vma (section
->sh_addr
, LONG_HEX
);
4200 if ((long) section
->sh_offset
== section
->sh_offset
)
4201 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4205 print_vma (section
->sh_offset
, LONG_HEX
);
4208 print_vma (section
->sh_size
, LONG_HEX
);
4210 print_vma (section
->sh_entsize
, LONG_HEX
);
4212 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4214 printf (" %2ld %3lu %ld\n",
4215 (unsigned long) section
->sh_link
,
4216 (unsigned long) section
->sh_info
,
4217 (unsigned long) section
->sh_addralign
);
4220 if (do_section_details
)
4221 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4224 if (!do_section_details
)
4225 printf (_("Key to Flags:\n\
4226 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4227 I (info), L (link order), G (group), x (unknown)\n\
4228 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4234 get_group_flags (unsigned int flags
)
4236 static char buff
[32];
4243 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4250 process_section_groups (FILE *file
)
4252 Elf_Internal_Shdr
*section
;
4254 struct group
*group
;
4255 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4256 Elf_Internal_Sym
*symtab
;
4260 /* Don't process section groups unless needed. */
4261 if (!do_unwind
&& !do_section_groups
)
4264 if (elf_header
.e_shnum
== 0)
4266 if (do_section_groups
)
4267 printf (_("\nThere are no sections in this file.\n"));
4272 if (section_headers
== NULL
)
4274 error (_("Section headers are not available!\n"));
4278 section_headers_groups
= calloc (elf_header
.e_shnum
,
4279 sizeof (struct group
*));
4281 if (section_headers_groups
== NULL
)
4283 error (_("Out of memory\n"));
4287 /* Scan the sections for the group section. */
4289 for (i
= 0, section
= section_headers
;
4290 i
< elf_header
.e_shnum
;
4292 if (section
->sh_type
== SHT_GROUP
)
4295 if (group_count
== 0)
4297 if (do_section_groups
)
4298 printf (_("\nThere are no section groups in this file.\n"));
4303 section_groups
= calloc (group_count
, sizeof (struct group
));
4305 if (section_groups
== NULL
)
4307 error (_("Out of memory\n"));
4316 for (i
= 0, section
= section_headers
, group
= section_groups
;
4317 i
< elf_header
.e_shnum
;
4320 if (section
->sh_type
== SHT_GROUP
)
4322 char *name
= SECTION_NAME (section
);
4324 unsigned char *start
, *indices
;
4325 unsigned int entry
, j
, size
;
4326 Elf_Internal_Shdr
*sec
;
4327 Elf_Internal_Sym
*sym
;
4329 /* Get the symbol table. */
4330 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4331 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4334 error (_("Bad sh_link in group section `%s'\n"), name
);
4338 if (symtab_sec
!= sec
)
4343 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4346 sym
= symtab
+ section
->sh_info
;
4348 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4350 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4353 error (_("Bad sh_info in group section `%s'\n"), name
);
4357 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4366 /* Get the string table. */
4367 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4368 >= elf_header
.e_shnum
)
4377 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4382 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4383 1, strtab_sec
->sh_size
,
4385 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4387 group_name
= sym
->st_name
< strtab_size
4388 ? strtab
+ sym
->st_name
: "<corrupt>";
4391 start
= get_data (NULL
, file
, section
->sh_offset
,
4392 1, section
->sh_size
, _("section data"));
4395 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4396 entry
= byte_get (indices
, 4);
4399 if (do_section_groups
)
4401 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4402 get_group_flags (entry
), i
, name
, group_name
, size
);
4404 printf (_(" [Index] Name\n"));
4407 group
->group_index
= i
;
4409 for (j
= 0; j
< size
; j
++)
4411 struct group_list
*g
;
4413 entry
= byte_get (indices
, 4);
4416 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4418 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4419 entry
, i
, elf_header
.e_shnum
- 1);
4422 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4424 error (_("invalid section [%5u] in group section [%5u]\n"),
4429 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4434 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4436 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4441 /* Intel C/C++ compiler may put section 0 in a
4442 section group. We just warn it the first time
4443 and ignore it afterwards. */
4444 static int warned
= 0;
4447 error (_("section 0 in group section [%5u]\n"),
4448 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4454 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4457 if (do_section_groups
)
4459 sec
= SECTION_HEADER (entry
);
4460 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4463 g
= xmalloc (sizeof (struct group_list
));
4464 g
->section_index
= entry
;
4465 g
->next
= group
->root
;
4489 } dynamic_relocations
[] =
4491 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4492 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4493 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4496 /* Process the reloc section. */
4499 process_relocs (FILE *file
)
4501 unsigned long rel_size
;
4502 unsigned long rel_offset
;
4508 if (do_using_dynamic
)
4512 int has_dynamic_reloc
;
4515 has_dynamic_reloc
= 0;
4517 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4519 is_rela
= dynamic_relocations
[i
].rela
;
4520 name
= dynamic_relocations
[i
].name
;
4521 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4522 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4524 has_dynamic_reloc
|= rel_size
;
4526 if (is_rela
== UNKNOWN
)
4528 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4529 switch (dynamic_info
[DT_PLTREL
])
4543 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4544 name
, rel_offset
, rel_size
);
4546 dump_relocations (file
,
4547 offset_from_vma (file
, rel_offset
, rel_size
),
4549 dynamic_symbols
, num_dynamic_syms
,
4550 dynamic_strings
, dynamic_strings_length
, is_rela
);
4554 if (! has_dynamic_reloc
)
4555 printf (_("\nThere are no dynamic relocations in this file.\n"));
4559 Elf_Internal_Shdr
*section
;
4563 for (i
= 0, section
= section_headers
;
4564 i
< elf_header
.e_shnum
;
4567 if ( section
->sh_type
!= SHT_RELA
4568 && section
->sh_type
!= SHT_REL
)
4571 rel_offset
= section
->sh_offset
;
4572 rel_size
= section
->sh_size
;
4576 Elf_Internal_Shdr
*strsec
;
4579 printf (_("\nRelocation section "));
4581 if (string_table
== NULL
)
4582 printf ("%d", section
->sh_name
);
4584 printf (_("'%s'"), SECTION_NAME (section
));
4586 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4587 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4589 is_rela
= section
->sh_type
== SHT_RELA
;
4591 if (section
->sh_link
4592 && SECTION_HEADER_INDEX (section
->sh_link
)
4593 < elf_header
.e_shnum
)
4595 Elf_Internal_Shdr
*symsec
;
4596 Elf_Internal_Sym
*symtab
;
4597 unsigned long nsyms
;
4598 unsigned long strtablen
= 0;
4599 char *strtab
= NULL
;
4601 symsec
= SECTION_HEADER (section
->sh_link
);
4602 if (symsec
->sh_type
!= SHT_SYMTAB
4603 && symsec
->sh_type
!= SHT_DYNSYM
)
4606 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4607 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4612 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4613 < elf_header
.e_shnum
)
4615 strsec
= SECTION_HEADER (symsec
->sh_link
);
4617 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4620 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4623 dump_relocations (file
, rel_offset
, rel_size
,
4624 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4630 dump_relocations (file
, rel_offset
, rel_size
,
4631 NULL
, 0, NULL
, 0, is_rela
);
4638 printf (_("\nThere are no relocations in this file.\n"));
4644 /* Process the unwind section. */
4646 #include "unwind-ia64.h"
4648 /* An absolute address consists of a section and an offset. If the
4649 section is NULL, the offset itself is the address, otherwise, the
4650 address equals to LOAD_ADDRESS(section) + offset. */
4654 unsigned short section
;
4658 #define ABSADDR(a) \
4660 ? section_headers [(a).section].sh_addr + (a).offset \
4663 struct ia64_unw_aux_info
4665 struct ia64_unw_table_entry
4667 struct absaddr start
;
4669 struct absaddr info
;
4671 *table
; /* Unwind table. */
4672 unsigned long table_len
; /* Length of unwind table. */
4673 unsigned char *info
; /* Unwind info. */
4674 unsigned long info_size
; /* Size of unwind info. */
4675 bfd_vma info_addr
; /* starting address of unwind info. */
4676 bfd_vma seg_base
; /* Starting address of segment. */
4677 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4678 unsigned long nsyms
; /* Number of symbols. */
4679 char *strtab
; /* The string table. */
4680 unsigned long strtab_size
; /* Size of string table. */
4684 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4685 unsigned long nsyms
,
4687 unsigned long strtab_size
,
4688 struct absaddr addr
,
4689 const char **symname
,
4692 bfd_vma dist
= 0x100000;
4693 Elf_Internal_Sym
*sym
, *best
= NULL
;
4696 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4698 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4699 && sym
->st_name
!= 0
4700 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4701 && addr
.offset
>= sym
->st_value
4702 && addr
.offset
- sym
->st_value
< dist
)
4705 dist
= addr
.offset
- sym
->st_value
;
4712 *symname
= (best
->st_name
>= strtab_size
4713 ? "<corrupt>" : strtab
+ best
->st_name
);
4718 *offset
= addr
.offset
;
4722 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4724 struct ia64_unw_table_entry
*tp
;
4727 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4731 const unsigned char *dp
;
4732 const unsigned char *head
;
4733 const char *procname
;
4735 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4736 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4738 fputs ("\n<", stdout
);
4742 fputs (procname
, stdout
);
4745 printf ("+%lx", (unsigned long) offset
);
4748 fputs (">: [", stdout
);
4749 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4750 fputc ('-', stdout
);
4751 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4752 printf ("], info at +0x%lx\n",
4753 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4755 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4756 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4758 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4759 (unsigned) UNW_VER (stamp
),
4760 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4761 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4762 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4763 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4765 if (UNW_VER (stamp
) != 1)
4767 printf ("\tUnknown version.\n");
4772 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4773 dp
= unw_decode (dp
, in_body
, & in_body
);
4778 slurp_ia64_unwind_table (FILE *file
,
4779 struct ia64_unw_aux_info
*aux
,
4780 Elf_Internal_Shdr
*sec
)
4782 unsigned long size
, nrelas
, i
;
4783 Elf_Internal_Phdr
*seg
;
4784 struct ia64_unw_table_entry
*tep
;
4785 Elf_Internal_Shdr
*relsec
;
4786 Elf_Internal_Rela
*rela
, *rp
;
4787 unsigned char *table
, *tp
;
4788 Elf_Internal_Sym
*sym
;
4789 const char *relname
;
4791 /* First, find the starting address of the segment that includes
4794 if (elf_header
.e_phnum
)
4796 if (! get_program_headers (file
))
4799 for (seg
= program_headers
;
4800 seg
< program_headers
+ elf_header
.e_phnum
;
4803 if (seg
->p_type
!= PT_LOAD
)
4806 if (sec
->sh_addr
>= seg
->p_vaddr
4807 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4809 aux
->seg_base
= seg
->p_vaddr
;
4815 /* Second, build the unwind table from the contents of the unwind section: */
4816 size
= sec
->sh_size
;
4817 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4821 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4823 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4825 tep
->start
.section
= SHN_UNDEF
;
4826 tep
->end
.section
= SHN_UNDEF
;
4827 tep
->info
.section
= SHN_UNDEF
;
4830 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4831 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4832 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4836 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4837 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4838 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4840 tep
->start
.offset
+= aux
->seg_base
;
4841 tep
->end
.offset
+= aux
->seg_base
;
4842 tep
->info
.offset
+= aux
->seg_base
;
4846 /* Third, apply any relocations to the unwind table: */
4848 for (relsec
= section_headers
;
4849 relsec
< section_headers
+ elf_header
.e_shnum
;
4852 if (relsec
->sh_type
!= SHT_RELA
4853 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4854 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4857 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4861 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4865 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4866 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4870 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4871 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4874 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4876 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4880 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4882 switch (rp
->r_offset
/eh_addr_size
% 3)
4885 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4886 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4889 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4890 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4893 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4894 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4904 aux
->table_len
= size
/ (3 * eh_addr_size
);
4909 ia64_process_unwind (FILE *file
)
4911 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4912 unsigned long i
, unwcount
= 0, unwstart
= 0;
4913 struct ia64_unw_aux_info aux
;
4915 memset (& aux
, 0, sizeof (aux
));
4917 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4919 if (sec
->sh_type
== SHT_SYMTAB
4920 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
4922 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4923 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4925 strsec
= SECTION_HEADER (sec
->sh_link
);
4926 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4927 1, strsec
->sh_size
, _("string table"));
4928 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
4930 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4935 printf (_("\nThere are no unwind sections in this file.\n"));
4937 while (unwcount
-- > 0)
4942 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4943 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4944 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4951 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4953 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4955 /* We need to find which section group it is in. */
4956 struct group_list
*g
= section_headers_groups
[i
]->root
;
4958 for (; g
!= NULL
; g
= g
->next
)
4960 sec
= SECTION_HEADER (g
->section_index
);
4962 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4967 i
= elf_header
.e_shnum
;
4969 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4971 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4972 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4973 suffix
= SECTION_NAME (unwsec
) + len
;
4974 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4976 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4977 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4982 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4983 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4984 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4985 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4987 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4988 suffix
= SECTION_NAME (unwsec
) + len
;
4989 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4991 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4992 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4996 if (i
== elf_header
.e_shnum
)
4998 printf (_("\nCould not find unwind info section for "));
5000 if (string_table
== NULL
)
5001 printf ("%d", unwsec
->sh_name
);
5003 printf (_("'%s'"), SECTION_NAME (unwsec
));
5007 aux
.info_size
= sec
->sh_size
;
5008 aux
.info_addr
= sec
->sh_addr
;
5009 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5012 printf (_("\nUnwind section "));
5014 if (string_table
== NULL
)
5015 printf ("%d", unwsec
->sh_name
);
5017 printf (_("'%s'"), SECTION_NAME (unwsec
));
5019 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5020 (unsigned long) unwsec
->sh_offset
,
5021 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5023 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5025 if (aux
.table_len
> 0)
5026 dump_ia64_unwind (& aux
);
5029 free ((char *) aux
.table
);
5031 free ((char *) aux
.info
);
5040 free ((char *) aux
.strtab
);
5045 struct hppa_unw_aux_info
5047 struct hppa_unw_table_entry
5049 struct absaddr start
;
5051 unsigned int Cannot_unwind
:1; /* 0 */
5052 unsigned int Millicode
:1; /* 1 */
5053 unsigned int Millicode_save_sr0
:1; /* 2 */
5054 unsigned int Region_description
:2; /* 3..4 */
5055 unsigned int reserved1
:1; /* 5 */
5056 unsigned int Entry_SR
:1; /* 6 */
5057 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5058 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5059 unsigned int Args_stored
:1; /* 16 */
5060 unsigned int Variable_Frame
:1; /* 17 */
5061 unsigned int Separate_Package_Body
:1; /* 18 */
5062 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5063 unsigned int Stack_Overflow_Check
:1; /* 20 */
5064 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5065 unsigned int Ada_Region
:1; /* 22 */
5066 unsigned int cxx_info
:1; /* 23 */
5067 unsigned int cxx_try_catch
:1; /* 24 */
5068 unsigned int sched_entry_seq
:1; /* 25 */
5069 unsigned int reserved2
:1; /* 26 */
5070 unsigned int Save_SP
:1; /* 27 */
5071 unsigned int Save_RP
:1; /* 28 */
5072 unsigned int Save_MRP_in_frame
:1; /* 29 */
5073 unsigned int extn_ptr_defined
:1; /* 30 */
5074 unsigned int Cleanup_defined
:1; /* 31 */
5076 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5077 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5078 unsigned int Large_frame
:1; /* 2 */
5079 unsigned int Pseudo_SP_Set
:1; /* 3 */
5080 unsigned int reserved4
:1; /* 4 */
5081 unsigned int Total_frame_size
:27; /* 5..31 */
5083 *table
; /* Unwind table. */
5084 unsigned long table_len
; /* Length of unwind table. */
5085 bfd_vma seg_base
; /* Starting address of segment. */
5086 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5087 unsigned long nsyms
; /* Number of symbols. */
5088 char *strtab
; /* The string table. */
5089 unsigned long strtab_size
; /* Size of string table. */
5093 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5095 struct hppa_unw_table_entry
*tp
;
5097 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5100 const char *procname
;
5102 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5103 aux
->strtab_size
, tp
->start
, &procname
,
5106 fputs ("\n<", stdout
);
5110 fputs (procname
, stdout
);
5113 printf ("+%lx", (unsigned long) offset
);
5116 fputs (">: [", stdout
);
5117 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5118 fputc ('-', stdout
);
5119 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5122 #define PF(_m) if (tp->_m) printf (#_m " ");
5123 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5126 PF(Millicode_save_sr0
);
5127 /* PV(Region_description); */
5133 PF(Separate_Package_Body
);
5134 PF(Frame_Extension_Millicode
);
5135 PF(Stack_Overflow_Check
);
5136 PF(Two_Instruction_SP_Increment
);
5140 PF(sched_entry_seq
);
5143 PF(Save_MRP_in_frame
);
5144 PF(extn_ptr_defined
);
5145 PF(Cleanup_defined
);
5146 PF(MPE_XL_interrupt_marker
);
5147 PF(HP_UX_interrupt_marker
);
5150 PV(Total_frame_size
);
5159 slurp_hppa_unwind_table (FILE *file
,
5160 struct hppa_unw_aux_info
*aux
,
5161 Elf_Internal_Shdr
*sec
)
5163 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5164 Elf_Internal_Phdr
*seg
;
5165 struct hppa_unw_table_entry
*tep
;
5166 Elf_Internal_Shdr
*relsec
;
5167 Elf_Internal_Rela
*rela
, *rp
;
5168 unsigned char *table
, *tp
;
5169 Elf_Internal_Sym
*sym
;
5170 const char *relname
;
5172 /* First, find the starting address of the segment that includes
5175 if (elf_header
.e_phnum
)
5177 if (! get_program_headers (file
))
5180 for (seg
= program_headers
;
5181 seg
< program_headers
+ elf_header
.e_phnum
;
5184 if (seg
->p_type
!= PT_LOAD
)
5187 if (sec
->sh_addr
>= seg
->p_vaddr
5188 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5190 aux
->seg_base
= seg
->p_vaddr
;
5196 /* Second, build the unwind table from the contents of the unwind
5198 size
= sec
->sh_size
;
5199 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5204 nentries
= size
/ unw_ent_size
;
5205 size
= unw_ent_size
* nentries
;
5207 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5209 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5211 unsigned int tmp1
, tmp2
;
5213 tep
->start
.section
= SHN_UNDEF
;
5214 tep
->end
.section
= SHN_UNDEF
;
5216 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5217 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5218 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5219 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5221 tep
->start
.offset
+= aux
->seg_base
;
5222 tep
->end
.offset
+= aux
->seg_base
;
5224 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5225 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5226 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5227 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5228 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5229 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5230 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5231 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5232 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5233 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5234 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5235 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5236 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5237 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5238 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5239 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5240 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5241 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5242 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5243 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5244 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5245 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5246 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5247 tep
->Cleanup_defined
= tmp1
& 0x1;
5249 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5250 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5251 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5252 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5253 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5254 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5258 /* Third, apply any relocations to the unwind table. */
5260 for (relsec
= section_headers
;
5261 relsec
< section_headers
+ elf_header
.e_shnum
;
5264 if (relsec
->sh_type
!= SHT_RELA
5265 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5266 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5269 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5273 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5277 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5278 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5282 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5283 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5286 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5287 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5289 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5293 i
= rp
->r_offset
/ unw_ent_size
;
5295 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5298 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5299 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5302 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5303 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5313 aux
->table_len
= nentries
;
5319 hppa_process_unwind (FILE *file
)
5321 struct hppa_unw_aux_info aux
;
5322 Elf_Internal_Shdr
*unwsec
= NULL
;
5323 Elf_Internal_Shdr
*strsec
;
5324 Elf_Internal_Shdr
*sec
;
5327 memset (& aux
, 0, sizeof (aux
));
5329 if (string_table
== NULL
)
5332 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5334 if (sec
->sh_type
== SHT_SYMTAB
5335 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5337 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5338 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5340 strsec
= SECTION_HEADER (sec
->sh_link
);
5341 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5342 1, strsec
->sh_size
, _("string table"));
5343 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5345 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5350 printf (_("\nThere are no unwind sections in this file.\n"));
5352 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5354 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5356 printf (_("\nUnwind section "));
5357 printf (_("'%s'"), SECTION_NAME (sec
));
5359 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5360 (unsigned long) sec
->sh_offset
,
5361 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5363 slurp_hppa_unwind_table (file
, &aux
, sec
);
5364 if (aux
.table_len
> 0)
5365 dump_hppa_unwind (&aux
);
5368 free ((char *) aux
.table
);
5376 free ((char *) aux
.strtab
);
5382 process_unwind (FILE *file
)
5384 struct unwind_handler
{
5386 int (*handler
)(FILE *file
);
5388 { EM_IA_64
, ia64_process_unwind
},
5389 { EM_PARISC
, hppa_process_unwind
},
5397 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5398 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5399 return handlers
[i
].handler (file
);
5401 printf (_("\nThere are no unwind sections in this file.\n"));
5406 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5408 switch (entry
->d_tag
)
5411 if (entry
->d_un
.d_val
== 0)
5415 static const char * opts
[] =
5417 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5418 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5419 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5420 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5425 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5426 if (entry
->d_un
.d_val
& (1 << cnt
))
5428 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5435 case DT_MIPS_IVERSION
:
5436 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5437 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5439 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5442 case DT_MIPS_TIME_STAMP
:
5447 time_t time
= entry
->d_un
.d_val
;
5448 tmp
= gmtime (&time
);
5449 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5450 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5451 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5452 printf ("Time Stamp: %s\n", timebuf
);
5456 case DT_MIPS_RLD_VERSION
:
5457 case DT_MIPS_LOCAL_GOTNO
:
5458 case DT_MIPS_CONFLICTNO
:
5459 case DT_MIPS_LIBLISTNO
:
5460 case DT_MIPS_SYMTABNO
:
5461 case DT_MIPS_UNREFEXTNO
:
5462 case DT_MIPS_HIPAGENO
:
5463 case DT_MIPS_DELTA_CLASS_NO
:
5464 case DT_MIPS_DELTA_INSTANCE_NO
:
5465 case DT_MIPS_DELTA_RELOC_NO
:
5466 case DT_MIPS_DELTA_SYM_NO
:
5467 case DT_MIPS_DELTA_CLASSSYM_NO
:
5468 case DT_MIPS_COMPACT_SIZE
:
5469 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5473 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5479 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5481 switch (entry
->d_tag
)
5483 case DT_HP_DLD_FLAGS
:
5492 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5493 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5494 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5495 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5496 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5497 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5498 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5499 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5500 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5501 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5502 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5503 { DT_HP_GST
, "HP_GST" },
5504 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5505 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5506 { DT_HP_NODELETE
, "HP_NODELETE" },
5507 { DT_HP_GROUP
, "HP_GROUP" },
5508 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5512 bfd_vma val
= entry
->d_un
.d_val
;
5514 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5515 if (val
& flags
[cnt
].bit
)
5519 fputs (flags
[cnt
].str
, stdout
);
5521 val
^= flags
[cnt
].bit
;
5524 if (val
!= 0 || first
)
5528 print_vma (val
, HEX
);
5534 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5541 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5543 switch (entry
->d_tag
)
5545 case DT_IA_64_PLT_RESERVE
:
5546 /* First 3 slots reserved. */
5547 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5549 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5553 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5560 get_32bit_dynamic_section (FILE *file
)
5562 Elf32_External_Dyn
*edyn
, *ext
;
5563 Elf_Internal_Dyn
*entry
;
5565 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5566 _("dynamic section"));
5570 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5571 might not have the luxury of section headers. Look for the DT_NULL
5572 terminator to determine the number of entries. */
5573 for (ext
= edyn
, dynamic_nent
= 0;
5574 (char *) ext
< (char *) edyn
+ dynamic_size
;
5578 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5582 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5583 if (dynamic_section
== NULL
)
5585 error (_("Out of memory\n"));
5590 for (ext
= edyn
, entry
= dynamic_section
;
5591 entry
< dynamic_section
+ dynamic_nent
;
5594 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5595 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5604 get_64bit_dynamic_section (FILE *file
)
5606 Elf64_External_Dyn
*edyn
, *ext
;
5607 Elf_Internal_Dyn
*entry
;
5609 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5610 _("dynamic section"));
5614 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5615 might not have the luxury of section headers. Look for the DT_NULL
5616 terminator to determine the number of entries. */
5617 for (ext
= edyn
, dynamic_nent
= 0;
5618 (char *) ext
< (char *) edyn
+ dynamic_size
;
5622 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5626 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5627 if (dynamic_section
== NULL
)
5629 error (_("Out of memory\n"));
5634 for (ext
= edyn
, entry
= dynamic_section
;
5635 entry
< dynamic_section
+ dynamic_nent
;
5638 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5639 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5648 print_dynamic_flags (bfd_vma flags
)
5656 flag
= flags
& - flags
;
5666 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5667 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5668 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5669 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5670 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5671 default: fputs ("unknown", stdout
); break;
5677 /* Parse and display the contents of the dynamic section. */
5680 process_dynamic_section (FILE *file
)
5682 Elf_Internal_Dyn
*entry
;
5684 if (dynamic_size
== 0)
5687 printf (_("\nThere is no dynamic section in this file.\n"));
5694 if (! get_32bit_dynamic_section (file
))
5697 else if (! get_64bit_dynamic_section (file
))
5700 /* Find the appropriate symbol table. */
5701 if (dynamic_symbols
== NULL
)
5703 for (entry
= dynamic_section
;
5704 entry
< dynamic_section
+ dynamic_nent
;
5707 Elf_Internal_Shdr section
;
5709 if (entry
->d_tag
!= DT_SYMTAB
)
5712 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5714 /* Since we do not know how big the symbol table is,
5715 we default to reading in the entire file (!) and
5716 processing that. This is overkill, I know, but it
5718 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5720 if (archive_file_offset
!= 0)
5721 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5724 if (fseek (file
, 0, SEEK_END
))
5725 error (_("Unable to seek to end of file!"));
5727 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5731 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5733 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5735 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5736 if (num_dynamic_syms
< 1)
5738 error (_("Unable to determine the number of symbols to load\n"));
5742 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5746 /* Similarly find a string table. */
5747 if (dynamic_strings
== NULL
)
5749 for (entry
= dynamic_section
;
5750 entry
< dynamic_section
+ dynamic_nent
;
5753 unsigned long offset
;
5756 if (entry
->d_tag
!= DT_STRTAB
)
5759 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5761 /* Since we do not know how big the string table is,
5762 we default to reading in the entire file (!) and
5763 processing that. This is overkill, I know, but it
5766 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5768 if (archive_file_offset
!= 0)
5769 str_tab_len
= archive_file_size
- offset
;
5772 if (fseek (file
, 0, SEEK_END
))
5773 error (_("Unable to seek to end of file\n"));
5774 str_tab_len
= ftell (file
) - offset
;
5777 if (str_tab_len
< 1)
5780 (_("Unable to determine the length of the dynamic string table\n"));
5784 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5785 _("dynamic string table"));
5786 dynamic_strings_length
= str_tab_len
;
5791 /* And find the syminfo section if available. */
5792 if (dynamic_syminfo
== NULL
)
5794 unsigned long syminsz
= 0;
5796 for (entry
= dynamic_section
;
5797 entry
< dynamic_section
+ dynamic_nent
;
5800 if (entry
->d_tag
== DT_SYMINENT
)
5802 /* Note: these braces are necessary to avoid a syntax
5803 error from the SunOS4 C compiler. */
5804 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5806 else if (entry
->d_tag
== DT_SYMINSZ
)
5807 syminsz
= entry
->d_un
.d_val
;
5808 else if (entry
->d_tag
== DT_SYMINFO
)
5809 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5813 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5815 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5816 Elf_Internal_Syminfo
*syminfo
;
5818 /* There is a syminfo section. Read the data. */
5819 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5820 syminsz
, _("symbol information"));
5824 dynamic_syminfo
= malloc (syminsz
);
5825 if (dynamic_syminfo
== NULL
)
5827 error (_("Out of memory\n"));
5831 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5832 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5833 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5834 ++syminfo
, ++extsym
)
5836 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5837 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5844 if (do_dynamic
&& dynamic_addr
)
5845 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5846 dynamic_addr
, dynamic_nent
);
5848 printf (_(" Tag Type Name/Value\n"));
5850 for (entry
= dynamic_section
;
5851 entry
< dynamic_section
+ dynamic_nent
;
5859 print_vma (entry
->d_tag
, FULL_HEX
);
5860 dtype
= get_dynamic_type (entry
->d_tag
);
5861 printf (" (%s)%*s", dtype
,
5862 ((is_32bit_elf
? 27 : 19)
5863 - (int) strlen (dtype
)),
5867 switch (entry
->d_tag
)
5871 print_dynamic_flags (entry
->d_un
.d_val
);
5881 switch (entry
->d_tag
)
5884 printf (_("Auxiliary library"));
5888 printf (_("Filter library"));
5892 printf (_("Configuration file"));
5896 printf (_("Dependency audit library"));
5900 printf (_("Audit library"));
5904 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5905 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5909 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5918 printf (_("Flags:"));
5920 if (entry
->d_un
.d_val
== 0)
5921 printf (_(" None\n"));
5924 unsigned long int val
= entry
->d_un
.d_val
;
5926 if (val
& DTF_1_PARINIT
)
5928 printf (" PARINIT");
5929 val
^= DTF_1_PARINIT
;
5931 if (val
& DTF_1_CONFEXP
)
5933 printf (" CONFEXP");
5934 val
^= DTF_1_CONFEXP
;
5937 printf (" %lx", val
);
5946 printf (_("Flags:"));
5948 if (entry
->d_un
.d_val
== 0)
5949 printf (_(" None\n"));
5952 unsigned long int val
= entry
->d_un
.d_val
;
5954 if (val
& DF_P1_LAZYLOAD
)
5956 printf (" LAZYLOAD");
5957 val
^= DF_P1_LAZYLOAD
;
5959 if (val
& DF_P1_GROUPPERM
)
5961 printf (" GROUPPERM");
5962 val
^= DF_P1_GROUPPERM
;
5965 printf (" %lx", val
);
5974 printf (_("Flags:"));
5975 if (entry
->d_un
.d_val
== 0)
5976 printf (_(" None\n"));
5979 unsigned long int val
= entry
->d_un
.d_val
;
5986 if (val
& DF_1_GLOBAL
)
5991 if (val
& DF_1_GROUP
)
5996 if (val
& DF_1_NODELETE
)
5998 printf (" NODELETE");
5999 val
^= DF_1_NODELETE
;
6001 if (val
& DF_1_LOADFLTR
)
6003 printf (" LOADFLTR");
6004 val
^= DF_1_LOADFLTR
;
6006 if (val
& DF_1_INITFIRST
)
6008 printf (" INITFIRST");
6009 val
^= DF_1_INITFIRST
;
6011 if (val
& DF_1_NOOPEN
)
6016 if (val
& DF_1_ORIGIN
)
6021 if (val
& DF_1_DIRECT
)
6026 if (val
& DF_1_TRANS
)
6031 if (val
& DF_1_INTERPOSE
)
6033 printf (" INTERPOSE");
6034 val
^= DF_1_INTERPOSE
;
6036 if (val
& DF_1_NODEFLIB
)
6038 printf (" NODEFLIB");
6039 val
^= DF_1_NODEFLIB
;
6041 if (val
& DF_1_NODUMP
)
6046 if (val
& DF_1_CONLFAT
)
6048 printf (" CONLFAT");
6049 val
^= DF_1_CONLFAT
;
6052 printf (" %lx", val
);
6059 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6061 puts (get_dynamic_type (entry
->d_un
.d_val
));
6081 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6087 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6088 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6094 switch (entry
->d_tag
)
6097 printf (_("Shared library: [%s]"), name
);
6099 if (streq (name
, program_interpreter
))
6100 printf (_(" program interpreter"));
6104 printf (_("Library soname: [%s]"), name
);
6108 printf (_("Library rpath: [%s]"), name
);
6112 printf (_("Library runpath: [%s]"), name
);
6116 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6121 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6134 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6138 case DT_INIT_ARRAYSZ
:
6139 case DT_FINI_ARRAYSZ
:
6140 case DT_GNU_CONFLICTSZ
:
6141 case DT_GNU_LIBLISTSZ
:
6144 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6145 printf (" (bytes)\n");
6155 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6168 if (entry
->d_tag
== DT_USED
6169 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6171 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6175 printf (_("Not needed object: [%s]\n"), name
);
6180 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6186 /* The value of this entry is ignored. */
6191 case DT_GNU_PRELINKED
:
6195 time_t time
= entry
->d_un
.d_val
;
6197 tmp
= gmtime (&time
);
6198 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6199 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6200 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6206 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6207 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6212 switch (elf_header
.e_machine
)
6215 case EM_MIPS_RS3_LE
:
6216 dynamic_section_mips_val (entry
);
6219 dynamic_section_parisc_val (entry
);
6222 dynamic_section_ia64_val (entry
);
6225 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6237 get_ver_flags (unsigned int flags
)
6239 static char buff
[32];
6246 if (flags
& VER_FLG_BASE
)
6247 strcat (buff
, "BASE ");
6249 if (flags
& VER_FLG_WEAK
)
6251 if (flags
& VER_FLG_BASE
)
6252 strcat (buff
, "| ");
6254 strcat (buff
, "WEAK ");
6257 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6258 strcat (buff
, "| <unknown>");
6263 /* Display the contents of the version sections. */
6265 process_version_sections (FILE *file
)
6267 Elf_Internal_Shdr
*section
;
6274 for (i
= 0, section
= section_headers
;
6275 i
< elf_header
.e_shnum
;
6278 switch (section
->sh_type
)
6280 case SHT_GNU_verdef
:
6282 Elf_External_Verdef
*edefs
;
6289 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6290 SECTION_NAME (section
), section
->sh_info
);
6292 printf (_(" Addr: 0x"));
6293 printf_vma (section
->sh_addr
);
6294 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6295 (unsigned long) section
->sh_offset
, section
->sh_link
,
6296 SECTION_HEADER_INDEX (section
->sh_link
)
6297 < elf_header
.e_shnum
6298 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6301 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6303 _("version definition section"));
6307 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6310 Elf_External_Verdef
*edef
;
6311 Elf_Internal_Verdef ent
;
6312 Elf_External_Verdaux
*eaux
;
6313 Elf_Internal_Verdaux aux
;
6317 vstart
= ((char *) edefs
) + idx
;
6319 edef
= (Elf_External_Verdef
*) vstart
;
6321 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6322 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6323 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6324 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6325 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6326 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6327 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6329 printf (_(" %#06x: Rev: %d Flags: %s"),
6330 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6332 printf (_(" Index: %d Cnt: %d "),
6333 ent
.vd_ndx
, ent
.vd_cnt
);
6335 vstart
+= ent
.vd_aux
;
6337 eaux
= (Elf_External_Verdaux
*) vstart
;
6339 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6340 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6342 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6343 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6345 printf (_("Name index: %ld\n"), aux
.vda_name
);
6347 isum
= idx
+ ent
.vd_aux
;
6349 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6351 isum
+= aux
.vda_next
;
6352 vstart
+= aux
.vda_next
;
6354 eaux
= (Elf_External_Verdaux
*) vstart
;
6356 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6357 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6359 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6360 printf (_(" %#06x: Parent %d: %s\n"),
6361 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6363 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6364 isum
, j
, aux
.vda_name
);
6374 case SHT_GNU_verneed
:
6376 Elf_External_Verneed
*eneed
;
6382 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6383 SECTION_NAME (section
), section
->sh_info
);
6385 printf (_(" Addr: 0x"));
6386 printf_vma (section
->sh_addr
);
6387 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6388 (unsigned long) section
->sh_offset
, section
->sh_link
,
6389 SECTION_HEADER_INDEX (section
->sh_link
)
6390 < elf_header
.e_shnum
6391 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6394 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6396 _("version need section"));
6400 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6402 Elf_External_Verneed
*entry
;
6403 Elf_Internal_Verneed ent
;
6408 vstart
= ((char *) eneed
) + idx
;
6410 entry
= (Elf_External_Verneed
*) vstart
;
6412 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6413 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6414 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6415 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6416 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6418 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6420 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6421 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6423 printf (_(" File: %lx"), ent
.vn_file
);
6425 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6427 vstart
+= ent
.vn_aux
;
6429 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6431 Elf_External_Vernaux
*eaux
;
6432 Elf_Internal_Vernaux aux
;
6434 eaux
= (Elf_External_Vernaux
*) vstart
;
6436 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6437 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6438 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6439 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6440 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6442 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6443 printf (_(" %#06x: Name: %s"),
6444 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6446 printf (_(" %#06x: Name index: %lx"),
6447 isum
, aux
.vna_name
);
6449 printf (_(" Flags: %s Version: %d\n"),
6450 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6452 isum
+= aux
.vna_next
;
6453 vstart
+= aux
.vna_next
;
6463 case SHT_GNU_versym
:
6465 Elf_Internal_Shdr
*link_section
;
6468 unsigned char *edata
;
6469 unsigned short *data
;
6471 Elf_Internal_Sym
*symbols
;
6472 Elf_Internal_Shdr
*string_sec
;
6475 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6478 link_section
= SECTION_HEADER (section
->sh_link
);
6479 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6481 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6482 >= elf_header
.e_shnum
)
6487 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6489 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6491 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6492 string_sec
->sh_size
, _("version string table"));
6496 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6497 SECTION_NAME (section
), total
);
6499 printf (_(" Addr: "));
6500 printf_vma (section
->sh_addr
);
6501 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6502 (unsigned long) section
->sh_offset
, section
->sh_link
,
6503 SECTION_NAME (link_section
));
6505 off
= offset_from_vma (file
,
6506 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6507 total
* sizeof (short));
6508 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6509 _("version symbol data"));
6516 data
= cmalloc (total
, sizeof (short));
6518 for (cnt
= total
; cnt
--;)
6519 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6524 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6527 int check_def
, check_need
;
6530 printf (" %03x:", cnt
);
6532 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6533 switch (data
[cnt
+ j
])
6536 fputs (_(" 0 (*local*) "), stdout
);
6540 fputs (_(" 1 (*global*) "), stdout
);
6544 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6545 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6549 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6550 >= elf_header
.e_shnum
6551 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6554 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6561 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6563 Elf_Internal_Verneed ivn
;
6564 unsigned long offset
;
6566 offset
= offset_from_vma
6567 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6568 sizeof (Elf_External_Verneed
));
6572 Elf_Internal_Vernaux ivna
;
6573 Elf_External_Verneed evn
;
6574 Elf_External_Vernaux evna
;
6575 unsigned long a_off
;
6577 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6580 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6581 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6583 a_off
= offset
+ ivn
.vn_aux
;
6587 get_data (&evna
, file
, a_off
, sizeof (evna
),
6588 1, _("version need aux (2)"));
6590 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6591 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6593 a_off
+= ivna
.vna_next
;
6595 while (ivna
.vna_other
!= data
[cnt
+ j
]
6596 && ivna
.vna_next
!= 0);
6598 if (ivna
.vna_other
== data
[cnt
+ j
])
6600 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6602 name
= strtab
+ ivna
.vna_name
;
6603 nn
+= printf ("(%s%-*s",
6605 12 - (int) strlen (name
),
6611 offset
+= ivn
.vn_next
;
6613 while (ivn
.vn_next
);
6616 if (check_def
&& data
[cnt
+ j
] != 0x8001
6617 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6619 Elf_Internal_Verdef ivd
;
6620 Elf_External_Verdef evd
;
6621 unsigned long offset
;
6623 offset
= offset_from_vma
6624 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6629 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6632 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6633 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6635 offset
+= ivd
.vd_next
;
6637 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6638 && ivd
.vd_next
!= 0);
6640 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6642 Elf_External_Verdaux evda
;
6643 Elf_Internal_Verdaux ivda
;
6645 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6647 get_data (&evda
, file
,
6648 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6650 _("version def aux"));
6652 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6654 name
= strtab
+ ivda
.vda_name
;
6655 nn
+= printf ("(%s%-*s",
6657 12 - (int) strlen (name
),
6663 printf ("%*c", 18 - nn
, ' ');
6681 printf (_("\nNo version information found in this file.\n"));
6687 get_symbol_binding (unsigned int binding
)
6689 static char buff
[32];
6693 case STB_LOCAL
: return "LOCAL";
6694 case STB_GLOBAL
: return "GLOBAL";
6695 case STB_WEAK
: return "WEAK";
6697 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6698 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6700 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6701 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6703 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6709 get_symbol_type (unsigned int type
)
6711 static char buff
[32];
6715 case STT_NOTYPE
: return "NOTYPE";
6716 case STT_OBJECT
: return "OBJECT";
6717 case STT_FUNC
: return "FUNC";
6718 case STT_SECTION
: return "SECTION";
6719 case STT_FILE
: return "FILE";
6720 case STT_COMMON
: return "COMMON";
6721 case STT_TLS
: return "TLS";
6723 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6725 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6726 return "THUMB_FUNC";
6728 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6731 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6732 return "PARISC_MILLI";
6734 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6736 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6738 if (elf_header
.e_machine
== EM_PARISC
)
6740 if (type
== STT_HP_OPAQUE
)
6742 if (type
== STT_HP_STUB
)
6746 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6749 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6755 get_symbol_visibility (unsigned int visibility
)
6759 case STV_DEFAULT
: return "DEFAULT";
6760 case STV_INTERNAL
: return "INTERNAL";
6761 case STV_HIDDEN
: return "HIDDEN";
6762 case STV_PROTECTED
: return "PROTECTED";
6768 get_mips_symbol_other (unsigned int other
)
6772 case STO_OPTIONAL
: return "OPTIONAL";
6773 case STO_MIPS16
: return "MIPS16";
6774 default: return NULL
;
6779 get_symbol_other (unsigned int other
)
6781 const char * result
= NULL
;
6782 static char buff
[32];
6787 switch (elf_header
.e_machine
)
6790 result
= get_mips_symbol_other (other
);
6798 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6803 get_symbol_index_type (unsigned int type
)
6805 static char buff
[32];
6809 case SHN_UNDEF
: return "UND";
6810 case SHN_ABS
: return "ABS";
6811 case SHN_COMMON
: return "COM";
6813 if (type
== SHN_IA_64_ANSI_COMMON
6814 && elf_header
.e_machine
== EM_IA_64
6815 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6817 else if (elf_header
.e_machine
== EM_X86_64
6818 && type
== SHN_X86_64_LCOMMON
)
6820 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6821 sprintf (buff
, "PRC[0x%04x]", type
);
6822 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6823 sprintf (buff
, "OS [0x%04x]", type
);
6824 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6825 sprintf (buff
, "RSV[0x%04x]", type
);
6827 sprintf (buff
, "%3d", type
);
6835 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6837 unsigned char *e_data
;
6840 e_data
= cmalloc (number
, ent_size
);
6844 error (_("Out of memory\n"));
6848 if (fread (e_data
, ent_size
, number
, file
) != number
)
6850 error (_("Unable to read in dynamic data\n"));
6854 i_data
= cmalloc (number
, sizeof (*i_data
));
6858 error (_("Out of memory\n"));
6864 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6871 /* Dump the symbol table. */
6873 process_symbol_table (FILE *file
)
6875 Elf_Internal_Shdr
*section
;
6876 bfd_vma nbuckets
= 0;
6877 bfd_vma nchains
= 0;
6878 bfd_vma
*buckets
= NULL
;
6879 bfd_vma
*chains
= NULL
;
6881 if (! do_syms
&& !do_histogram
)
6884 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6887 unsigned char nb
[8];
6888 unsigned char nc
[8];
6889 int hash_ent_size
= 4;
6891 if ((elf_header
.e_machine
== EM_ALPHA
6892 || elf_header
.e_machine
== EM_S390
6893 || elf_header
.e_machine
== EM_S390_OLD
)
6894 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6898 (archive_file_offset
6899 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6900 sizeof nb
+ sizeof nc
)),
6903 error (_("Unable to seek to start of dynamic information"));
6907 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6909 error (_("Failed to read in number of buckets\n"));
6913 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6915 error (_("Failed to read in number of chains\n"));
6919 nbuckets
= byte_get (nb
, hash_ent_size
);
6920 nchains
= byte_get (nc
, hash_ent_size
);
6922 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6923 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6925 if (buckets
== NULL
|| chains
== NULL
)
6930 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6935 printf (_("\nSymbol table for image:\n"));
6937 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6939 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6941 for (hn
= 0; hn
< nbuckets
; hn
++)
6946 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6948 Elf_Internal_Sym
*psym
;
6951 psym
= dynamic_symbols
+ si
;
6953 n
= print_vma (si
, DEC_5
);
6955 fputs (" " + n
, stdout
);
6956 printf (" %3lu: ", hn
);
6957 print_vma (psym
->st_value
, LONG_HEX
);
6959 print_vma (psym
->st_size
, DEC_5
);
6961 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6962 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6963 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6964 /* Check to see if any other bits in the st_other field are set.
6965 Note - displaying this information disrupts the layout of the
6966 table being generated, but for the moment this case is very rare. */
6967 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
6968 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
6969 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6970 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6971 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6973 printf (" <corrupt: %14ld>", psym
->st_name
);
6978 else if (do_syms
&& !do_using_dynamic
)
6982 for (i
= 0, section
= section_headers
;
6983 i
< elf_header
.e_shnum
;
6987 char *strtab
= NULL
;
6988 unsigned long int strtab_size
= 0;
6989 Elf_Internal_Sym
*symtab
;
6990 Elf_Internal_Sym
*psym
;
6993 if ( section
->sh_type
!= SHT_SYMTAB
6994 && section
->sh_type
!= SHT_DYNSYM
)
6997 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6998 SECTION_NAME (section
),
6999 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7001 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7003 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7005 symtab
= GET_ELF_SYMBOLS (file
, section
);
7009 if (section
->sh_link
== elf_header
.e_shstrndx
)
7011 strtab
= string_table
;
7012 strtab_size
= string_table_length
;
7014 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7016 Elf_Internal_Shdr
*string_sec
;
7018 string_sec
= SECTION_HEADER (section
->sh_link
);
7020 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7021 1, string_sec
->sh_size
, _("string table"));
7022 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7025 for (si
= 0, psym
= symtab
;
7026 si
< section
->sh_size
/ section
->sh_entsize
;
7029 printf ("%6d: ", si
);
7030 print_vma (psym
->st_value
, LONG_HEX
);
7032 print_vma (psym
->st_size
, DEC_5
);
7033 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7034 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7035 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7036 /* Check to see if any other bits in the st_other field are set.
7037 Note - displaying this information disrupts the layout of the
7038 table being generated, but for the moment this case is very rare. */
7039 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7040 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7041 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7042 print_symbol (25, psym
->st_name
< strtab_size
7043 ? strtab
+ psym
->st_name
: "<corrupt>");
7045 if (section
->sh_type
== SHT_DYNSYM
&&
7046 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7048 unsigned char data
[2];
7049 unsigned short vers_data
;
7050 unsigned long offset
;
7054 offset
= offset_from_vma
7055 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7056 sizeof data
+ si
* sizeof (vers_data
));
7058 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7059 sizeof (data
), 1, _("version data"));
7061 vers_data
= byte_get (data
, 2);
7063 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7064 < elf_header
.e_shnum
7065 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7068 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7070 if ((vers_data
& 0x8000) || vers_data
> 1)
7072 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7073 && (is_nobits
|| ! check_def
))
7075 Elf_External_Verneed evn
;
7076 Elf_Internal_Verneed ivn
;
7077 Elf_Internal_Vernaux ivna
;
7079 /* We must test both. */
7080 offset
= offset_from_vma
7081 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7086 unsigned long vna_off
;
7088 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7091 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7092 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7094 vna_off
= offset
+ ivn
.vn_aux
;
7098 Elf_External_Vernaux evna
;
7100 get_data (&evna
, file
, vna_off
,
7102 _("version need aux (3)"));
7104 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7105 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7106 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7108 vna_off
+= ivna
.vna_next
;
7110 while (ivna
.vna_other
!= vers_data
7111 && ivna
.vna_next
!= 0);
7113 if (ivna
.vna_other
== vers_data
)
7116 offset
+= ivn
.vn_next
;
7118 while (ivn
.vn_next
!= 0);
7120 if (ivna
.vna_other
== vers_data
)
7123 ivna
.vna_name
< strtab_size
7124 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7128 else if (! is_nobits
)
7129 error (_("bad dynamic symbol"));
7136 if (vers_data
!= 0x8001
7137 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7139 Elf_Internal_Verdef ivd
;
7140 Elf_Internal_Verdaux ivda
;
7141 Elf_External_Verdaux evda
;
7142 unsigned long offset
;
7144 offset
= offset_from_vma
7146 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7147 sizeof (Elf_External_Verdef
));
7151 Elf_External_Verdef evd
;
7153 get_data (&evd
, file
, offset
, sizeof (evd
),
7154 1, _("version def"));
7156 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7157 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7158 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7160 offset
+= ivd
.vd_next
;
7162 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7163 && ivd
.vd_next
!= 0);
7165 offset
-= ivd
.vd_next
;
7166 offset
+= ivd
.vd_aux
;
7168 get_data (&evda
, file
, offset
, sizeof (evda
),
7169 1, _("version def aux"));
7171 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7173 if (psym
->st_name
!= ivda
.vda_name
)
7174 printf ((vers_data
& 0x8000)
7176 ivda
.vda_name
< strtab_size
7177 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7187 if (strtab
!= string_table
)
7193 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7195 if (do_histogram
&& buckets
!= NULL
)
7197 unsigned long *lengths
;
7198 unsigned long *counts
;
7201 unsigned long maxlength
= 0;
7202 unsigned long nzero_counts
= 0;
7203 unsigned long nsyms
= 0;
7205 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7206 (unsigned long) nbuckets
);
7207 printf (_(" Length Number %% of total Coverage\n"));
7209 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7210 if (lengths
== NULL
)
7212 error (_("Out of memory"));
7215 for (hn
= 0; hn
< nbuckets
; ++hn
)
7217 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7220 if (maxlength
< ++lengths
[hn
])
7225 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7228 error (_("Out of memory"));
7232 for (hn
= 0; hn
< nbuckets
; ++hn
)
7233 ++counts
[lengths
[hn
]];
7238 printf (" 0 %-10lu (%5.1f%%)\n",
7239 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7240 for (i
= 1; i
<= maxlength
; ++i
)
7242 nzero_counts
+= counts
[i
] * i
;
7243 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7244 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7245 (nzero_counts
* 100.0) / nsyms
);
7253 if (buckets
!= NULL
)
7263 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7267 if (dynamic_syminfo
== NULL
7269 /* No syminfo, this is ok. */
7272 /* There better should be a dynamic symbol section. */
7273 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7277 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7278 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7280 printf (_(" Num: Name BoundTo Flags\n"));
7281 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7283 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7285 printf ("%4d: ", i
);
7286 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7287 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7289 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7292 switch (dynamic_syminfo
[i
].si_boundto
)
7294 case SYMINFO_BT_SELF
:
7295 fputs ("SELF ", stdout
);
7297 case SYMINFO_BT_PARENT
:
7298 fputs ("PARENT ", stdout
);
7301 if (dynamic_syminfo
[i
].si_boundto
> 0
7302 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7303 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7305 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7309 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7313 if (flags
& SYMINFO_FLG_DIRECT
)
7315 if (flags
& SYMINFO_FLG_PASSTHRU
)
7316 printf (" PASSTHRU");
7317 if (flags
& SYMINFO_FLG_COPY
)
7319 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7320 printf (" LAZYLOAD");
7328 #ifdef SUPPORT_DISASSEMBLY
7330 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7332 printf (_("\nAssembly dump of section %s\n"),
7333 SECTION_NAME (section
));
7335 /* XXX -- to be done --- XXX */
7342 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7344 bfd_size_type bytes
;
7346 unsigned char *data
;
7347 unsigned char *start
;
7349 bytes
= section
->sh_size
;
7351 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7353 printf (_("\nSection '%s' has no data to dump.\n"),
7354 SECTION_NAME (section
));
7358 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7360 addr
= section
->sh_addr
;
7362 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7375 lbytes
= (bytes
> 16 ? 16 : bytes
);
7377 printf (" 0x%8.8lx ", (unsigned long) addr
);
7379 switch (elf_header
.e_ident
[EI_DATA
])
7383 for (j
= 15; j
>= 0; j
--)
7386 printf ("%2.2x", data
[j
]);
7396 for (j
= 0; j
< 16; j
++)
7399 printf ("%2.2x", data
[j
]);
7409 for (j
= 0; j
< lbytes
; j
++)
7412 if (k
>= ' ' && k
< 0x7f)
7430 /* Apply addends of RELA relocations. */
7433 debug_apply_rela_addends (void *file
,
7434 Elf_Internal_Shdr
*section
,
7435 unsigned char *start
)
7437 Elf_Internal_Shdr
*relsec
;
7438 unsigned char *end
= start
+ section
->sh_size
;
7439 /* FIXME: The relocation field size is relocation type dependent. */
7440 unsigned int reloc_size
= 4;
7442 if (!is_relocatable
)
7445 if (section
->sh_size
< reloc_size
)
7448 for (relsec
= section_headers
;
7449 relsec
< section_headers
+ elf_header
.e_shnum
;
7452 unsigned long nrelas
;
7453 Elf_Internal_Rela
*rela
, *rp
;
7454 Elf_Internal_Shdr
*symsec
;
7455 Elf_Internal_Sym
*symtab
;
7456 Elf_Internal_Sym
*sym
;
7458 if (relsec
->sh_type
!= SHT_RELA
7459 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7460 || SECTION_HEADER (relsec
->sh_info
) != section
7461 || relsec
->sh_size
== 0
7462 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7465 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7469 symsec
= SECTION_HEADER (relsec
->sh_link
);
7470 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7472 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7476 loc
= start
+ rp
->r_offset
;
7477 if ((loc
+ reloc_size
) > end
)
7479 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7480 (unsigned long) rp
->r_offset
,
7481 SECTION_NAME (section
));
7487 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7489 if (ELF32_R_SYM (rp
->r_info
) != 0
7490 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7491 /* Relocations against object symbols can happen,
7492 eg when referencing a global array. For an
7493 example of this see the _clz.o binary in libgcc.a. */
7494 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7496 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7497 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7498 SECTION_NAME (section
));
7504 /* In MIPS little-endian objects, r_info isn't really a
7505 64-bit little-endian value: it has a 32-bit little-endian
7506 symbol index followed by four individual byte fields.
7507 Reorder INFO accordingly. */
7508 if (elf_header
.e_machine
== EM_MIPS
7509 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7510 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7511 | ((rp
->r_info
>> 56) & 0xff)
7512 | ((rp
->r_info
>> 40) & 0xff00)
7513 | ((rp
->r_info
>> 24) & 0xff0000)
7514 | ((rp
->r_info
>> 8) & 0xff000000));
7516 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7518 if (ELF64_R_SYM (rp
->r_info
) != 0
7519 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7520 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7522 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7523 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7524 SECTION_NAME (section
));
7529 byte_put (loc
, rp
->r_addend
, reloc_size
);
7540 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
7542 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7543 Elf_Internal_Shdr
*sec
;
7546 /* If it is already loaded, do nothing. */
7547 if (section
->start
!= NULL
)
7550 /* Locate the debug section. */
7551 sec
= find_section (section
->name
);
7555 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
7556 section
->address
= sec
->sh_addr
;
7557 section
->size
= sec
->sh_size
;
7558 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7561 if (debug_displays
[debug
].relocate
)
7562 debug_apply_rela_addends (file
, sec
, section
->start
);
7564 return section
->start
!= NULL
;
7568 free_debug_section (enum dwarf_section_display_enum debug
)
7570 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7572 if (section
->start
== NULL
)
7575 free ((char *) section
->start
);
7576 section
->start
= NULL
;
7577 section
->address
= 0;
7582 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
7584 char *name
= SECTION_NAME (section
);
7585 bfd_size_type length
;
7587 enum dwarf_section_display_enum i
;
7589 length
= section
->sh_size
;
7592 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7596 if (strneq (name
, ".gnu.linkonce.wi.", 17))
7597 name
= ".debug_info";
7599 /* See if we know how to display the contents of this section. */
7600 for (i
= 0; i
< max
; i
++)
7601 if (streq (debug_displays
[i
].section
.name
, name
))
7603 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
7605 if (load_debug_section (i
, file
))
7607 result
&= debug_displays
[i
].display (sec
, file
);
7609 if (i
!= info
&& i
!= abbrev
)
7610 free_debug_section (i
);
7618 printf (_("Unrecognized debug section: %s\n"), name
);
7625 /* Set DUMP_SECTS for all sections where dumps were requested
7626 based on section name. */
7629 initialise_dumps_byname (void)
7631 struct dump_list_entry
*cur
;
7633 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
7638 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
7639 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
7641 request_dump (i
, cur
->type
);
7646 warn (_("Section '%s' was not dumped because it does not exist!\n"),
7652 process_section_contents (FILE *file
)
7654 Elf_Internal_Shdr
*section
;
7660 initialise_dumps_byname ();
7662 for (i
= 0, section
= section_headers
;
7663 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7666 #ifdef SUPPORT_DISASSEMBLY
7667 if (dump_sects
[i
] & DISASS_DUMP
)
7668 disassemble_section (section
, file
);
7670 if (dump_sects
[i
] & HEX_DUMP
)
7671 dump_section (section
, file
);
7673 if (dump_sects
[i
] & DEBUG_DUMP
)
7674 display_debug_section (section
, file
);
7677 /* Check to see if the user requested a
7678 dump of a section that does not exist. */
7679 while (i
++ < num_dump_sects
)
7681 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
7685 process_mips_fpe_exception (int mask
)
7690 if (mask
& OEX_FPU_INEX
)
7691 fputs ("INEX", stdout
), first
= 0;
7692 if (mask
& OEX_FPU_UFLO
)
7693 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7694 if (mask
& OEX_FPU_OFLO
)
7695 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7696 if (mask
& OEX_FPU_DIV0
)
7697 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7698 if (mask
& OEX_FPU_INVAL
)
7699 printf ("%sINVAL", first
? "" : "|");
7702 fputs ("0", stdout
);
7705 /* ARM EABI attributes section. */
7710 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
7713 } arm_attr_public_tag
;
7715 static const char *arm_attr_tag_CPU_arch
[] =
7716 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
7718 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
7719 static const char *arm_attr_tag_THUMB_ISA_use
[] =
7720 {"No", "Thumb-1", "Thumb-2"};
7721 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2"};
7722 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
7723 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
7724 static const char *arm_attr_tag_ABI_PCS_config
[] =
7725 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
7726 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
7727 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
7728 {"V6", "SB", "TLS", "Unused"};
7729 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
7730 {"Absolute", "PC-relative", "SB-relative", "None"};
7731 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
7732 {"Absolute", "PC-relative", "None"};
7733 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
7734 {"None", "direct", "GOT-indirect"};
7735 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
7736 {"None", "??? 1", "2", "??? 3", "4"};
7737 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
7738 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
7739 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
7740 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
7741 static const char *arm_attr_tag_ABI_FP_number_model
[] =
7742 {"Unused", "Finite", "RTABI", "IEEE 754"};
7743 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
7744 static const char *arm_attr_tag_ABI_align8_preserved
[] =
7745 {"No", "Yes, except leaf SP", "Yes"};
7746 static const char *arm_attr_tag_ABI_enum_size
[] =
7747 {"Unused", "small", "int", "forced to int"};
7748 static const char *arm_attr_tag_ABI_HardFP_use
[] =
7749 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
7750 static const char *arm_attr_tag_ABI_VFP_args
[] =
7751 {"AAPCS", "VFP registers", "custom"};
7752 static const char *arm_attr_tag_ABI_WMMX_args
[] =
7753 {"AAPCS", "WMMX registers", "custom"};
7754 static const char *arm_attr_tag_ABI_optimization_goals
[] =
7755 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7756 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
7757 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
7758 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7759 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
7761 #define LOOKUP(id, name) \
7762 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
7763 static arm_attr_public_tag arm_attr_public_tags
[] =
7765 {4, "CPU_raw_name", 1, NULL
},
7766 {5, "CPU_name", 1, NULL
},
7767 LOOKUP(6, CPU_arch
),
7768 {7, "CPU_arch_profile", 0, NULL
},
7769 LOOKUP(8, ARM_ISA_use
),
7770 LOOKUP(9, THUMB_ISA_use
),
7771 LOOKUP(10, VFP_arch
),
7772 LOOKUP(11, WMMX_arch
),
7773 LOOKUP(12, NEON_arch
),
7774 LOOKUP(13, ABI_PCS_config
),
7775 LOOKUP(14, ABI_PCS_R9_use
),
7776 LOOKUP(15, ABI_PCS_RW_data
),
7777 LOOKUP(16, ABI_PCS_RO_DATA
),
7778 LOOKUP(17, ABI_PCS_GOT_use
),
7779 LOOKUP(18, ABI_PCS_wchar_t
),
7780 LOOKUP(19, ABI_FP_rounding
),
7781 LOOKUP(20, ABI_FP_denormal
),
7782 LOOKUP(21, ABI_FP_exceptions
),
7783 LOOKUP(22, ABI_FP_user_exceptions
),
7784 LOOKUP(23, ABI_FP_number_model
),
7785 LOOKUP(24, ABI_align8_needed
),
7786 LOOKUP(25, ABI_align8_preserved
),
7787 LOOKUP(26, ABI_enum_size
),
7788 LOOKUP(27, ABI_HardFP_use
),
7789 LOOKUP(28, ABI_VFP_args
),
7790 LOOKUP(29, ABI_WMMX_args
),
7791 LOOKUP(30, ABI_optimization_goals
),
7792 LOOKUP(31, ABI_FP_optimization_goals
),
7793 {32, "compatibility", 0, NULL
}
7797 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
7800 read_uleb128 (unsigned char *p
, unsigned int *plen
)
7814 val
|= ((unsigned int)c
& 0x7f) << shift
;
7823 static unsigned char *
7824 display_arm_attribute (unsigned char *p
)
7829 arm_attr_public_tag
*attr
;
7833 tag
= read_uleb128 (p
, &len
);
7836 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
7838 if (arm_attr_public_tags
[i
].tag
== tag
)
7840 attr
= &arm_attr_public_tags
[i
];
7847 printf (" Tag_%s: ", attr
->name
);
7853 case 7: /* Tag_CPU_arch_profile. */
7854 val
= read_uleb128 (p
, &len
);
7858 case 0: printf ("None\n"); break;
7859 case 'A': printf ("Application\n"); break;
7860 case 'R': printf ("Realtime\n"); break;
7861 case 'M': printf ("Microcontroller\n"); break;
7862 default: printf ("??? (%d)\n", val
); break;
7866 case 32: /* Tag_compatibility. */
7867 val
= read_uleb128 (p
, &len
);
7869 printf ("flag = %d, vendor = %s\n", val
, p
);
7870 p
+= strlen((char *)p
) + 1;
7884 assert (attr
->type
& 0x80);
7885 val
= read_uleb128 (p
, &len
);
7887 type
= attr
->type
& 0x7f;
7889 printf ("??? (%d)\n", val
);
7891 printf ("%s\n", attr
->table
[val
]);
7898 type
= 1; /* String. */
7900 type
= 2; /* uleb128. */
7901 printf (" Tag_unknown_%d: ", tag
);
7906 printf ("\"%s\"\n", p
);
7907 p
+= strlen((char *)p
) + 1;
7911 val
= read_uleb128 (p
, &len
);
7913 printf ("%d (0x%x)\n", val
, val
);
7920 process_arm_specific (FILE *file
)
7922 Elf_Internal_Shdr
*sect
;
7923 unsigned char *contents
;
7926 bfd_vma section_len
;
7930 /* Find the section header so that we get the size. */
7931 for (i
= 0, sect
= section_headers
;
7932 i
< elf_header
.e_shnum
;
7935 if (sect
->sh_type
!= SHT_ARM_ATTRIBUTES
)
7938 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
7946 len
= sect
->sh_size
- 1;
7951 bfd_boolean public_section
;
7953 section_len
= byte_get (p
, 4);
7955 if (section_len
> len
)
7957 printf (_("ERROR: Bad section length (%d > %d)\n"),
7958 (int)section_len
, (int)len
);
7962 printf ("Attribute Section: %s\n", p
);
7963 if (strcmp ((char *)p
, "aeabi") == 0)
7964 public_section
= TRUE
;
7966 public_section
= FALSE
;
7967 namelen
= strlen ((char *)p
) + 1;
7969 section_len
-= namelen
+ 4;
7970 while (section_len
> 0)
7975 size
= byte_get (p
, 4);
7976 if (size
> section_len
)
7978 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
7979 (int)size
, (int)section_len
);
7982 section_len
-= size
;
7988 printf ("File Attributes\n");
7991 printf ("Section Attributes:");
7994 printf ("Symbol Attributes:");
7999 val
= read_uleb128 (p
, &i
);
8003 printf (" %d", val
);
8008 printf ("Unknown tag: %d\n", tag
);
8009 public_section
= FALSE
;
8015 p
= display_arm_attribute(p
);
8019 /* ??? Do something sensible, like dump hex. */
8020 printf (" Unknown section contexts\n");
8028 printf (_("Unknown format '%c'\n"), *p
);
8037 process_mips_specific (FILE *file
)
8039 Elf_Internal_Dyn
*entry
;
8040 size_t liblist_offset
= 0;
8041 size_t liblistno
= 0;
8042 size_t conflictsno
= 0;
8043 size_t options_offset
= 0;
8044 size_t conflicts_offset
= 0;
8046 /* We have a lot of special sections. Thanks SGI! */
8047 if (dynamic_section
== NULL
)
8048 /* No information available. */
8051 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
8052 switch (entry
->d_tag
)
8054 case DT_MIPS_LIBLIST
:
8056 = offset_from_vma (file
, entry
->d_un
.d_val
,
8057 liblistno
* sizeof (Elf32_External_Lib
));
8059 case DT_MIPS_LIBLISTNO
:
8060 liblistno
= entry
->d_un
.d_val
;
8062 case DT_MIPS_OPTIONS
:
8063 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8065 case DT_MIPS_CONFLICT
:
8067 = offset_from_vma (file
, entry
->d_un
.d_val
,
8068 conflictsno
* sizeof (Elf32_External_Conflict
));
8070 case DT_MIPS_CONFLICTNO
:
8071 conflictsno
= entry
->d_un
.d_val
;
8077 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8079 Elf32_External_Lib
*elib
;
8082 elib
= get_data (NULL
, file
, liblist_offset
,
8083 liblistno
, sizeof (Elf32_External_Lib
),
8087 printf ("\nSection '.liblist' contains %lu entries:\n",
8088 (unsigned long) liblistno
);
8089 fputs (" Library Time Stamp Checksum Version Flags\n",
8092 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8099 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8100 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8101 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8102 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8103 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8105 tmp
= gmtime (&time
);
8106 snprintf (timebuf
, sizeof (timebuf
),
8107 "%04u-%02u-%02uT%02u:%02u:%02u",
8108 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8109 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8111 printf ("%3lu: ", (unsigned long) cnt
);
8112 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
8113 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
8115 printf ("<corrupt: %9ld>", liblist
.l_name
);
8116 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8119 if (liblist
.l_flags
== 0)
8130 { " EXACT_MATCH", LL_EXACT_MATCH
},
8131 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8132 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8133 { " EXPORTS", LL_EXPORTS
},
8134 { " DELAY_LOAD", LL_DELAY_LOAD
},
8135 { " DELTA", LL_DELTA
}
8137 int flags
= liblist
.l_flags
;
8141 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
8143 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8145 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8146 flags
^= l_flags_vals
[fcnt
].bit
;
8149 printf (" %#x", (unsigned int) flags
);
8159 if (options_offset
!= 0)
8161 Elf_External_Options
*eopt
;
8162 Elf_Internal_Shdr
*sect
= section_headers
;
8163 Elf_Internal_Options
*iopt
;
8164 Elf_Internal_Options
*option
;
8168 /* Find the section header so that we get the size. */
8169 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8172 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8176 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8179 error (_("Out of memory"));
8186 while (offset
< sect
->sh_size
)
8188 Elf_External_Options
*eoption
;
8190 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8192 option
->kind
= BYTE_GET (eoption
->kind
);
8193 option
->size
= BYTE_GET (eoption
->size
);
8194 option
->section
= BYTE_GET (eoption
->section
);
8195 option
->info
= BYTE_GET (eoption
->info
);
8197 offset
+= option
->size
;
8203 printf (_("\nSection '%s' contains %d entries:\n"),
8204 SECTION_NAME (sect
), cnt
);
8212 switch (option
->kind
)
8215 /* This shouldn't happen. */
8216 printf (" NULL %d %lx", option
->section
, option
->info
);
8219 printf (" REGINFO ");
8220 if (elf_header
.e_machine
== EM_MIPS
)
8223 Elf32_External_RegInfo
*ereg
;
8224 Elf32_RegInfo reginfo
;
8226 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8227 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8228 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8229 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8230 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8231 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8232 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8234 printf ("GPR %08lx GP 0x%lx\n",
8236 (unsigned long) reginfo
.ri_gp_value
);
8237 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8238 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8239 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8244 Elf64_External_RegInfo
*ereg
;
8245 Elf64_Internal_RegInfo reginfo
;
8247 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8248 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8249 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8250 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8251 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8252 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8253 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8255 printf ("GPR %08lx GP 0x",
8256 reginfo
.ri_gprmask
);
8257 printf_vma (reginfo
.ri_gp_value
);
8260 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8261 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8262 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8266 case ODK_EXCEPTIONS
:
8267 fputs (" EXCEPTIONS fpe_min(", stdout
);
8268 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8269 fputs (") fpe_max(", stdout
);
8270 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8271 fputs (")", stdout
);
8273 if (option
->info
& OEX_PAGE0
)
8274 fputs (" PAGE0", stdout
);
8275 if (option
->info
& OEX_SMM
)
8276 fputs (" SMM", stdout
);
8277 if (option
->info
& OEX_FPDBUG
)
8278 fputs (" FPDBUG", stdout
);
8279 if (option
->info
& OEX_DISMISS
)
8280 fputs (" DISMISS", stdout
);
8283 fputs (" PAD ", stdout
);
8284 if (option
->info
& OPAD_PREFIX
)
8285 fputs (" PREFIX", stdout
);
8286 if (option
->info
& OPAD_POSTFIX
)
8287 fputs (" POSTFIX", stdout
);
8288 if (option
->info
& OPAD_SYMBOL
)
8289 fputs (" SYMBOL", stdout
);
8292 fputs (" HWPATCH ", stdout
);
8293 if (option
->info
& OHW_R4KEOP
)
8294 fputs (" R4KEOP", stdout
);
8295 if (option
->info
& OHW_R8KPFETCH
)
8296 fputs (" R8KPFETCH", stdout
);
8297 if (option
->info
& OHW_R5KEOP
)
8298 fputs (" R5KEOP", stdout
);
8299 if (option
->info
& OHW_R5KCVTL
)
8300 fputs (" R5KCVTL", stdout
);
8303 fputs (" FILL ", stdout
);
8304 /* XXX Print content of info word? */
8307 fputs (" TAGS ", stdout
);
8308 /* XXX Print content of info word? */
8311 fputs (" HWAND ", stdout
);
8312 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8313 fputs (" R4KEOP_CHECKED", stdout
);
8314 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8315 fputs (" R4KEOP_CLEAN", stdout
);
8318 fputs (" HWOR ", stdout
);
8319 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8320 fputs (" R4KEOP_CHECKED", stdout
);
8321 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8322 fputs (" R4KEOP_CLEAN", stdout
);
8325 printf (" GP_GROUP %#06lx self-contained %#06lx",
8326 option
->info
& OGP_GROUP
,
8327 (option
->info
& OGP_SELF
) >> 16);
8330 printf (" IDENT %#06lx self-contained %#06lx",
8331 option
->info
& OGP_GROUP
,
8332 (option
->info
& OGP_SELF
) >> 16);
8335 /* This shouldn't happen. */
8336 printf (" %3d ??? %d %lx",
8337 option
->kind
, option
->section
, option
->info
);
8341 len
= sizeof (*eopt
);
8342 while (len
< option
->size
)
8343 if (((char *) option
)[len
] >= ' '
8344 && ((char *) option
)[len
] < 0x7f)
8345 printf ("%c", ((char *) option
)[len
++]);
8347 printf ("\\%03o", ((char *) option
)[len
++]);
8349 fputs ("\n", stdout
);
8357 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8359 Elf32_Conflict
*iconf
;
8362 if (dynamic_symbols
== NULL
)
8364 error (_("conflict list found without a dynamic symbol table"));
8368 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
8371 error (_("Out of memory"));
8377 Elf32_External_Conflict
*econf32
;
8379 econf32
= get_data (NULL
, file
, conflicts_offset
,
8380 conflictsno
, sizeof (*econf32
), _("conflict"));
8384 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8385 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8391 Elf64_External_Conflict
*econf64
;
8393 econf64
= get_data (NULL
, file
, conflicts_offset
,
8394 conflictsno
, sizeof (*econf64
), _("conflict"));
8398 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8399 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8404 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8405 (unsigned long) conflictsno
);
8406 puts (_(" Num: Index Value Name"));
8408 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8410 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
8412 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8413 print_vma (psym
->st_value
, FULL_HEX
);
8415 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8416 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8418 printf ("<corrupt: %14ld>", psym
->st_name
);
8429 process_gnu_liblist (FILE *file
)
8431 Elf_Internal_Shdr
*section
, *string_sec
;
8432 Elf32_External_Lib
*elib
;
8441 for (i
= 0, section
= section_headers
;
8442 i
< elf_header
.e_shnum
;
8445 switch (section
->sh_type
)
8447 case SHT_GNU_LIBLIST
:
8448 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
8451 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
8456 string_sec
= SECTION_HEADER (section
->sh_link
);
8458 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8459 string_sec
->sh_size
, _("liblist string table"));
8460 strtab_size
= string_sec
->sh_size
;
8463 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
8469 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8470 SECTION_NAME (section
),
8471 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
8473 puts (" Library Time Stamp Checksum Version Flags");
8475 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
8483 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8484 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8485 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8486 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8487 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8489 tmp
= gmtime (&time
);
8490 snprintf (timebuf
, sizeof (timebuf
),
8491 "%04u-%02u-%02uT%02u:%02u:%02u",
8492 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8493 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8495 printf ("%3lu: ", (unsigned long) cnt
);
8497 printf ("%-20s", liblist
.l_name
< strtab_size
8498 ? strtab
+ liblist
.l_name
: "<corrupt>");
8500 printf ("%-20.20s", liblist
.l_name
< strtab_size
8501 ? strtab
+ liblist
.l_name
: "<corrupt>");
8502 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
8503 liblist
.l_version
, liblist
.l_flags
);
8514 get_note_type (unsigned e_type
)
8516 static char buff
[64];
8518 if (elf_header
.e_type
== ET_CORE
)
8522 return _("NT_AUXV (auxiliary vector)");
8524 return _("NT_PRSTATUS (prstatus structure)");
8526 return _("NT_FPREGSET (floating point registers)");
8528 return _("NT_PRPSINFO (prpsinfo structure)");
8530 return _("NT_TASKSTRUCT (task structure)");
8532 return _("NT_PRXFPREG (user_xfpregs structure)");
8534 return _("NT_PSTATUS (pstatus structure)");
8536 return _("NT_FPREGS (floating point registers)");
8538 return _("NT_PSINFO (psinfo structure)");
8540 return _("NT_LWPSTATUS (lwpstatus_t structure)");
8542 return _("NT_LWPSINFO (lwpsinfo_t structure)");
8543 case NT_WIN32PSTATUS
:
8544 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8552 return _("NT_VERSION (version)");
8554 return _("NT_ARCH (architecture)");
8559 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8564 get_netbsd_elfcore_note_type (unsigned e_type
)
8566 static char buff
[64];
8568 if (e_type
== NT_NETBSDCORE_PROCINFO
)
8570 /* NetBSD core "procinfo" structure. */
8571 return _("NetBSD procinfo structure");
8574 /* As of Jan 2002 there are no other machine-independent notes
8575 defined for NetBSD core files. If the note type is less
8576 than the start of the machine-dependent note types, we don't
8579 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
8581 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8585 switch (elf_header
.e_machine
)
8587 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8588 and PT_GETFPREGS == mach+2. */
8593 case EM_SPARC32PLUS
:
8597 case NT_NETBSDCORE_FIRSTMACH
+0:
8598 return _("PT_GETREGS (reg structure)");
8599 case NT_NETBSDCORE_FIRSTMACH
+2:
8600 return _("PT_GETFPREGS (fpreg structure)");
8606 /* On all other arch's, PT_GETREGS == mach+1 and
8607 PT_GETFPREGS == mach+3. */
8611 case NT_NETBSDCORE_FIRSTMACH
+1:
8612 return _("PT_GETREGS (reg structure)");
8613 case NT_NETBSDCORE_FIRSTMACH
+3:
8614 return _("PT_GETFPREGS (fpreg structure)");
8620 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
8621 e_type
- NT_NETBSDCORE_FIRSTMACH
);
8625 /* Note that by the ELF standard, the name field is already null byte
8626 terminated, and namesz includes the terminating null byte.
8627 I.E. the value of namesz for the name "FSF" is 4.
8629 If the value of namesz is zero, there is no name present. */
8631 process_note (Elf_Internal_Note
*pnote
)
8635 if (pnote
->namesz
== 0)
8636 /* If there is no note name, then use the default set of
8637 note type strings. */
8638 nt
= get_note_type (pnote
->type
);
8640 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
8641 /* NetBSD-specific core file notes. */
8642 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
8645 /* Don't recognize this note name; just use the default set of
8646 note type strings. */
8647 nt
= get_note_type (pnote
->type
);
8649 printf (" %s\t\t0x%08lx\t%s\n",
8650 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8657 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
8659 Elf_External_Note
*pnotes
;
8660 Elf_External_Note
*external
;
8666 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
8672 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8673 (unsigned long) offset
, (unsigned long) length
);
8674 printf (_(" Owner\t\tData size\tDescription\n"));
8676 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8678 Elf_External_Note
*next
;
8679 Elf_Internal_Note inote
;
8682 inote
.type
= BYTE_GET (external
->type
);
8683 inote
.namesz
= BYTE_GET (external
->namesz
);
8684 inote
.namedata
= external
->name
;
8685 inote
.descsz
= BYTE_GET (external
->descsz
);
8686 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8687 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8689 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8691 if (((char *) next
) > (((char *) pnotes
) + length
))
8693 warn (_("corrupt note found at offset %lx into core notes\n"),
8694 (long)((char *)external
- (char *)pnotes
));
8695 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8696 inote
.type
, inote
.namesz
, inote
.descsz
);
8702 /* Verify that name is null terminated. It appears that at least
8703 one version of Linux (RedHat 6.0) generates corefiles that don't
8704 comply with the ELF spec by failing to include the null byte in
8706 if (inote
.namedata
[inote
.namesz
] != '\0')
8708 temp
= malloc (inote
.namesz
+ 1);
8712 error (_("Out of memory\n"));
8717 strncpy (temp
, inote
.namedata
, inote
.namesz
);
8718 temp
[inote
.namesz
] = 0;
8720 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8721 inote
.namedata
= temp
;
8724 res
&= process_note (& inote
);
8739 process_corefile_note_segments (FILE *file
)
8741 Elf_Internal_Phdr
*segment
;
8745 if (! get_program_headers (file
))
8748 for (i
= 0, segment
= program_headers
;
8749 i
< elf_header
.e_phnum
;
8752 if (segment
->p_type
== PT_NOTE
)
8753 res
&= process_corefile_note_segment (file
,
8754 (bfd_vma
) segment
->p_offset
,
8755 (bfd_vma
) segment
->p_filesz
);
8762 process_note_sections (FILE *file
)
8764 Elf_Internal_Shdr
*section
;
8768 for (i
= 0, section
= section_headers
;
8769 i
< elf_header
.e_shnum
;
8771 if (section
->sh_type
== SHT_NOTE
)
8772 res
&= process_corefile_note_segment (file
,
8773 (bfd_vma
) section
->sh_offset
,
8774 (bfd_vma
) section
->sh_size
);
8780 process_notes (FILE *file
)
8782 /* If we have not been asked to display the notes then do nothing. */
8786 if (elf_header
.e_type
!= ET_CORE
)
8787 return process_note_sections (file
);
8789 /* No program headers means no NOTE segment. */
8790 if (elf_header
.e_phnum
> 0)
8791 return process_corefile_note_segments (file
);
8793 printf (_("No note segments present in the core file.\n"));
8798 process_arch_specific (FILE *file
)
8803 switch (elf_header
.e_machine
)
8806 return process_arm_specific (file
);
8808 case EM_MIPS_RS3_LE
:
8809 return process_mips_specific (file
);
8818 get_file_header (FILE *file
)
8820 /* Read in the identity array. */
8821 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
8824 /* Determine how to read the rest of the header. */
8825 switch (elf_header
.e_ident
[EI_DATA
])
8827 default: /* fall through */
8828 case ELFDATANONE
: /* fall through */
8830 byte_get
= byte_get_little_endian
;
8831 byte_put
= byte_put_little_endian
;
8834 byte_get
= byte_get_big_endian
;
8835 byte_put
= byte_put_big_endian
;
8839 /* For now we only support 32 bit and 64 bit ELF files. */
8840 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
8842 /* Read in the rest of the header. */
8845 Elf32_External_Ehdr ehdr32
;
8847 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
8850 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
8851 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
8852 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
8853 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
8854 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
8855 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
8856 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
8857 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
8858 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
8859 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
8860 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
8861 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
8862 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
8866 Elf64_External_Ehdr ehdr64
;
8868 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8869 we will not be able to cope with the 64bit data found in
8870 64 ELF files. Detect this now and abort before we start
8871 overwriting things. */
8872 if (sizeof (bfd_vma
) < 8)
8874 error (_("This instance of readelf has been built without support for a\n\
8875 64 bit data type and so it cannot read 64 bit ELF files.\n"));
8879 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
8882 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
8883 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
8884 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
8885 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
8886 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
8887 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
8888 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
8889 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
8890 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
8891 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
8892 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
8893 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
8894 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
8897 if (elf_header
.e_shoff
)
8899 /* There may be some extensions in the first section header. Don't
8900 bomb if we can't read it. */
8902 get_32bit_section_headers (file
, 1);
8904 get_64bit_section_headers (file
, 1);
8907 is_relocatable
= elf_header
.e_type
== ET_REL
;
8912 /* Process one ELF object file according to the command line options.
8913 This file may actually be stored in an archive. The file is
8914 positioned at the start of the ELF object. */
8917 process_object (char *file_name
, FILE *file
)
8921 if (! get_file_header (file
))
8923 error (_("%s: Failed to read file header\n"), file_name
);
8927 /* Initialise per file variables. */
8928 for (i
= NUM_ELEM (version_info
); i
--;)
8929 version_info
[i
] = 0;
8931 for (i
= NUM_ELEM (dynamic_info
); i
--;)
8932 dynamic_info
[i
] = 0;
8934 /* Process the file. */
8936 printf (_("\nFile: %s\n"), file_name
);
8938 /* Initialise the dump_sects array from the cmdline_dump_sects array.
8939 Note we do this even if cmdline_dump_sects is empty because we
8940 must make sure that the dump_sets array is zeroed out before each
8941 object file is processed. */
8942 if (num_dump_sects
> num_cmdline_dump_sects
)
8943 memset (dump_sects
, 0, num_dump_sects
);
8945 if (num_cmdline_dump_sects
> 0)
8947 if (num_dump_sects
== 0)
8948 /* A sneaky way of allocating the dump_sects array. */
8949 request_dump (num_cmdline_dump_sects
, 0);
8951 assert (num_dump_sects
>= num_cmdline_dump_sects
);
8952 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
8955 if (! process_file_header ())
8958 if (! process_section_headers (file
))
8960 /* Without loaded section headers we cannot process lots of
8962 do_unwind
= do_version
= do_dump
= do_arch
= 0;
8964 if (! do_using_dynamic
)
8965 do_syms
= do_reloc
= 0;
8968 if (! process_section_groups (file
))
8970 /* Without loaded section groups we cannot process unwind. */
8974 if (process_program_headers (file
))
8975 process_dynamic_section (file
);
8977 process_relocs (file
);
8979 process_unwind (file
);
8981 process_symbol_table (file
);
8983 process_syminfo (file
);
8985 process_version_sections (file
);
8987 process_section_contents (file
);
8989 process_notes (file
);
8991 process_gnu_liblist (file
);
8993 process_arch_specific (file
);
8995 if (program_headers
)
8997 free (program_headers
);
8998 program_headers
= NULL
;
9001 if (section_headers
)
9003 free (section_headers
);
9004 section_headers
= NULL
;
9009 free (string_table
);
9010 string_table
= NULL
;
9011 string_table_length
= 0;
9014 if (dynamic_strings
)
9016 free (dynamic_strings
);
9017 dynamic_strings
= NULL
;
9018 dynamic_strings_length
= 0;
9021 if (dynamic_symbols
)
9023 free (dynamic_symbols
);
9024 dynamic_symbols
= NULL
;
9025 num_dynamic_syms
= 0;
9028 if (dynamic_syminfo
)
9030 free (dynamic_syminfo
);
9031 dynamic_syminfo
= NULL
;
9034 if (section_headers_groups
)
9036 free (section_headers_groups
);
9037 section_headers_groups
= NULL
;
9042 struct group_list
*g
, *next
;
9044 for (i
= 0; i
< group_count
; i
++)
9046 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
9053 free (section_groups
);
9054 section_groups
= NULL
;
9057 free_debug_memory ();
9062 /* Process an ELF archive. The file is positioned just after the
9066 process_archive (char *file_name
, FILE *file
)
9068 struct ar_hdr arhdr
;
9071 char *longnames
= NULL
;
9072 unsigned long longnames_size
= 0;
9073 size_t file_name_size
;
9078 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9079 if (got
!= sizeof arhdr
)
9084 error (_("%s: failed to read archive header\n"), file_name
);
9088 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
9090 /* This is the archive symbol table. Skip it.
9091 FIXME: We should have an option to dump it. */
9092 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9093 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
9095 error (_("%s: failed to skip archive symbol table\n"), file_name
);
9099 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9100 if (got
!= sizeof arhdr
)
9105 error (_("%s: failed to read archive header\n"), file_name
);
9110 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
9112 /* This is the archive string table holding long member
9115 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9117 longnames
= malloc (longnames_size
);
9118 if (longnames
== NULL
)
9120 error (_("Out of memory\n"));
9124 if (fread (longnames
, longnames_size
, 1, file
) != 1)
9127 error (_("%s: failed to read string table\n"), file_name
);
9131 if ((longnames_size
& 1) != 0)
9134 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9135 if (got
!= sizeof arhdr
)
9142 error (_("%s: failed to read archive header\n"), file_name
);
9147 file_name_size
= strlen (file_name
);
9156 if (arhdr
.ar_name
[0] == '/')
9160 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
9161 if (off
>= longnames_size
)
9163 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
9168 name
= longnames
+ off
;
9169 nameend
= memchr (name
, '/', longnames_size
- off
);
9173 name
= arhdr
.ar_name
;
9174 nameend
= memchr (name
, '/', 16);
9177 if (nameend
== NULL
)
9179 error (_("%s: bad archive file name\n"), file_name
);
9184 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
9185 if (namealc
== NULL
)
9187 error (_("Out of memory\n"));
9192 memcpy (namealc
, file_name
, file_name_size
);
9193 namealc
[file_name_size
] = '(';
9194 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
9195 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
9196 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
9198 archive_file_offset
= ftell (file
);
9199 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9201 ret
|= process_object (namealc
, file
);
9206 (archive_file_offset
9208 + (archive_file_size
& 1)),
9211 error (_("%s: failed to seek to next archive header\n"), file_name
);
9216 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9217 if (got
!= sizeof arhdr
)
9222 error (_("%s: failed to read archive header\n"), file_name
);
9235 process_file (char *file_name
)
9238 struct stat statbuf
;
9242 if (stat (file_name
, &statbuf
) < 0)
9244 if (errno
== ENOENT
)
9245 error (_("'%s': No such file\n"), file_name
);
9247 error (_("Could not locate '%s'. System error message: %s\n"),
9248 file_name
, strerror (errno
));
9252 if (! S_ISREG (statbuf
.st_mode
))
9254 error (_("'%s' is not an ordinary file\n"), file_name
);
9258 file
= fopen (file_name
, "rb");
9261 error (_("Input file '%s' is not readable.\n"), file_name
);
9265 if (fread (armag
, SARMAG
, 1, file
) != 1)
9267 error (_("%s: Failed to read file header\n"), file_name
);
9272 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
9273 ret
= process_archive (file_name
, file
);
9277 archive_file_size
= archive_file_offset
= 0;
9278 ret
= process_object (file_name
, file
);
9286 #ifdef SUPPORT_DISASSEMBLY
9287 /* Needed by the i386 disassembler. For extra credit, someone could
9288 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9292 print_address (unsigned int addr
, FILE *outfile
)
9294 fprintf (outfile
,"0x%8.8x", addr
);
9297 /* Needed by the i386 disassembler. */
9299 db_task_printsym (unsigned int addr
)
9301 print_address (addr
, stderr
);
9306 main (int argc
, char **argv
)
9310 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9311 setlocale (LC_MESSAGES
, "");
9313 #if defined (HAVE_SETLOCALE)
9314 setlocale (LC_CTYPE
, "");
9316 bindtextdomain (PACKAGE
, LOCALEDIR
);
9317 textdomain (PACKAGE
);
9319 expandargv (&argc
, &argv
);
9321 parse_args (argc
, argv
);
9323 if (num_dump_sects
> 0)
9325 /* Make a copy of the dump_sects array. */
9326 cmdline_dump_sects
= malloc (num_dump_sects
);
9327 if (cmdline_dump_sects
== NULL
)
9328 error (_("Out of memory allocating dump request table."));
9331 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
9332 num_cmdline_dump_sects
= num_dump_sects
;
9336 if (optind
< (argc
- 1))
9340 while (optind
< argc
)
9341 err
|= process_file (argv
[optind
++]);
9343 if (dump_sects
!= NULL
)
9345 if (cmdline_dump_sects
!= NULL
)
9346 free (cmdline_dump_sects
);