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 default: strcat (buf
, ", unknown ISA"); break;
2133 if (e_flags
& EF_SPARC_32PLUS
)
2134 strcat (buf
, ", v8+");
2136 if (e_flags
& EF_SPARC_SUN_US1
)
2137 strcat (buf
, ", ultrasparcI");
2139 if (e_flags
& EF_SPARC_SUN_US3
)
2140 strcat (buf
, ", ultrasparcIII");
2142 if (e_flags
& EF_SPARC_HAL_R1
)
2143 strcat (buf
, ", halr1");
2145 if (e_flags
& EF_SPARC_LEDATA
)
2146 strcat (buf
, ", ledata");
2148 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2149 strcat (buf
, ", tso");
2151 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2152 strcat (buf
, ", pso");
2154 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2155 strcat (buf
, ", rmo");
2159 switch (e_flags
& EF_PARISC_ARCH
)
2161 case EFA_PARISC_1_0
:
2162 strcpy (buf
, ", PA-RISC 1.0");
2164 case EFA_PARISC_1_1
:
2165 strcpy (buf
, ", PA-RISC 1.1");
2167 case EFA_PARISC_2_0
:
2168 strcpy (buf
, ", PA-RISC 2.0");
2173 if (e_flags
& EF_PARISC_TRAPNIL
)
2174 strcat (buf
, ", trapnil");
2175 if (e_flags
& EF_PARISC_EXT
)
2176 strcat (buf
, ", ext");
2177 if (e_flags
& EF_PARISC_LSB
)
2178 strcat (buf
, ", lsb");
2179 if (e_flags
& EF_PARISC_WIDE
)
2180 strcat (buf
, ", wide");
2181 if (e_flags
& EF_PARISC_NO_KABP
)
2182 strcat (buf
, ", no kabp");
2183 if (e_flags
& EF_PARISC_LAZYSWAP
)
2184 strcat (buf
, ", lazyswap");
2189 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2190 strcat (buf
, ", new calling convention");
2192 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2193 strcat (buf
, ", gnu calling convention");
2197 if ((e_flags
& EF_IA_64_ABI64
))
2198 strcat (buf
, ", 64-bit");
2200 strcat (buf
, ", 32-bit");
2201 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2202 strcat (buf
, ", reduced fp model");
2203 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2204 strcat (buf
, ", no function descriptors, constant gp");
2205 else if ((e_flags
& EF_IA_64_CONS_GP
))
2206 strcat (buf
, ", constant gp");
2207 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2208 strcat (buf
, ", absolute");
2212 if ((e_flags
& EF_VAX_NONPIC
))
2213 strcat (buf
, ", non-PIC");
2214 if ((e_flags
& EF_VAX_DFLOAT
))
2215 strcat (buf
, ", D-Float");
2216 if ((e_flags
& EF_VAX_GFLOAT
))
2217 strcat (buf
, ", G-Float");
2226 get_osabi_name (unsigned int osabi
)
2228 static char buff
[32];
2232 case ELFOSABI_NONE
: return "UNIX - System V";
2233 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2234 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2235 case ELFOSABI_LINUX
: return "UNIX - Linux";
2236 case ELFOSABI_HURD
: return "GNU/Hurd";
2237 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2238 case ELFOSABI_AIX
: return "UNIX - AIX";
2239 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2240 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2241 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2242 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2243 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2244 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2245 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2246 case ELFOSABI_AROS
: return "Amiga Research OS";
2247 case ELFOSABI_STANDALONE
: return _("Standalone App");
2248 case ELFOSABI_ARM
: return "ARM";
2250 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2256 get_arm_segment_type (unsigned long type
)
2270 get_mips_segment_type (unsigned long type
)
2274 case PT_MIPS_REGINFO
:
2276 case PT_MIPS_RTPROC
:
2278 case PT_MIPS_OPTIONS
:
2288 get_parisc_segment_type (unsigned long type
)
2292 case PT_HP_TLS
: return "HP_TLS";
2293 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2294 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2295 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2296 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2297 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2298 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2299 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2300 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2301 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2302 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2303 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2304 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2305 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2306 case PT_HP_STACK
: return "HP_STACK";
2307 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2308 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2309 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2310 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2319 get_ia64_segment_type (unsigned long type
)
2323 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2324 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2325 case PT_HP_TLS
: return "HP_TLS";
2326 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2327 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2328 case PT_IA_64_HP_STACK
: return "HP_STACK";
2337 get_segment_type (unsigned long p_type
)
2339 static char buff
[32];
2343 case PT_NULL
: return "NULL";
2344 case PT_LOAD
: return "LOAD";
2345 case PT_DYNAMIC
: return "DYNAMIC";
2346 case PT_INTERP
: return "INTERP";
2347 case PT_NOTE
: return "NOTE";
2348 case PT_SHLIB
: return "SHLIB";
2349 case PT_PHDR
: return "PHDR";
2350 case PT_TLS
: return "TLS";
2352 case PT_GNU_EH_FRAME
:
2353 return "GNU_EH_FRAME";
2354 case PT_GNU_STACK
: return "GNU_STACK";
2355 case PT_GNU_RELRO
: return "GNU_RELRO";
2358 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2362 switch (elf_header
.e_machine
)
2365 result
= get_arm_segment_type (p_type
);
2368 case EM_MIPS_RS3_LE
:
2369 result
= get_mips_segment_type (p_type
);
2372 result
= get_parisc_segment_type (p_type
);
2375 result
= get_ia64_segment_type (p_type
);
2385 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2387 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2391 switch (elf_header
.e_machine
)
2394 result
= get_parisc_segment_type (p_type
);
2397 result
= get_ia64_segment_type (p_type
);
2407 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2410 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2417 get_mips_section_type_name (unsigned int sh_type
)
2421 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2422 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2423 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2424 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2425 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2426 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2427 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2428 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2429 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2430 case SHT_MIPS_RELD
: return "MIPS_RELD";
2431 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2432 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2433 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2434 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2435 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2436 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2437 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2438 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2439 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2440 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2441 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2442 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2443 case SHT_MIPS_LINE
: return "MIPS_LINE";
2444 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2445 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2446 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2447 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2448 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2449 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2450 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2451 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2452 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2453 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2454 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2455 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2456 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2457 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2458 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2459 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2467 get_parisc_section_type_name (unsigned int sh_type
)
2471 case SHT_PARISC_EXT
: return "PARISC_EXT";
2472 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2473 case SHT_PARISC_DOC
: return "PARISC_DOC";
2474 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2475 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2476 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2477 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2485 get_ia64_section_type_name (unsigned int sh_type
)
2487 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2488 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2489 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2493 case SHT_IA_64_EXT
: return "IA_64_EXT";
2494 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2495 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2503 get_x86_64_section_type_name (unsigned int sh_type
)
2507 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2515 get_arm_section_type_name (unsigned int sh_type
)
2521 case SHT_ARM_PREEMPTMAP
:
2522 return "ARM_PREEMPTMAP";
2523 case SHT_ARM_ATTRIBUTES
:
2524 return "ARM_ATTRIBUTES";
2532 get_section_type_name (unsigned int sh_type
)
2534 static char buff
[32];
2538 case SHT_NULL
: return "NULL";
2539 case SHT_PROGBITS
: return "PROGBITS";
2540 case SHT_SYMTAB
: return "SYMTAB";
2541 case SHT_STRTAB
: return "STRTAB";
2542 case SHT_RELA
: return "RELA";
2543 case SHT_HASH
: return "HASH";
2544 case SHT_DYNAMIC
: return "DYNAMIC";
2545 case SHT_NOTE
: return "NOTE";
2546 case SHT_NOBITS
: return "NOBITS";
2547 case SHT_REL
: return "REL";
2548 case SHT_SHLIB
: return "SHLIB";
2549 case SHT_DYNSYM
: return "DYNSYM";
2550 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2551 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2552 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2553 case SHT_GROUP
: return "GROUP";
2554 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2555 case SHT_GNU_verdef
: return "VERDEF";
2556 case SHT_GNU_verneed
: return "VERNEED";
2557 case SHT_GNU_versym
: return "VERSYM";
2558 case 0x6ffffff0: return "VERSYM";
2559 case 0x6ffffffc: return "VERDEF";
2560 case 0x7ffffffd: return "AUXILIARY";
2561 case 0x7fffffff: return "FILTER";
2562 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2565 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2569 switch (elf_header
.e_machine
)
2572 case EM_MIPS_RS3_LE
:
2573 result
= get_mips_section_type_name (sh_type
);
2576 result
= get_parisc_section_type_name (sh_type
);
2579 result
= get_ia64_section_type_name (sh_type
);
2582 result
= get_x86_64_section_type_name (sh_type
);
2585 result
= get_arm_section_type_name (sh_type
);
2595 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2597 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2598 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2599 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2600 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2602 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2608 #define OPTION_DEBUG_DUMP 512
2610 static struct option options
[] =
2612 {"all", no_argument
, 0, 'a'},
2613 {"file-header", no_argument
, 0, 'h'},
2614 {"program-headers", no_argument
, 0, 'l'},
2615 {"headers", no_argument
, 0, 'e'},
2616 {"histogram", no_argument
, 0, 'I'},
2617 {"segments", no_argument
, 0, 'l'},
2618 {"sections", no_argument
, 0, 'S'},
2619 {"section-headers", no_argument
, 0, 'S'},
2620 {"section-groups", no_argument
, 0, 'g'},
2621 {"section-details", no_argument
, 0, 't'},
2622 {"full-section-name",no_argument
, 0, 'N'},
2623 {"symbols", no_argument
, 0, 's'},
2624 {"syms", no_argument
, 0, 's'},
2625 {"relocs", no_argument
, 0, 'r'},
2626 {"notes", no_argument
, 0, 'n'},
2627 {"dynamic", no_argument
, 0, 'd'},
2628 {"arch-specific", no_argument
, 0, 'A'},
2629 {"version-info", no_argument
, 0, 'V'},
2630 {"use-dynamic", no_argument
, 0, 'D'},
2631 {"hex-dump", required_argument
, 0, 'x'},
2632 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2633 {"unwind", no_argument
, 0, 'u'},
2634 #ifdef SUPPORT_DISASSEMBLY
2635 {"instruction-dump", required_argument
, 0, 'i'},
2638 {"version", no_argument
, 0, 'v'},
2639 {"wide", no_argument
, 0, 'W'},
2640 {"help", no_argument
, 0, 'H'},
2641 {0, no_argument
, 0, 0}
2647 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2648 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2649 fprintf (stdout
, _(" Options are:\n\
2650 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2651 -h --file-header Display the ELF file header\n\
2652 -l --program-headers Display the program headers\n\
2653 --segments An alias for --program-headers\n\
2654 -S --section-headers Display the sections' header\n\
2655 --sections An alias for --section-headers\n\
2656 -g --section-groups Display the section groups\n\
2657 -t --section-details Display the section details\n\
2658 -e --headers Equivalent to: -h -l -S\n\
2659 -s --syms Display the symbol table\n\
2660 --symbols An alias for --syms\n\
2661 -n --notes Display the core notes (if present)\n\
2662 -r --relocs Display the relocations (if present)\n\
2663 -u --unwind Display the unwind info (if present)\n\
2664 -d --dynamic Display the dynamic section (if present)\n\
2665 -V --version-info Display the version sections (if present)\n\
2666 -A --arch-specific Display architecture specific information (if any).\n\
2667 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2668 -x --hex-dump=<number> Dump the contents of section <number>\n\
2669 -w[liaprmfFsoR] or\n\
2670 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2671 Display the contents of DWARF2 debug sections\n"));
2672 #ifdef SUPPORT_DISASSEMBLY
2673 fprintf (stdout
, _("\
2674 -i --instruction-dump=<number>\n\
2675 Disassemble the contents of section <number>\n"));
2677 fprintf (stdout
, _("\
2678 -I --histogram Display histogram of bucket list lengths\n\
2679 -W --wide Allow output width to exceed 80 characters\n\
2680 @<file> Read options from <file>\n\
2681 -H --help Display this information\n\
2682 -v --version Display the version number of readelf\n"));
2683 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2688 /* Record the fact that the user wants the contents of section number
2689 SECTION to be displayed using the method(s) encoded as flags bits
2690 in TYPE. Note, TYPE can be zero if we are creating the array for
2694 request_dump (unsigned int section
, int type
)
2696 if (section
>= num_dump_sects
)
2698 char *new_dump_sects
;
2700 new_dump_sects
= calloc (section
+ 1, 1);
2702 if (new_dump_sects
== NULL
)
2703 error (_("Out of memory allocating dump request table."));
2706 /* Copy current flag settings. */
2707 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2711 dump_sects
= new_dump_sects
;
2712 num_dump_sects
= section
+ 1;
2717 dump_sects
[section
] |= type
;
2722 /* Request a dump by section name. */
2725 request_dump_byname (const char *section
, int type
)
2727 struct dump_list_entry
*new_request
;
2729 new_request
= malloc (sizeof (struct dump_list_entry
));
2731 error (_("Out of memory allocating dump request table."));
2733 new_request
->name
= strdup (section
);
2734 if (!new_request
->name
)
2735 error (_("Out of memory allocating dump request table."));
2737 new_request
->type
= type
;
2739 new_request
->next
= dump_sects_byname
;
2740 dump_sects_byname
= new_request
;
2744 parse_args (int argc
, char **argv
)
2751 while ((c
= getopt_long
2752 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2773 do_section_groups
++;
2781 do_section_groups
++;
2786 do_section_details
++;
2828 section
= strtoul (optarg
, & cp
, 0);
2829 if (! *cp
&& section
>= 0)
2830 request_dump (section
, HEX_DUMP
);
2832 request_dump_byname (optarg
, HEX_DUMP
);
2840 unsigned int index
= 0;
2844 while (optarg
[index
])
2845 switch (optarg
[index
++])
2854 do_debug_abbrevs
= 1;
2864 do_debug_pubnames
= 1;
2868 do_debug_aranges
= 1;
2872 do_debug_ranges
= 1;
2876 do_debug_frames_interp
= 1;
2878 do_debug_frames
= 1;
2883 do_debug_macinfo
= 1;
2897 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2902 case OPTION_DEBUG_DUMP
:
2910 const char * option
;
2913 debug_dump_long_opts
;
2915 debug_dump_long_opts opts_table
[] =
2917 /* Please keep this table alpha- sorted. */
2918 { "Ranges", & do_debug_ranges
},
2919 { "abbrev", & do_debug_abbrevs
},
2920 { "aranges", & do_debug_aranges
},
2921 { "frames", & do_debug_frames
},
2922 { "frames-interp", & do_debug_frames_interp
},
2923 { "info", & do_debug_info
},
2924 { "line", & do_debug_lines
},
2925 { "loc", & do_debug_loc
},
2926 { "macro", & do_debug_macinfo
},
2927 { "pubnames", & do_debug_pubnames
},
2928 /* This entry is for compatability
2929 with earlier versions of readelf. */
2930 { "ranges", & do_debug_aranges
},
2931 { "str", & do_debug_str
},
2942 debug_dump_long_opts
* entry
;
2944 for (entry
= opts_table
; entry
->option
; entry
++)
2946 size_t len
= strlen (entry
->option
);
2948 if (strneq (p
, entry
->option
, len
)
2949 && (p
[len
] == ',' || p
[len
] == '\0'))
2951 * entry
->variable
= 1;
2953 /* The --debug-dump=frames-interp option also
2954 enables the --debug-dump=frames option. */
2955 if (do_debug_frames_interp
)
2956 do_debug_frames
= 1;
2963 if (entry
->option
== NULL
)
2965 warn (_("Unrecognized debug option '%s'\n"), p
);
2966 p
= strchr (p
, ',');
2976 #ifdef SUPPORT_DISASSEMBLY
2979 section
= strtoul (optarg
, & cp
, 0);
2980 if (! *cp
&& section
>= 0)
2982 request_dump (section
, DISASS_DUMP
);
2988 print_version (program_name
);
2997 #ifdef SUPPORT_DISASSEMBLY
3000 /* xgettext:c-format */
3001 error (_("Invalid option '-%c'\n"), c
);
3008 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3009 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3010 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3011 && !do_section_groups
)
3015 warn (_("Nothing to do.\n"));
3021 get_elf_class (unsigned int elf_class
)
3023 static char buff
[32];
3027 case ELFCLASSNONE
: return _("none");
3028 case ELFCLASS32
: return "ELF32";
3029 case ELFCLASS64
: return "ELF64";
3031 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3037 get_data_encoding (unsigned int encoding
)
3039 static char buff
[32];
3043 case ELFDATANONE
: return _("none");
3044 case ELFDATA2LSB
: return _("2's complement, little endian");
3045 case ELFDATA2MSB
: return _("2's complement, big endian");
3047 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3052 /* Decode the data held in 'elf_header'. */
3055 process_file_header (void)
3057 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3058 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3059 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3060 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3063 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3071 printf (_("ELF Header:\n"));
3072 printf (_(" Magic: "));
3073 for (i
= 0; i
< EI_NIDENT
; i
++)
3074 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3076 printf (_(" Class: %s\n"),
3077 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3078 printf (_(" Data: %s\n"),
3079 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3080 printf (_(" Version: %d %s\n"),
3081 elf_header
.e_ident
[EI_VERSION
],
3082 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3084 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3087 printf (_(" OS/ABI: %s\n"),
3088 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3089 printf (_(" ABI Version: %d\n"),
3090 elf_header
.e_ident
[EI_ABIVERSION
]);
3091 printf (_(" Type: %s\n"),
3092 get_file_type (elf_header
.e_type
));
3093 printf (_(" Machine: %s\n"),
3094 get_machine_name (elf_header
.e_machine
));
3095 printf (_(" Version: 0x%lx\n"),
3096 (unsigned long) elf_header
.e_version
);
3098 printf (_(" Entry point address: "));
3099 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3100 printf (_("\n Start of program headers: "));
3101 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3102 printf (_(" (bytes into file)\n Start of section headers: "));
3103 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3104 printf (_(" (bytes into file)\n"));
3106 printf (_(" Flags: 0x%lx%s\n"),
3107 (unsigned long) elf_header
.e_flags
,
3108 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3109 printf (_(" Size of this header: %ld (bytes)\n"),
3110 (long) elf_header
.e_ehsize
);
3111 printf (_(" Size of program headers: %ld (bytes)\n"),
3112 (long) elf_header
.e_phentsize
);
3113 printf (_(" Number of program headers: %ld\n"),
3114 (long) elf_header
.e_phnum
);
3115 printf (_(" Size of section headers: %ld (bytes)\n"),
3116 (long) elf_header
.e_shentsize
);
3117 printf (_(" Number of section headers: %ld"),
3118 (long) elf_header
.e_shnum
);
3119 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3120 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3121 putc ('\n', stdout
);
3122 printf (_(" Section header string table index: %ld"),
3123 (long) elf_header
.e_shstrndx
);
3124 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3125 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3126 putc ('\n', stdout
);
3129 if (section_headers
!= NULL
)
3131 if (elf_header
.e_shnum
== 0)
3132 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3133 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3134 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3135 free (section_headers
);
3136 section_headers
= NULL
;
3144 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3146 Elf32_External_Phdr
*phdrs
;
3147 Elf32_External_Phdr
*external
;
3148 Elf_Internal_Phdr
*internal
;
3151 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3152 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3153 _("program headers"));
3157 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3158 i
< elf_header
.e_phnum
;
3159 i
++, internal
++, external
++)
3161 internal
->p_type
= BYTE_GET (external
->p_type
);
3162 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3163 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3164 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3165 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3166 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3167 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3168 internal
->p_align
= BYTE_GET (external
->p_align
);
3177 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3179 Elf64_External_Phdr
*phdrs
;
3180 Elf64_External_Phdr
*external
;
3181 Elf_Internal_Phdr
*internal
;
3184 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3185 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3186 _("program headers"));
3190 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3191 i
< elf_header
.e_phnum
;
3192 i
++, internal
++, external
++)
3194 internal
->p_type
= BYTE_GET (external
->p_type
);
3195 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3196 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3197 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3198 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3199 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3200 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3201 internal
->p_align
= BYTE_GET (external
->p_align
);
3209 /* Returns 1 if the program headers were read into `program_headers'. */
3212 get_program_headers (FILE *file
)
3214 Elf_Internal_Phdr
*phdrs
;
3216 /* Check cache of prior read. */
3217 if (program_headers
!= NULL
)
3220 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3224 error (_("Out of memory\n"));
3229 ? get_32bit_program_headers (file
, phdrs
)
3230 : get_64bit_program_headers (file
, phdrs
))
3232 program_headers
= phdrs
;
3240 /* Returns 1 if the program headers were loaded. */
3243 process_program_headers (FILE *file
)
3245 Elf_Internal_Phdr
*segment
;
3248 if (elf_header
.e_phnum
== 0)
3251 printf (_("\nThere are no program headers in this file.\n"));
3255 if (do_segments
&& !do_header
)
3257 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3258 printf (_("Entry point "));
3259 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3260 printf (_("\nThere are %d program headers, starting at offset "),
3261 elf_header
.e_phnum
);
3262 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3266 if (! get_program_headers (file
))
3271 if (elf_header
.e_phnum
> 1)
3272 printf (_("\nProgram Headers:\n"));
3274 printf (_("\nProgram Headers:\n"));
3278 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3281 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3285 (_(" Type Offset VirtAddr PhysAddr\n"));
3287 (_(" FileSiz MemSiz Flags Align\n"));
3294 for (i
= 0, segment
= program_headers
;
3295 i
< elf_header
.e_phnum
;
3300 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3304 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3305 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3306 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3307 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3308 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3310 (segment
->p_flags
& PF_R
? 'R' : ' '),
3311 (segment
->p_flags
& PF_W
? 'W' : ' '),
3312 (segment
->p_flags
& PF_X
? 'E' : ' '));
3313 printf ("%#lx", (unsigned long) segment
->p_align
);
3317 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3318 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3321 print_vma (segment
->p_offset
, FULL_HEX
);
3325 print_vma (segment
->p_vaddr
, FULL_HEX
);
3327 print_vma (segment
->p_paddr
, FULL_HEX
);
3330 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3331 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3334 print_vma (segment
->p_filesz
, FULL_HEX
);
3338 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3339 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3342 print_vma (segment
->p_offset
, FULL_HEX
);
3346 (segment
->p_flags
& PF_R
? 'R' : ' '),
3347 (segment
->p_flags
& PF_W
? 'W' : ' '),
3348 (segment
->p_flags
& PF_X
? 'E' : ' '));
3350 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3351 printf ("%#lx", (unsigned long) segment
->p_align
);
3354 print_vma (segment
->p_align
, PREFIX_HEX
);
3359 print_vma (segment
->p_offset
, FULL_HEX
);
3361 print_vma (segment
->p_vaddr
, FULL_HEX
);
3363 print_vma (segment
->p_paddr
, FULL_HEX
);
3365 print_vma (segment
->p_filesz
, FULL_HEX
);
3367 print_vma (segment
->p_memsz
, FULL_HEX
);
3369 (segment
->p_flags
& PF_R
? 'R' : ' '),
3370 (segment
->p_flags
& PF_W
? 'W' : ' '),
3371 (segment
->p_flags
& PF_X
? 'E' : ' '));
3372 print_vma (segment
->p_align
, HEX
);
3376 switch (segment
->p_type
)
3380 error (_("more than one dynamic segment\n"));
3382 /* Try to locate the .dynamic section. If there is
3383 a section header table, we can easily locate it. */
3384 if (section_headers
!= NULL
)
3386 Elf_Internal_Shdr
*sec
;
3388 sec
= find_section (".dynamic");
3389 if (sec
== NULL
|| sec
->sh_size
== 0)
3391 error (_("no .dynamic section in the dynamic segment"));
3395 dynamic_addr
= sec
->sh_offset
;
3396 dynamic_size
= sec
->sh_size
;
3398 if (dynamic_addr
< segment
->p_offset
3399 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3400 warn (_("the .dynamic section is not contained within the dynamic segment"));
3401 else if (dynamic_addr
> segment
->p_offset
)
3402 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3406 /* Otherwise, we can only assume that the .dynamic
3407 section is the first section in the DYNAMIC segment. */
3408 dynamic_addr
= segment
->p_offset
;
3409 dynamic_size
= segment
->p_filesz
;
3414 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3416 error (_("Unable to find program interpreter name\n"));
3419 program_interpreter
[0] = 0;
3420 fscanf (file
, "%63s", program_interpreter
);
3423 printf (_("\n [Requesting program interpreter: %s]"),
3424 program_interpreter
);
3430 putc ('\n', stdout
);
3433 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3435 printf (_("\n Section to Segment mapping:\n"));
3436 printf (_(" Segment Sections...\n"));
3438 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3441 Elf_Internal_Shdr
*section
;
3443 segment
= program_headers
+ i
;
3444 section
= section_headers
;
3446 printf (" %2.2d ", i
);
3448 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3450 if (section
->sh_size
> 0
3451 /* PT_TLS segment contains only SHF_TLS sections. */
3452 && (segment
->p_type
!= PT_TLS
3453 || (section
->sh_flags
& SHF_TLS
) != 0)
3454 /* Compare allocated sections by VMA, unallocated
3455 sections by file offset. */
3456 && (section
->sh_flags
& SHF_ALLOC
3457 ? (section
->sh_addr
>= segment
->p_vaddr
3458 && section
->sh_addr
+ section
->sh_size
3459 <= segment
->p_vaddr
+ segment
->p_memsz
)
3460 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3461 && (section
->sh_offset
+ section
->sh_size
3462 <= segment
->p_offset
+ segment
->p_filesz
)))
3463 /* .tbss is special. It doesn't contribute memory space
3464 to normal segments. */
3465 && (!((section
->sh_flags
& SHF_TLS
) != 0
3466 && section
->sh_type
== SHT_NOBITS
)
3467 || segment
->p_type
== PT_TLS
))
3468 printf ("%s ", SECTION_NAME (section
));
3479 /* Find the file offset corresponding to VMA by using the program headers. */
3482 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3484 Elf_Internal_Phdr
*seg
;
3486 if (! get_program_headers (file
))
3488 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3492 for (seg
= program_headers
;
3493 seg
< program_headers
+ elf_header
.e_phnum
;
3496 if (seg
->p_type
!= PT_LOAD
)
3499 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3500 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3501 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3504 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3511 get_32bit_section_headers (FILE *file
, unsigned int num
)
3513 Elf32_External_Shdr
*shdrs
;
3514 Elf_Internal_Shdr
*internal
;
3517 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3518 elf_header
.e_shentsize
, num
, _("section headers"));
3522 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3524 if (section_headers
== NULL
)
3526 error (_("Out of memory\n"));
3530 for (i
= 0, internal
= section_headers
;
3534 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3535 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3536 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3537 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3538 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3539 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3540 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3541 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3542 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3543 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3552 get_64bit_section_headers (FILE *file
, unsigned int num
)
3554 Elf64_External_Shdr
*shdrs
;
3555 Elf_Internal_Shdr
*internal
;
3558 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3559 elf_header
.e_shentsize
, num
, _("section headers"));
3563 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3565 if (section_headers
== NULL
)
3567 error (_("Out of memory\n"));
3571 for (i
= 0, internal
= section_headers
;
3575 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3576 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3577 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3578 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3579 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3580 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3581 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3582 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3583 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3584 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3592 static Elf_Internal_Sym
*
3593 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3595 unsigned long number
;
3596 Elf32_External_Sym
*esyms
;
3597 Elf_External_Sym_Shndx
*shndx
;
3598 Elf_Internal_Sym
*isyms
;
3599 Elf_Internal_Sym
*psym
;
3602 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3608 if (symtab_shndx_hdr
!= NULL
3609 && (symtab_shndx_hdr
->sh_link
3610 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3612 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3613 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3621 number
= section
->sh_size
/ section
->sh_entsize
;
3622 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3626 error (_("Out of memory\n"));
3633 for (j
= 0, psym
= isyms
;
3637 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3638 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3639 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3640 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3641 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3643 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3644 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3645 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3655 static Elf_Internal_Sym
*
3656 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3658 unsigned long number
;
3659 Elf64_External_Sym
*esyms
;
3660 Elf_External_Sym_Shndx
*shndx
;
3661 Elf_Internal_Sym
*isyms
;
3662 Elf_Internal_Sym
*psym
;
3665 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3671 if (symtab_shndx_hdr
!= NULL
3672 && (symtab_shndx_hdr
->sh_link
3673 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3675 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3676 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3684 number
= section
->sh_size
/ section
->sh_entsize
;
3685 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3689 error (_("Out of memory\n"));
3696 for (j
= 0, psym
= isyms
;
3700 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3701 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3702 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3703 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3704 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3706 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3707 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3708 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3719 get_elf_section_flags (bfd_vma sh_flags
)
3721 static char buff
[1024];
3723 int field_size
= is_32bit_elf
? 8 : 16;
3724 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3725 bfd_vma os_flags
= 0;
3726 bfd_vma proc_flags
= 0;
3727 bfd_vma unknown_flags
= 0;
3741 { "LINK ORDER", 10 },
3742 { "OS NONCONF", 10 },
3747 if (do_section_details
)
3749 sprintf (buff
, "[%*.*lx]: ",
3750 field_size
, field_size
, (unsigned long) sh_flags
);
3751 p
+= field_size
+ 4;
3758 flag
= sh_flags
& - sh_flags
;
3761 if (do_section_details
)
3765 case SHF_WRITE
: index
= 0; break;
3766 case SHF_ALLOC
: index
= 1; break;
3767 case SHF_EXECINSTR
: index
= 2; break;
3768 case SHF_MERGE
: index
= 3; break;
3769 case SHF_STRINGS
: index
= 4; break;
3770 case SHF_INFO_LINK
: index
= 5; break;
3771 case SHF_LINK_ORDER
: index
= 6; break;
3772 case SHF_OS_NONCONFORMING
: index
= 7; break;
3773 case SHF_GROUP
: index
= 8; break;
3774 case SHF_TLS
: index
= 9; break;
3783 if (p
!= buff
+ field_size
+ 4)
3785 if (size
< (10 + 2))
3792 size
-= flags
[index
].len
;
3793 p
= stpcpy (p
, flags
[index
].str
);
3795 else if (flag
& SHF_MASKOS
)
3797 else if (flag
& SHF_MASKPROC
)
3800 unknown_flags
|= flag
;
3806 case SHF_WRITE
: *p
= 'W'; break;
3807 case SHF_ALLOC
: *p
= 'A'; break;
3808 case SHF_EXECINSTR
: *p
= 'X'; break;
3809 case SHF_MERGE
: *p
= 'M'; break;
3810 case SHF_STRINGS
: *p
= 'S'; break;
3811 case SHF_INFO_LINK
: *p
= 'I'; break;
3812 case SHF_LINK_ORDER
: *p
= 'L'; break;
3813 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3814 case SHF_GROUP
: *p
= 'G'; break;
3815 case SHF_TLS
: *p
= 'T'; break;
3818 if (elf_header
.e_machine
== EM_X86_64
3819 && flag
== SHF_X86_64_LARGE
)
3821 else if (flag
& SHF_MASKOS
)
3824 sh_flags
&= ~ SHF_MASKOS
;
3826 else if (flag
& SHF_MASKPROC
)
3829 sh_flags
&= ~ SHF_MASKPROC
;
3839 if (do_section_details
)
3843 size
-= 5 + field_size
;
3844 if (p
!= buff
+ field_size
+ 4)
3852 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3853 (unsigned long) os_flags
);
3854 p
+= 5 + field_size
;
3858 size
-= 7 + field_size
;
3859 if (p
!= buff
+ field_size
+ 4)
3867 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3868 (unsigned long) proc_flags
);
3869 p
+= 7 + field_size
;
3873 size
-= 10 + field_size
;
3874 if (p
!= buff
+ field_size
+ 4)
3882 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3883 (unsigned long) unknown_flags
);
3884 p
+= 10 + field_size
;
3893 process_section_headers (FILE *file
)
3895 Elf_Internal_Shdr
*section
;
3898 section_headers
= NULL
;
3900 if (elf_header
.e_shnum
== 0)
3903 printf (_("\nThere are no sections in this file.\n"));
3908 if (do_sections
&& !do_header
)
3909 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3910 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3914 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3917 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3920 /* Read in the string table, so that we have names to display. */
3921 if (SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3923 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3925 if (section
->sh_size
!= 0)
3927 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3928 1, section
->sh_size
, _("string table"));
3930 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
3934 /* Scan the sections for the dynamic symbol table
3935 and dynamic string table and debug sections. */
3936 dynamic_symbols
= NULL
;
3937 dynamic_strings
= NULL
;
3938 dynamic_syminfo
= NULL
;
3939 symtab_shndx_hdr
= NULL
;
3941 eh_addr_size
= is_32bit_elf
? 4 : 8;
3942 switch (elf_header
.e_machine
)
3945 case EM_MIPS_RS3_LE
:
3946 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3947 FDE addresses. However, the ABI also has a semi-official ILP32
3948 variant for which the normal FDE address size rules apply.
3950 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3951 section, where XX is the size of longs in bits. Unfortunately,
3952 earlier compilers provided no way of distinguishing ILP32 objects
3953 from LP64 objects, so if there's any doubt, we should assume that
3954 the official LP64 form is being used. */
3955 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3956 && find_section (".gcc_compiled_long32") == NULL
)
3961 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3964 size_t expected_entsize \
3965 = is_32bit_elf ? size32 : size64; \
3966 if (section->sh_entsize != expected_entsize) \
3967 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
3968 i, (unsigned long int) section->sh_entsize, \
3969 (unsigned long int) expected_entsize); \
3970 section->sh_entsize = expected_entsize; \
3973 #define CHECK_ENTSIZE(section, i, type) \
3974 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
3975 sizeof (Elf64_External_##type))
3977 for (i
= 0, section
= section_headers
;
3978 i
< elf_header
.e_shnum
;
3981 char *name
= SECTION_NAME (section
);
3983 if (section
->sh_type
== SHT_DYNSYM
)
3985 if (dynamic_symbols
!= NULL
)
3987 error (_("File contains multiple dynamic symbol tables\n"));
3991 CHECK_ENTSIZE (section
, i
, Sym
);
3992 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3993 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3995 else if (section
->sh_type
== SHT_STRTAB
3996 && streq (name
, ".dynstr"))
3998 if (dynamic_strings
!= NULL
)
4000 error (_("File contains multiple dynamic string tables\n"));
4004 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4005 1, section
->sh_size
, _("dynamic strings"));
4006 dynamic_strings_length
= section
->sh_size
;
4008 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4010 if (symtab_shndx_hdr
!= NULL
)
4012 error (_("File contains multiple symtab shndx tables\n"));
4015 symtab_shndx_hdr
= section
;
4017 else if (section
->sh_type
== SHT_SYMTAB
)
4018 CHECK_ENTSIZE (section
, i
, Sym
);
4019 else if (section
->sh_type
== SHT_GROUP
)
4020 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4021 else if (section
->sh_type
== SHT_REL
)
4022 CHECK_ENTSIZE (section
, i
, Rel
);
4023 else if (section
->sh_type
== SHT_RELA
)
4024 CHECK_ENTSIZE (section
, i
, Rela
);
4025 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4026 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4027 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4028 || do_debug_loc
|| do_debug_ranges
)
4029 && strneq (name
, ".debug_", 7))
4034 || (do_debug_info
&& streq (name
, "info"))
4035 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4036 || (do_debug_lines
&& streq (name
, "line"))
4037 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4038 || (do_debug_aranges
&& streq (name
, "aranges"))
4039 || (do_debug_ranges
&& streq (name
, "ranges"))
4040 || (do_debug_frames
&& streq (name
, "frame"))
4041 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4042 || (do_debug_str
&& streq (name
, "str"))
4043 || (do_debug_loc
&& streq (name
, "loc"))
4045 request_dump (i
, DEBUG_DUMP
);
4047 /* linkonce section to be combined with .debug_info at link time. */
4048 else if ((do_debugging
|| do_debug_info
)
4049 && strneq (name
, ".gnu.linkonce.wi.", 17))
4050 request_dump (i
, DEBUG_DUMP
);
4051 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4052 request_dump (i
, DEBUG_DUMP
);
4058 if (elf_header
.e_shnum
> 1)
4059 printf (_("\nSection Headers:\n"));
4061 printf (_("\nSection Header:\n"));
4065 if (do_section_details
)
4067 printf (_(" [Nr] Name\n"));
4068 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4072 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4076 if (do_section_details
)
4078 printf (_(" [Nr] Name\n"));
4079 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4083 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4087 if (do_section_details
)
4089 printf (_(" [Nr] Name\n"));
4090 printf (_(" Type Address Offset Link\n"));
4091 printf (_(" Size EntSize Info Align\n"));
4095 printf (_(" [Nr] Name Type Address Offset\n"));
4096 printf (_(" Size EntSize Flags Link Info Align\n"));
4100 if (do_section_details
)
4101 printf (_(" Flags\n"));
4103 for (i
= 0, section
= section_headers
;
4104 i
< elf_header
.e_shnum
;
4107 if (do_section_details
)
4109 printf (" [%2u] %s\n",
4110 SECTION_HEADER_NUM (i
),
4111 SECTION_NAME (section
));
4112 if (is_32bit_elf
|| do_wide
)
4113 printf (" %-15.15s ",
4114 get_section_type_name (section
->sh_type
));
4117 printf (" [%2u] %-17.17s %-15.15s ",
4118 SECTION_HEADER_NUM (i
),
4119 SECTION_NAME (section
),
4120 get_section_type_name (section
->sh_type
));
4124 print_vma (section
->sh_addr
, LONG_HEX
);
4126 printf ( " %6.6lx %6.6lx %2.2lx",
4127 (unsigned long) section
->sh_offset
,
4128 (unsigned long) section
->sh_size
,
4129 (unsigned long) section
->sh_entsize
);
4131 if (do_section_details
)
4132 fputs (" ", stdout
);
4134 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4136 printf ("%2ld %3lu %2ld\n",
4137 (unsigned long) section
->sh_link
,
4138 (unsigned long) section
->sh_info
,
4139 (unsigned long) section
->sh_addralign
);
4143 print_vma (section
->sh_addr
, LONG_HEX
);
4145 if ((long) section
->sh_offset
== section
->sh_offset
)
4146 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4150 print_vma (section
->sh_offset
, LONG_HEX
);
4153 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4154 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4158 print_vma (section
->sh_size
, LONG_HEX
);
4161 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4162 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4166 print_vma (section
->sh_entsize
, LONG_HEX
);
4169 if (do_section_details
)
4170 fputs (" ", stdout
);
4172 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4174 printf ("%2ld %3lu ",
4175 (unsigned long) section
->sh_link
,
4176 (unsigned long) section
->sh_info
);
4178 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4179 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4182 print_vma (section
->sh_addralign
, DEC
);
4186 else if (do_section_details
)
4188 printf (" %-15.15s ",
4189 get_section_type_name (section
->sh_type
));
4190 print_vma (section
->sh_addr
, LONG_HEX
);
4191 if ((long) section
->sh_offset
== section
->sh_offset
)
4192 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4196 print_vma (section
->sh_offset
, LONG_HEX
);
4198 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4199 print_vma (section
->sh_size
, LONG_HEX
);
4201 print_vma (section
->sh_entsize
, LONG_HEX
);
4203 printf (" %-16lu %ld\n",
4204 (unsigned long) section
->sh_info
,
4205 (unsigned long) section
->sh_addralign
);
4210 print_vma (section
->sh_addr
, LONG_HEX
);
4211 if ((long) section
->sh_offset
== section
->sh_offset
)
4212 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4216 print_vma (section
->sh_offset
, LONG_HEX
);
4219 print_vma (section
->sh_size
, LONG_HEX
);
4221 print_vma (section
->sh_entsize
, LONG_HEX
);
4223 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4225 printf (" %2ld %3lu %ld\n",
4226 (unsigned long) section
->sh_link
,
4227 (unsigned long) section
->sh_info
,
4228 (unsigned long) section
->sh_addralign
);
4231 if (do_section_details
)
4232 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4235 if (!do_section_details
)
4236 printf (_("Key to Flags:\n\
4237 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4238 I (info), L (link order), G (group), x (unknown)\n\
4239 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4245 get_group_flags (unsigned int flags
)
4247 static char buff
[32];
4254 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4261 process_section_groups (FILE *file
)
4263 Elf_Internal_Shdr
*section
;
4265 struct group
*group
;
4266 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4267 Elf_Internal_Sym
*symtab
;
4271 /* Don't process section groups unless needed. */
4272 if (!do_unwind
&& !do_section_groups
)
4275 if (elf_header
.e_shnum
== 0)
4277 if (do_section_groups
)
4278 printf (_("\nThere are no sections in this file.\n"));
4283 if (section_headers
== NULL
)
4285 error (_("Section headers are not available!\n"));
4289 section_headers_groups
= calloc (elf_header
.e_shnum
,
4290 sizeof (struct group
*));
4292 if (section_headers_groups
== NULL
)
4294 error (_("Out of memory\n"));
4298 /* Scan the sections for the group section. */
4300 for (i
= 0, section
= section_headers
;
4301 i
< elf_header
.e_shnum
;
4303 if (section
->sh_type
== SHT_GROUP
)
4306 if (group_count
== 0)
4308 if (do_section_groups
)
4309 printf (_("\nThere are no section groups in this file.\n"));
4314 section_groups
= calloc (group_count
, sizeof (struct group
));
4316 if (section_groups
== NULL
)
4318 error (_("Out of memory\n"));
4327 for (i
= 0, section
= section_headers
, group
= section_groups
;
4328 i
< elf_header
.e_shnum
;
4331 if (section
->sh_type
== SHT_GROUP
)
4333 char *name
= SECTION_NAME (section
);
4335 unsigned char *start
, *indices
;
4336 unsigned int entry
, j
, size
;
4337 Elf_Internal_Shdr
*sec
;
4338 Elf_Internal_Sym
*sym
;
4340 /* Get the symbol table. */
4341 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4342 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4345 error (_("Bad sh_link in group section `%s'\n"), name
);
4349 if (symtab_sec
!= sec
)
4354 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4357 sym
= symtab
+ section
->sh_info
;
4359 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4361 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4364 error (_("Bad sh_info in group section `%s'\n"), name
);
4368 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4377 /* Get the string table. */
4378 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4379 >= elf_header
.e_shnum
)
4388 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4393 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4394 1, strtab_sec
->sh_size
,
4396 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4398 group_name
= sym
->st_name
< strtab_size
4399 ? strtab
+ sym
->st_name
: "<corrupt>";
4402 start
= get_data (NULL
, file
, section
->sh_offset
,
4403 1, section
->sh_size
, _("section data"));
4406 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4407 entry
= byte_get (indices
, 4);
4410 if (do_section_groups
)
4412 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4413 get_group_flags (entry
), i
, name
, group_name
, size
);
4415 printf (_(" [Index] Name\n"));
4418 group
->group_index
= i
;
4420 for (j
= 0; j
< size
; j
++)
4422 struct group_list
*g
;
4424 entry
= byte_get (indices
, 4);
4427 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4429 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4430 entry
, i
, elf_header
.e_shnum
- 1);
4433 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4435 error (_("invalid section [%5u] in group section [%5u]\n"),
4440 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4445 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4447 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4452 /* Intel C/C++ compiler may put section 0 in a
4453 section group. We just warn it the first time
4454 and ignore it afterwards. */
4455 static int warned
= 0;
4458 error (_("section 0 in group section [%5u]\n"),
4459 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4465 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4468 if (do_section_groups
)
4470 sec
= SECTION_HEADER (entry
);
4471 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4474 g
= xmalloc (sizeof (struct group_list
));
4475 g
->section_index
= entry
;
4476 g
->next
= group
->root
;
4500 } dynamic_relocations
[] =
4502 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4503 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4504 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4507 /* Process the reloc section. */
4510 process_relocs (FILE *file
)
4512 unsigned long rel_size
;
4513 unsigned long rel_offset
;
4519 if (do_using_dynamic
)
4523 int has_dynamic_reloc
;
4526 has_dynamic_reloc
= 0;
4528 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4530 is_rela
= dynamic_relocations
[i
].rela
;
4531 name
= dynamic_relocations
[i
].name
;
4532 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4533 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4535 has_dynamic_reloc
|= rel_size
;
4537 if (is_rela
== UNKNOWN
)
4539 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4540 switch (dynamic_info
[DT_PLTREL
])
4554 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4555 name
, rel_offset
, rel_size
);
4557 dump_relocations (file
,
4558 offset_from_vma (file
, rel_offset
, rel_size
),
4560 dynamic_symbols
, num_dynamic_syms
,
4561 dynamic_strings
, dynamic_strings_length
, is_rela
);
4565 if (! has_dynamic_reloc
)
4566 printf (_("\nThere are no dynamic relocations in this file.\n"));
4570 Elf_Internal_Shdr
*section
;
4574 for (i
= 0, section
= section_headers
;
4575 i
< elf_header
.e_shnum
;
4578 if ( section
->sh_type
!= SHT_RELA
4579 && section
->sh_type
!= SHT_REL
)
4582 rel_offset
= section
->sh_offset
;
4583 rel_size
= section
->sh_size
;
4587 Elf_Internal_Shdr
*strsec
;
4590 printf (_("\nRelocation section "));
4592 if (string_table
== NULL
)
4593 printf ("%d", section
->sh_name
);
4595 printf (_("'%s'"), SECTION_NAME (section
));
4597 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4598 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4600 is_rela
= section
->sh_type
== SHT_RELA
;
4602 if (section
->sh_link
4603 && SECTION_HEADER_INDEX (section
->sh_link
)
4604 < elf_header
.e_shnum
)
4606 Elf_Internal_Shdr
*symsec
;
4607 Elf_Internal_Sym
*symtab
;
4608 unsigned long nsyms
;
4609 unsigned long strtablen
= 0;
4610 char *strtab
= NULL
;
4612 symsec
= SECTION_HEADER (section
->sh_link
);
4613 if (symsec
->sh_type
!= SHT_SYMTAB
4614 && symsec
->sh_type
!= SHT_DYNSYM
)
4617 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4618 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4623 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4624 < elf_header
.e_shnum
)
4626 strsec
= SECTION_HEADER (symsec
->sh_link
);
4628 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4631 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4634 dump_relocations (file
, rel_offset
, rel_size
,
4635 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4641 dump_relocations (file
, rel_offset
, rel_size
,
4642 NULL
, 0, NULL
, 0, is_rela
);
4649 printf (_("\nThere are no relocations in this file.\n"));
4655 /* Process the unwind section. */
4657 #include "unwind-ia64.h"
4659 /* An absolute address consists of a section and an offset. If the
4660 section is NULL, the offset itself is the address, otherwise, the
4661 address equals to LOAD_ADDRESS(section) + offset. */
4665 unsigned short section
;
4669 #define ABSADDR(a) \
4671 ? section_headers [(a).section].sh_addr + (a).offset \
4674 struct ia64_unw_aux_info
4676 struct ia64_unw_table_entry
4678 struct absaddr start
;
4680 struct absaddr info
;
4682 *table
; /* Unwind table. */
4683 unsigned long table_len
; /* Length of unwind table. */
4684 unsigned char *info
; /* Unwind info. */
4685 unsigned long info_size
; /* Size of unwind info. */
4686 bfd_vma info_addr
; /* starting address of unwind info. */
4687 bfd_vma seg_base
; /* Starting address of segment. */
4688 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4689 unsigned long nsyms
; /* Number of symbols. */
4690 char *strtab
; /* The string table. */
4691 unsigned long strtab_size
; /* Size of string table. */
4695 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4696 unsigned long nsyms
,
4698 unsigned long strtab_size
,
4699 struct absaddr addr
,
4700 const char **symname
,
4703 bfd_vma dist
= 0x100000;
4704 Elf_Internal_Sym
*sym
, *best
= NULL
;
4707 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4709 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4710 && sym
->st_name
!= 0
4711 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4712 && addr
.offset
>= sym
->st_value
4713 && addr
.offset
- sym
->st_value
< dist
)
4716 dist
= addr
.offset
- sym
->st_value
;
4723 *symname
= (best
->st_name
>= strtab_size
4724 ? "<corrupt>" : strtab
+ best
->st_name
);
4729 *offset
= addr
.offset
;
4733 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4735 struct ia64_unw_table_entry
*tp
;
4738 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4742 const unsigned char *dp
;
4743 const unsigned char *head
;
4744 const char *procname
;
4746 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4747 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4749 fputs ("\n<", stdout
);
4753 fputs (procname
, stdout
);
4756 printf ("+%lx", (unsigned long) offset
);
4759 fputs (">: [", stdout
);
4760 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4761 fputc ('-', stdout
);
4762 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4763 printf ("], info at +0x%lx\n",
4764 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4766 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4767 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4769 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4770 (unsigned) UNW_VER (stamp
),
4771 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4772 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4773 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4774 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4776 if (UNW_VER (stamp
) != 1)
4778 printf ("\tUnknown version.\n");
4783 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4784 dp
= unw_decode (dp
, in_body
, & in_body
);
4789 slurp_ia64_unwind_table (FILE *file
,
4790 struct ia64_unw_aux_info
*aux
,
4791 Elf_Internal_Shdr
*sec
)
4793 unsigned long size
, nrelas
, i
;
4794 Elf_Internal_Phdr
*seg
;
4795 struct ia64_unw_table_entry
*tep
;
4796 Elf_Internal_Shdr
*relsec
;
4797 Elf_Internal_Rela
*rela
, *rp
;
4798 unsigned char *table
, *tp
;
4799 Elf_Internal_Sym
*sym
;
4800 const char *relname
;
4802 /* First, find the starting address of the segment that includes
4805 if (elf_header
.e_phnum
)
4807 if (! get_program_headers (file
))
4810 for (seg
= program_headers
;
4811 seg
< program_headers
+ elf_header
.e_phnum
;
4814 if (seg
->p_type
!= PT_LOAD
)
4817 if (sec
->sh_addr
>= seg
->p_vaddr
4818 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4820 aux
->seg_base
= seg
->p_vaddr
;
4826 /* Second, build the unwind table from the contents of the unwind section: */
4827 size
= sec
->sh_size
;
4828 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4832 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4834 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4836 tep
->start
.section
= SHN_UNDEF
;
4837 tep
->end
.section
= SHN_UNDEF
;
4838 tep
->info
.section
= SHN_UNDEF
;
4841 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4842 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4843 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4847 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4848 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4849 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4851 tep
->start
.offset
+= aux
->seg_base
;
4852 tep
->end
.offset
+= aux
->seg_base
;
4853 tep
->info
.offset
+= aux
->seg_base
;
4857 /* Third, apply any relocations to the unwind table: */
4859 for (relsec
= section_headers
;
4860 relsec
< section_headers
+ elf_header
.e_shnum
;
4863 if (relsec
->sh_type
!= SHT_RELA
4864 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4865 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4868 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4872 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4876 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4877 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4881 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4882 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4885 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4887 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4891 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4893 switch (rp
->r_offset
/eh_addr_size
% 3)
4896 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4897 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4900 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4901 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4904 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4905 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4915 aux
->table_len
= size
/ (3 * eh_addr_size
);
4920 ia64_process_unwind (FILE *file
)
4922 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4923 unsigned long i
, unwcount
= 0, unwstart
= 0;
4924 struct ia64_unw_aux_info aux
;
4926 memset (& aux
, 0, sizeof (aux
));
4928 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4930 if (sec
->sh_type
== SHT_SYMTAB
4931 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
4933 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4934 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4936 strsec
= SECTION_HEADER (sec
->sh_link
);
4937 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4938 1, strsec
->sh_size
, _("string table"));
4939 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
4941 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4946 printf (_("\nThere are no unwind sections in this file.\n"));
4948 while (unwcount
-- > 0)
4953 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4954 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4955 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4962 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4964 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4966 /* We need to find which section group it is in. */
4967 struct group_list
*g
= section_headers_groups
[i
]->root
;
4969 for (; g
!= NULL
; g
= g
->next
)
4971 sec
= SECTION_HEADER (g
->section_index
);
4973 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4978 i
= elf_header
.e_shnum
;
4980 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4982 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4983 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4984 suffix
= SECTION_NAME (unwsec
) + len
;
4985 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4987 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4988 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4993 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4994 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4995 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4996 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4998 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4999 suffix
= SECTION_NAME (unwsec
) + len
;
5000 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5002 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5003 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5007 if (i
== elf_header
.e_shnum
)
5009 printf (_("\nCould not find unwind info section for "));
5011 if (string_table
== NULL
)
5012 printf ("%d", unwsec
->sh_name
);
5014 printf (_("'%s'"), SECTION_NAME (unwsec
));
5018 aux
.info_size
= sec
->sh_size
;
5019 aux
.info_addr
= sec
->sh_addr
;
5020 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5023 printf (_("\nUnwind section "));
5025 if (string_table
== NULL
)
5026 printf ("%d", unwsec
->sh_name
);
5028 printf (_("'%s'"), SECTION_NAME (unwsec
));
5030 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5031 (unsigned long) unwsec
->sh_offset
,
5032 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5034 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5036 if (aux
.table_len
> 0)
5037 dump_ia64_unwind (& aux
);
5040 free ((char *) aux
.table
);
5042 free ((char *) aux
.info
);
5051 free ((char *) aux
.strtab
);
5056 struct hppa_unw_aux_info
5058 struct hppa_unw_table_entry
5060 struct absaddr start
;
5062 unsigned int Cannot_unwind
:1; /* 0 */
5063 unsigned int Millicode
:1; /* 1 */
5064 unsigned int Millicode_save_sr0
:1; /* 2 */
5065 unsigned int Region_description
:2; /* 3..4 */
5066 unsigned int reserved1
:1; /* 5 */
5067 unsigned int Entry_SR
:1; /* 6 */
5068 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5069 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5070 unsigned int Args_stored
:1; /* 16 */
5071 unsigned int Variable_Frame
:1; /* 17 */
5072 unsigned int Separate_Package_Body
:1; /* 18 */
5073 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5074 unsigned int Stack_Overflow_Check
:1; /* 20 */
5075 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5076 unsigned int Ada_Region
:1; /* 22 */
5077 unsigned int cxx_info
:1; /* 23 */
5078 unsigned int cxx_try_catch
:1; /* 24 */
5079 unsigned int sched_entry_seq
:1; /* 25 */
5080 unsigned int reserved2
:1; /* 26 */
5081 unsigned int Save_SP
:1; /* 27 */
5082 unsigned int Save_RP
:1; /* 28 */
5083 unsigned int Save_MRP_in_frame
:1; /* 29 */
5084 unsigned int extn_ptr_defined
:1; /* 30 */
5085 unsigned int Cleanup_defined
:1; /* 31 */
5087 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5088 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5089 unsigned int Large_frame
:1; /* 2 */
5090 unsigned int Pseudo_SP_Set
:1; /* 3 */
5091 unsigned int reserved4
:1; /* 4 */
5092 unsigned int Total_frame_size
:27; /* 5..31 */
5094 *table
; /* Unwind table. */
5095 unsigned long table_len
; /* Length of unwind table. */
5096 bfd_vma seg_base
; /* Starting address of segment. */
5097 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5098 unsigned long nsyms
; /* Number of symbols. */
5099 char *strtab
; /* The string table. */
5100 unsigned long strtab_size
; /* Size of string table. */
5104 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5106 struct hppa_unw_table_entry
*tp
;
5108 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5111 const char *procname
;
5113 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5114 aux
->strtab_size
, tp
->start
, &procname
,
5117 fputs ("\n<", stdout
);
5121 fputs (procname
, stdout
);
5124 printf ("+%lx", (unsigned long) offset
);
5127 fputs (">: [", stdout
);
5128 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5129 fputc ('-', stdout
);
5130 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5133 #define PF(_m) if (tp->_m) printf (#_m " ");
5134 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5137 PF(Millicode_save_sr0
);
5138 /* PV(Region_description); */
5144 PF(Separate_Package_Body
);
5145 PF(Frame_Extension_Millicode
);
5146 PF(Stack_Overflow_Check
);
5147 PF(Two_Instruction_SP_Increment
);
5151 PF(sched_entry_seq
);
5154 PF(Save_MRP_in_frame
);
5155 PF(extn_ptr_defined
);
5156 PF(Cleanup_defined
);
5157 PF(MPE_XL_interrupt_marker
);
5158 PF(HP_UX_interrupt_marker
);
5161 PV(Total_frame_size
);
5170 slurp_hppa_unwind_table (FILE *file
,
5171 struct hppa_unw_aux_info
*aux
,
5172 Elf_Internal_Shdr
*sec
)
5174 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5175 Elf_Internal_Phdr
*seg
;
5176 struct hppa_unw_table_entry
*tep
;
5177 Elf_Internal_Shdr
*relsec
;
5178 Elf_Internal_Rela
*rela
, *rp
;
5179 unsigned char *table
, *tp
;
5180 Elf_Internal_Sym
*sym
;
5181 const char *relname
;
5183 /* First, find the starting address of the segment that includes
5186 if (elf_header
.e_phnum
)
5188 if (! get_program_headers (file
))
5191 for (seg
= program_headers
;
5192 seg
< program_headers
+ elf_header
.e_phnum
;
5195 if (seg
->p_type
!= PT_LOAD
)
5198 if (sec
->sh_addr
>= seg
->p_vaddr
5199 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5201 aux
->seg_base
= seg
->p_vaddr
;
5207 /* Second, build the unwind table from the contents of the unwind
5209 size
= sec
->sh_size
;
5210 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5215 nentries
= size
/ unw_ent_size
;
5216 size
= unw_ent_size
* nentries
;
5218 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5220 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5222 unsigned int tmp1
, tmp2
;
5224 tep
->start
.section
= SHN_UNDEF
;
5225 tep
->end
.section
= SHN_UNDEF
;
5227 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5228 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5229 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5230 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5232 tep
->start
.offset
+= aux
->seg_base
;
5233 tep
->end
.offset
+= aux
->seg_base
;
5235 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5236 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5237 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5238 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5239 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5240 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5241 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5242 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5243 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5244 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5245 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5246 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5247 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5248 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5249 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5250 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5251 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5252 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5253 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5254 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5255 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5256 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5257 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5258 tep
->Cleanup_defined
= tmp1
& 0x1;
5260 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5261 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5262 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5263 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5264 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5265 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5269 /* Third, apply any relocations to the unwind table. */
5271 for (relsec
= section_headers
;
5272 relsec
< section_headers
+ elf_header
.e_shnum
;
5275 if (relsec
->sh_type
!= SHT_RELA
5276 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5277 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5280 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5284 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5288 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5289 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5293 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5294 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5297 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5298 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5300 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5304 i
= rp
->r_offset
/ unw_ent_size
;
5306 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5309 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5310 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5313 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5314 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5324 aux
->table_len
= nentries
;
5330 hppa_process_unwind (FILE *file
)
5332 struct hppa_unw_aux_info aux
;
5333 Elf_Internal_Shdr
*unwsec
= NULL
;
5334 Elf_Internal_Shdr
*strsec
;
5335 Elf_Internal_Shdr
*sec
;
5338 memset (& aux
, 0, sizeof (aux
));
5340 if (string_table
== NULL
)
5343 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5345 if (sec
->sh_type
== SHT_SYMTAB
5346 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5348 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5349 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5351 strsec
= SECTION_HEADER (sec
->sh_link
);
5352 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5353 1, strsec
->sh_size
, _("string table"));
5354 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5356 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5361 printf (_("\nThere are no unwind sections in this file.\n"));
5363 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5365 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5367 printf (_("\nUnwind section "));
5368 printf (_("'%s'"), SECTION_NAME (sec
));
5370 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5371 (unsigned long) sec
->sh_offset
,
5372 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5374 slurp_hppa_unwind_table (file
, &aux
, sec
);
5375 if (aux
.table_len
> 0)
5376 dump_hppa_unwind (&aux
);
5379 free ((char *) aux
.table
);
5387 free ((char *) aux
.strtab
);
5393 process_unwind (FILE *file
)
5395 struct unwind_handler
{
5397 int (*handler
)(FILE *file
);
5399 { EM_IA_64
, ia64_process_unwind
},
5400 { EM_PARISC
, hppa_process_unwind
},
5408 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5409 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5410 return handlers
[i
].handler (file
);
5412 printf (_("\nThere are no unwind sections in this file.\n"));
5417 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5419 switch (entry
->d_tag
)
5422 if (entry
->d_un
.d_val
== 0)
5426 static const char * opts
[] =
5428 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5429 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5430 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5431 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5436 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5437 if (entry
->d_un
.d_val
& (1 << cnt
))
5439 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5446 case DT_MIPS_IVERSION
:
5447 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5448 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5450 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5453 case DT_MIPS_TIME_STAMP
:
5458 time_t time
= entry
->d_un
.d_val
;
5459 tmp
= gmtime (&time
);
5460 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5461 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5462 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5463 printf ("Time Stamp: %s\n", timebuf
);
5467 case DT_MIPS_RLD_VERSION
:
5468 case DT_MIPS_LOCAL_GOTNO
:
5469 case DT_MIPS_CONFLICTNO
:
5470 case DT_MIPS_LIBLISTNO
:
5471 case DT_MIPS_SYMTABNO
:
5472 case DT_MIPS_UNREFEXTNO
:
5473 case DT_MIPS_HIPAGENO
:
5474 case DT_MIPS_DELTA_CLASS_NO
:
5475 case DT_MIPS_DELTA_INSTANCE_NO
:
5476 case DT_MIPS_DELTA_RELOC_NO
:
5477 case DT_MIPS_DELTA_SYM_NO
:
5478 case DT_MIPS_DELTA_CLASSSYM_NO
:
5479 case DT_MIPS_COMPACT_SIZE
:
5480 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5484 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5490 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5492 switch (entry
->d_tag
)
5494 case DT_HP_DLD_FLAGS
:
5503 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5504 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5505 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5506 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5507 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5508 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5509 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5510 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5511 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5512 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5513 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5514 { DT_HP_GST
, "HP_GST" },
5515 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5516 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5517 { DT_HP_NODELETE
, "HP_NODELETE" },
5518 { DT_HP_GROUP
, "HP_GROUP" },
5519 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5523 bfd_vma val
= entry
->d_un
.d_val
;
5525 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5526 if (val
& flags
[cnt
].bit
)
5530 fputs (flags
[cnt
].str
, stdout
);
5532 val
^= flags
[cnt
].bit
;
5535 if (val
!= 0 || first
)
5539 print_vma (val
, HEX
);
5545 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5552 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5554 switch (entry
->d_tag
)
5556 case DT_IA_64_PLT_RESERVE
:
5557 /* First 3 slots reserved. */
5558 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5560 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5564 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5571 get_32bit_dynamic_section (FILE *file
)
5573 Elf32_External_Dyn
*edyn
, *ext
;
5574 Elf_Internal_Dyn
*entry
;
5576 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5577 _("dynamic section"));
5581 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5582 might not have the luxury of section headers. Look for the DT_NULL
5583 terminator to determine the number of entries. */
5584 for (ext
= edyn
, dynamic_nent
= 0;
5585 (char *) ext
< (char *) edyn
+ dynamic_size
;
5589 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5593 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5594 if (dynamic_section
== NULL
)
5596 error (_("Out of memory\n"));
5601 for (ext
= edyn
, entry
= dynamic_section
;
5602 entry
< dynamic_section
+ dynamic_nent
;
5605 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5606 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5615 get_64bit_dynamic_section (FILE *file
)
5617 Elf64_External_Dyn
*edyn
, *ext
;
5618 Elf_Internal_Dyn
*entry
;
5620 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5621 _("dynamic section"));
5625 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5626 might not have the luxury of section headers. Look for the DT_NULL
5627 terminator to determine the number of entries. */
5628 for (ext
= edyn
, dynamic_nent
= 0;
5629 (char *) ext
< (char *) edyn
+ dynamic_size
;
5633 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5637 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5638 if (dynamic_section
== NULL
)
5640 error (_("Out of memory\n"));
5645 for (ext
= edyn
, entry
= dynamic_section
;
5646 entry
< dynamic_section
+ dynamic_nent
;
5649 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5650 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5659 print_dynamic_flags (bfd_vma flags
)
5667 flag
= flags
& - flags
;
5677 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5678 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5679 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5680 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5681 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5682 default: fputs ("unknown", stdout
); break;
5688 /* Parse and display the contents of the dynamic section. */
5691 process_dynamic_section (FILE *file
)
5693 Elf_Internal_Dyn
*entry
;
5695 if (dynamic_size
== 0)
5698 printf (_("\nThere is no dynamic section in this file.\n"));
5705 if (! get_32bit_dynamic_section (file
))
5708 else if (! get_64bit_dynamic_section (file
))
5711 /* Find the appropriate symbol table. */
5712 if (dynamic_symbols
== NULL
)
5714 for (entry
= dynamic_section
;
5715 entry
< dynamic_section
+ dynamic_nent
;
5718 Elf_Internal_Shdr section
;
5720 if (entry
->d_tag
!= DT_SYMTAB
)
5723 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5725 /* Since we do not know how big the symbol table is,
5726 we default to reading in the entire file (!) and
5727 processing that. This is overkill, I know, but it
5729 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5731 if (archive_file_offset
!= 0)
5732 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5735 if (fseek (file
, 0, SEEK_END
))
5736 error (_("Unable to seek to end of file!"));
5738 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5742 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5744 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5746 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5747 if (num_dynamic_syms
< 1)
5749 error (_("Unable to determine the number of symbols to load\n"));
5753 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5757 /* Similarly find a string table. */
5758 if (dynamic_strings
== NULL
)
5760 for (entry
= dynamic_section
;
5761 entry
< dynamic_section
+ dynamic_nent
;
5764 unsigned long offset
;
5767 if (entry
->d_tag
!= DT_STRTAB
)
5770 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5772 /* Since we do not know how big the string table is,
5773 we default to reading in the entire file (!) and
5774 processing that. This is overkill, I know, but it
5777 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5779 if (archive_file_offset
!= 0)
5780 str_tab_len
= archive_file_size
- offset
;
5783 if (fseek (file
, 0, SEEK_END
))
5784 error (_("Unable to seek to end of file\n"));
5785 str_tab_len
= ftell (file
) - offset
;
5788 if (str_tab_len
< 1)
5791 (_("Unable to determine the length of the dynamic string table\n"));
5795 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5796 _("dynamic string table"));
5797 dynamic_strings_length
= str_tab_len
;
5802 /* And find the syminfo section if available. */
5803 if (dynamic_syminfo
== NULL
)
5805 unsigned long syminsz
= 0;
5807 for (entry
= dynamic_section
;
5808 entry
< dynamic_section
+ dynamic_nent
;
5811 if (entry
->d_tag
== DT_SYMINENT
)
5813 /* Note: these braces are necessary to avoid a syntax
5814 error from the SunOS4 C compiler. */
5815 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5817 else if (entry
->d_tag
== DT_SYMINSZ
)
5818 syminsz
= entry
->d_un
.d_val
;
5819 else if (entry
->d_tag
== DT_SYMINFO
)
5820 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5824 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5826 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5827 Elf_Internal_Syminfo
*syminfo
;
5829 /* There is a syminfo section. Read the data. */
5830 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5831 syminsz
, _("symbol information"));
5835 dynamic_syminfo
= malloc (syminsz
);
5836 if (dynamic_syminfo
== NULL
)
5838 error (_("Out of memory\n"));
5842 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5843 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5844 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5845 ++syminfo
, ++extsym
)
5847 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5848 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5855 if (do_dynamic
&& dynamic_addr
)
5856 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5857 dynamic_addr
, dynamic_nent
);
5859 printf (_(" Tag Type Name/Value\n"));
5861 for (entry
= dynamic_section
;
5862 entry
< dynamic_section
+ dynamic_nent
;
5870 print_vma (entry
->d_tag
, FULL_HEX
);
5871 dtype
= get_dynamic_type (entry
->d_tag
);
5872 printf (" (%s)%*s", dtype
,
5873 ((is_32bit_elf
? 27 : 19)
5874 - (int) strlen (dtype
)),
5878 switch (entry
->d_tag
)
5882 print_dynamic_flags (entry
->d_un
.d_val
);
5892 switch (entry
->d_tag
)
5895 printf (_("Auxiliary library"));
5899 printf (_("Filter library"));
5903 printf (_("Configuration file"));
5907 printf (_("Dependency audit library"));
5911 printf (_("Audit library"));
5915 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5916 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5920 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5929 printf (_("Flags:"));
5931 if (entry
->d_un
.d_val
== 0)
5932 printf (_(" None\n"));
5935 unsigned long int val
= entry
->d_un
.d_val
;
5937 if (val
& DTF_1_PARINIT
)
5939 printf (" PARINIT");
5940 val
^= DTF_1_PARINIT
;
5942 if (val
& DTF_1_CONFEXP
)
5944 printf (" CONFEXP");
5945 val
^= DTF_1_CONFEXP
;
5948 printf (" %lx", val
);
5957 printf (_("Flags:"));
5959 if (entry
->d_un
.d_val
== 0)
5960 printf (_(" None\n"));
5963 unsigned long int val
= entry
->d_un
.d_val
;
5965 if (val
& DF_P1_LAZYLOAD
)
5967 printf (" LAZYLOAD");
5968 val
^= DF_P1_LAZYLOAD
;
5970 if (val
& DF_P1_GROUPPERM
)
5972 printf (" GROUPPERM");
5973 val
^= DF_P1_GROUPPERM
;
5976 printf (" %lx", val
);
5985 printf (_("Flags:"));
5986 if (entry
->d_un
.d_val
== 0)
5987 printf (_(" None\n"));
5990 unsigned long int val
= entry
->d_un
.d_val
;
5997 if (val
& DF_1_GLOBAL
)
6002 if (val
& DF_1_GROUP
)
6007 if (val
& DF_1_NODELETE
)
6009 printf (" NODELETE");
6010 val
^= DF_1_NODELETE
;
6012 if (val
& DF_1_LOADFLTR
)
6014 printf (" LOADFLTR");
6015 val
^= DF_1_LOADFLTR
;
6017 if (val
& DF_1_INITFIRST
)
6019 printf (" INITFIRST");
6020 val
^= DF_1_INITFIRST
;
6022 if (val
& DF_1_NOOPEN
)
6027 if (val
& DF_1_ORIGIN
)
6032 if (val
& DF_1_DIRECT
)
6037 if (val
& DF_1_TRANS
)
6042 if (val
& DF_1_INTERPOSE
)
6044 printf (" INTERPOSE");
6045 val
^= DF_1_INTERPOSE
;
6047 if (val
& DF_1_NODEFLIB
)
6049 printf (" NODEFLIB");
6050 val
^= DF_1_NODEFLIB
;
6052 if (val
& DF_1_NODUMP
)
6057 if (val
& DF_1_CONLFAT
)
6059 printf (" CONLFAT");
6060 val
^= DF_1_CONLFAT
;
6063 printf (" %lx", val
);
6070 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6072 puts (get_dynamic_type (entry
->d_un
.d_val
));
6092 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6098 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6099 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6105 switch (entry
->d_tag
)
6108 printf (_("Shared library: [%s]"), name
);
6110 if (streq (name
, program_interpreter
))
6111 printf (_(" program interpreter"));
6115 printf (_("Library soname: [%s]"), name
);
6119 printf (_("Library rpath: [%s]"), name
);
6123 printf (_("Library runpath: [%s]"), name
);
6127 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6132 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6145 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6149 case DT_INIT_ARRAYSZ
:
6150 case DT_FINI_ARRAYSZ
:
6151 case DT_GNU_CONFLICTSZ
:
6152 case DT_GNU_LIBLISTSZ
:
6155 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6156 printf (" (bytes)\n");
6166 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6179 if (entry
->d_tag
== DT_USED
6180 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6182 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6186 printf (_("Not needed object: [%s]\n"), name
);
6191 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6197 /* The value of this entry is ignored. */
6202 case DT_GNU_PRELINKED
:
6206 time_t time
= entry
->d_un
.d_val
;
6208 tmp
= gmtime (&time
);
6209 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6210 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6211 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6217 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6218 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6223 switch (elf_header
.e_machine
)
6226 case EM_MIPS_RS3_LE
:
6227 dynamic_section_mips_val (entry
);
6230 dynamic_section_parisc_val (entry
);
6233 dynamic_section_ia64_val (entry
);
6236 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6248 get_ver_flags (unsigned int flags
)
6250 static char buff
[32];
6257 if (flags
& VER_FLG_BASE
)
6258 strcat (buff
, "BASE ");
6260 if (flags
& VER_FLG_WEAK
)
6262 if (flags
& VER_FLG_BASE
)
6263 strcat (buff
, "| ");
6265 strcat (buff
, "WEAK ");
6268 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6269 strcat (buff
, "| <unknown>");
6274 /* Display the contents of the version sections. */
6276 process_version_sections (FILE *file
)
6278 Elf_Internal_Shdr
*section
;
6285 for (i
= 0, section
= section_headers
;
6286 i
< elf_header
.e_shnum
;
6289 switch (section
->sh_type
)
6291 case SHT_GNU_verdef
:
6293 Elf_External_Verdef
*edefs
;
6300 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6301 SECTION_NAME (section
), section
->sh_info
);
6303 printf (_(" Addr: 0x"));
6304 printf_vma (section
->sh_addr
);
6305 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6306 (unsigned long) section
->sh_offset
, section
->sh_link
,
6307 SECTION_HEADER_INDEX (section
->sh_link
)
6308 < elf_header
.e_shnum
6309 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6312 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6314 _("version definition section"));
6318 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6321 Elf_External_Verdef
*edef
;
6322 Elf_Internal_Verdef ent
;
6323 Elf_External_Verdaux
*eaux
;
6324 Elf_Internal_Verdaux aux
;
6328 vstart
= ((char *) edefs
) + idx
;
6330 edef
= (Elf_External_Verdef
*) vstart
;
6332 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6333 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6334 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6335 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6336 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6337 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6338 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6340 printf (_(" %#06x: Rev: %d Flags: %s"),
6341 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6343 printf (_(" Index: %d Cnt: %d "),
6344 ent
.vd_ndx
, ent
.vd_cnt
);
6346 vstart
+= ent
.vd_aux
;
6348 eaux
= (Elf_External_Verdaux
*) vstart
;
6350 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6351 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6353 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6354 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6356 printf (_("Name index: %ld\n"), aux
.vda_name
);
6358 isum
= idx
+ ent
.vd_aux
;
6360 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6362 isum
+= aux
.vda_next
;
6363 vstart
+= aux
.vda_next
;
6365 eaux
= (Elf_External_Verdaux
*) vstart
;
6367 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6368 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6370 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6371 printf (_(" %#06x: Parent %d: %s\n"),
6372 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6374 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6375 isum
, j
, aux
.vda_name
);
6385 case SHT_GNU_verneed
:
6387 Elf_External_Verneed
*eneed
;
6393 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6394 SECTION_NAME (section
), section
->sh_info
);
6396 printf (_(" Addr: 0x"));
6397 printf_vma (section
->sh_addr
);
6398 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6399 (unsigned long) section
->sh_offset
, section
->sh_link
,
6400 SECTION_HEADER_INDEX (section
->sh_link
)
6401 < elf_header
.e_shnum
6402 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6405 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6407 _("version need section"));
6411 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6413 Elf_External_Verneed
*entry
;
6414 Elf_Internal_Verneed ent
;
6419 vstart
= ((char *) eneed
) + idx
;
6421 entry
= (Elf_External_Verneed
*) vstart
;
6423 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6424 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6425 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6426 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6427 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6429 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6431 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6432 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6434 printf (_(" File: %lx"), ent
.vn_file
);
6436 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6438 vstart
+= ent
.vn_aux
;
6440 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6442 Elf_External_Vernaux
*eaux
;
6443 Elf_Internal_Vernaux aux
;
6445 eaux
= (Elf_External_Vernaux
*) vstart
;
6447 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6448 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6449 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6450 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6451 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6453 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6454 printf (_(" %#06x: Name: %s"),
6455 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6457 printf (_(" %#06x: Name index: %lx"),
6458 isum
, aux
.vna_name
);
6460 printf (_(" Flags: %s Version: %d\n"),
6461 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6463 isum
+= aux
.vna_next
;
6464 vstart
+= aux
.vna_next
;
6474 case SHT_GNU_versym
:
6476 Elf_Internal_Shdr
*link_section
;
6479 unsigned char *edata
;
6480 unsigned short *data
;
6482 Elf_Internal_Sym
*symbols
;
6483 Elf_Internal_Shdr
*string_sec
;
6486 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6489 link_section
= SECTION_HEADER (section
->sh_link
);
6490 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6492 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6493 >= elf_header
.e_shnum
)
6498 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6500 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6502 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6503 string_sec
->sh_size
, _("version string table"));
6507 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6508 SECTION_NAME (section
), total
);
6510 printf (_(" Addr: "));
6511 printf_vma (section
->sh_addr
);
6512 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6513 (unsigned long) section
->sh_offset
, section
->sh_link
,
6514 SECTION_NAME (link_section
));
6516 off
= offset_from_vma (file
,
6517 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6518 total
* sizeof (short));
6519 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6520 _("version symbol data"));
6527 data
= cmalloc (total
, sizeof (short));
6529 for (cnt
= total
; cnt
--;)
6530 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6535 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6538 int check_def
, check_need
;
6541 printf (" %03x:", cnt
);
6543 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6544 switch (data
[cnt
+ j
])
6547 fputs (_(" 0 (*local*) "), stdout
);
6551 fputs (_(" 1 (*global*) "), stdout
);
6555 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6556 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6560 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6561 >= elf_header
.e_shnum
6562 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6565 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6572 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6574 Elf_Internal_Verneed ivn
;
6575 unsigned long offset
;
6577 offset
= offset_from_vma
6578 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6579 sizeof (Elf_External_Verneed
));
6583 Elf_Internal_Vernaux ivna
;
6584 Elf_External_Verneed evn
;
6585 Elf_External_Vernaux evna
;
6586 unsigned long a_off
;
6588 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6591 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6592 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6594 a_off
= offset
+ ivn
.vn_aux
;
6598 get_data (&evna
, file
, a_off
, sizeof (evna
),
6599 1, _("version need aux (2)"));
6601 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6602 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6604 a_off
+= ivna
.vna_next
;
6606 while (ivna
.vna_other
!= data
[cnt
+ j
]
6607 && ivna
.vna_next
!= 0);
6609 if (ivna
.vna_other
== data
[cnt
+ j
])
6611 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6613 name
= strtab
+ ivna
.vna_name
;
6614 nn
+= printf ("(%s%-*s",
6616 12 - (int) strlen (name
),
6622 offset
+= ivn
.vn_next
;
6624 while (ivn
.vn_next
);
6627 if (check_def
&& data
[cnt
+ j
] != 0x8001
6628 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6630 Elf_Internal_Verdef ivd
;
6631 Elf_External_Verdef evd
;
6632 unsigned long offset
;
6634 offset
= offset_from_vma
6635 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6640 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6643 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6644 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6646 offset
+= ivd
.vd_next
;
6648 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6649 && ivd
.vd_next
!= 0);
6651 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6653 Elf_External_Verdaux evda
;
6654 Elf_Internal_Verdaux ivda
;
6656 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6658 get_data (&evda
, file
,
6659 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6661 _("version def aux"));
6663 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6665 name
= strtab
+ ivda
.vda_name
;
6666 nn
+= printf ("(%s%-*s",
6668 12 - (int) strlen (name
),
6674 printf ("%*c", 18 - nn
, ' ');
6692 printf (_("\nNo version information found in this file.\n"));
6698 get_symbol_binding (unsigned int binding
)
6700 static char buff
[32];
6704 case STB_LOCAL
: return "LOCAL";
6705 case STB_GLOBAL
: return "GLOBAL";
6706 case STB_WEAK
: return "WEAK";
6708 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6709 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6711 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6712 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6714 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6720 get_symbol_type (unsigned int type
)
6722 static char buff
[32];
6726 case STT_NOTYPE
: return "NOTYPE";
6727 case STT_OBJECT
: return "OBJECT";
6728 case STT_FUNC
: return "FUNC";
6729 case STT_SECTION
: return "SECTION";
6730 case STT_FILE
: return "FILE";
6731 case STT_COMMON
: return "COMMON";
6732 case STT_TLS
: return "TLS";
6734 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6736 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6737 return "THUMB_FUNC";
6739 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6742 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6743 return "PARISC_MILLI";
6745 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6747 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6749 if (elf_header
.e_machine
== EM_PARISC
)
6751 if (type
== STT_HP_OPAQUE
)
6753 if (type
== STT_HP_STUB
)
6757 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6760 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6766 get_symbol_visibility (unsigned int visibility
)
6770 case STV_DEFAULT
: return "DEFAULT";
6771 case STV_INTERNAL
: return "INTERNAL";
6772 case STV_HIDDEN
: return "HIDDEN";
6773 case STV_PROTECTED
: return "PROTECTED";
6779 get_mips_symbol_other (unsigned int other
)
6783 case STO_OPTIONAL
: return "OPTIONAL";
6784 case STO_MIPS16
: return "MIPS16";
6785 default: return NULL
;
6790 get_symbol_other (unsigned int other
)
6792 const char * result
= NULL
;
6793 static char buff
[32];
6798 switch (elf_header
.e_machine
)
6801 result
= get_mips_symbol_other (other
);
6809 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6814 get_symbol_index_type (unsigned int type
)
6816 static char buff
[32];
6820 case SHN_UNDEF
: return "UND";
6821 case SHN_ABS
: return "ABS";
6822 case SHN_COMMON
: return "COM";
6824 if (type
== SHN_IA_64_ANSI_COMMON
6825 && elf_header
.e_machine
== EM_IA_64
6826 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6828 else if (elf_header
.e_machine
== EM_X86_64
6829 && type
== SHN_X86_64_LCOMMON
)
6831 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6832 sprintf (buff
, "PRC[0x%04x]", type
);
6833 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6834 sprintf (buff
, "OS [0x%04x]", type
);
6835 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6836 sprintf (buff
, "RSV[0x%04x]", type
);
6838 sprintf (buff
, "%3d", type
);
6846 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6848 unsigned char *e_data
;
6851 e_data
= cmalloc (number
, ent_size
);
6855 error (_("Out of memory\n"));
6859 if (fread (e_data
, ent_size
, number
, file
) != number
)
6861 error (_("Unable to read in dynamic data\n"));
6865 i_data
= cmalloc (number
, sizeof (*i_data
));
6869 error (_("Out of memory\n"));
6875 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6882 /* Dump the symbol table. */
6884 process_symbol_table (FILE *file
)
6886 Elf_Internal_Shdr
*section
;
6887 bfd_vma nbuckets
= 0;
6888 bfd_vma nchains
= 0;
6889 bfd_vma
*buckets
= NULL
;
6890 bfd_vma
*chains
= NULL
;
6892 if (! do_syms
&& !do_histogram
)
6895 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6898 unsigned char nb
[8];
6899 unsigned char nc
[8];
6900 int hash_ent_size
= 4;
6902 if ((elf_header
.e_machine
== EM_ALPHA
6903 || elf_header
.e_machine
== EM_S390
6904 || elf_header
.e_machine
== EM_S390_OLD
)
6905 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6909 (archive_file_offset
6910 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6911 sizeof nb
+ sizeof nc
)),
6914 error (_("Unable to seek to start of dynamic information"));
6918 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6920 error (_("Failed to read in number of buckets\n"));
6924 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6926 error (_("Failed to read in number of chains\n"));
6930 nbuckets
= byte_get (nb
, hash_ent_size
);
6931 nchains
= byte_get (nc
, hash_ent_size
);
6933 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6934 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6936 if (buckets
== NULL
|| chains
== NULL
)
6941 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6946 printf (_("\nSymbol table for image:\n"));
6948 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6950 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6952 for (hn
= 0; hn
< nbuckets
; hn
++)
6957 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6959 Elf_Internal_Sym
*psym
;
6962 psym
= dynamic_symbols
+ si
;
6964 n
= print_vma (si
, DEC_5
);
6966 fputs (" " + n
, stdout
);
6967 printf (" %3lu: ", hn
);
6968 print_vma (psym
->st_value
, LONG_HEX
);
6970 print_vma (psym
->st_size
, DEC_5
);
6972 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6973 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6974 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6975 /* Check to see if any other bits in the st_other field are set.
6976 Note - displaying this information disrupts the layout of the
6977 table being generated, but for the moment this case is very rare. */
6978 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
6979 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
6980 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6981 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6982 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6984 printf (" <corrupt: %14ld>", psym
->st_name
);
6989 else if (do_syms
&& !do_using_dynamic
)
6993 for (i
= 0, section
= section_headers
;
6994 i
< elf_header
.e_shnum
;
6998 char *strtab
= NULL
;
6999 unsigned long int strtab_size
= 0;
7000 Elf_Internal_Sym
*symtab
;
7001 Elf_Internal_Sym
*psym
;
7004 if ( section
->sh_type
!= SHT_SYMTAB
7005 && section
->sh_type
!= SHT_DYNSYM
)
7008 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7009 SECTION_NAME (section
),
7010 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7012 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7014 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7016 symtab
= GET_ELF_SYMBOLS (file
, section
);
7020 if (section
->sh_link
== elf_header
.e_shstrndx
)
7022 strtab
= string_table
;
7023 strtab_size
= string_table_length
;
7025 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7027 Elf_Internal_Shdr
*string_sec
;
7029 string_sec
= SECTION_HEADER (section
->sh_link
);
7031 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7032 1, string_sec
->sh_size
, _("string table"));
7033 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7036 for (si
= 0, psym
= symtab
;
7037 si
< section
->sh_size
/ section
->sh_entsize
;
7040 printf ("%6d: ", si
);
7041 print_vma (psym
->st_value
, LONG_HEX
);
7043 print_vma (psym
->st_size
, DEC_5
);
7044 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7045 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7046 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7047 /* Check to see if any other bits in the st_other field are set.
7048 Note - displaying this information disrupts the layout of the
7049 table being generated, but for the moment this case is very rare. */
7050 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7051 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7052 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7053 print_symbol (25, psym
->st_name
< strtab_size
7054 ? strtab
+ psym
->st_name
: "<corrupt>");
7056 if (section
->sh_type
== SHT_DYNSYM
&&
7057 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7059 unsigned char data
[2];
7060 unsigned short vers_data
;
7061 unsigned long offset
;
7065 offset
= offset_from_vma
7066 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7067 sizeof data
+ si
* sizeof (vers_data
));
7069 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7070 sizeof (data
), 1, _("version data"));
7072 vers_data
= byte_get (data
, 2);
7074 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7075 < elf_header
.e_shnum
7076 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7079 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7081 if ((vers_data
& 0x8000) || vers_data
> 1)
7083 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7084 && (is_nobits
|| ! check_def
))
7086 Elf_External_Verneed evn
;
7087 Elf_Internal_Verneed ivn
;
7088 Elf_Internal_Vernaux ivna
;
7090 /* We must test both. */
7091 offset
= offset_from_vma
7092 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7097 unsigned long vna_off
;
7099 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7102 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7103 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7105 vna_off
= offset
+ ivn
.vn_aux
;
7109 Elf_External_Vernaux evna
;
7111 get_data (&evna
, file
, vna_off
,
7113 _("version need aux (3)"));
7115 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7116 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7117 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7119 vna_off
+= ivna
.vna_next
;
7121 while (ivna
.vna_other
!= vers_data
7122 && ivna
.vna_next
!= 0);
7124 if (ivna
.vna_other
== vers_data
)
7127 offset
+= ivn
.vn_next
;
7129 while (ivn
.vn_next
!= 0);
7131 if (ivna
.vna_other
== vers_data
)
7134 ivna
.vna_name
< strtab_size
7135 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7139 else if (! is_nobits
)
7140 error (_("bad dynamic symbol"));
7147 if (vers_data
!= 0x8001
7148 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7150 Elf_Internal_Verdef ivd
;
7151 Elf_Internal_Verdaux ivda
;
7152 Elf_External_Verdaux evda
;
7153 unsigned long offset
;
7155 offset
= offset_from_vma
7157 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7158 sizeof (Elf_External_Verdef
));
7162 Elf_External_Verdef evd
;
7164 get_data (&evd
, file
, offset
, sizeof (evd
),
7165 1, _("version def"));
7167 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7168 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7169 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7171 offset
+= ivd
.vd_next
;
7173 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7174 && ivd
.vd_next
!= 0);
7176 offset
-= ivd
.vd_next
;
7177 offset
+= ivd
.vd_aux
;
7179 get_data (&evda
, file
, offset
, sizeof (evda
),
7180 1, _("version def aux"));
7182 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7184 if (psym
->st_name
!= ivda
.vda_name
)
7185 printf ((vers_data
& 0x8000)
7187 ivda
.vda_name
< strtab_size
7188 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7198 if (strtab
!= string_table
)
7204 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7206 if (do_histogram
&& buckets
!= NULL
)
7208 unsigned long *lengths
;
7209 unsigned long *counts
;
7212 unsigned long maxlength
= 0;
7213 unsigned long nzero_counts
= 0;
7214 unsigned long nsyms
= 0;
7216 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7217 (unsigned long) nbuckets
);
7218 printf (_(" Length Number %% of total Coverage\n"));
7220 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7221 if (lengths
== NULL
)
7223 error (_("Out of memory"));
7226 for (hn
= 0; hn
< nbuckets
; ++hn
)
7228 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7231 if (maxlength
< ++lengths
[hn
])
7236 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7239 error (_("Out of memory"));
7243 for (hn
= 0; hn
< nbuckets
; ++hn
)
7244 ++counts
[lengths
[hn
]];
7249 printf (" 0 %-10lu (%5.1f%%)\n",
7250 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7251 for (i
= 1; i
<= maxlength
; ++i
)
7253 nzero_counts
+= counts
[i
] * i
;
7254 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7255 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7256 (nzero_counts
* 100.0) / nsyms
);
7264 if (buckets
!= NULL
)
7274 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7278 if (dynamic_syminfo
== NULL
7280 /* No syminfo, this is ok. */
7283 /* There better should be a dynamic symbol section. */
7284 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7288 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7289 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7291 printf (_(" Num: Name BoundTo Flags\n"));
7292 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7294 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7296 printf ("%4d: ", i
);
7297 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7298 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7300 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7303 switch (dynamic_syminfo
[i
].si_boundto
)
7305 case SYMINFO_BT_SELF
:
7306 fputs ("SELF ", stdout
);
7308 case SYMINFO_BT_PARENT
:
7309 fputs ("PARENT ", stdout
);
7312 if (dynamic_syminfo
[i
].si_boundto
> 0
7313 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7314 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7316 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7320 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7324 if (flags
& SYMINFO_FLG_DIRECT
)
7326 if (flags
& SYMINFO_FLG_PASSTHRU
)
7327 printf (" PASSTHRU");
7328 if (flags
& SYMINFO_FLG_COPY
)
7330 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7331 printf (" LAZYLOAD");
7339 #ifdef SUPPORT_DISASSEMBLY
7341 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7343 printf (_("\nAssembly dump of section %s\n"),
7344 SECTION_NAME (section
));
7346 /* XXX -- to be done --- XXX */
7353 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7355 bfd_size_type bytes
;
7357 unsigned char *data
;
7358 unsigned char *start
;
7360 bytes
= section
->sh_size
;
7362 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7364 printf (_("\nSection '%s' has no data to dump.\n"),
7365 SECTION_NAME (section
));
7369 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7371 addr
= section
->sh_addr
;
7373 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7386 lbytes
= (bytes
> 16 ? 16 : bytes
);
7388 printf (" 0x%8.8lx ", (unsigned long) addr
);
7390 switch (elf_header
.e_ident
[EI_DATA
])
7394 for (j
= 15; j
>= 0; j
--)
7397 printf ("%2.2x", data
[j
]);
7407 for (j
= 0; j
< 16; j
++)
7410 printf ("%2.2x", data
[j
]);
7420 for (j
= 0; j
< lbytes
; j
++)
7423 if (k
>= ' ' && k
< 0x7f)
7441 /* Apply addends of RELA relocations. */
7444 debug_apply_rela_addends (void *file
,
7445 Elf_Internal_Shdr
*section
,
7446 unsigned char *start
)
7448 Elf_Internal_Shdr
*relsec
;
7449 unsigned char *end
= start
+ section
->sh_size
;
7450 /* FIXME: The relocation field size is relocation type dependent. */
7451 unsigned int reloc_size
= 4;
7453 if (!is_relocatable
)
7456 if (section
->sh_size
< reloc_size
)
7459 for (relsec
= section_headers
;
7460 relsec
< section_headers
+ elf_header
.e_shnum
;
7463 unsigned long nrelas
;
7464 Elf_Internal_Rela
*rela
, *rp
;
7465 Elf_Internal_Shdr
*symsec
;
7466 Elf_Internal_Sym
*symtab
;
7467 Elf_Internal_Sym
*sym
;
7469 if (relsec
->sh_type
!= SHT_RELA
7470 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7471 || SECTION_HEADER (relsec
->sh_info
) != section
7472 || relsec
->sh_size
== 0
7473 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7476 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7480 symsec
= SECTION_HEADER (relsec
->sh_link
);
7481 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7483 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7487 loc
= start
+ rp
->r_offset
;
7488 if ((loc
+ reloc_size
) > end
)
7490 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7491 (unsigned long) rp
->r_offset
,
7492 SECTION_NAME (section
));
7498 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7500 if (ELF32_R_SYM (rp
->r_info
) != 0
7501 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7502 /* Relocations against object symbols can happen,
7503 eg when referencing a global array. For an
7504 example of this see the _clz.o binary in libgcc.a. */
7505 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7507 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7508 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7509 SECTION_NAME (section
));
7515 /* In MIPS little-endian objects, r_info isn't really a
7516 64-bit little-endian value: it has a 32-bit little-endian
7517 symbol index followed by four individual byte fields.
7518 Reorder INFO accordingly. */
7519 if (elf_header
.e_machine
== EM_MIPS
7520 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7521 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7522 | ((rp
->r_info
>> 56) & 0xff)
7523 | ((rp
->r_info
>> 40) & 0xff00)
7524 | ((rp
->r_info
>> 24) & 0xff0000)
7525 | ((rp
->r_info
>> 8) & 0xff000000));
7527 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7529 if (ELF64_R_SYM (rp
->r_info
) != 0
7530 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7531 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7533 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7534 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7535 SECTION_NAME (section
));
7540 byte_put (loc
, rp
->r_addend
, reloc_size
);
7551 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
7553 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7554 Elf_Internal_Shdr
*sec
;
7557 /* If it is already loaded, do nothing. */
7558 if (section
->start
!= NULL
)
7561 /* Locate the debug section. */
7562 sec
= find_section (section
->name
);
7566 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
7567 section
->address
= sec
->sh_addr
;
7568 section
->size
= sec
->sh_size
;
7569 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7572 if (debug_displays
[debug
].relocate
)
7573 debug_apply_rela_addends (file
, sec
, section
->start
);
7575 return section
->start
!= NULL
;
7579 free_debug_section (enum dwarf_section_display_enum debug
)
7581 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7583 if (section
->start
== NULL
)
7586 free ((char *) section
->start
);
7587 section
->start
= NULL
;
7588 section
->address
= 0;
7593 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
7595 char *name
= SECTION_NAME (section
);
7596 bfd_size_type length
;
7598 enum dwarf_section_display_enum i
;
7600 length
= section
->sh_size
;
7603 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7607 if (strneq (name
, ".gnu.linkonce.wi.", 17))
7608 name
= ".debug_info";
7610 /* See if we know how to display the contents of this section. */
7611 for (i
= 0; i
< max
; i
++)
7612 if (streq (debug_displays
[i
].section
.name
, name
))
7614 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
7616 if (load_debug_section (i
, file
))
7618 result
&= debug_displays
[i
].display (sec
, file
);
7620 if (i
!= info
&& i
!= abbrev
)
7621 free_debug_section (i
);
7629 printf (_("Unrecognized debug section: %s\n"), name
);
7636 /* Set DUMP_SECTS for all sections where dumps were requested
7637 based on section name. */
7640 initialise_dumps_byname (void)
7642 struct dump_list_entry
*cur
;
7644 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
7649 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
7650 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
7652 request_dump (i
, cur
->type
);
7657 warn (_("Section '%s' was not dumped because it does not exist!\n"),
7663 process_section_contents (FILE *file
)
7665 Elf_Internal_Shdr
*section
;
7671 initialise_dumps_byname ();
7673 for (i
= 0, section
= section_headers
;
7674 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7677 #ifdef SUPPORT_DISASSEMBLY
7678 if (dump_sects
[i
] & DISASS_DUMP
)
7679 disassemble_section (section
, file
);
7681 if (dump_sects
[i
] & HEX_DUMP
)
7682 dump_section (section
, file
);
7684 if (dump_sects
[i
] & DEBUG_DUMP
)
7685 display_debug_section (section
, file
);
7688 /* Check to see if the user requested a
7689 dump of a section that does not exist. */
7690 while (i
++ < num_dump_sects
)
7692 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
7696 process_mips_fpe_exception (int mask
)
7701 if (mask
& OEX_FPU_INEX
)
7702 fputs ("INEX", stdout
), first
= 0;
7703 if (mask
& OEX_FPU_UFLO
)
7704 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7705 if (mask
& OEX_FPU_OFLO
)
7706 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7707 if (mask
& OEX_FPU_DIV0
)
7708 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7709 if (mask
& OEX_FPU_INVAL
)
7710 printf ("%sINVAL", first
? "" : "|");
7713 fputs ("0", stdout
);
7716 /* ARM EABI attributes section. */
7721 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
7724 } arm_attr_public_tag
;
7726 static const char *arm_attr_tag_CPU_arch
[] =
7727 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
7729 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
7730 static const char *arm_attr_tag_THUMB_ISA_use
[] =
7731 {"No", "Thumb-1", "Thumb-2"};
7732 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2"};
7733 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
7734 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
7735 static const char *arm_attr_tag_ABI_PCS_config
[] =
7736 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
7737 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
7738 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
7739 {"V6", "SB", "TLS", "Unused"};
7740 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
7741 {"Absolute", "PC-relative", "SB-relative", "None"};
7742 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
7743 {"Absolute", "PC-relative", "None"};
7744 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
7745 {"None", "direct", "GOT-indirect"};
7746 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
7747 {"None", "??? 1", "2", "??? 3", "4"};
7748 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
7749 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
7750 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
7751 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
7752 static const char *arm_attr_tag_ABI_FP_number_model
[] =
7753 {"Unused", "Finite", "RTABI", "IEEE 754"};
7754 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
7755 static const char *arm_attr_tag_ABI_align8_preserved
[] =
7756 {"No", "Yes, except leaf SP", "Yes"};
7757 static const char *arm_attr_tag_ABI_enum_size
[] =
7758 {"Unused", "small", "int", "forced to int"};
7759 static const char *arm_attr_tag_ABI_HardFP_use
[] =
7760 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
7761 static const char *arm_attr_tag_ABI_VFP_args
[] =
7762 {"AAPCS", "VFP registers", "custom"};
7763 static const char *arm_attr_tag_ABI_WMMX_args
[] =
7764 {"AAPCS", "WMMX registers", "custom"};
7765 static const char *arm_attr_tag_ABI_optimization_goals
[] =
7766 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7767 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
7768 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
7769 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7770 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
7772 #define LOOKUP(id, name) \
7773 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
7774 static arm_attr_public_tag arm_attr_public_tags
[] =
7776 {4, "CPU_raw_name", 1, NULL
},
7777 {5, "CPU_name", 1, NULL
},
7778 LOOKUP(6, CPU_arch
),
7779 {7, "CPU_arch_profile", 0, NULL
},
7780 LOOKUP(8, ARM_ISA_use
),
7781 LOOKUP(9, THUMB_ISA_use
),
7782 LOOKUP(10, VFP_arch
),
7783 LOOKUP(11, WMMX_arch
),
7784 LOOKUP(12, NEON_arch
),
7785 LOOKUP(13, ABI_PCS_config
),
7786 LOOKUP(14, ABI_PCS_R9_use
),
7787 LOOKUP(15, ABI_PCS_RW_data
),
7788 LOOKUP(16, ABI_PCS_RO_DATA
),
7789 LOOKUP(17, ABI_PCS_GOT_use
),
7790 LOOKUP(18, ABI_PCS_wchar_t
),
7791 LOOKUP(19, ABI_FP_rounding
),
7792 LOOKUP(20, ABI_FP_denormal
),
7793 LOOKUP(21, ABI_FP_exceptions
),
7794 LOOKUP(22, ABI_FP_user_exceptions
),
7795 LOOKUP(23, ABI_FP_number_model
),
7796 LOOKUP(24, ABI_align8_needed
),
7797 LOOKUP(25, ABI_align8_preserved
),
7798 LOOKUP(26, ABI_enum_size
),
7799 LOOKUP(27, ABI_HardFP_use
),
7800 LOOKUP(28, ABI_VFP_args
),
7801 LOOKUP(29, ABI_WMMX_args
),
7802 LOOKUP(30, ABI_optimization_goals
),
7803 LOOKUP(31, ABI_FP_optimization_goals
),
7804 {32, "compatibility", 0, NULL
}
7808 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
7811 read_uleb128 (unsigned char *p
, unsigned int *plen
)
7825 val
|= ((unsigned int)c
& 0x7f) << shift
;
7834 static unsigned char *
7835 display_arm_attribute (unsigned char *p
)
7840 arm_attr_public_tag
*attr
;
7844 tag
= read_uleb128 (p
, &len
);
7847 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
7849 if (arm_attr_public_tags
[i
].tag
== tag
)
7851 attr
= &arm_attr_public_tags
[i
];
7858 printf (" Tag_%s: ", attr
->name
);
7864 case 7: /* Tag_CPU_arch_profile. */
7865 val
= read_uleb128 (p
, &len
);
7869 case 0: printf ("None\n"); break;
7870 case 'A': printf ("Application\n"); break;
7871 case 'R': printf ("Realtime\n"); break;
7872 case 'M': printf ("Microcontroller\n"); break;
7873 default: printf ("??? (%d)\n", val
); break;
7877 case 32: /* Tag_compatibility. */
7878 val
= read_uleb128 (p
, &len
);
7880 printf ("flag = %d, vendor = %s\n", val
, p
);
7881 p
+= strlen((char *)p
) + 1;
7895 assert (attr
->type
& 0x80);
7896 val
= read_uleb128 (p
, &len
);
7898 type
= attr
->type
& 0x7f;
7900 printf ("??? (%d)\n", val
);
7902 printf ("%s\n", attr
->table
[val
]);
7909 type
= 1; /* String. */
7911 type
= 2; /* uleb128. */
7912 printf (" Tag_unknown_%d: ", tag
);
7917 printf ("\"%s\"\n", p
);
7918 p
+= strlen((char *)p
) + 1;
7922 val
= read_uleb128 (p
, &len
);
7924 printf ("%d (0x%x)\n", val
, val
);
7931 process_arm_specific (FILE *file
)
7933 Elf_Internal_Shdr
*sect
;
7934 unsigned char *contents
;
7937 bfd_vma section_len
;
7941 /* Find the section header so that we get the size. */
7942 for (i
= 0, sect
= section_headers
;
7943 i
< elf_header
.e_shnum
;
7946 if (sect
->sh_type
!= SHT_ARM_ATTRIBUTES
)
7949 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
7957 len
= sect
->sh_size
- 1;
7962 bfd_boolean public_section
;
7964 section_len
= byte_get (p
, 4);
7966 if (section_len
> len
)
7968 printf (_("ERROR: Bad section length (%d > %d)\n"),
7969 (int)section_len
, (int)len
);
7973 printf ("Attribute Section: %s\n", p
);
7974 if (strcmp ((char *)p
, "aeabi") == 0)
7975 public_section
= TRUE
;
7977 public_section
= FALSE
;
7978 namelen
= strlen ((char *)p
) + 1;
7980 section_len
-= namelen
+ 4;
7981 while (section_len
> 0)
7986 size
= byte_get (p
, 4);
7987 if (size
> section_len
)
7989 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
7990 (int)size
, (int)section_len
);
7993 section_len
-= size
;
7999 printf ("File Attributes\n");
8002 printf ("Section Attributes:");
8005 printf ("Symbol Attributes:");
8010 val
= read_uleb128 (p
, &i
);
8014 printf (" %d", val
);
8019 printf ("Unknown tag: %d\n", tag
);
8020 public_section
= FALSE
;
8026 p
= display_arm_attribute(p
);
8030 /* ??? Do something sensible, like dump hex. */
8031 printf (" Unknown section contexts\n");
8039 printf (_("Unknown format '%c'\n"), *p
);
8048 process_mips_specific (FILE *file
)
8050 Elf_Internal_Dyn
*entry
;
8051 size_t liblist_offset
= 0;
8052 size_t liblistno
= 0;
8053 size_t conflictsno
= 0;
8054 size_t options_offset
= 0;
8055 size_t conflicts_offset
= 0;
8057 /* We have a lot of special sections. Thanks SGI! */
8058 if (dynamic_section
== NULL
)
8059 /* No information available. */
8062 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
8063 switch (entry
->d_tag
)
8065 case DT_MIPS_LIBLIST
:
8067 = offset_from_vma (file
, entry
->d_un
.d_val
,
8068 liblistno
* sizeof (Elf32_External_Lib
));
8070 case DT_MIPS_LIBLISTNO
:
8071 liblistno
= entry
->d_un
.d_val
;
8073 case DT_MIPS_OPTIONS
:
8074 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8076 case DT_MIPS_CONFLICT
:
8078 = offset_from_vma (file
, entry
->d_un
.d_val
,
8079 conflictsno
* sizeof (Elf32_External_Conflict
));
8081 case DT_MIPS_CONFLICTNO
:
8082 conflictsno
= entry
->d_un
.d_val
;
8088 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8090 Elf32_External_Lib
*elib
;
8093 elib
= get_data (NULL
, file
, liblist_offset
,
8094 liblistno
, sizeof (Elf32_External_Lib
),
8098 printf ("\nSection '.liblist' contains %lu entries:\n",
8099 (unsigned long) liblistno
);
8100 fputs (" Library Time Stamp Checksum Version Flags\n",
8103 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8110 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8111 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8112 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8113 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8114 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8116 tmp
= gmtime (&time
);
8117 snprintf (timebuf
, sizeof (timebuf
),
8118 "%04u-%02u-%02uT%02u:%02u:%02u",
8119 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8120 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8122 printf ("%3lu: ", (unsigned long) cnt
);
8123 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
8124 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
8126 printf ("<corrupt: %9ld>", liblist
.l_name
);
8127 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8130 if (liblist
.l_flags
== 0)
8141 { " EXACT_MATCH", LL_EXACT_MATCH
},
8142 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8143 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8144 { " EXPORTS", LL_EXPORTS
},
8145 { " DELAY_LOAD", LL_DELAY_LOAD
},
8146 { " DELTA", LL_DELTA
}
8148 int flags
= liblist
.l_flags
;
8152 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
8154 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8156 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8157 flags
^= l_flags_vals
[fcnt
].bit
;
8160 printf (" %#x", (unsigned int) flags
);
8170 if (options_offset
!= 0)
8172 Elf_External_Options
*eopt
;
8173 Elf_Internal_Shdr
*sect
= section_headers
;
8174 Elf_Internal_Options
*iopt
;
8175 Elf_Internal_Options
*option
;
8179 /* Find the section header so that we get the size. */
8180 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8183 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8187 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8190 error (_("Out of memory"));
8197 while (offset
< sect
->sh_size
)
8199 Elf_External_Options
*eoption
;
8201 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8203 option
->kind
= BYTE_GET (eoption
->kind
);
8204 option
->size
= BYTE_GET (eoption
->size
);
8205 option
->section
= BYTE_GET (eoption
->section
);
8206 option
->info
= BYTE_GET (eoption
->info
);
8208 offset
+= option
->size
;
8214 printf (_("\nSection '%s' contains %d entries:\n"),
8215 SECTION_NAME (sect
), cnt
);
8223 switch (option
->kind
)
8226 /* This shouldn't happen. */
8227 printf (" NULL %d %lx", option
->section
, option
->info
);
8230 printf (" REGINFO ");
8231 if (elf_header
.e_machine
== EM_MIPS
)
8234 Elf32_External_RegInfo
*ereg
;
8235 Elf32_RegInfo reginfo
;
8237 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8238 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8239 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8240 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8241 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8242 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8243 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8245 printf ("GPR %08lx GP 0x%lx\n",
8247 (unsigned long) reginfo
.ri_gp_value
);
8248 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8249 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8250 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8255 Elf64_External_RegInfo
*ereg
;
8256 Elf64_Internal_RegInfo reginfo
;
8258 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8259 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8260 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8261 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8262 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8263 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8264 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8266 printf ("GPR %08lx GP 0x",
8267 reginfo
.ri_gprmask
);
8268 printf_vma (reginfo
.ri_gp_value
);
8271 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8272 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8273 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8277 case ODK_EXCEPTIONS
:
8278 fputs (" EXCEPTIONS fpe_min(", stdout
);
8279 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8280 fputs (") fpe_max(", stdout
);
8281 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8282 fputs (")", stdout
);
8284 if (option
->info
& OEX_PAGE0
)
8285 fputs (" PAGE0", stdout
);
8286 if (option
->info
& OEX_SMM
)
8287 fputs (" SMM", stdout
);
8288 if (option
->info
& OEX_FPDBUG
)
8289 fputs (" FPDBUG", stdout
);
8290 if (option
->info
& OEX_DISMISS
)
8291 fputs (" DISMISS", stdout
);
8294 fputs (" PAD ", stdout
);
8295 if (option
->info
& OPAD_PREFIX
)
8296 fputs (" PREFIX", stdout
);
8297 if (option
->info
& OPAD_POSTFIX
)
8298 fputs (" POSTFIX", stdout
);
8299 if (option
->info
& OPAD_SYMBOL
)
8300 fputs (" SYMBOL", stdout
);
8303 fputs (" HWPATCH ", stdout
);
8304 if (option
->info
& OHW_R4KEOP
)
8305 fputs (" R4KEOP", stdout
);
8306 if (option
->info
& OHW_R8KPFETCH
)
8307 fputs (" R8KPFETCH", stdout
);
8308 if (option
->info
& OHW_R5KEOP
)
8309 fputs (" R5KEOP", stdout
);
8310 if (option
->info
& OHW_R5KCVTL
)
8311 fputs (" R5KCVTL", stdout
);
8314 fputs (" FILL ", stdout
);
8315 /* XXX Print content of info word? */
8318 fputs (" TAGS ", stdout
);
8319 /* XXX Print content of info word? */
8322 fputs (" HWAND ", stdout
);
8323 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8324 fputs (" R4KEOP_CHECKED", stdout
);
8325 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8326 fputs (" R4KEOP_CLEAN", stdout
);
8329 fputs (" HWOR ", stdout
);
8330 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8331 fputs (" R4KEOP_CHECKED", stdout
);
8332 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8333 fputs (" R4KEOP_CLEAN", stdout
);
8336 printf (" GP_GROUP %#06lx self-contained %#06lx",
8337 option
->info
& OGP_GROUP
,
8338 (option
->info
& OGP_SELF
) >> 16);
8341 printf (" IDENT %#06lx self-contained %#06lx",
8342 option
->info
& OGP_GROUP
,
8343 (option
->info
& OGP_SELF
) >> 16);
8346 /* This shouldn't happen. */
8347 printf (" %3d ??? %d %lx",
8348 option
->kind
, option
->section
, option
->info
);
8352 len
= sizeof (*eopt
);
8353 while (len
< option
->size
)
8354 if (((char *) option
)[len
] >= ' '
8355 && ((char *) option
)[len
] < 0x7f)
8356 printf ("%c", ((char *) option
)[len
++]);
8358 printf ("\\%03o", ((char *) option
)[len
++]);
8360 fputs ("\n", stdout
);
8368 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8370 Elf32_Conflict
*iconf
;
8373 if (dynamic_symbols
== NULL
)
8375 error (_("conflict list found without a dynamic symbol table"));
8379 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
8382 error (_("Out of memory"));
8388 Elf32_External_Conflict
*econf32
;
8390 econf32
= get_data (NULL
, file
, conflicts_offset
,
8391 conflictsno
, sizeof (*econf32
), _("conflict"));
8395 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8396 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8402 Elf64_External_Conflict
*econf64
;
8404 econf64
= get_data (NULL
, file
, conflicts_offset
,
8405 conflictsno
, sizeof (*econf64
), _("conflict"));
8409 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8410 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8415 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8416 (unsigned long) conflictsno
);
8417 puts (_(" Num: Index Value Name"));
8419 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8421 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
8423 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8424 print_vma (psym
->st_value
, FULL_HEX
);
8426 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8427 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8429 printf ("<corrupt: %14ld>", psym
->st_name
);
8440 process_gnu_liblist (FILE *file
)
8442 Elf_Internal_Shdr
*section
, *string_sec
;
8443 Elf32_External_Lib
*elib
;
8452 for (i
= 0, section
= section_headers
;
8453 i
< elf_header
.e_shnum
;
8456 switch (section
->sh_type
)
8458 case SHT_GNU_LIBLIST
:
8459 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
8462 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
8467 string_sec
= SECTION_HEADER (section
->sh_link
);
8469 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8470 string_sec
->sh_size
, _("liblist string table"));
8471 strtab_size
= string_sec
->sh_size
;
8474 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
8480 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8481 SECTION_NAME (section
),
8482 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
8484 puts (" Library Time Stamp Checksum Version Flags");
8486 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
8494 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8495 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8496 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8497 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8498 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8500 tmp
= gmtime (&time
);
8501 snprintf (timebuf
, sizeof (timebuf
),
8502 "%04u-%02u-%02uT%02u:%02u:%02u",
8503 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8504 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8506 printf ("%3lu: ", (unsigned long) cnt
);
8508 printf ("%-20s", liblist
.l_name
< strtab_size
8509 ? strtab
+ liblist
.l_name
: "<corrupt>");
8511 printf ("%-20.20s", liblist
.l_name
< strtab_size
8512 ? strtab
+ liblist
.l_name
: "<corrupt>");
8513 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
8514 liblist
.l_version
, liblist
.l_flags
);
8525 get_note_type (unsigned e_type
)
8527 static char buff
[64];
8529 if (elf_header
.e_type
== ET_CORE
)
8533 return _("NT_AUXV (auxiliary vector)");
8535 return _("NT_PRSTATUS (prstatus structure)");
8537 return _("NT_FPREGSET (floating point registers)");
8539 return _("NT_PRPSINFO (prpsinfo structure)");
8541 return _("NT_TASKSTRUCT (task structure)");
8543 return _("NT_PRXFPREG (user_xfpregs structure)");
8545 return _("NT_PSTATUS (pstatus structure)");
8547 return _("NT_FPREGS (floating point registers)");
8549 return _("NT_PSINFO (psinfo structure)");
8551 return _("NT_LWPSTATUS (lwpstatus_t structure)");
8553 return _("NT_LWPSINFO (lwpsinfo_t structure)");
8554 case NT_WIN32PSTATUS
:
8555 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8563 return _("NT_VERSION (version)");
8565 return _("NT_ARCH (architecture)");
8570 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8575 get_netbsd_elfcore_note_type (unsigned e_type
)
8577 static char buff
[64];
8579 if (e_type
== NT_NETBSDCORE_PROCINFO
)
8581 /* NetBSD core "procinfo" structure. */
8582 return _("NetBSD procinfo structure");
8585 /* As of Jan 2002 there are no other machine-independent notes
8586 defined for NetBSD core files. If the note type is less
8587 than the start of the machine-dependent note types, we don't
8590 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
8592 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8596 switch (elf_header
.e_machine
)
8598 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8599 and PT_GETFPREGS == mach+2. */
8604 case EM_SPARC32PLUS
:
8608 case NT_NETBSDCORE_FIRSTMACH
+0:
8609 return _("PT_GETREGS (reg structure)");
8610 case NT_NETBSDCORE_FIRSTMACH
+2:
8611 return _("PT_GETFPREGS (fpreg structure)");
8617 /* On all other arch's, PT_GETREGS == mach+1 and
8618 PT_GETFPREGS == mach+3. */
8622 case NT_NETBSDCORE_FIRSTMACH
+1:
8623 return _("PT_GETREGS (reg structure)");
8624 case NT_NETBSDCORE_FIRSTMACH
+3:
8625 return _("PT_GETFPREGS (fpreg structure)");
8631 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
8632 e_type
- NT_NETBSDCORE_FIRSTMACH
);
8636 /* Note that by the ELF standard, the name field is already null byte
8637 terminated, and namesz includes the terminating null byte.
8638 I.E. the value of namesz for the name "FSF" is 4.
8640 If the value of namesz is zero, there is no name present. */
8642 process_note (Elf_Internal_Note
*pnote
)
8646 if (pnote
->namesz
== 0)
8647 /* If there is no note name, then use the default set of
8648 note type strings. */
8649 nt
= get_note_type (pnote
->type
);
8651 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
8652 /* NetBSD-specific core file notes. */
8653 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
8656 /* Don't recognize this note name; just use the default set of
8657 note type strings. */
8658 nt
= get_note_type (pnote
->type
);
8660 printf (" %s\t\t0x%08lx\t%s\n",
8661 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8668 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
8670 Elf_External_Note
*pnotes
;
8671 Elf_External_Note
*external
;
8677 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
8683 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8684 (unsigned long) offset
, (unsigned long) length
);
8685 printf (_(" Owner\t\tData size\tDescription\n"));
8687 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8689 Elf_External_Note
*next
;
8690 Elf_Internal_Note inote
;
8693 inote
.type
= BYTE_GET (external
->type
);
8694 inote
.namesz
= BYTE_GET (external
->namesz
);
8695 inote
.namedata
= external
->name
;
8696 inote
.descsz
= BYTE_GET (external
->descsz
);
8697 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8698 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8700 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8702 if (((char *) next
) > (((char *) pnotes
) + length
))
8704 warn (_("corrupt note found at offset %lx into core notes\n"),
8705 (long)((char *)external
- (char *)pnotes
));
8706 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8707 inote
.type
, inote
.namesz
, inote
.descsz
);
8713 /* Verify that name is null terminated. It appears that at least
8714 one version of Linux (RedHat 6.0) generates corefiles that don't
8715 comply with the ELF spec by failing to include the null byte in
8717 if (inote
.namedata
[inote
.namesz
] != '\0')
8719 temp
= malloc (inote
.namesz
+ 1);
8723 error (_("Out of memory\n"));
8728 strncpy (temp
, inote
.namedata
, inote
.namesz
);
8729 temp
[inote
.namesz
] = 0;
8731 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8732 inote
.namedata
= temp
;
8735 res
&= process_note (& inote
);
8750 process_corefile_note_segments (FILE *file
)
8752 Elf_Internal_Phdr
*segment
;
8756 if (! get_program_headers (file
))
8759 for (i
= 0, segment
= program_headers
;
8760 i
< elf_header
.e_phnum
;
8763 if (segment
->p_type
== PT_NOTE
)
8764 res
&= process_corefile_note_segment (file
,
8765 (bfd_vma
) segment
->p_offset
,
8766 (bfd_vma
) segment
->p_filesz
);
8773 process_note_sections (FILE *file
)
8775 Elf_Internal_Shdr
*section
;
8779 for (i
= 0, section
= section_headers
;
8780 i
< elf_header
.e_shnum
;
8782 if (section
->sh_type
== SHT_NOTE
)
8783 res
&= process_corefile_note_segment (file
,
8784 (bfd_vma
) section
->sh_offset
,
8785 (bfd_vma
) section
->sh_size
);
8791 process_notes (FILE *file
)
8793 /* If we have not been asked to display the notes then do nothing. */
8797 if (elf_header
.e_type
!= ET_CORE
)
8798 return process_note_sections (file
);
8800 /* No program headers means no NOTE segment. */
8801 if (elf_header
.e_phnum
> 0)
8802 return process_corefile_note_segments (file
);
8804 printf (_("No note segments present in the core file.\n"));
8809 process_arch_specific (FILE *file
)
8814 switch (elf_header
.e_machine
)
8817 return process_arm_specific (file
);
8819 case EM_MIPS_RS3_LE
:
8820 return process_mips_specific (file
);
8829 get_file_header (FILE *file
)
8831 /* Read in the identity array. */
8832 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
8835 /* Determine how to read the rest of the header. */
8836 switch (elf_header
.e_ident
[EI_DATA
])
8838 default: /* fall through */
8839 case ELFDATANONE
: /* fall through */
8841 byte_get
= byte_get_little_endian
;
8842 byte_put
= byte_put_little_endian
;
8845 byte_get
= byte_get_big_endian
;
8846 byte_put
= byte_put_big_endian
;
8850 /* For now we only support 32 bit and 64 bit ELF files. */
8851 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
8853 /* Read in the rest of the header. */
8856 Elf32_External_Ehdr ehdr32
;
8858 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
8861 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
8862 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
8863 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
8864 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
8865 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
8866 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
8867 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
8868 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
8869 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
8870 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
8871 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
8872 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
8873 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
8877 Elf64_External_Ehdr ehdr64
;
8879 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8880 we will not be able to cope with the 64bit data found in
8881 64 ELF files. Detect this now and abort before we start
8882 overwriting things. */
8883 if (sizeof (bfd_vma
) < 8)
8885 error (_("This instance of readelf has been built without support for a\n\
8886 64 bit data type and so it cannot read 64 bit ELF files.\n"));
8890 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
8893 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
8894 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
8895 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
8896 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
8897 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
8898 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
8899 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
8900 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
8901 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
8902 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
8903 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
8904 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
8905 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
8908 if (elf_header
.e_shoff
)
8910 /* There may be some extensions in the first section header. Don't
8911 bomb if we can't read it. */
8913 get_32bit_section_headers (file
, 1);
8915 get_64bit_section_headers (file
, 1);
8918 is_relocatable
= elf_header
.e_type
== ET_REL
;
8923 /* Process one ELF object file according to the command line options.
8924 This file may actually be stored in an archive. The file is
8925 positioned at the start of the ELF object. */
8928 process_object (char *file_name
, FILE *file
)
8932 if (! get_file_header (file
))
8934 error (_("%s: Failed to read file header\n"), file_name
);
8938 /* Initialise per file variables. */
8939 for (i
= NUM_ELEM (version_info
); i
--;)
8940 version_info
[i
] = 0;
8942 for (i
= NUM_ELEM (dynamic_info
); i
--;)
8943 dynamic_info
[i
] = 0;
8945 /* Process the file. */
8947 printf (_("\nFile: %s\n"), file_name
);
8949 /* Initialise the dump_sects array from the cmdline_dump_sects array.
8950 Note we do this even if cmdline_dump_sects is empty because we
8951 must make sure that the dump_sets array is zeroed out before each
8952 object file is processed. */
8953 if (num_dump_sects
> num_cmdline_dump_sects
)
8954 memset (dump_sects
, 0, num_dump_sects
);
8956 if (num_cmdline_dump_sects
> 0)
8958 if (num_dump_sects
== 0)
8959 /* A sneaky way of allocating the dump_sects array. */
8960 request_dump (num_cmdline_dump_sects
, 0);
8962 assert (num_dump_sects
>= num_cmdline_dump_sects
);
8963 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
8966 if (! process_file_header ())
8969 if (! process_section_headers (file
))
8971 /* Without loaded section headers we cannot process lots of
8973 do_unwind
= do_version
= do_dump
= do_arch
= 0;
8975 if (! do_using_dynamic
)
8976 do_syms
= do_reloc
= 0;
8979 if (! process_section_groups (file
))
8981 /* Without loaded section groups we cannot process unwind. */
8985 if (process_program_headers (file
))
8986 process_dynamic_section (file
);
8988 process_relocs (file
);
8990 process_unwind (file
);
8992 process_symbol_table (file
);
8994 process_syminfo (file
);
8996 process_version_sections (file
);
8998 process_section_contents (file
);
9000 process_notes (file
);
9002 process_gnu_liblist (file
);
9004 process_arch_specific (file
);
9006 if (program_headers
)
9008 free (program_headers
);
9009 program_headers
= NULL
;
9012 if (section_headers
)
9014 free (section_headers
);
9015 section_headers
= NULL
;
9020 free (string_table
);
9021 string_table
= NULL
;
9022 string_table_length
= 0;
9025 if (dynamic_strings
)
9027 free (dynamic_strings
);
9028 dynamic_strings
= NULL
;
9029 dynamic_strings_length
= 0;
9032 if (dynamic_symbols
)
9034 free (dynamic_symbols
);
9035 dynamic_symbols
= NULL
;
9036 num_dynamic_syms
= 0;
9039 if (dynamic_syminfo
)
9041 free (dynamic_syminfo
);
9042 dynamic_syminfo
= NULL
;
9045 if (section_headers_groups
)
9047 free (section_headers_groups
);
9048 section_headers_groups
= NULL
;
9053 struct group_list
*g
, *next
;
9055 for (i
= 0; i
< group_count
; i
++)
9057 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
9064 free (section_groups
);
9065 section_groups
= NULL
;
9068 free_debug_memory ();
9073 /* Process an ELF archive. The file is positioned just after the
9077 process_archive (char *file_name
, FILE *file
)
9079 struct ar_hdr arhdr
;
9082 char *longnames
= NULL
;
9083 unsigned long longnames_size
= 0;
9084 size_t file_name_size
;
9089 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9090 if (got
!= sizeof arhdr
)
9095 error (_("%s: failed to read archive header\n"), file_name
);
9099 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
9101 /* This is the archive symbol table. Skip it.
9102 FIXME: We should have an option to dump it. */
9103 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9104 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
9106 error (_("%s: failed to skip archive symbol table\n"), file_name
);
9110 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9111 if (got
!= sizeof arhdr
)
9116 error (_("%s: failed to read archive header\n"), file_name
);
9121 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
9123 /* This is the archive string table holding long member
9126 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9128 longnames
= malloc (longnames_size
);
9129 if (longnames
== NULL
)
9131 error (_("Out of memory\n"));
9135 if (fread (longnames
, longnames_size
, 1, file
) != 1)
9138 error (_("%s: failed to read string table\n"), file_name
);
9142 if ((longnames_size
& 1) != 0)
9145 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9146 if (got
!= sizeof arhdr
)
9153 error (_("%s: failed to read archive header\n"), file_name
);
9158 file_name_size
= strlen (file_name
);
9167 if (arhdr
.ar_name
[0] == '/')
9171 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
9172 if (off
>= longnames_size
)
9174 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
9179 name
= longnames
+ off
;
9180 nameend
= memchr (name
, '/', longnames_size
- off
);
9184 name
= arhdr
.ar_name
;
9185 nameend
= memchr (name
, '/', 16);
9188 if (nameend
== NULL
)
9190 error (_("%s: bad archive file name\n"), file_name
);
9195 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
9196 if (namealc
== NULL
)
9198 error (_("Out of memory\n"));
9203 memcpy (namealc
, file_name
, file_name_size
);
9204 namealc
[file_name_size
] = '(';
9205 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
9206 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
9207 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
9209 archive_file_offset
= ftell (file
);
9210 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9212 ret
|= process_object (namealc
, file
);
9217 (archive_file_offset
9219 + (archive_file_size
& 1)),
9222 error (_("%s: failed to seek to next archive header\n"), file_name
);
9227 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9228 if (got
!= sizeof arhdr
)
9233 error (_("%s: failed to read archive header\n"), file_name
);
9246 process_file (char *file_name
)
9249 struct stat statbuf
;
9253 if (stat (file_name
, &statbuf
) < 0)
9255 if (errno
== ENOENT
)
9256 error (_("'%s': No such file\n"), file_name
);
9258 error (_("Could not locate '%s'. System error message: %s\n"),
9259 file_name
, strerror (errno
));
9263 if (! S_ISREG (statbuf
.st_mode
))
9265 error (_("'%s' is not an ordinary file\n"), file_name
);
9269 file
= fopen (file_name
, "rb");
9272 error (_("Input file '%s' is not readable.\n"), file_name
);
9276 if (fread (armag
, SARMAG
, 1, file
) != 1)
9278 error (_("%s: Failed to read file header\n"), file_name
);
9283 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
9284 ret
= process_archive (file_name
, file
);
9288 archive_file_size
= archive_file_offset
= 0;
9289 ret
= process_object (file_name
, file
);
9297 #ifdef SUPPORT_DISASSEMBLY
9298 /* Needed by the i386 disassembler. For extra credit, someone could
9299 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9303 print_address (unsigned int addr
, FILE *outfile
)
9305 fprintf (outfile
,"0x%8.8x", addr
);
9308 /* Needed by the i386 disassembler. */
9310 db_task_printsym (unsigned int addr
)
9312 print_address (addr
, stderr
);
9317 main (int argc
, char **argv
)
9321 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9322 setlocale (LC_MESSAGES
, "");
9324 #if defined (HAVE_SETLOCALE)
9325 setlocale (LC_CTYPE
, "");
9327 bindtextdomain (PACKAGE
, LOCALEDIR
);
9328 textdomain (PACKAGE
);
9330 expandargv (&argc
, &argv
);
9332 parse_args (argc
, argv
);
9334 if (num_dump_sects
> 0)
9336 /* Make a copy of the dump_sects array. */
9337 cmdline_dump_sects
= malloc (num_dump_sects
);
9338 if (cmdline_dump_sects
== NULL
)
9339 error (_("Out of memory allocating dump request table."));
9342 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
9343 num_cmdline_dump_sects
= num_dump_sects
;
9347 if (optind
< (argc
- 1))
9351 while (optind
< argc
)
9352 err
|= process_file (argv
[optind
++]);
9354 if (dump_sects
!= NULL
)
9356 if (cmdline_dump_sects
!= NULL
)
9357 free (cmdline_dump_sects
);