1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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 dynamic array of flags indicating for which sections a hex dump
181 has been requested (via the -x switch) and/or a disassembly dump
182 (via the -i switch). */
183 char *cmdline_dump_sects
= NULL
;
184 unsigned num_cmdline_dump_sects
= 0;
186 /* A dynamic array of flags indicating for which sections a dump of
187 some kind has been requested. It is reset on a per-object file
188 basis and then initialised from the cmdline_dump_sects array and
189 the results of interpreting the -w switch. */
190 char *dump_sects
= NULL
;
191 unsigned int num_dump_sects
= 0;
193 #define HEX_DUMP (1 << 0)
194 #define DISASS_DUMP (1 << 1)
195 #define DEBUG_DUMP (1 << 2)
197 /* How to print a vma value. */
198 typedef enum print_mode
210 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
214 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
215 ((X)->sh_name >= string_table_length \
216 ? "<corrupt>" : string_table + (X)->sh_name))
218 /* Given st_shndx I, map to section_headers index. */
219 #define SECTION_HEADER_INDEX(I) \
220 ((I) < SHN_LORESERVE \
222 : ((I) <= SHN_HIRESERVE \
224 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
226 /* Reverse of the above. */
227 #define SECTION_HEADER_NUM(N) \
228 ((N) < SHN_LORESERVE \
230 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
232 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
234 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
236 #define BYTE_GET(field) byte_get (field, sizeof (field))
238 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
240 #define GET_ELF_SYMBOLS(file, section) \
241 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
242 : get_64bit_elf_symbols (file, section))
244 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
245 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
246 already been called and verified that the string exists. */
247 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
249 /* This is just a bit of syntatic sugar. */
250 #define streq(a,b) (strcmp ((a), (b)) == 0)
251 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
254 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
259 if (size
== 0 || nmemb
== 0)
262 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
264 error (_("Unable to seek to 0x%lx for %s\n"),
265 archive_file_offset
+ offset
, reason
);
272 /* Check for overflow. */
273 if (nmemb
< (~(size_t) 0 - 1) / size
)
274 /* + 1 so that we can '\0' terminate invalid string table sections. */
275 mvar
= malloc (size
* nmemb
+ 1);
279 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
280 (unsigned long)(size
* nmemb
), reason
);
284 ((char *) mvar
)[size
* nmemb
] = '\0';
287 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
289 error (_("Unable to read in 0x%lx bytes of %s\n"),
290 (unsigned long)(size
* nmemb
), reason
);
300 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
305 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
306 field
[6] = ((value
>> 24) >> 24) & 0xff;
307 field
[5] = ((value
>> 24) >> 16) & 0xff;
308 field
[4] = ((value
>> 24) >> 8) & 0xff;
311 field
[3] = (value
>> 24) & 0xff;
312 field
[2] = (value
>> 16) & 0xff;
315 field
[1] = (value
>> 8) & 0xff;
318 field
[0] = value
& 0xff;
322 error (_("Unhandled data length: %d\n"), size
);
327 #if defined BFD64 && !BFD_HOST_64BIT_LONG
329 print_dec_vma (bfd_vma vma
, int is_signed
)
335 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
344 *bufp
++ = '0' + vma
% 10;
356 print_hex_vma (bfd_vma vma
)
364 char digit
= '0' + (vma
& 0x0f);
366 digit
+= 'a' - '0' - 10;
379 /* Print a VMA value. */
381 print_vma (bfd_vma vma
, print_mode mode
)
390 return printf ("0x%8.8lx", (unsigned long) vma
);
393 return printf ("%8.8lx", (unsigned long) vma
);
397 return printf ("%5ld", (long) vma
);
401 return printf ("0x%lx", (unsigned long) vma
);
404 return printf ("%lx", (unsigned long) vma
);
407 return printf ("%ld", (unsigned long) vma
);
410 return printf ("%lu", (unsigned long) vma
);
433 #if BFD_HOST_64BIT_LONG
434 return nc
+ printf ("%lx", vma
);
436 return nc
+ print_hex_vma (vma
);
440 #if BFD_HOST_64BIT_LONG
441 return printf ("%ld", vma
);
443 return print_dec_vma (vma
, 1);
447 #if BFD_HOST_64BIT_LONG
449 return printf ("%5ld", vma
);
451 return printf ("%#lx", vma
);
454 return printf ("%5ld", _bfd_int64_low (vma
));
456 return print_hex_vma (vma
);
460 #if BFD_HOST_64BIT_LONG
461 return printf ("%lu", vma
);
463 return print_dec_vma (vma
, 0);
471 /* Display a symbol on stdout. If do_wide is not true then
472 format the symbol to be at most WIDTH characters,
473 truncating as necessary. If WIDTH is negative then
474 format the string to be exactly - WIDTH characters,
475 truncating or padding as necessary. */
478 print_symbol (int width
, const char *symbol
)
481 printf ("%s", symbol
);
483 printf ("%-*.*s", width
, width
, symbol
);
485 printf ("%-.*s", width
, symbol
);
489 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
494 field
[7] = value
& 0xff;
495 field
[6] = (value
>> 8) & 0xff;
496 field
[5] = (value
>> 16) & 0xff;
497 field
[4] = (value
>> 24) & 0xff;
502 field
[3] = value
& 0xff;
503 field
[2] = (value
>> 8) & 0xff;
507 field
[1] = value
& 0xff;
511 field
[0] = value
& 0xff;
515 error (_("Unhandled data length: %d\n"), size
);
520 /* Return a pointer to section NAME, or NULL if no such section exists. */
522 static Elf_Internal_Shdr
*
523 find_section (const char *name
)
527 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
528 if (streq (SECTION_NAME (section_headers
+ i
), name
))
529 return section_headers
+ i
;
534 /* Guess the relocation size commonly used by the specific machines. */
537 guess_is_rela (unsigned long e_machine
)
541 /* Targets that use REL relocations. */
556 /* Targets that use RELA relocations. */
571 case EM_CYGNUS_MN10200
:
573 case EM_CYGNUS_MN10300
:
623 warn (_("Don't know about relocations on this machine architecture\n"));
629 slurp_rela_relocs (FILE *file
,
630 unsigned long rel_offset
,
631 unsigned long rel_size
,
632 Elf_Internal_Rela
**relasp
,
633 unsigned long *nrelasp
)
635 Elf_Internal_Rela
*relas
;
636 unsigned long nrelas
;
641 Elf32_External_Rela
*erelas
;
643 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
647 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
649 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
654 error (_("out of memory parsing relocs"));
658 for (i
= 0; i
< nrelas
; i
++)
660 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
661 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
662 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
669 Elf64_External_Rela
*erelas
;
671 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
675 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
677 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
682 error (_("out of memory parsing relocs"));
686 for (i
= 0; i
< nrelas
; i
++)
688 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
689 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
690 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
701 slurp_rel_relocs (FILE *file
,
702 unsigned long rel_offset
,
703 unsigned long rel_size
,
704 Elf_Internal_Rela
**relsp
,
705 unsigned long *nrelsp
)
707 Elf_Internal_Rela
*rels
;
713 Elf32_External_Rel
*erels
;
715 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
719 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
721 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
726 error (_("out of memory parsing relocs"));
730 for (i
= 0; i
< nrels
; i
++)
732 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
733 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
734 rels
[i
].r_addend
= 0;
741 Elf64_External_Rel
*erels
;
743 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
747 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
749 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
754 error (_("out of memory parsing relocs"));
758 for (i
= 0; i
< nrels
; i
++)
760 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
761 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
762 rels
[i
].r_addend
= 0;
772 /* Display the contents of the relocation data found at the specified
776 dump_relocations (FILE *file
,
777 unsigned long rel_offset
,
778 unsigned long rel_size
,
779 Elf_Internal_Sym
*symtab
,
782 unsigned long strtablen
,
786 Elf_Internal_Rela
*rels
;
789 if (is_rela
== UNKNOWN
)
790 is_rela
= guess_is_rela (elf_header
.e_machine
);
794 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
799 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
808 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
810 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
815 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
817 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
825 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
827 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
832 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
834 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
838 for (i
= 0; i
< rel_size
; i
++)
841 const char *rtype2
= NULL
;
842 const char *rtype3
= NULL
;
845 bfd_vma symtab_index
;
850 offset
= rels
[i
].r_offset
;
851 info
= rels
[i
].r_info
;
855 type
= ELF32_R_TYPE (info
);
856 symtab_index
= ELF32_R_SYM (info
);
860 /* The #ifdef BFD64 below is to prevent a compile time warning.
861 We know that if we do not have a 64 bit data type that we
862 will never execute this code anyway. */
864 if (elf_header
.e_machine
== EM_MIPS
)
866 /* In little-endian objects, r_info isn't really a 64-bit
867 little-endian value: it has a 32-bit little-endian
868 symbol index followed by four individual byte fields.
869 Reorder INFO accordingly. */
870 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
871 info
= (((info
& 0xffffffff) << 32)
872 | ((info
>> 56) & 0xff)
873 | ((info
>> 40) & 0xff00)
874 | ((info
>> 24) & 0xff0000)
875 | ((info
>> 8) & 0xff000000));
876 type
= ELF64_MIPS_R_TYPE (info
);
877 type2
= ELF64_MIPS_R_TYPE2 (info
);
878 type3
= ELF64_MIPS_R_TYPE3 (info
);
880 else if (elf_header
.e_machine
== EM_SPARCV9
)
881 type
= ELF64_R_TYPE_ID (info
);
883 type
= ELF64_R_TYPE (info
);
885 symtab_index
= ELF64_R_SYM (info
);
891 #ifdef _bfd_int64_low
892 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
894 printf ("%8.8lx %8.8lx ", offset
, info
);
899 #ifdef _bfd_int64_low
901 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
902 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
903 _bfd_int64_high (offset
),
904 _bfd_int64_low (offset
),
905 _bfd_int64_high (info
),
906 _bfd_int64_low (info
));
909 ? "%16.16lx %16.16lx "
910 : "%12.12lx %12.12lx ",
915 switch (elf_header
.e_machine
)
923 rtype
= elf_m32r_reloc_type (type
);
928 rtype
= elf_i386_reloc_type (type
);
933 rtype
= elf_m68hc11_reloc_type (type
);
937 rtype
= elf_m68k_reloc_type (type
);
941 rtype
= elf_i960_reloc_type (type
);
946 rtype
= elf_avr_reloc_type (type
);
953 rtype
= elf_sparc_reloc_type (type
);
958 rtype
= v850_reloc_type (type
);
963 rtype
= elf_d10v_reloc_type (type
);
968 rtype
= elf_d30v_reloc_type (type
);
972 rtype
= elf_dlx_reloc_type (type
);
976 rtype
= elf_sh_reloc_type (type
);
980 case EM_CYGNUS_MN10300
:
981 rtype
= elf_mn10300_reloc_type (type
);
985 case EM_CYGNUS_MN10200
:
986 rtype
= elf_mn10200_reloc_type (type
);
991 rtype
= elf_fr30_reloc_type (type
);
995 rtype
= elf_frv_reloc_type (type
);
999 rtype
= elf_mcore_reloc_type (type
);
1003 rtype
= elf_mmix_reloc_type (type
);
1008 rtype
= elf_msp430_reloc_type (type
);
1012 rtype
= elf_ppc_reloc_type (type
);
1016 rtype
= elf_ppc64_reloc_type (type
);
1020 case EM_MIPS_RS3_LE
:
1021 rtype
= elf_mips_reloc_type (type
);
1024 rtype2
= elf_mips_reloc_type (type2
);
1025 rtype3
= elf_mips_reloc_type (type3
);
1030 rtype
= elf_alpha_reloc_type (type
);
1034 rtype
= elf_arm_reloc_type (type
);
1038 rtype
= elf_arc_reloc_type (type
);
1042 rtype
= elf_hppa_reloc_type (type
);
1048 rtype
= elf_h8_reloc_type (type
);
1053 rtype
= elf_or32_reloc_type (type
);
1058 rtype
= elf_pj_reloc_type (type
);
1061 rtype
= elf_ia64_reloc_type (type
);
1065 rtype
= elf_cris_reloc_type (type
);
1069 rtype
= elf_i860_reloc_type (type
);
1073 rtype
= elf_x86_64_reloc_type (type
);
1077 rtype
= i370_reloc_type (type
);
1082 rtype
= elf_s390_reloc_type (type
);
1086 rtype
= elf_xstormy16_reloc_type (type
);
1090 rtype
= elf_crx_reloc_type (type
);
1094 rtype
= elf_vax_reloc_type (type
);
1099 rtype
= elf_ip2k_reloc_type (type
);
1103 rtype
= elf_iq2000_reloc_type (type
);
1108 rtype
= elf_xtensa_reloc_type (type
);
1112 rtype
= elf_m32c_reloc_type (type
);
1116 rtype
= elf_ms1_reloc_type (type
);
1120 rtype
= elf_bfin_reloc_type (type
);
1126 #ifdef _bfd_int64_low
1127 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1129 printf (_("unrecognized: %-7lx"), type
);
1132 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1134 if (elf_header
.e_machine
== EM_ALPHA
1135 && streq (rtype
, "R_ALPHA_LITUSE")
1138 switch (rels
[i
].r_addend
)
1140 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1141 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1142 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1143 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1144 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1145 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1146 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1147 default: rtype
= NULL
;
1150 printf (" (%s)", rtype
);
1154 printf (_("<unknown addend: %lx>"),
1155 (unsigned long) rels
[i
].r_addend
);
1158 else if (symtab_index
)
1160 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1161 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1164 Elf_Internal_Sym
*psym
;
1166 psym
= symtab
+ symtab_index
;
1169 print_vma (psym
->st_value
, LONG_HEX
);
1170 printf (is_32bit_elf
? " " : " ");
1172 if (psym
->st_name
== 0)
1174 const char *sec_name
= "<null>";
1177 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1179 bfd_vma sec_index
= (bfd_vma
) -1;
1181 if (psym
->st_shndx
< SHN_LORESERVE
)
1182 sec_index
= psym
->st_shndx
;
1183 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1184 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1187 if (sec_index
!= (bfd_vma
) -1)
1188 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1189 else if (psym
->st_shndx
== SHN_ABS
)
1191 else if (psym
->st_shndx
== SHN_COMMON
)
1192 sec_name
= "COMMON";
1193 else if (elf_header
.e_machine
== EM_X86_64
1194 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1195 sec_name
= "LARGE_COMMON";
1196 else if (elf_header
.e_machine
== EM_IA_64
1197 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1198 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1199 sec_name
= "ANSI_COM";
1202 sprintf (name_buf
, "<section 0x%x>",
1203 (unsigned int) psym
->st_shndx
);
1204 sec_name
= name_buf
;
1207 print_symbol (22, sec_name
);
1209 else if (strtab
== NULL
)
1210 printf (_("<string table index: %3ld>"), psym
->st_name
);
1211 else if (psym
->st_name
>= strtablen
)
1212 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1214 print_symbol (22, strtab
+ psym
->st_name
);
1217 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1222 printf ("%*c", is_32bit_elf
?
1223 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1224 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1227 if (elf_header
.e_machine
== EM_SPARCV9
&& streq (rtype
, "R_SPARC_OLO10"))
1228 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1232 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1234 printf (" Type2: ");
1237 #ifdef _bfd_int64_low
1238 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1240 printf (_("unrecognized: %-7lx"), type2
);
1243 printf ("%-17.17s", rtype2
);
1245 printf ("\n Type3: ");
1248 #ifdef _bfd_int64_low
1249 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1251 printf (_("unrecognized: %-7lx"), type3
);
1254 printf ("%-17.17s", rtype3
);
1266 get_mips_dynamic_type (unsigned long type
)
1270 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1271 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1272 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1273 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1274 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1275 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1276 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1277 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1278 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1279 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1280 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1281 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1282 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1283 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1284 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1285 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1286 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1287 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1288 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1289 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1290 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1291 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1292 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1293 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1294 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1295 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1296 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1297 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1298 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1299 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1300 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1301 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1302 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1303 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1304 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1305 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1306 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1307 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1308 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1309 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1310 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1311 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1312 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1319 get_sparc64_dynamic_type (unsigned long type
)
1323 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1330 get_ppc_dynamic_type (unsigned long type
)
1334 case DT_PPC_GOT
: return "PPC_GOT";
1341 get_ppc64_dynamic_type (unsigned long type
)
1345 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1346 case DT_PPC64_OPD
: return "PPC64_OPD";
1347 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1354 get_parisc_dynamic_type (unsigned long type
)
1358 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1359 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1360 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1361 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1362 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1363 case DT_HP_PREINIT
: return "HP_PREINIT";
1364 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1365 case DT_HP_NEEDED
: return "HP_NEEDED";
1366 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1367 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1368 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1369 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1370 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1371 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1372 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1373 case DT_HP_FILTERED
: return "HP_FILTERED";
1374 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1375 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1376 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1377 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1378 case DT_PLT
: return "PLT";
1379 case DT_PLT_SIZE
: return "PLT_SIZE";
1380 case DT_DLT
: return "DLT";
1381 case DT_DLT_SIZE
: return "DLT_SIZE";
1388 get_ia64_dynamic_type (unsigned long type
)
1392 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1399 get_alpha_dynamic_type (unsigned long type
)
1403 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1410 get_dynamic_type (unsigned long type
)
1412 static char buff
[64];
1416 case DT_NULL
: return "NULL";
1417 case DT_NEEDED
: return "NEEDED";
1418 case DT_PLTRELSZ
: return "PLTRELSZ";
1419 case DT_PLTGOT
: return "PLTGOT";
1420 case DT_HASH
: return "HASH";
1421 case DT_STRTAB
: return "STRTAB";
1422 case DT_SYMTAB
: return "SYMTAB";
1423 case DT_RELA
: return "RELA";
1424 case DT_RELASZ
: return "RELASZ";
1425 case DT_RELAENT
: return "RELAENT";
1426 case DT_STRSZ
: return "STRSZ";
1427 case DT_SYMENT
: return "SYMENT";
1428 case DT_INIT
: return "INIT";
1429 case DT_FINI
: return "FINI";
1430 case DT_SONAME
: return "SONAME";
1431 case DT_RPATH
: return "RPATH";
1432 case DT_SYMBOLIC
: return "SYMBOLIC";
1433 case DT_REL
: return "REL";
1434 case DT_RELSZ
: return "RELSZ";
1435 case DT_RELENT
: return "RELENT";
1436 case DT_PLTREL
: return "PLTREL";
1437 case DT_DEBUG
: return "DEBUG";
1438 case DT_TEXTREL
: return "TEXTREL";
1439 case DT_JMPREL
: return "JMPREL";
1440 case DT_BIND_NOW
: return "BIND_NOW";
1441 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1442 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1443 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1444 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1445 case DT_RUNPATH
: return "RUNPATH";
1446 case DT_FLAGS
: return "FLAGS";
1448 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1449 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1451 case DT_CHECKSUM
: return "CHECKSUM";
1452 case DT_PLTPADSZ
: return "PLTPADSZ";
1453 case DT_MOVEENT
: return "MOVEENT";
1454 case DT_MOVESZ
: return "MOVESZ";
1455 case DT_FEATURE
: return "FEATURE";
1456 case DT_POSFLAG_1
: return "POSFLAG_1";
1457 case DT_SYMINSZ
: return "SYMINSZ";
1458 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1460 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1461 case DT_CONFIG
: return "CONFIG";
1462 case DT_DEPAUDIT
: return "DEPAUDIT";
1463 case DT_AUDIT
: return "AUDIT";
1464 case DT_PLTPAD
: return "PLTPAD";
1465 case DT_MOVETAB
: return "MOVETAB";
1466 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1468 case DT_VERSYM
: return "VERSYM";
1470 case DT_RELACOUNT
: return "RELACOUNT";
1471 case DT_RELCOUNT
: return "RELCOUNT";
1472 case DT_FLAGS_1
: return "FLAGS_1";
1473 case DT_VERDEF
: return "VERDEF";
1474 case DT_VERDEFNUM
: return "VERDEFNUM";
1475 case DT_VERNEED
: return "VERNEED";
1476 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1478 case DT_AUXILIARY
: return "AUXILIARY";
1479 case DT_USED
: return "USED";
1480 case DT_FILTER
: return "FILTER";
1482 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1483 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1484 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1485 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1486 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1489 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1493 switch (elf_header
.e_machine
)
1496 case EM_MIPS_RS3_LE
:
1497 result
= get_mips_dynamic_type (type
);
1500 result
= get_sparc64_dynamic_type (type
);
1503 result
= get_ppc_dynamic_type (type
);
1506 result
= get_ppc64_dynamic_type (type
);
1509 result
= get_ia64_dynamic_type (type
);
1512 result
= get_alpha_dynamic_type (type
);
1522 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1524 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1525 || (elf_header
.e_machine
== EM_PARISC
1526 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1530 switch (elf_header
.e_machine
)
1533 result
= get_parisc_dynamic_type (type
);
1543 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1547 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1554 get_file_type (unsigned e_type
)
1556 static char buff
[32];
1560 case ET_NONE
: return _("NONE (None)");
1561 case ET_REL
: return _("REL (Relocatable file)");
1562 case ET_EXEC
: return _("EXEC (Executable file)");
1563 case ET_DYN
: return _("DYN (Shared object file)");
1564 case ET_CORE
: return _("CORE (Core file)");
1567 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1568 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1569 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1570 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1572 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1578 get_machine_name (unsigned e_machine
)
1580 static char buff
[64]; /* XXX */
1584 case EM_NONE
: return _("None");
1585 case EM_M32
: return "WE32100";
1586 case EM_SPARC
: return "Sparc";
1587 case EM_386
: return "Intel 80386";
1588 case EM_68K
: return "MC68000";
1589 case EM_88K
: return "MC88000";
1590 case EM_486
: return "Intel 80486";
1591 case EM_860
: return "Intel 80860";
1592 case EM_MIPS
: return "MIPS R3000";
1593 case EM_S370
: return "IBM System/370";
1594 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1595 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1596 case EM_PARISC
: return "HPPA";
1597 case EM_PPC_OLD
: return "Power PC (old)";
1598 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1599 case EM_960
: return "Intel 90860";
1600 case EM_PPC
: return "PowerPC";
1601 case EM_PPC64
: return "PowerPC64";
1602 case EM_V800
: return "NEC V800";
1603 case EM_FR20
: return "Fujitsu FR20";
1604 case EM_RH32
: return "TRW RH32";
1605 case EM_MCORE
: return "MCORE";
1606 case EM_ARM
: return "ARM";
1607 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1608 case EM_SH
: return "Renesas / SuperH SH";
1609 case EM_SPARCV9
: return "Sparc v9";
1610 case EM_TRICORE
: return "Siemens Tricore";
1611 case EM_ARC
: return "ARC";
1612 case EM_H8_300
: return "Renesas H8/300";
1613 case EM_H8_300H
: return "Renesas H8/300H";
1614 case EM_H8S
: return "Renesas H8S";
1615 case EM_H8_500
: return "Renesas H8/500";
1616 case EM_IA_64
: return "Intel IA-64";
1617 case EM_MIPS_X
: return "Stanford MIPS-X";
1618 case EM_COLDFIRE
: return "Motorola Coldfire";
1619 case EM_68HC12
: return "Motorola M68HC12";
1620 case EM_ALPHA
: return "Alpha";
1621 case EM_CYGNUS_D10V
:
1622 case EM_D10V
: return "d10v";
1623 case EM_CYGNUS_D30V
:
1624 case EM_D30V
: return "d30v";
1625 case EM_CYGNUS_M32R
:
1626 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1627 case EM_CYGNUS_V850
:
1628 case EM_V850
: return "NEC v850";
1629 case EM_CYGNUS_MN10300
:
1630 case EM_MN10300
: return "mn10300";
1631 case EM_CYGNUS_MN10200
:
1632 case EM_MN10200
: return "mn10200";
1633 case EM_CYGNUS_FR30
:
1634 case EM_FR30
: return "Fujitsu FR30";
1635 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1637 case EM_PJ
: return "picoJava";
1638 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1639 case EM_PCP
: return "Siemens PCP";
1640 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1641 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1642 case EM_STARCORE
: return "Motorola Star*Core processor";
1643 case EM_ME16
: return "Toyota ME16 processor";
1644 case EM_ST100
: return "STMicroelectronics ST100 processor";
1645 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1646 case EM_FX66
: return "Siemens FX66 microcontroller";
1647 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1648 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1649 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1650 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1651 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1652 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1653 case EM_SVX
: return "Silicon Graphics SVx";
1654 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1655 case EM_VAX
: return "Digital VAX";
1657 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1658 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1659 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1660 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1661 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1662 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1663 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1664 case EM_PRISM
: return "Vitesse Prism";
1665 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1667 case EM_S390
: return "IBM S/390";
1668 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1670 case EM_OR32
: return "OpenRISC";
1671 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1672 case EM_DLX
: return "OpenDLX";
1674 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1675 case EM_IQ2000
: return "Vitesse IQ2000";
1677 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1678 case EM_M32C
: return "Renesas M32c";
1679 case EM_MS1
: return "Morpho Techologies MS1 processor";
1681 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1687 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1692 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1693 e_flags
&= ~ EF_ARM_EABIMASK
;
1695 /* Handle "generic" ARM flags. */
1696 if (e_flags
& EF_ARM_RELEXEC
)
1698 strcat (buf
, ", relocatable executable");
1699 e_flags
&= ~ EF_ARM_RELEXEC
;
1702 if (e_flags
& EF_ARM_HASENTRY
)
1704 strcat (buf
, ", has entry point");
1705 e_flags
&= ~ EF_ARM_HASENTRY
;
1708 /* Now handle EABI specific flags. */
1712 strcat (buf
, ", <unrecognized EABI>");
1717 case EF_ARM_EABI_VER1
:
1718 strcat (buf
, ", Version1 EABI");
1723 /* Process flags one bit at a time. */
1724 flag
= e_flags
& - e_flags
;
1729 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1730 strcat (buf
, ", sorted symbol tables");
1740 case EF_ARM_EABI_VER2
:
1741 strcat (buf
, ", Version2 EABI");
1746 /* Process flags one bit at a time. */
1747 flag
= e_flags
& - e_flags
;
1752 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1753 strcat (buf
, ", sorted symbol tables");
1756 case EF_ARM_DYNSYMSUSESEGIDX
:
1757 strcat (buf
, ", dynamic symbols use segment index");
1760 case EF_ARM_MAPSYMSFIRST
:
1761 strcat (buf
, ", mapping symbols precede others");
1771 case EF_ARM_EABI_VER3
:
1772 strcat (buf
, ", Version3 EABI");
1775 case EF_ARM_EABI_VER4
:
1776 strcat (buf
, ", Version4 EABI");
1781 /* Process flags one bit at a time. */
1782 flag
= e_flags
& - e_flags
;
1788 strcat (buf
, ", BE8");
1792 strcat (buf
, ", LE8");
1802 case EF_ARM_EABI_UNKNOWN
:
1803 strcat (buf
, ", GNU EABI");
1808 /* Process flags one bit at a time. */
1809 flag
= e_flags
& - e_flags
;
1814 case EF_ARM_INTERWORK
:
1815 strcat (buf
, ", interworking enabled");
1818 case EF_ARM_APCS_26
:
1819 strcat (buf
, ", uses APCS/26");
1822 case EF_ARM_APCS_FLOAT
:
1823 strcat (buf
, ", uses APCS/float");
1827 strcat (buf
, ", position independent");
1831 strcat (buf
, ", 8 bit structure alignment");
1834 case EF_ARM_NEW_ABI
:
1835 strcat (buf
, ", uses new ABI");
1838 case EF_ARM_OLD_ABI
:
1839 strcat (buf
, ", uses old ABI");
1842 case EF_ARM_SOFT_FLOAT
:
1843 strcat (buf
, ", software FP");
1846 case EF_ARM_VFP_FLOAT
:
1847 strcat (buf
, ", VFP");
1850 case EF_ARM_MAVERICK_FLOAT
:
1851 strcat (buf
, ", Maverick FP");
1862 strcat (buf
,", <unknown>");
1866 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1868 static char buf
[1024];
1880 decode_ARM_machine_flags (e_flags
, buf
);
1884 switch (e_flags
& EF_FRV_CPU_MASK
)
1886 case EF_FRV_CPU_GENERIC
:
1890 strcat (buf
, ", fr???");
1893 case EF_FRV_CPU_FR300
:
1894 strcat (buf
, ", fr300");
1897 case EF_FRV_CPU_FR400
:
1898 strcat (buf
, ", fr400");
1900 case EF_FRV_CPU_FR405
:
1901 strcat (buf
, ", fr405");
1904 case EF_FRV_CPU_FR450
:
1905 strcat (buf
, ", fr450");
1908 case EF_FRV_CPU_FR500
:
1909 strcat (buf
, ", fr500");
1911 case EF_FRV_CPU_FR550
:
1912 strcat (buf
, ", fr550");
1915 case EF_FRV_CPU_SIMPLE
:
1916 strcat (buf
, ", simple");
1918 case EF_FRV_CPU_TOMCAT
:
1919 strcat (buf
, ", tomcat");
1925 if (e_flags
& EF_CPU32
)
1926 strcat (buf
, ", cpu32");
1927 if (e_flags
& EF_M68000
)
1928 strcat (buf
, ", m68000");
1932 if (e_flags
& EF_PPC_EMB
)
1933 strcat (buf
, ", emb");
1935 if (e_flags
& EF_PPC_RELOCATABLE
)
1936 strcat (buf
, ", relocatable");
1938 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1939 strcat (buf
, ", relocatable-lib");
1943 case EM_CYGNUS_V850
:
1944 switch (e_flags
& EF_V850_ARCH
)
1947 strcat (buf
, ", v850e1");
1950 strcat (buf
, ", v850e");
1953 strcat (buf
, ", v850");
1956 strcat (buf
, ", unknown v850 architecture variant");
1962 case EM_CYGNUS_M32R
:
1963 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1964 strcat (buf
, ", m32r");
1969 case EM_MIPS_RS3_LE
:
1970 if (e_flags
& EF_MIPS_NOREORDER
)
1971 strcat (buf
, ", noreorder");
1973 if (e_flags
& EF_MIPS_PIC
)
1974 strcat (buf
, ", pic");
1976 if (e_flags
& EF_MIPS_CPIC
)
1977 strcat (buf
, ", cpic");
1979 if (e_flags
& EF_MIPS_UCODE
)
1980 strcat (buf
, ", ugen_reserved");
1982 if (e_flags
& EF_MIPS_ABI2
)
1983 strcat (buf
, ", abi2");
1985 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1986 strcat (buf
, ", odk first");
1988 if (e_flags
& EF_MIPS_32BITMODE
)
1989 strcat (buf
, ", 32bitmode");
1991 switch ((e_flags
& EF_MIPS_MACH
))
1993 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1994 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1995 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1996 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1997 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1998 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1999 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2000 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2001 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2002 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2004 /* We simply ignore the field in this case to avoid confusion:
2005 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2008 default: strcat (buf
, ", unknown CPU"); break;
2011 switch ((e_flags
& EF_MIPS_ABI
))
2013 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2014 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2015 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2016 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2018 /* We simply ignore the field in this case to avoid confusion:
2019 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2020 This means it is likely to be an o32 file, but not for
2023 default: strcat (buf
, ", unknown ABI"); break;
2026 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2027 strcat (buf
, ", mdmx");
2029 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2030 strcat (buf
, ", mips16");
2032 switch ((e_flags
& EF_MIPS_ARCH
))
2034 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2035 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2036 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2037 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2038 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2039 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2040 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2041 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2042 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2043 default: strcat (buf
, ", unknown ISA"); break;
2049 switch ((e_flags
& EF_SH_MACH_MASK
))
2051 case EF_SH1
: strcat (buf
, ", sh1"); break;
2052 case EF_SH2
: strcat (buf
, ", sh2"); break;
2053 case EF_SH3
: strcat (buf
, ", sh3"); break;
2054 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2055 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2056 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2057 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2058 case EF_SH4
: strcat (buf
, ", sh4"); break;
2059 case EF_SH5
: strcat (buf
, ", sh5"); break;
2060 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2061 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2062 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2063 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2064 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2065 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2066 default: strcat (buf
, ", unknown ISA"); break;
2072 if (e_flags
& EF_SPARC_32PLUS
)
2073 strcat (buf
, ", v8+");
2075 if (e_flags
& EF_SPARC_SUN_US1
)
2076 strcat (buf
, ", ultrasparcI");
2078 if (e_flags
& EF_SPARC_SUN_US3
)
2079 strcat (buf
, ", ultrasparcIII");
2081 if (e_flags
& EF_SPARC_HAL_R1
)
2082 strcat (buf
, ", halr1");
2084 if (e_flags
& EF_SPARC_LEDATA
)
2085 strcat (buf
, ", ledata");
2087 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2088 strcat (buf
, ", tso");
2090 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2091 strcat (buf
, ", pso");
2093 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2094 strcat (buf
, ", rmo");
2098 switch (e_flags
& EF_PARISC_ARCH
)
2100 case EFA_PARISC_1_0
:
2101 strcpy (buf
, ", PA-RISC 1.0");
2103 case EFA_PARISC_1_1
:
2104 strcpy (buf
, ", PA-RISC 1.1");
2106 case EFA_PARISC_2_0
:
2107 strcpy (buf
, ", PA-RISC 2.0");
2112 if (e_flags
& EF_PARISC_TRAPNIL
)
2113 strcat (buf
, ", trapnil");
2114 if (e_flags
& EF_PARISC_EXT
)
2115 strcat (buf
, ", ext");
2116 if (e_flags
& EF_PARISC_LSB
)
2117 strcat (buf
, ", lsb");
2118 if (e_flags
& EF_PARISC_WIDE
)
2119 strcat (buf
, ", wide");
2120 if (e_flags
& EF_PARISC_NO_KABP
)
2121 strcat (buf
, ", no kabp");
2122 if (e_flags
& EF_PARISC_LAZYSWAP
)
2123 strcat (buf
, ", lazyswap");
2128 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2129 strcat (buf
, ", new calling convention");
2131 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2132 strcat (buf
, ", gnu calling convention");
2136 if ((e_flags
& EF_IA_64_ABI64
))
2137 strcat (buf
, ", 64-bit");
2139 strcat (buf
, ", 32-bit");
2140 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2141 strcat (buf
, ", reduced fp model");
2142 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2143 strcat (buf
, ", no function descriptors, constant gp");
2144 else if ((e_flags
& EF_IA_64_CONS_GP
))
2145 strcat (buf
, ", constant gp");
2146 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2147 strcat (buf
, ", absolute");
2151 if ((e_flags
& EF_VAX_NONPIC
))
2152 strcat (buf
, ", non-PIC");
2153 if ((e_flags
& EF_VAX_DFLOAT
))
2154 strcat (buf
, ", D-Float");
2155 if ((e_flags
& EF_VAX_GFLOAT
))
2156 strcat (buf
, ", G-Float");
2165 get_osabi_name (unsigned int osabi
)
2167 static char buff
[32];
2171 case ELFOSABI_NONE
: return "UNIX - System V";
2172 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2173 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2174 case ELFOSABI_LINUX
: return "UNIX - Linux";
2175 case ELFOSABI_HURD
: return "GNU/Hurd";
2176 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2177 case ELFOSABI_AIX
: return "UNIX - AIX";
2178 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2179 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2180 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2181 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2182 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2183 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2184 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2185 case ELFOSABI_AROS
: return "Amiga Research OS";
2186 case ELFOSABI_STANDALONE
: return _("Standalone App");
2187 case ELFOSABI_ARM
: return "ARM";
2189 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2195 get_arm_segment_type (unsigned long type
)
2209 get_mips_segment_type (unsigned long type
)
2213 case PT_MIPS_REGINFO
:
2215 case PT_MIPS_RTPROC
:
2217 case PT_MIPS_OPTIONS
:
2227 get_parisc_segment_type (unsigned long type
)
2231 case PT_HP_TLS
: return "HP_TLS";
2232 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2233 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2234 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2235 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2236 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2237 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2238 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2239 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2240 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2241 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2242 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2243 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2244 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2245 case PT_HP_STACK
: return "HP_STACK";
2246 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2247 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2248 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2249 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2258 get_ia64_segment_type (unsigned long type
)
2262 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2263 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2264 case PT_HP_TLS
: return "HP_TLS";
2265 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2266 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2267 case PT_IA_64_HP_STACK
: return "HP_STACK";
2276 get_segment_type (unsigned long p_type
)
2278 static char buff
[32];
2282 case PT_NULL
: return "NULL";
2283 case PT_LOAD
: return "LOAD";
2284 case PT_DYNAMIC
: return "DYNAMIC";
2285 case PT_INTERP
: return "INTERP";
2286 case PT_NOTE
: return "NOTE";
2287 case PT_SHLIB
: return "SHLIB";
2288 case PT_PHDR
: return "PHDR";
2289 case PT_TLS
: return "TLS";
2291 case PT_GNU_EH_FRAME
:
2292 return "GNU_EH_FRAME";
2293 case PT_GNU_STACK
: return "GNU_STACK";
2294 case PT_GNU_RELRO
: return "GNU_RELRO";
2297 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2301 switch (elf_header
.e_machine
)
2304 result
= get_arm_segment_type (p_type
);
2307 case EM_MIPS_RS3_LE
:
2308 result
= get_mips_segment_type (p_type
);
2311 result
= get_parisc_segment_type (p_type
);
2314 result
= get_ia64_segment_type (p_type
);
2324 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2326 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2330 switch (elf_header
.e_machine
)
2333 result
= get_parisc_segment_type (p_type
);
2336 result
= get_ia64_segment_type (p_type
);
2346 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2349 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2356 get_mips_section_type_name (unsigned int sh_type
)
2360 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2361 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2362 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2363 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2364 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2365 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2366 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2367 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2368 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2369 case SHT_MIPS_RELD
: return "MIPS_RELD";
2370 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2371 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2372 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2373 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2374 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2375 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2376 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2377 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2378 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2379 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2380 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2381 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2382 case SHT_MIPS_LINE
: return "MIPS_LINE";
2383 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2384 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2385 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2386 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2387 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2388 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2389 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2390 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2391 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2392 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2393 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2394 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2395 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2396 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2397 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2398 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2406 get_parisc_section_type_name (unsigned int sh_type
)
2410 case SHT_PARISC_EXT
: return "PARISC_EXT";
2411 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2412 case SHT_PARISC_DOC
: return "PARISC_DOC";
2413 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2414 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2415 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2416 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2424 get_ia64_section_type_name (unsigned int sh_type
)
2426 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2427 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2428 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2432 case SHT_IA_64_EXT
: return "IA_64_EXT";
2433 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2434 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2442 get_x86_64_section_type_name (unsigned int sh_type
)
2446 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2454 get_arm_section_type_name (unsigned int sh_type
)
2460 case SHT_ARM_PREEMPTMAP
:
2461 return "ARM_PREEMPTMAP";
2462 case SHT_ARM_ATTRIBUTES
:
2463 return "ARM_ATTRIBUTES";
2471 get_section_type_name (unsigned int sh_type
)
2473 static char buff
[32];
2477 case SHT_NULL
: return "NULL";
2478 case SHT_PROGBITS
: return "PROGBITS";
2479 case SHT_SYMTAB
: return "SYMTAB";
2480 case SHT_STRTAB
: return "STRTAB";
2481 case SHT_RELA
: return "RELA";
2482 case SHT_HASH
: return "HASH";
2483 case SHT_DYNAMIC
: return "DYNAMIC";
2484 case SHT_NOTE
: return "NOTE";
2485 case SHT_NOBITS
: return "NOBITS";
2486 case SHT_REL
: return "REL";
2487 case SHT_SHLIB
: return "SHLIB";
2488 case SHT_DYNSYM
: return "DYNSYM";
2489 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2490 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2491 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2492 case SHT_GROUP
: return "GROUP";
2493 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2494 case SHT_GNU_verdef
: return "VERDEF";
2495 case SHT_GNU_verneed
: return "VERNEED";
2496 case SHT_GNU_versym
: return "VERSYM";
2497 case 0x6ffffff0: return "VERSYM";
2498 case 0x6ffffffc: return "VERDEF";
2499 case 0x7ffffffd: return "AUXILIARY";
2500 case 0x7fffffff: return "FILTER";
2501 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2504 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2508 switch (elf_header
.e_machine
)
2511 case EM_MIPS_RS3_LE
:
2512 result
= get_mips_section_type_name (sh_type
);
2515 result
= get_parisc_section_type_name (sh_type
);
2518 result
= get_ia64_section_type_name (sh_type
);
2521 result
= get_x86_64_section_type_name (sh_type
);
2524 result
= get_arm_section_type_name (sh_type
);
2534 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2536 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2537 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2538 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2539 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2541 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2547 #define OPTION_DEBUG_DUMP 512
2549 static struct option options
[] =
2551 {"all", no_argument
, 0, 'a'},
2552 {"file-header", no_argument
, 0, 'h'},
2553 {"program-headers", no_argument
, 0, 'l'},
2554 {"headers", no_argument
, 0, 'e'},
2555 {"histogram", no_argument
, 0, 'I'},
2556 {"segments", no_argument
, 0, 'l'},
2557 {"sections", no_argument
, 0, 'S'},
2558 {"section-headers", no_argument
, 0, 'S'},
2559 {"section-groups", no_argument
, 0, 'g'},
2560 {"section-details", no_argument
, 0, 't'},
2561 {"full-section-name",no_argument
, 0, 'N'},
2562 {"symbols", no_argument
, 0, 's'},
2563 {"syms", no_argument
, 0, 's'},
2564 {"relocs", no_argument
, 0, 'r'},
2565 {"notes", no_argument
, 0, 'n'},
2566 {"dynamic", no_argument
, 0, 'd'},
2567 {"arch-specific", no_argument
, 0, 'A'},
2568 {"version-info", no_argument
, 0, 'V'},
2569 {"use-dynamic", no_argument
, 0, 'D'},
2570 {"hex-dump", required_argument
, 0, 'x'},
2571 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2572 {"unwind", no_argument
, 0, 'u'},
2573 #ifdef SUPPORT_DISASSEMBLY
2574 {"instruction-dump", required_argument
, 0, 'i'},
2577 {"version", no_argument
, 0, 'v'},
2578 {"wide", no_argument
, 0, 'W'},
2579 {"help", no_argument
, 0, 'H'},
2580 {0, no_argument
, 0, 0}
2586 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2587 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2588 fprintf (stdout
, _(" Options are:\n\
2589 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2590 -h --file-header Display the ELF file header\n\
2591 -l --program-headers Display the program headers\n\
2592 --segments An alias for --program-headers\n\
2593 -S --section-headers Display the sections' header\n\
2594 --sections An alias for --section-headers\n\
2595 -g --section-groups Display the section groups\n\
2596 -t --section-details Display the section details\n\
2597 -e --headers Equivalent to: -h -l -S\n\
2598 -s --syms Display the symbol table\n\
2599 --symbols An alias for --syms\n\
2600 -n --notes Display the core notes (if present)\n\
2601 -r --relocs Display the relocations (if present)\n\
2602 -u --unwind Display the unwind info (if present)\n\
2603 -d --dynamic Display the dynamic section (if present)\n\
2604 -V --version-info Display the version sections (if present)\n\
2605 -A --arch-specific Display architecture specific information (if any).\n\
2606 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2607 -x --hex-dump=<number> Dump the contents of section <number>\n\
2608 -w[liaprmfFsoR] or\n\
2609 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2610 Display the contents of DWARF2 debug sections\n"));
2611 #ifdef SUPPORT_DISASSEMBLY
2612 fprintf (stdout
, _("\
2613 -i --instruction-dump=<number>\n\
2614 Disassemble the contents of section <number>\n"));
2616 fprintf (stdout
, _("\
2617 -I --histogram Display histogram of bucket list lengths\n\
2618 -W --wide Allow output width to exceed 80 characters\n\
2619 @<file> Read options from <file>\n\
2620 -H --help Display this information\n\
2621 -v --version Display the version number of readelf\n"));
2622 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2627 /* Record the fact that the user wants the contents of section number
2628 SECTION to be displayed using the method(s) encoded as flags bits
2629 in TYPE. Note, TYPE can be zero if we are creating the array for
2633 request_dump (unsigned int section
, int type
)
2635 if (section
>= num_dump_sects
)
2637 char *new_dump_sects
;
2639 new_dump_sects
= calloc (section
+ 1, 1);
2641 if (new_dump_sects
== NULL
)
2642 error (_("Out of memory allocating dump request table."));
2645 /* Copy current flag settings. */
2646 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2650 dump_sects
= new_dump_sects
;
2651 num_dump_sects
= section
+ 1;
2656 dump_sects
[section
] |= type
;
2662 parse_args (int argc
, char **argv
)
2669 while ((c
= getopt_long
2670 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2691 do_section_groups
++;
2699 do_section_groups
++;
2704 do_section_details
++;
2746 section
= strtoul (optarg
, & cp
, 0);
2747 if (! *cp
&& section
>= 0)
2749 request_dump (section
, HEX_DUMP
);
2759 unsigned int index
= 0;
2763 while (optarg
[index
])
2764 switch (optarg
[index
++])
2773 do_debug_abbrevs
= 1;
2783 do_debug_pubnames
= 1;
2787 do_debug_aranges
= 1;
2791 do_debug_ranges
= 1;
2795 do_debug_frames_interp
= 1;
2797 do_debug_frames
= 1;
2802 do_debug_macinfo
= 1;
2816 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2821 case OPTION_DEBUG_DUMP
:
2829 const char * option
;
2832 debug_dump_long_opts
;
2834 debug_dump_long_opts opts_table
[] =
2836 /* Please keep this table alpha- sorted. */
2837 { "Ranges", & do_debug_ranges
},
2838 { "abbrev", & do_debug_abbrevs
},
2839 { "aranges", & do_debug_aranges
},
2840 { "frames", & do_debug_frames
},
2841 { "frames-interp", & do_debug_frames_interp
},
2842 { "info", & do_debug_info
},
2843 { "line", & do_debug_lines
},
2844 { "loc", & do_debug_loc
},
2845 { "macro", & do_debug_macinfo
},
2846 { "pubnames", & do_debug_pubnames
},
2847 /* This entry is for compatability
2848 with earlier versions of readelf. */
2849 { "ranges", & do_debug_aranges
},
2850 { "str", & do_debug_str
},
2861 debug_dump_long_opts
* entry
;
2863 for (entry
= opts_table
; entry
->option
; entry
++)
2865 size_t len
= strlen (entry
->option
);
2867 if (strneq (p
, entry
->option
, len
)
2868 && (p
[len
] == ',' || p
[len
] == '\0'))
2870 * entry
->variable
= 1;
2872 /* The --debug-dump=frames-interp option also
2873 enables the --debug-dump=frames option. */
2874 if (do_debug_frames_interp
)
2875 do_debug_frames
= 1;
2882 if (entry
->option
== NULL
)
2884 warn (_("Unrecognized debug option '%s'\n"), p
);
2885 p
= strchr (p
, ',');
2895 #ifdef SUPPORT_DISASSEMBLY
2898 section
= strtoul (optarg
, & cp
, 0);
2899 if (! *cp
&& section
>= 0)
2901 request_dump (section
, DISASS_DUMP
);
2907 print_version (program_name
);
2917 /* xgettext:c-format */
2918 error (_("Invalid option '-%c'\n"), c
);
2925 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2926 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2927 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2928 && !do_section_groups
)
2932 warn (_("Nothing to do.\n"));
2938 get_elf_class (unsigned int elf_class
)
2940 static char buff
[32];
2944 case ELFCLASSNONE
: return _("none");
2945 case ELFCLASS32
: return "ELF32";
2946 case ELFCLASS64
: return "ELF64";
2948 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
2954 get_data_encoding (unsigned int encoding
)
2956 static char buff
[32];
2960 case ELFDATANONE
: return _("none");
2961 case ELFDATA2LSB
: return _("2's complement, little endian");
2962 case ELFDATA2MSB
: return _("2's complement, big endian");
2964 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
2969 /* Decode the data held in 'elf_header'. */
2972 process_file_header (void)
2974 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2975 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2976 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2977 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2980 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2988 printf (_("ELF Header:\n"));
2989 printf (_(" Magic: "));
2990 for (i
= 0; i
< EI_NIDENT
; i
++)
2991 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2993 printf (_(" Class: %s\n"),
2994 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2995 printf (_(" Data: %s\n"),
2996 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2997 printf (_(" Version: %d %s\n"),
2998 elf_header
.e_ident
[EI_VERSION
],
2999 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3001 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3004 printf (_(" OS/ABI: %s\n"),
3005 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3006 printf (_(" ABI Version: %d\n"),
3007 elf_header
.e_ident
[EI_ABIVERSION
]);
3008 printf (_(" Type: %s\n"),
3009 get_file_type (elf_header
.e_type
));
3010 printf (_(" Machine: %s\n"),
3011 get_machine_name (elf_header
.e_machine
));
3012 printf (_(" Version: 0x%lx\n"),
3013 (unsigned long) elf_header
.e_version
);
3015 printf (_(" Entry point address: "));
3016 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3017 printf (_("\n Start of program headers: "));
3018 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3019 printf (_(" (bytes into file)\n Start of section headers: "));
3020 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3021 printf (_(" (bytes into file)\n"));
3023 printf (_(" Flags: 0x%lx%s\n"),
3024 (unsigned long) elf_header
.e_flags
,
3025 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3026 printf (_(" Size of this header: %ld (bytes)\n"),
3027 (long) elf_header
.e_ehsize
);
3028 printf (_(" Size of program headers: %ld (bytes)\n"),
3029 (long) elf_header
.e_phentsize
);
3030 printf (_(" Number of program headers: %ld\n"),
3031 (long) elf_header
.e_phnum
);
3032 printf (_(" Size of section headers: %ld (bytes)\n"),
3033 (long) elf_header
.e_shentsize
);
3034 printf (_(" Number of section headers: %ld"),
3035 (long) elf_header
.e_shnum
);
3036 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3037 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3038 putc ('\n', stdout
);
3039 printf (_(" Section header string table index: %ld"),
3040 (long) elf_header
.e_shstrndx
);
3041 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3042 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3043 putc ('\n', stdout
);
3046 if (section_headers
!= NULL
)
3048 if (elf_header
.e_shnum
== 0)
3049 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3050 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3051 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3052 free (section_headers
);
3053 section_headers
= NULL
;
3061 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3063 Elf32_External_Phdr
*phdrs
;
3064 Elf32_External_Phdr
*external
;
3065 Elf_Internal_Phdr
*internal
;
3068 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3069 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3070 _("program headers"));
3074 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3075 i
< elf_header
.e_phnum
;
3076 i
++, internal
++, external
++)
3078 internal
->p_type
= BYTE_GET (external
->p_type
);
3079 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3080 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3081 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3082 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3083 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3084 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3085 internal
->p_align
= BYTE_GET (external
->p_align
);
3094 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3096 Elf64_External_Phdr
*phdrs
;
3097 Elf64_External_Phdr
*external
;
3098 Elf_Internal_Phdr
*internal
;
3101 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3102 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3103 _("program headers"));
3107 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3108 i
< elf_header
.e_phnum
;
3109 i
++, internal
++, external
++)
3111 internal
->p_type
= BYTE_GET (external
->p_type
);
3112 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3113 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3114 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3115 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3116 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3117 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3118 internal
->p_align
= BYTE_GET (external
->p_align
);
3126 /* Returns 1 if the program headers were read into `program_headers'. */
3129 get_program_headers (FILE *file
)
3131 Elf_Internal_Phdr
*phdrs
;
3133 /* Check cache of prior read. */
3134 if (program_headers
!= NULL
)
3137 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3141 error (_("Out of memory\n"));
3146 ? get_32bit_program_headers (file
, phdrs
)
3147 : get_64bit_program_headers (file
, phdrs
))
3149 program_headers
= phdrs
;
3157 /* Returns 1 if the program headers were loaded. */
3160 process_program_headers (FILE *file
)
3162 Elf_Internal_Phdr
*segment
;
3165 if (elf_header
.e_phnum
== 0)
3168 printf (_("\nThere are no program headers in this file.\n"));
3172 if (do_segments
&& !do_header
)
3174 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3175 printf (_("Entry point "));
3176 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3177 printf (_("\nThere are %d program headers, starting at offset "),
3178 elf_header
.e_phnum
);
3179 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3183 if (! get_program_headers (file
))
3188 if (elf_header
.e_phnum
> 1)
3189 printf (_("\nProgram Headers:\n"));
3191 printf (_("\nProgram Headers:\n"));
3195 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3198 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3202 (_(" Type Offset VirtAddr PhysAddr\n"));
3204 (_(" FileSiz MemSiz Flags Align\n"));
3211 for (i
= 0, segment
= program_headers
;
3212 i
< elf_header
.e_phnum
;
3217 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3221 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3222 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3223 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3224 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3225 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3227 (segment
->p_flags
& PF_R
? 'R' : ' '),
3228 (segment
->p_flags
& PF_W
? 'W' : ' '),
3229 (segment
->p_flags
& PF_X
? 'E' : ' '));
3230 printf ("%#lx", (unsigned long) segment
->p_align
);
3234 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3235 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3238 print_vma (segment
->p_offset
, FULL_HEX
);
3242 print_vma (segment
->p_vaddr
, FULL_HEX
);
3244 print_vma (segment
->p_paddr
, FULL_HEX
);
3247 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3248 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3251 print_vma (segment
->p_filesz
, FULL_HEX
);
3255 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3256 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3259 print_vma (segment
->p_offset
, FULL_HEX
);
3263 (segment
->p_flags
& PF_R
? 'R' : ' '),
3264 (segment
->p_flags
& PF_W
? 'W' : ' '),
3265 (segment
->p_flags
& PF_X
? 'E' : ' '));
3267 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3268 printf ("%#lx", (unsigned long) segment
->p_align
);
3271 print_vma (segment
->p_align
, PREFIX_HEX
);
3276 print_vma (segment
->p_offset
, FULL_HEX
);
3278 print_vma (segment
->p_vaddr
, FULL_HEX
);
3280 print_vma (segment
->p_paddr
, FULL_HEX
);
3282 print_vma (segment
->p_filesz
, FULL_HEX
);
3284 print_vma (segment
->p_memsz
, FULL_HEX
);
3286 (segment
->p_flags
& PF_R
? 'R' : ' '),
3287 (segment
->p_flags
& PF_W
? 'W' : ' '),
3288 (segment
->p_flags
& PF_X
? 'E' : ' '));
3289 print_vma (segment
->p_align
, HEX
);
3293 switch (segment
->p_type
)
3297 error (_("more than one dynamic segment\n"));
3299 /* Try to locate the .dynamic section. If there is
3300 a section header table, we can easily locate it. */
3301 if (section_headers
!= NULL
)
3303 Elf_Internal_Shdr
*sec
;
3305 sec
= find_section (".dynamic");
3306 if (sec
== NULL
|| sec
->sh_size
== 0)
3308 error (_("no .dynamic section in the dynamic segment"));
3312 dynamic_addr
= sec
->sh_offset
;
3313 dynamic_size
= sec
->sh_size
;
3315 if (dynamic_addr
< segment
->p_offset
3316 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3317 warn (_("the .dynamic section is not contained within the dynamic segment"));
3318 else if (dynamic_addr
> segment
->p_offset
)
3319 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3323 /* Otherwise, we can only assume that the .dynamic
3324 section is the first section in the DYNAMIC segment. */
3325 dynamic_addr
= segment
->p_offset
;
3326 dynamic_size
= segment
->p_filesz
;
3331 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3333 error (_("Unable to find program interpreter name\n"));
3336 program_interpreter
[0] = 0;
3337 fscanf (file
, "%63s", program_interpreter
);
3340 printf (_("\n [Requesting program interpreter: %s]"),
3341 program_interpreter
);
3347 putc ('\n', stdout
);
3350 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3352 printf (_("\n Section to Segment mapping:\n"));
3353 printf (_(" Segment Sections...\n"));
3355 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3358 Elf_Internal_Shdr
*section
;
3360 segment
= program_headers
+ i
;
3361 section
= section_headers
;
3363 printf (" %2.2d ", i
);
3365 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3367 if (section
->sh_size
> 0
3368 /* Compare allocated sections by VMA, unallocated
3369 sections by file offset. */
3370 && (section
->sh_flags
& SHF_ALLOC
3371 ? (section
->sh_addr
>= segment
->p_vaddr
3372 && section
->sh_addr
+ section
->sh_size
3373 <= segment
->p_vaddr
+ segment
->p_memsz
)
3374 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3375 && (section
->sh_offset
+ section
->sh_size
3376 <= segment
->p_offset
+ segment
->p_filesz
)))
3377 /* .tbss is special. It doesn't contribute memory space
3378 to normal segments. */
3379 && (!((section
->sh_flags
& SHF_TLS
) != 0
3380 && section
->sh_type
== SHT_NOBITS
)
3381 || segment
->p_type
== PT_TLS
))
3382 printf ("%s ", SECTION_NAME (section
));
3393 /* Find the file offset corresponding to VMA by using the program headers. */
3396 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3398 Elf_Internal_Phdr
*seg
;
3400 if (! get_program_headers (file
))
3402 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3406 for (seg
= program_headers
;
3407 seg
< program_headers
+ elf_header
.e_phnum
;
3410 if (seg
->p_type
!= PT_LOAD
)
3413 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3414 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3415 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3418 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3425 get_32bit_section_headers (FILE *file
, unsigned int num
)
3427 Elf32_External_Shdr
*shdrs
;
3428 Elf_Internal_Shdr
*internal
;
3431 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3432 elf_header
.e_shentsize
, num
, _("section headers"));
3436 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3438 if (section_headers
== NULL
)
3440 error (_("Out of memory\n"));
3444 for (i
= 0, internal
= section_headers
;
3448 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3449 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3450 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3451 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3452 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3453 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3454 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3455 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3456 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3457 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3466 get_64bit_section_headers (FILE *file
, unsigned int num
)
3468 Elf64_External_Shdr
*shdrs
;
3469 Elf_Internal_Shdr
*internal
;
3472 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3473 elf_header
.e_shentsize
, num
, _("section headers"));
3477 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3479 if (section_headers
== NULL
)
3481 error (_("Out of memory\n"));
3485 for (i
= 0, internal
= section_headers
;
3489 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3490 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3491 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3492 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3493 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3494 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3495 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3496 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3497 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3498 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3506 static Elf_Internal_Sym
*
3507 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3509 unsigned long number
;
3510 Elf32_External_Sym
*esyms
;
3511 Elf_External_Sym_Shndx
*shndx
;
3512 Elf_Internal_Sym
*isyms
;
3513 Elf_Internal_Sym
*psym
;
3516 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3522 if (symtab_shndx_hdr
!= NULL
3523 && (symtab_shndx_hdr
->sh_link
3524 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3526 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3527 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3535 number
= section
->sh_size
/ section
->sh_entsize
;
3536 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3540 error (_("Out of memory\n"));
3547 for (j
= 0, psym
= isyms
;
3551 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3552 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3553 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3554 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3555 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3557 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3558 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3559 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3569 static Elf_Internal_Sym
*
3570 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3572 unsigned long number
;
3573 Elf64_External_Sym
*esyms
;
3574 Elf_External_Sym_Shndx
*shndx
;
3575 Elf_Internal_Sym
*isyms
;
3576 Elf_Internal_Sym
*psym
;
3579 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3585 if (symtab_shndx_hdr
!= NULL
3586 && (symtab_shndx_hdr
->sh_link
3587 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3589 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3590 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3598 number
= section
->sh_size
/ section
->sh_entsize
;
3599 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3603 error (_("Out of memory\n"));
3610 for (j
= 0, psym
= isyms
;
3614 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3615 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3616 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3617 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3618 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3620 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3621 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3622 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3633 get_elf_section_flags (bfd_vma sh_flags
)
3635 static char buff
[1024];
3637 int field_size
= is_32bit_elf
? 8 : 16;
3638 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3639 bfd_vma os_flags
= 0;
3640 bfd_vma proc_flags
= 0;
3641 bfd_vma unknown_flags
= 0;
3655 { "LINK ORDER", 10 },
3656 { "OS NONCONF", 10 },
3661 if (do_section_details
)
3663 sprintf (buff
, "[%*.*lx]: ",
3664 field_size
, field_size
, (unsigned long) sh_flags
);
3665 p
+= field_size
+ 4;
3672 flag
= sh_flags
& - sh_flags
;
3675 if (do_section_details
)
3679 case SHF_WRITE
: index
= 0; break;
3680 case SHF_ALLOC
: index
= 1; break;
3681 case SHF_EXECINSTR
: index
= 2; break;
3682 case SHF_MERGE
: index
= 3; break;
3683 case SHF_STRINGS
: index
= 4; break;
3684 case SHF_INFO_LINK
: index
= 5; break;
3685 case SHF_LINK_ORDER
: index
= 6; break;
3686 case SHF_OS_NONCONFORMING
: index
= 7; break;
3687 case SHF_GROUP
: index
= 8; break;
3688 case SHF_TLS
: index
= 9; break;
3697 if (p
!= buff
+ field_size
+ 4)
3699 if (size
< (10 + 2))
3706 size
-= flags
[index
].len
;
3707 p
= stpcpy (p
, flags
[index
].str
);
3709 else if (flag
& SHF_MASKOS
)
3711 else if (flag
& SHF_MASKPROC
)
3714 unknown_flags
|= flag
;
3720 case SHF_WRITE
: *p
= 'W'; break;
3721 case SHF_ALLOC
: *p
= 'A'; break;
3722 case SHF_EXECINSTR
: *p
= 'X'; break;
3723 case SHF_MERGE
: *p
= 'M'; break;
3724 case SHF_STRINGS
: *p
= 'S'; break;
3725 case SHF_INFO_LINK
: *p
= 'I'; break;
3726 case SHF_LINK_ORDER
: *p
= 'L'; break;
3727 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3728 case SHF_GROUP
: *p
= 'G'; break;
3729 case SHF_TLS
: *p
= 'T'; break;
3732 if (elf_header
.e_machine
== EM_X86_64
3733 && flag
== SHF_X86_64_LARGE
)
3735 else if (flag
& SHF_MASKOS
)
3738 sh_flags
&= ~ SHF_MASKOS
;
3740 else if (flag
& SHF_MASKPROC
)
3743 sh_flags
&= ~ SHF_MASKPROC
;
3753 if (do_section_details
)
3757 size
-= 5 + field_size
;
3758 if (p
!= buff
+ field_size
+ 4)
3766 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3767 (unsigned long) os_flags
);
3768 p
+= 5 + field_size
;
3772 size
-= 7 + field_size
;
3773 if (p
!= buff
+ field_size
+ 4)
3781 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3782 (unsigned long) proc_flags
);
3783 p
+= 7 + field_size
;
3787 size
-= 10 + field_size
;
3788 if (p
!= buff
+ field_size
+ 4)
3796 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3797 (unsigned long) unknown_flags
);
3798 p
+= 10 + field_size
;
3807 process_section_headers (FILE *file
)
3809 Elf_Internal_Shdr
*section
;
3812 section_headers
= NULL
;
3814 if (elf_header
.e_shnum
== 0)
3817 printf (_("\nThere are no sections in this file.\n"));
3822 if (do_sections
&& !do_header
)
3823 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3824 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3828 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3831 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3834 /* Read in the string table, so that we have names to display. */
3835 if (SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
3837 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3839 if (section
->sh_size
!= 0)
3841 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3842 1, section
->sh_size
, _("string table"));
3844 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
3848 /* Scan the sections for the dynamic symbol table
3849 and dynamic string table and debug sections. */
3850 dynamic_symbols
= NULL
;
3851 dynamic_strings
= NULL
;
3852 dynamic_syminfo
= NULL
;
3853 symtab_shndx_hdr
= NULL
;
3855 eh_addr_size
= is_32bit_elf
? 4 : 8;
3856 switch (elf_header
.e_machine
)
3859 case EM_MIPS_RS3_LE
:
3860 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3861 FDE addresses. However, the ABI also has a semi-official ILP32
3862 variant for which the normal FDE address size rules apply.
3864 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3865 section, where XX is the size of longs in bits. Unfortunately,
3866 earlier compilers provided no way of distinguishing ILP32 objects
3867 from LP64 objects, so if there's any doubt, we should assume that
3868 the official LP64 form is being used. */
3869 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3870 && find_section (".gcc_compiled_long32") == NULL
)
3875 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3878 size_t expected_entsize \
3879 = is_32bit_elf ? size32 : size64; \
3880 if (section->sh_entsize != expected_entsize) \
3881 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
3882 i, (unsigned long int) section->sh_entsize, \
3883 (unsigned long int) expected_entsize); \
3884 section->sh_entsize = expected_entsize; \
3887 #define CHECK_ENTSIZE(section, i, type) \
3888 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
3889 sizeof (Elf64_External_##type))
3891 for (i
= 0, section
= section_headers
;
3892 i
< elf_header
.e_shnum
;
3895 char *name
= SECTION_NAME (section
);
3897 if (section
->sh_type
== SHT_DYNSYM
)
3899 if (dynamic_symbols
!= NULL
)
3901 error (_("File contains multiple dynamic symbol tables\n"));
3905 CHECK_ENTSIZE (section
, i
, Sym
);
3906 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3907 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3909 else if (section
->sh_type
== SHT_STRTAB
3910 && streq (name
, ".dynstr"))
3912 if (dynamic_strings
!= NULL
)
3914 error (_("File contains multiple dynamic string tables\n"));
3918 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3919 1, section
->sh_size
, _("dynamic strings"));
3920 dynamic_strings_length
= section
->sh_size
;
3922 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3924 if (symtab_shndx_hdr
!= NULL
)
3926 error (_("File contains multiple symtab shndx tables\n"));
3929 symtab_shndx_hdr
= section
;
3931 else if (section
->sh_type
== SHT_SYMTAB
)
3932 CHECK_ENTSIZE (section
, i
, Sym
);
3933 else if (section
->sh_type
== SHT_GROUP
)
3934 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
3935 else if (section
->sh_type
== SHT_REL
)
3936 CHECK_ENTSIZE (section
, i
, Rel
);
3937 else if (section
->sh_type
== SHT_RELA
)
3938 CHECK_ENTSIZE (section
, i
, Rela
);
3939 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3940 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3941 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3942 || do_debug_loc
|| do_debug_ranges
)
3943 && strneq (name
, ".debug_", 7))
3948 || (do_debug_info
&& streq (name
, "info"))
3949 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3950 || (do_debug_lines
&& streq (name
, "line"))
3951 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3952 || (do_debug_aranges
&& streq (name
, "aranges"))
3953 || (do_debug_ranges
&& streq (name
, "ranges"))
3954 || (do_debug_frames
&& streq (name
, "frame"))
3955 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3956 || (do_debug_str
&& streq (name
, "str"))
3957 || (do_debug_loc
&& streq (name
, "loc"))
3959 request_dump (i
, DEBUG_DUMP
);
3961 /* linkonce section to be combined with .debug_info at link time. */
3962 else if ((do_debugging
|| do_debug_info
)
3963 && strneq (name
, ".gnu.linkonce.wi.", 17))
3964 request_dump (i
, DEBUG_DUMP
);
3965 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3966 request_dump (i
, DEBUG_DUMP
);
3972 if (elf_header
.e_shnum
> 1)
3973 printf (_("\nSection Headers:\n"));
3975 printf (_("\nSection Header:\n"));
3979 if (do_section_details
)
3981 printf (_(" [Nr] Name\n"));
3982 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
3986 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3990 if (do_section_details
)
3992 printf (_(" [Nr] Name\n"));
3993 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
3997 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4001 if (do_section_details
)
4003 printf (_(" [Nr] Name\n"));
4004 printf (_(" Type Address Offset Link\n"));
4005 printf (_(" Size EntSize Info Align\n"));
4009 printf (_(" [Nr] Name Type Address Offset\n"));
4010 printf (_(" Size EntSize Flags Link Info Align\n"));
4014 if (do_section_details
)
4015 printf (_(" Flags\n"));
4017 for (i
= 0, section
= section_headers
;
4018 i
< elf_header
.e_shnum
;
4021 if (do_section_details
)
4023 printf (" [%2u] %s\n",
4024 SECTION_HEADER_NUM (i
),
4025 SECTION_NAME (section
));
4026 if (is_32bit_elf
|| do_wide
)
4027 printf (" %-15.15s ",
4028 get_section_type_name (section
->sh_type
));
4031 printf (" [%2u] %-17.17s %-15.15s ",
4032 SECTION_HEADER_NUM (i
),
4033 SECTION_NAME (section
),
4034 get_section_type_name (section
->sh_type
));
4038 print_vma (section
->sh_addr
, LONG_HEX
);
4040 printf ( " %6.6lx %6.6lx %2.2lx",
4041 (unsigned long) section
->sh_offset
,
4042 (unsigned long) section
->sh_size
,
4043 (unsigned long) section
->sh_entsize
);
4045 if (do_section_details
)
4046 fputs (" ", stdout
);
4048 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4050 printf ("%2ld %3lu %2ld\n",
4051 (unsigned long) section
->sh_link
,
4052 (unsigned long) section
->sh_info
,
4053 (unsigned long) section
->sh_addralign
);
4057 print_vma (section
->sh_addr
, LONG_HEX
);
4059 if ((long) section
->sh_offset
== section
->sh_offset
)
4060 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4064 print_vma (section
->sh_offset
, LONG_HEX
);
4067 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4068 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4072 print_vma (section
->sh_size
, LONG_HEX
);
4075 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4076 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4080 print_vma (section
->sh_entsize
, LONG_HEX
);
4083 if (do_section_details
)
4084 fputs (" ", stdout
);
4086 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4088 printf ("%2ld %3lu ",
4089 (unsigned long) section
->sh_link
,
4090 (unsigned long) section
->sh_info
);
4092 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4093 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4096 print_vma (section
->sh_addralign
, DEC
);
4100 else if (do_section_details
)
4102 printf (" %-15.15s ",
4103 get_section_type_name (section
->sh_type
));
4104 print_vma (section
->sh_addr
, LONG_HEX
);
4105 if ((long) section
->sh_offset
== section
->sh_offset
)
4106 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4110 print_vma (section
->sh_offset
, LONG_HEX
);
4112 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4113 print_vma (section
->sh_size
, LONG_HEX
);
4115 print_vma (section
->sh_entsize
, LONG_HEX
);
4117 printf (" %-16lu %ld\n",
4118 (unsigned long) section
->sh_info
,
4119 (unsigned long) section
->sh_addralign
);
4124 print_vma (section
->sh_addr
, LONG_HEX
);
4125 if ((long) section
->sh_offset
== section
->sh_offset
)
4126 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4130 print_vma (section
->sh_offset
, LONG_HEX
);
4133 print_vma (section
->sh_size
, LONG_HEX
);
4135 print_vma (section
->sh_entsize
, LONG_HEX
);
4137 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4139 printf (" %2ld %3lu %ld\n",
4140 (unsigned long) section
->sh_link
,
4141 (unsigned long) section
->sh_info
,
4142 (unsigned long) section
->sh_addralign
);
4145 if (do_section_details
)
4146 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4149 if (!do_section_details
)
4150 printf (_("Key to Flags:\n\
4151 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4152 I (info), L (link order), G (group), x (unknown)\n\
4153 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4159 get_group_flags (unsigned int flags
)
4161 static char buff
[32];
4168 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4175 process_section_groups (FILE *file
)
4177 Elf_Internal_Shdr
*section
;
4179 struct group
*group
;
4180 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4181 Elf_Internal_Sym
*symtab
;
4185 /* Don't process section groups unless needed. */
4186 if (!do_unwind
&& !do_section_groups
)
4189 if (elf_header
.e_shnum
== 0)
4191 if (do_section_groups
)
4192 printf (_("\nThere are no sections in this file.\n"));
4197 if (section_headers
== NULL
)
4199 error (_("Section headers are not available!\n"));
4203 section_headers_groups
= calloc (elf_header
.e_shnum
,
4204 sizeof (struct group
*));
4206 if (section_headers_groups
== NULL
)
4208 error (_("Out of memory\n"));
4212 /* Scan the sections for the group section. */
4214 for (i
= 0, section
= section_headers
;
4215 i
< elf_header
.e_shnum
;
4217 if (section
->sh_type
== SHT_GROUP
)
4220 if (group_count
== 0)
4222 if (do_section_groups
)
4223 printf (_("\nThere are no section groups in this file.\n"));
4228 section_groups
= calloc (group_count
, sizeof (struct group
));
4230 if (section_groups
== NULL
)
4232 error (_("Out of memory\n"));
4241 for (i
= 0, section
= section_headers
, group
= section_groups
;
4242 i
< elf_header
.e_shnum
;
4245 if (section
->sh_type
== SHT_GROUP
)
4247 char *name
= SECTION_NAME (section
);
4249 unsigned char *start
, *indices
;
4250 unsigned int entry
, j
, size
;
4251 Elf_Internal_Shdr
*sec
;
4252 Elf_Internal_Sym
*sym
;
4254 /* Get the symbol table. */
4255 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4256 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4259 error (_("Bad sh_link in group section `%s'\n"), name
);
4263 if (symtab_sec
!= sec
)
4268 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4271 sym
= symtab
+ section
->sh_info
;
4273 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4275 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4278 error (_("Bad sh_info in group section `%s'\n"), name
);
4282 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4291 /* Get the string table. */
4292 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4293 >= elf_header
.e_shnum
)
4302 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4307 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4308 1, strtab_sec
->sh_size
,
4310 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4312 group_name
= sym
->st_name
< strtab_size
4313 ? strtab
+ sym
->st_name
: "<corrupt>";
4316 start
= get_data (NULL
, file
, section
->sh_offset
,
4317 1, section
->sh_size
, _("section data"));
4320 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4321 entry
= byte_get (indices
, 4);
4324 if (do_section_groups
)
4326 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4327 get_group_flags (entry
), i
, name
, group_name
, size
);
4329 printf (_(" [Index] Name\n"));
4332 group
->group_index
= i
;
4334 for (j
= 0; j
< size
; j
++)
4336 struct group_list
*g
;
4338 entry
= byte_get (indices
, 4);
4341 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4343 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4344 entry
, i
, elf_header
.e_shnum
- 1);
4347 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4349 error (_("invalid section [%5u] in group section [%5u]\n"),
4354 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4359 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4361 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4366 /* Intel C/C++ compiler may put section 0 in a
4367 section group. We just warn it the first time
4368 and ignore it afterwards. */
4369 static int warned
= 0;
4372 error (_("section 0 in group section [%5u]\n"),
4373 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4379 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4382 if (do_section_groups
)
4384 sec
= SECTION_HEADER (entry
);
4385 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4388 g
= xmalloc (sizeof (struct group_list
));
4389 g
->section_index
= entry
;
4390 g
->next
= group
->root
;
4414 } dynamic_relocations
[] =
4416 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4417 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4418 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4421 /* Process the reloc section. */
4424 process_relocs (FILE *file
)
4426 unsigned long rel_size
;
4427 unsigned long rel_offset
;
4433 if (do_using_dynamic
)
4437 int has_dynamic_reloc
;
4440 has_dynamic_reloc
= 0;
4442 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4444 is_rela
= dynamic_relocations
[i
].rela
;
4445 name
= dynamic_relocations
[i
].name
;
4446 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4447 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4449 has_dynamic_reloc
|= rel_size
;
4451 if (is_rela
== UNKNOWN
)
4453 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4454 switch (dynamic_info
[DT_PLTREL
])
4468 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4469 name
, rel_offset
, rel_size
);
4471 dump_relocations (file
,
4472 offset_from_vma (file
, rel_offset
, rel_size
),
4474 dynamic_symbols
, num_dynamic_syms
,
4475 dynamic_strings
, dynamic_strings_length
, is_rela
);
4479 if (! has_dynamic_reloc
)
4480 printf (_("\nThere are no dynamic relocations in this file.\n"));
4484 Elf_Internal_Shdr
*section
;
4488 for (i
= 0, section
= section_headers
;
4489 i
< elf_header
.e_shnum
;
4492 if ( section
->sh_type
!= SHT_RELA
4493 && section
->sh_type
!= SHT_REL
)
4496 rel_offset
= section
->sh_offset
;
4497 rel_size
= section
->sh_size
;
4501 Elf_Internal_Shdr
*strsec
;
4504 printf (_("\nRelocation section "));
4506 if (string_table
== NULL
)
4507 printf ("%d", section
->sh_name
);
4509 printf (_("'%s'"), SECTION_NAME (section
));
4511 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4512 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4514 is_rela
= section
->sh_type
== SHT_RELA
;
4516 if (section
->sh_link
4517 && SECTION_HEADER_INDEX (section
->sh_link
)
4518 < elf_header
.e_shnum
)
4520 Elf_Internal_Shdr
*symsec
;
4521 Elf_Internal_Sym
*symtab
;
4522 unsigned long nsyms
;
4523 unsigned long strtablen
= 0;
4524 char *strtab
= NULL
;
4526 symsec
= SECTION_HEADER (section
->sh_link
);
4527 if (symsec
->sh_type
!= SHT_SYMTAB
4528 && symsec
->sh_type
!= SHT_DYNSYM
)
4531 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4532 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4537 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4538 < elf_header
.e_shnum
)
4540 strsec
= SECTION_HEADER (symsec
->sh_link
);
4542 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4545 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4548 dump_relocations (file
, rel_offset
, rel_size
,
4549 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4555 dump_relocations (file
, rel_offset
, rel_size
,
4556 NULL
, 0, NULL
, 0, is_rela
);
4563 printf (_("\nThere are no relocations in this file.\n"));
4569 /* Process the unwind section. */
4571 #include "unwind-ia64.h"
4573 /* An absolute address consists of a section and an offset. If the
4574 section is NULL, the offset itself is the address, otherwise, the
4575 address equals to LOAD_ADDRESS(section) + offset. */
4579 unsigned short section
;
4583 struct ia64_unw_aux_info
4585 struct ia64_unw_table_entry
4587 struct absaddr start
;
4589 struct absaddr info
;
4591 *table
; /* Unwind table. */
4592 unsigned long table_len
; /* Length of unwind table. */
4593 unsigned char *info
; /* Unwind info. */
4594 unsigned long info_size
; /* Size of unwind info. */
4595 bfd_vma info_addr
; /* starting address of unwind info. */
4596 bfd_vma seg_base
; /* Starting address of segment. */
4597 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4598 unsigned long nsyms
; /* Number of symbols. */
4599 char *strtab
; /* The string table. */
4600 unsigned long strtab_size
; /* Size of string table. */
4604 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4605 unsigned long nsyms
,
4607 unsigned long strtab_size
,
4608 struct absaddr addr
,
4609 const char **symname
,
4612 bfd_vma dist
= 0x100000;
4613 Elf_Internal_Sym
*sym
, *best
= NULL
;
4616 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4618 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4619 && sym
->st_name
!= 0
4620 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4621 && addr
.offset
>= sym
->st_value
4622 && addr
.offset
- sym
->st_value
< dist
)
4625 dist
= addr
.offset
- sym
->st_value
;
4632 *symname
= (best
->st_name
>= strtab_size
4633 ? "<corrupt>" : strtab
+ best
->st_name
);
4638 *offset
= addr
.offset
;
4642 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4644 struct ia64_unw_table_entry
*tp
;
4647 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4651 const unsigned char *dp
;
4652 const unsigned char *head
;
4653 const char *procname
;
4655 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4656 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4658 fputs ("\n<", stdout
);
4662 fputs (procname
, stdout
);
4665 printf ("+%lx", (unsigned long) offset
);
4668 fputs (">: [", stdout
);
4669 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4670 fputc ('-', stdout
);
4671 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4672 printf ("], info at +0x%lx\n",
4673 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4675 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4676 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4678 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4679 (unsigned) UNW_VER (stamp
),
4680 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4681 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4682 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4683 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4685 if (UNW_VER (stamp
) != 1)
4687 printf ("\tUnknown version.\n");
4692 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4693 dp
= unw_decode (dp
, in_body
, & in_body
);
4698 slurp_ia64_unwind_table (FILE *file
,
4699 struct ia64_unw_aux_info
*aux
,
4700 Elf_Internal_Shdr
*sec
)
4702 unsigned long size
, nrelas
, i
;
4703 Elf_Internal_Phdr
*seg
;
4704 struct ia64_unw_table_entry
*tep
;
4705 Elf_Internal_Shdr
*relsec
;
4706 Elf_Internal_Rela
*rela
, *rp
;
4707 unsigned char *table
, *tp
;
4708 Elf_Internal_Sym
*sym
;
4709 const char *relname
;
4711 /* First, find the starting address of the segment that includes
4714 if (elf_header
.e_phnum
)
4716 if (! get_program_headers (file
))
4719 for (seg
= program_headers
;
4720 seg
< program_headers
+ elf_header
.e_phnum
;
4723 if (seg
->p_type
!= PT_LOAD
)
4726 if (sec
->sh_addr
>= seg
->p_vaddr
4727 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4729 aux
->seg_base
= seg
->p_vaddr
;
4735 /* Second, build the unwind table from the contents of the unwind section: */
4736 size
= sec
->sh_size
;
4737 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4741 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4743 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4745 tep
->start
.section
= SHN_UNDEF
;
4746 tep
->end
.section
= SHN_UNDEF
;
4747 tep
->info
.section
= SHN_UNDEF
;
4750 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4751 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4752 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4756 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4757 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4758 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4760 tep
->start
.offset
+= aux
->seg_base
;
4761 tep
->end
.offset
+= aux
->seg_base
;
4762 tep
->info
.offset
+= aux
->seg_base
;
4766 /* Third, apply any relocations to the unwind table: */
4768 for (relsec
= section_headers
;
4769 relsec
< section_headers
+ elf_header
.e_shnum
;
4772 if (relsec
->sh_type
!= SHT_RELA
4773 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4774 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4777 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4781 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4785 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4786 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4790 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4791 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4794 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4796 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4800 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4802 switch (rp
->r_offset
/eh_addr_size
% 3)
4805 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4806 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4809 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4810 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4813 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4814 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4824 aux
->table_len
= size
/ (3 * eh_addr_size
);
4829 ia64_process_unwind (FILE *file
)
4831 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4832 unsigned long i
, unwcount
= 0, unwstart
= 0;
4833 struct ia64_unw_aux_info aux
;
4835 memset (& aux
, 0, sizeof (aux
));
4837 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4839 if (sec
->sh_type
== SHT_SYMTAB
4840 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
4842 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4843 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4845 strsec
= SECTION_HEADER (sec
->sh_link
);
4846 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4847 1, strsec
->sh_size
, _("string table"));
4848 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
4850 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4855 printf (_("\nThere are no unwind sections in this file.\n"));
4857 while (unwcount
-- > 0)
4862 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4863 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4864 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4871 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4873 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4875 /* We need to find which section group it is in. */
4876 struct group_list
*g
= section_headers_groups
[i
]->root
;
4878 for (; g
!= NULL
; g
= g
->next
)
4880 sec
= SECTION_HEADER (g
->section_index
);
4882 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4887 i
= elf_header
.e_shnum
;
4889 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4891 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4892 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4893 suffix
= SECTION_NAME (unwsec
) + len
;
4894 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4896 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4897 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4902 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4903 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4904 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4905 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4907 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4908 suffix
= SECTION_NAME (unwsec
) + len
;
4909 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4911 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4912 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4916 if (i
== elf_header
.e_shnum
)
4918 printf (_("\nCould not find unwind info section for "));
4920 if (string_table
== NULL
)
4921 printf ("%d", unwsec
->sh_name
);
4923 printf (_("'%s'"), SECTION_NAME (unwsec
));
4927 aux
.info_size
= sec
->sh_size
;
4928 aux
.info_addr
= sec
->sh_addr
;
4929 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
4932 printf (_("\nUnwind section "));
4934 if (string_table
== NULL
)
4935 printf ("%d", unwsec
->sh_name
);
4937 printf (_("'%s'"), SECTION_NAME (unwsec
));
4939 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4940 (unsigned long) unwsec
->sh_offset
,
4941 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4943 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4945 if (aux
.table_len
> 0)
4946 dump_ia64_unwind (& aux
);
4949 free ((char *) aux
.table
);
4951 free ((char *) aux
.info
);
4960 free ((char *) aux
.strtab
);
4965 struct hppa_unw_aux_info
4967 struct hppa_unw_table_entry
4969 struct absaddr start
;
4971 unsigned int Cannot_unwind
:1; /* 0 */
4972 unsigned int Millicode
:1; /* 1 */
4973 unsigned int Millicode_save_sr0
:1; /* 2 */
4974 unsigned int Region_description
:2; /* 3..4 */
4975 unsigned int reserved1
:1; /* 5 */
4976 unsigned int Entry_SR
:1; /* 6 */
4977 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4978 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4979 unsigned int Args_stored
:1; /* 16 */
4980 unsigned int Variable_Frame
:1; /* 17 */
4981 unsigned int Separate_Package_Body
:1; /* 18 */
4982 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4983 unsigned int Stack_Overflow_Check
:1; /* 20 */
4984 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4985 unsigned int Ada_Region
:1; /* 22 */
4986 unsigned int cxx_info
:1; /* 23 */
4987 unsigned int cxx_try_catch
:1; /* 24 */
4988 unsigned int sched_entry_seq
:1; /* 25 */
4989 unsigned int reserved2
:1; /* 26 */
4990 unsigned int Save_SP
:1; /* 27 */
4991 unsigned int Save_RP
:1; /* 28 */
4992 unsigned int Save_MRP_in_frame
:1; /* 29 */
4993 unsigned int extn_ptr_defined
:1; /* 30 */
4994 unsigned int Cleanup_defined
:1; /* 31 */
4996 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4997 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4998 unsigned int Large_frame
:1; /* 2 */
4999 unsigned int Pseudo_SP_Set
:1; /* 3 */
5000 unsigned int reserved4
:1; /* 4 */
5001 unsigned int Total_frame_size
:27; /* 5..31 */
5003 *table
; /* Unwind table. */
5004 unsigned long table_len
; /* Length of unwind table. */
5005 bfd_vma seg_base
; /* Starting address of segment. */
5006 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5007 unsigned long nsyms
; /* Number of symbols. */
5008 char *strtab
; /* The string table. */
5009 unsigned long strtab_size
; /* Size of string table. */
5013 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5015 struct hppa_unw_table_entry
*tp
;
5017 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5020 const char *procname
;
5022 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5023 aux
->strtab_size
, tp
->start
, &procname
,
5026 fputs ("\n<", stdout
);
5030 fputs (procname
, stdout
);
5033 printf ("+%lx", (unsigned long) offset
);
5036 fputs (">: [", stdout
);
5037 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5038 fputc ('-', stdout
);
5039 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5042 #define PF(_m) if (tp->_m) printf (#_m " ");
5043 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5046 PF(Millicode_save_sr0
);
5047 /* PV(Region_description); */
5053 PF(Separate_Package_Body
);
5054 PF(Frame_Extension_Millicode
);
5055 PF(Stack_Overflow_Check
);
5056 PF(Two_Instruction_SP_Increment
);
5060 PF(sched_entry_seq
);
5063 PF(Save_MRP_in_frame
);
5064 PF(extn_ptr_defined
);
5065 PF(Cleanup_defined
);
5066 PF(MPE_XL_interrupt_marker
);
5067 PF(HP_UX_interrupt_marker
);
5070 PV(Total_frame_size
);
5079 slurp_hppa_unwind_table (FILE *file
,
5080 struct hppa_unw_aux_info
*aux
,
5081 Elf_Internal_Shdr
*sec
)
5083 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5084 Elf_Internal_Phdr
*seg
;
5085 struct hppa_unw_table_entry
*tep
;
5086 Elf_Internal_Shdr
*relsec
;
5087 Elf_Internal_Rela
*rela
, *rp
;
5088 unsigned char *table
, *tp
;
5089 Elf_Internal_Sym
*sym
;
5090 const char *relname
;
5092 /* First, find the starting address of the segment that includes
5095 if (elf_header
.e_phnum
)
5097 if (! get_program_headers (file
))
5100 for (seg
= program_headers
;
5101 seg
< program_headers
+ elf_header
.e_phnum
;
5104 if (seg
->p_type
!= PT_LOAD
)
5107 if (sec
->sh_addr
>= seg
->p_vaddr
5108 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5110 aux
->seg_base
= seg
->p_vaddr
;
5116 /* Second, build the unwind table from the contents of the unwind
5118 size
= sec
->sh_size
;
5119 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5124 nentries
= size
/ unw_ent_size
;
5125 size
= unw_ent_size
* nentries
;
5127 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5129 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5131 unsigned int tmp1
, tmp2
;
5133 tep
->start
.section
= SHN_UNDEF
;
5134 tep
->end
.section
= SHN_UNDEF
;
5136 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5137 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5138 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5139 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5141 tep
->start
.offset
+= aux
->seg_base
;
5142 tep
->end
.offset
+= aux
->seg_base
;
5144 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5145 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5146 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5147 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5148 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5149 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5150 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5151 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5152 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5153 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5154 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5155 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5156 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5157 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5158 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5159 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5160 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5161 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5162 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5163 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5164 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5165 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5166 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5167 tep
->Cleanup_defined
= tmp1
& 0x1;
5169 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5170 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5171 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5172 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5173 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5174 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5178 /* Third, apply any relocations to the unwind table. */
5180 for (relsec
= section_headers
;
5181 relsec
< section_headers
+ elf_header
.e_shnum
;
5184 if (relsec
->sh_type
!= SHT_RELA
5185 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5186 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5189 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5193 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5197 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5198 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5202 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5203 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5206 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5207 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5209 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5213 i
= rp
->r_offset
/ unw_ent_size
;
5215 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5218 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5219 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5222 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5223 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5233 aux
->table_len
= nentries
;
5239 hppa_process_unwind (FILE *file
)
5241 struct hppa_unw_aux_info aux
;
5242 Elf_Internal_Shdr
*unwsec
= NULL
;
5243 Elf_Internal_Shdr
*strsec
;
5244 Elf_Internal_Shdr
*sec
;
5247 memset (& aux
, 0, sizeof (aux
));
5249 if (string_table
== NULL
)
5252 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5254 if (sec
->sh_type
== SHT_SYMTAB
5255 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5257 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5258 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5260 strsec
= SECTION_HEADER (sec
->sh_link
);
5261 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5262 1, strsec
->sh_size
, _("string table"));
5263 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5265 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5270 printf (_("\nThere are no unwind sections in this file.\n"));
5272 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5274 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5276 printf (_("\nUnwind section "));
5277 printf (_("'%s'"), SECTION_NAME (sec
));
5279 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5280 (unsigned long) sec
->sh_offset
,
5281 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5283 slurp_hppa_unwind_table (file
, &aux
, sec
);
5284 if (aux
.table_len
> 0)
5285 dump_hppa_unwind (&aux
);
5288 free ((char *) aux
.table
);
5296 free ((char *) aux
.strtab
);
5302 process_unwind (FILE *file
)
5304 struct unwind_handler
{
5306 int (*handler
)(FILE *file
);
5308 { EM_IA_64
, ia64_process_unwind
},
5309 { EM_PARISC
, hppa_process_unwind
},
5317 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5318 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5319 return handlers
[i
].handler (file
);
5321 printf (_("\nThere are no unwind sections in this file.\n"));
5326 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5328 switch (entry
->d_tag
)
5331 if (entry
->d_un
.d_val
== 0)
5335 static const char * opts
[] =
5337 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5338 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5339 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5340 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5345 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5346 if (entry
->d_un
.d_val
& (1 << cnt
))
5348 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5355 case DT_MIPS_IVERSION
:
5356 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5357 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5359 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5362 case DT_MIPS_TIME_STAMP
:
5367 time_t time
= entry
->d_un
.d_val
;
5368 tmp
= gmtime (&time
);
5369 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5370 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5371 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5372 printf ("Time Stamp: %s\n", timebuf
);
5376 case DT_MIPS_RLD_VERSION
:
5377 case DT_MIPS_LOCAL_GOTNO
:
5378 case DT_MIPS_CONFLICTNO
:
5379 case DT_MIPS_LIBLISTNO
:
5380 case DT_MIPS_SYMTABNO
:
5381 case DT_MIPS_UNREFEXTNO
:
5382 case DT_MIPS_HIPAGENO
:
5383 case DT_MIPS_DELTA_CLASS_NO
:
5384 case DT_MIPS_DELTA_INSTANCE_NO
:
5385 case DT_MIPS_DELTA_RELOC_NO
:
5386 case DT_MIPS_DELTA_SYM_NO
:
5387 case DT_MIPS_DELTA_CLASSSYM_NO
:
5388 case DT_MIPS_COMPACT_SIZE
:
5389 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5393 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5399 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5401 switch (entry
->d_tag
)
5403 case DT_HP_DLD_FLAGS
:
5412 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5413 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5414 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5415 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5416 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5417 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5418 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5419 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5420 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5421 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5422 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5423 { DT_HP_GST
, "HP_GST" },
5424 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5425 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5426 { DT_HP_NODELETE
, "HP_NODELETE" },
5427 { DT_HP_GROUP
, "HP_GROUP" },
5428 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5432 bfd_vma val
= entry
->d_un
.d_val
;
5434 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5435 if (val
& flags
[cnt
].bit
)
5439 fputs (flags
[cnt
].str
, stdout
);
5441 val
^= flags
[cnt
].bit
;
5444 if (val
!= 0 || first
)
5448 print_vma (val
, HEX
);
5454 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5461 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5463 switch (entry
->d_tag
)
5465 case DT_IA_64_PLT_RESERVE
:
5466 /* First 3 slots reserved. */
5467 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5469 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5473 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5480 get_32bit_dynamic_section (FILE *file
)
5482 Elf32_External_Dyn
*edyn
, *ext
;
5483 Elf_Internal_Dyn
*entry
;
5485 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5486 _("dynamic section"));
5490 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5491 might not have the luxury of section headers. Look for the DT_NULL
5492 terminator to determine the number of entries. */
5493 for (ext
= edyn
, dynamic_nent
= 0;
5494 (char *) ext
< (char *) edyn
+ dynamic_size
;
5498 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5502 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5503 if (dynamic_section
== NULL
)
5505 error (_("Out of memory\n"));
5510 for (ext
= edyn
, entry
= dynamic_section
;
5511 entry
< dynamic_section
+ dynamic_nent
;
5514 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5515 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5524 get_64bit_dynamic_section (FILE *file
)
5526 Elf64_External_Dyn
*edyn
, *ext
;
5527 Elf_Internal_Dyn
*entry
;
5529 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5530 _("dynamic section"));
5534 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5535 might not have the luxury of section headers. Look for the DT_NULL
5536 terminator to determine the number of entries. */
5537 for (ext
= edyn
, dynamic_nent
= 0;
5538 (char *) ext
< (char *) edyn
+ dynamic_size
;
5542 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5546 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5547 if (dynamic_section
== NULL
)
5549 error (_("Out of memory\n"));
5554 for (ext
= edyn
, entry
= dynamic_section
;
5555 entry
< dynamic_section
+ dynamic_nent
;
5558 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5559 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5568 print_dynamic_flags (bfd_vma flags
)
5576 flag
= flags
& - flags
;
5586 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5587 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5588 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5589 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5590 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5591 default: fputs ("unknown", stdout
); break;
5597 /* Parse and display the contents of the dynamic section. */
5600 process_dynamic_section (FILE *file
)
5602 Elf_Internal_Dyn
*entry
;
5604 if (dynamic_size
== 0)
5607 printf (_("\nThere is no dynamic section in this file.\n"));
5614 if (! get_32bit_dynamic_section (file
))
5617 else if (! get_64bit_dynamic_section (file
))
5620 /* Find the appropriate symbol table. */
5621 if (dynamic_symbols
== NULL
)
5623 for (entry
= dynamic_section
;
5624 entry
< dynamic_section
+ dynamic_nent
;
5627 Elf_Internal_Shdr section
;
5629 if (entry
->d_tag
!= DT_SYMTAB
)
5632 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5634 /* Since we do not know how big the symbol table is,
5635 we default to reading in the entire file (!) and
5636 processing that. This is overkill, I know, but it
5638 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5640 if (archive_file_offset
!= 0)
5641 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5644 if (fseek (file
, 0, SEEK_END
))
5645 error (_("Unable to seek to end of file!"));
5647 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5651 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5653 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5655 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5656 if (num_dynamic_syms
< 1)
5658 error (_("Unable to determine the number of symbols to load\n"));
5662 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5666 /* Similarly find a string table. */
5667 if (dynamic_strings
== NULL
)
5669 for (entry
= dynamic_section
;
5670 entry
< dynamic_section
+ dynamic_nent
;
5673 unsigned long offset
;
5676 if (entry
->d_tag
!= DT_STRTAB
)
5679 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5681 /* Since we do not know how big the string table is,
5682 we default to reading in the entire file (!) and
5683 processing that. This is overkill, I know, but it
5686 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5688 if (archive_file_offset
!= 0)
5689 str_tab_len
= archive_file_size
- offset
;
5692 if (fseek (file
, 0, SEEK_END
))
5693 error (_("Unable to seek to end of file\n"));
5694 str_tab_len
= ftell (file
) - offset
;
5697 if (str_tab_len
< 1)
5700 (_("Unable to determine the length of the dynamic string table\n"));
5704 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5705 _("dynamic string table"));
5706 dynamic_strings_length
= str_tab_len
;
5711 /* And find the syminfo section if available. */
5712 if (dynamic_syminfo
== NULL
)
5714 unsigned long syminsz
= 0;
5716 for (entry
= dynamic_section
;
5717 entry
< dynamic_section
+ dynamic_nent
;
5720 if (entry
->d_tag
== DT_SYMINENT
)
5722 /* Note: these braces are necessary to avoid a syntax
5723 error from the SunOS4 C compiler. */
5724 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5726 else if (entry
->d_tag
== DT_SYMINSZ
)
5727 syminsz
= entry
->d_un
.d_val
;
5728 else if (entry
->d_tag
== DT_SYMINFO
)
5729 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5733 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5735 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5736 Elf_Internal_Syminfo
*syminfo
;
5738 /* There is a syminfo section. Read the data. */
5739 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5740 syminsz
, _("symbol information"));
5744 dynamic_syminfo
= malloc (syminsz
);
5745 if (dynamic_syminfo
== NULL
)
5747 error (_("Out of memory\n"));
5751 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5752 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5753 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5754 ++syminfo
, ++extsym
)
5756 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5757 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5764 if (do_dynamic
&& dynamic_addr
)
5765 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5766 dynamic_addr
, dynamic_nent
);
5768 printf (_(" Tag Type Name/Value\n"));
5770 for (entry
= dynamic_section
;
5771 entry
< dynamic_section
+ dynamic_nent
;
5779 print_vma (entry
->d_tag
, FULL_HEX
);
5780 dtype
= get_dynamic_type (entry
->d_tag
);
5781 printf (" (%s)%*s", dtype
,
5782 ((is_32bit_elf
? 27 : 19)
5783 - (int) strlen (dtype
)),
5787 switch (entry
->d_tag
)
5791 print_dynamic_flags (entry
->d_un
.d_val
);
5801 switch (entry
->d_tag
)
5804 printf (_("Auxiliary library"));
5808 printf (_("Filter library"));
5812 printf (_("Configuration file"));
5816 printf (_("Dependency audit library"));
5820 printf (_("Audit library"));
5824 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5825 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5829 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5838 printf (_("Flags:"));
5840 if (entry
->d_un
.d_val
== 0)
5841 printf (_(" None\n"));
5844 unsigned long int val
= entry
->d_un
.d_val
;
5846 if (val
& DTF_1_PARINIT
)
5848 printf (" PARINIT");
5849 val
^= DTF_1_PARINIT
;
5851 if (val
& DTF_1_CONFEXP
)
5853 printf (" CONFEXP");
5854 val
^= DTF_1_CONFEXP
;
5857 printf (" %lx", val
);
5866 printf (_("Flags:"));
5868 if (entry
->d_un
.d_val
== 0)
5869 printf (_(" None\n"));
5872 unsigned long int val
= entry
->d_un
.d_val
;
5874 if (val
& DF_P1_LAZYLOAD
)
5876 printf (" LAZYLOAD");
5877 val
^= DF_P1_LAZYLOAD
;
5879 if (val
& DF_P1_GROUPPERM
)
5881 printf (" GROUPPERM");
5882 val
^= DF_P1_GROUPPERM
;
5885 printf (" %lx", val
);
5894 printf (_("Flags:"));
5895 if (entry
->d_un
.d_val
== 0)
5896 printf (_(" None\n"));
5899 unsigned long int val
= entry
->d_un
.d_val
;
5906 if (val
& DF_1_GLOBAL
)
5911 if (val
& DF_1_GROUP
)
5916 if (val
& DF_1_NODELETE
)
5918 printf (" NODELETE");
5919 val
^= DF_1_NODELETE
;
5921 if (val
& DF_1_LOADFLTR
)
5923 printf (" LOADFLTR");
5924 val
^= DF_1_LOADFLTR
;
5926 if (val
& DF_1_INITFIRST
)
5928 printf (" INITFIRST");
5929 val
^= DF_1_INITFIRST
;
5931 if (val
& DF_1_NOOPEN
)
5936 if (val
& DF_1_ORIGIN
)
5941 if (val
& DF_1_DIRECT
)
5946 if (val
& DF_1_TRANS
)
5951 if (val
& DF_1_INTERPOSE
)
5953 printf (" INTERPOSE");
5954 val
^= DF_1_INTERPOSE
;
5956 if (val
& DF_1_NODEFLIB
)
5958 printf (" NODEFLIB");
5959 val
^= DF_1_NODEFLIB
;
5961 if (val
& DF_1_NODUMP
)
5966 if (val
& DF_1_CONLFAT
)
5968 printf (" CONLFAT");
5969 val
^= DF_1_CONLFAT
;
5972 printf (" %lx", val
);
5979 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5981 puts (get_dynamic_type (entry
->d_un
.d_val
));
6001 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6007 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6008 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6014 switch (entry
->d_tag
)
6017 printf (_("Shared library: [%s]"), name
);
6019 if (streq (name
, program_interpreter
))
6020 printf (_(" program interpreter"));
6024 printf (_("Library soname: [%s]"), name
);
6028 printf (_("Library rpath: [%s]"), name
);
6032 printf (_("Library runpath: [%s]"), name
);
6036 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6041 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6054 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6058 case DT_INIT_ARRAYSZ
:
6059 case DT_FINI_ARRAYSZ
:
6060 case DT_GNU_CONFLICTSZ
:
6061 case DT_GNU_LIBLISTSZ
:
6064 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6065 printf (" (bytes)\n");
6075 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6088 if (entry
->d_tag
== DT_USED
6089 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6091 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6095 printf (_("Not needed object: [%s]\n"), name
);
6100 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6106 /* The value of this entry is ignored. */
6111 case DT_GNU_PRELINKED
:
6115 time_t time
= entry
->d_un
.d_val
;
6117 tmp
= gmtime (&time
);
6118 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6119 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6120 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6126 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6127 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6132 switch (elf_header
.e_machine
)
6135 case EM_MIPS_RS3_LE
:
6136 dynamic_section_mips_val (entry
);
6139 dynamic_section_parisc_val (entry
);
6142 dynamic_section_ia64_val (entry
);
6145 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6157 get_ver_flags (unsigned int flags
)
6159 static char buff
[32];
6166 if (flags
& VER_FLG_BASE
)
6167 strcat (buff
, "BASE ");
6169 if (flags
& VER_FLG_WEAK
)
6171 if (flags
& VER_FLG_BASE
)
6172 strcat (buff
, "| ");
6174 strcat (buff
, "WEAK ");
6177 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6178 strcat (buff
, "| <unknown>");
6183 /* Display the contents of the version sections. */
6185 process_version_sections (FILE *file
)
6187 Elf_Internal_Shdr
*section
;
6194 for (i
= 0, section
= section_headers
;
6195 i
< elf_header
.e_shnum
;
6198 switch (section
->sh_type
)
6200 case SHT_GNU_verdef
:
6202 Elf_External_Verdef
*edefs
;
6209 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6210 SECTION_NAME (section
), section
->sh_info
);
6212 printf (_(" Addr: 0x"));
6213 printf_vma (section
->sh_addr
);
6214 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6215 (unsigned long) section
->sh_offset
, section
->sh_link
,
6216 SECTION_HEADER_INDEX (section
->sh_link
)
6217 < elf_header
.e_shnum
6218 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6221 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6223 _("version definition section"));
6227 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6230 Elf_External_Verdef
*edef
;
6231 Elf_Internal_Verdef ent
;
6232 Elf_External_Verdaux
*eaux
;
6233 Elf_Internal_Verdaux aux
;
6237 vstart
= ((char *) edefs
) + idx
;
6239 edef
= (Elf_External_Verdef
*) vstart
;
6241 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6242 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6243 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6244 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6245 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6246 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6247 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6249 printf (_(" %#06x: Rev: %d Flags: %s"),
6250 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6252 printf (_(" Index: %d Cnt: %d "),
6253 ent
.vd_ndx
, ent
.vd_cnt
);
6255 vstart
+= ent
.vd_aux
;
6257 eaux
= (Elf_External_Verdaux
*) vstart
;
6259 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6260 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6262 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6263 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6265 printf (_("Name index: %ld\n"), aux
.vda_name
);
6267 isum
= idx
+ ent
.vd_aux
;
6269 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6271 isum
+= aux
.vda_next
;
6272 vstart
+= aux
.vda_next
;
6274 eaux
= (Elf_External_Verdaux
*) vstart
;
6276 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6277 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6279 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6280 printf (_(" %#06x: Parent %d: %s\n"),
6281 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6283 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6284 isum
, j
, aux
.vda_name
);
6294 case SHT_GNU_verneed
:
6296 Elf_External_Verneed
*eneed
;
6302 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6303 SECTION_NAME (section
), section
->sh_info
);
6305 printf (_(" Addr: 0x"));
6306 printf_vma (section
->sh_addr
);
6307 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6308 (unsigned long) section
->sh_offset
, section
->sh_link
,
6309 SECTION_HEADER_INDEX (section
->sh_link
)
6310 < elf_header
.e_shnum
6311 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6314 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6316 _("version need section"));
6320 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6322 Elf_External_Verneed
*entry
;
6323 Elf_Internal_Verneed ent
;
6328 vstart
= ((char *) eneed
) + idx
;
6330 entry
= (Elf_External_Verneed
*) vstart
;
6332 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6333 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6334 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6335 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6336 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6338 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6340 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6341 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6343 printf (_(" File: %lx"), ent
.vn_file
);
6345 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6347 vstart
+= ent
.vn_aux
;
6349 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6351 Elf_External_Vernaux
*eaux
;
6352 Elf_Internal_Vernaux aux
;
6354 eaux
= (Elf_External_Vernaux
*) vstart
;
6356 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6357 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6358 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6359 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6360 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6362 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6363 printf (_(" %#06x: Name: %s"),
6364 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6366 printf (_(" %#06x: Name index: %lx"),
6367 isum
, aux
.vna_name
);
6369 printf (_(" Flags: %s Version: %d\n"),
6370 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6372 isum
+= aux
.vna_next
;
6373 vstart
+= aux
.vna_next
;
6383 case SHT_GNU_versym
:
6385 Elf_Internal_Shdr
*link_section
;
6388 unsigned char *edata
;
6389 unsigned short *data
;
6391 Elf_Internal_Sym
*symbols
;
6392 Elf_Internal_Shdr
*string_sec
;
6395 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6398 link_section
= SECTION_HEADER (section
->sh_link
);
6399 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6401 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6402 >= elf_header
.e_shnum
)
6407 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6409 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6411 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6412 string_sec
->sh_size
, _("version string table"));
6416 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6417 SECTION_NAME (section
), total
);
6419 printf (_(" Addr: "));
6420 printf_vma (section
->sh_addr
);
6421 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6422 (unsigned long) section
->sh_offset
, section
->sh_link
,
6423 SECTION_NAME (link_section
));
6425 off
= offset_from_vma (file
,
6426 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6427 total
* sizeof (short));
6428 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6429 _("version symbol data"));
6436 data
= cmalloc (total
, sizeof (short));
6438 for (cnt
= total
; cnt
--;)
6439 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6444 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6447 int check_def
, check_need
;
6450 printf (" %03x:", cnt
);
6452 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6453 switch (data
[cnt
+ j
])
6456 fputs (_(" 0 (*local*) "), stdout
);
6460 fputs (_(" 1 (*global*) "), stdout
);
6464 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6465 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6469 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6470 >= elf_header
.e_shnum
6471 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6474 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6481 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6483 Elf_Internal_Verneed ivn
;
6484 unsigned long offset
;
6486 offset
= offset_from_vma
6487 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6488 sizeof (Elf_External_Verneed
));
6492 Elf_Internal_Vernaux ivna
;
6493 Elf_External_Verneed evn
;
6494 Elf_External_Vernaux evna
;
6495 unsigned long a_off
;
6497 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6500 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6501 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6503 a_off
= offset
+ ivn
.vn_aux
;
6507 get_data (&evna
, file
, a_off
, sizeof (evna
),
6508 1, _("version need aux (2)"));
6510 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6511 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6513 a_off
+= ivna
.vna_next
;
6515 while (ivna
.vna_other
!= data
[cnt
+ j
]
6516 && ivna
.vna_next
!= 0);
6518 if (ivna
.vna_other
== data
[cnt
+ j
])
6520 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6522 name
= strtab
+ ivna
.vna_name
;
6523 nn
+= printf ("(%s%-*s",
6525 12 - (int) strlen (name
),
6531 offset
+= ivn
.vn_next
;
6533 while (ivn
.vn_next
);
6536 if (check_def
&& data
[cnt
+ j
] != 0x8001
6537 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6539 Elf_Internal_Verdef ivd
;
6540 Elf_External_Verdef evd
;
6541 unsigned long offset
;
6543 offset
= offset_from_vma
6544 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6549 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6552 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6553 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6555 offset
+= ivd
.vd_next
;
6557 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6558 && ivd
.vd_next
!= 0);
6560 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6562 Elf_External_Verdaux evda
;
6563 Elf_Internal_Verdaux ivda
;
6565 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6567 get_data (&evda
, file
,
6568 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6570 _("version def aux"));
6572 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6574 name
= strtab
+ ivda
.vda_name
;
6575 nn
+= printf ("(%s%-*s",
6577 12 - (int) strlen (name
),
6583 printf ("%*c", 18 - nn
, ' ');
6601 printf (_("\nNo version information found in this file.\n"));
6607 get_symbol_binding (unsigned int binding
)
6609 static char buff
[32];
6613 case STB_LOCAL
: return "LOCAL";
6614 case STB_GLOBAL
: return "GLOBAL";
6615 case STB_WEAK
: return "WEAK";
6617 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6618 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6620 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6621 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6623 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6629 get_symbol_type (unsigned int type
)
6631 static char buff
[32];
6635 case STT_NOTYPE
: return "NOTYPE";
6636 case STT_OBJECT
: return "OBJECT";
6637 case STT_FUNC
: return "FUNC";
6638 case STT_SECTION
: return "SECTION";
6639 case STT_FILE
: return "FILE";
6640 case STT_COMMON
: return "COMMON";
6641 case STT_TLS
: return "TLS";
6643 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6645 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6646 return "THUMB_FUNC";
6648 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6651 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6652 return "PARISC_MILLI";
6654 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6656 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6658 if (elf_header
.e_machine
== EM_PARISC
)
6660 if (type
== STT_HP_OPAQUE
)
6662 if (type
== STT_HP_STUB
)
6666 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6669 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6675 get_symbol_visibility (unsigned int visibility
)
6679 case STV_DEFAULT
: return "DEFAULT";
6680 case STV_INTERNAL
: return "INTERNAL";
6681 case STV_HIDDEN
: return "HIDDEN";
6682 case STV_PROTECTED
: return "PROTECTED";
6688 get_symbol_index_type (unsigned int type
)
6690 static char buff
[32];
6694 case SHN_UNDEF
: return "UND";
6695 case SHN_ABS
: return "ABS";
6696 case SHN_COMMON
: return "COM";
6698 if (type
== SHN_IA_64_ANSI_COMMON
6699 && elf_header
.e_machine
== EM_IA_64
6700 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6702 else if (elf_header
.e_machine
== EM_X86_64
6703 && type
== SHN_X86_64_LCOMMON
)
6705 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6706 sprintf (buff
, "PRC[0x%04x]", type
);
6707 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6708 sprintf (buff
, "OS [0x%04x]", type
);
6709 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6710 sprintf (buff
, "RSV[0x%04x]", type
);
6712 sprintf (buff
, "%3d", type
);
6720 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6722 unsigned char *e_data
;
6725 e_data
= cmalloc (number
, ent_size
);
6729 error (_("Out of memory\n"));
6733 if (fread (e_data
, ent_size
, number
, file
) != number
)
6735 error (_("Unable to read in dynamic data\n"));
6739 i_data
= cmalloc (number
, sizeof (*i_data
));
6743 error (_("Out of memory\n"));
6749 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6756 /* Dump the symbol table. */
6758 process_symbol_table (FILE *file
)
6760 Elf_Internal_Shdr
*section
;
6761 bfd_vma nbuckets
= 0;
6762 bfd_vma nchains
= 0;
6763 bfd_vma
*buckets
= NULL
;
6764 bfd_vma
*chains
= NULL
;
6766 if (! do_syms
&& !do_histogram
)
6769 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6772 unsigned char nb
[8];
6773 unsigned char nc
[8];
6774 int hash_ent_size
= 4;
6776 if ((elf_header
.e_machine
== EM_ALPHA
6777 || elf_header
.e_machine
== EM_S390
6778 || elf_header
.e_machine
== EM_S390_OLD
)
6779 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6783 (archive_file_offset
6784 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6785 sizeof nb
+ sizeof nc
)),
6788 error (_("Unable to seek to start of dynamic information"));
6792 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6794 error (_("Failed to read in number of buckets\n"));
6798 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6800 error (_("Failed to read in number of chains\n"));
6804 nbuckets
= byte_get (nb
, hash_ent_size
);
6805 nchains
= byte_get (nc
, hash_ent_size
);
6807 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6808 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6810 if (buckets
== NULL
|| chains
== NULL
)
6815 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6820 printf (_("\nSymbol table for image:\n"));
6822 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6824 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6826 for (hn
= 0; hn
< nbuckets
; hn
++)
6831 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6833 Elf_Internal_Sym
*psym
;
6836 psym
= dynamic_symbols
+ si
;
6838 n
= print_vma (si
, DEC_5
);
6840 fputs (" " + n
, stdout
);
6841 printf (" %3lu: ", hn
);
6842 print_vma (psym
->st_value
, LONG_HEX
);
6844 print_vma (psym
->st_size
, DEC_5
);
6846 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6847 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6848 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6849 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6850 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6851 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6853 printf (" <corrupt: %14ld>", psym
->st_name
);
6858 else if (do_syms
&& !do_using_dynamic
)
6862 for (i
= 0, section
= section_headers
;
6863 i
< elf_header
.e_shnum
;
6867 char *strtab
= NULL
;
6868 unsigned long int strtab_size
= 0;
6869 Elf_Internal_Sym
*symtab
;
6870 Elf_Internal_Sym
*psym
;
6873 if ( section
->sh_type
!= SHT_SYMTAB
6874 && section
->sh_type
!= SHT_DYNSYM
)
6877 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6878 SECTION_NAME (section
),
6879 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6881 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6883 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6885 symtab
= GET_ELF_SYMBOLS (file
, section
);
6889 if (section
->sh_link
== elf_header
.e_shstrndx
)
6891 strtab
= string_table
;
6892 strtab_size
= string_table_length
;
6894 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
6896 Elf_Internal_Shdr
*string_sec
;
6898 string_sec
= SECTION_HEADER (section
->sh_link
);
6900 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6901 1, string_sec
->sh_size
, _("string table"));
6902 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
6905 for (si
= 0, psym
= symtab
;
6906 si
< section
->sh_size
/ section
->sh_entsize
;
6909 printf ("%6d: ", si
);
6910 print_vma (psym
->st_value
, LONG_HEX
);
6912 print_vma (psym
->st_size
, DEC_5
);
6913 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6914 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6915 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6916 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6917 print_symbol (25, psym
->st_name
< strtab_size
6918 ? strtab
+ psym
->st_name
: "<corrupt>");
6920 if (section
->sh_type
== SHT_DYNSYM
&&
6921 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6923 unsigned char data
[2];
6924 unsigned short vers_data
;
6925 unsigned long offset
;
6929 offset
= offset_from_vma
6930 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6931 sizeof data
+ si
* sizeof (vers_data
));
6933 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6934 sizeof (data
), 1, _("version data"));
6936 vers_data
= byte_get (data
, 2);
6938 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
6939 < elf_header
.e_shnum
6940 && SECTION_HEADER (psym
->st_shndx
)->sh_type
6943 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6945 if ((vers_data
& 0x8000) || vers_data
> 1)
6947 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6948 && (is_nobits
|| ! check_def
))
6950 Elf_External_Verneed evn
;
6951 Elf_Internal_Verneed ivn
;
6952 Elf_Internal_Vernaux ivna
;
6954 /* We must test both. */
6955 offset
= offset_from_vma
6956 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6961 unsigned long vna_off
;
6963 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6966 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6967 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6969 vna_off
= offset
+ ivn
.vn_aux
;
6973 Elf_External_Vernaux evna
;
6975 get_data (&evna
, file
, vna_off
,
6977 _("version need aux (3)"));
6979 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6980 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6981 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6983 vna_off
+= ivna
.vna_next
;
6985 while (ivna
.vna_other
!= vers_data
6986 && ivna
.vna_next
!= 0);
6988 if (ivna
.vna_other
== vers_data
)
6991 offset
+= ivn
.vn_next
;
6993 while (ivn
.vn_next
!= 0);
6995 if (ivna
.vna_other
== vers_data
)
6998 ivna
.vna_name
< strtab_size
6999 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7003 else if (! is_nobits
)
7004 error (_("bad dynamic symbol"));
7011 if (vers_data
!= 0x8001
7012 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7014 Elf_Internal_Verdef ivd
;
7015 Elf_Internal_Verdaux ivda
;
7016 Elf_External_Verdaux evda
;
7017 unsigned long offset
;
7019 offset
= offset_from_vma
7021 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7022 sizeof (Elf_External_Verdef
));
7026 Elf_External_Verdef evd
;
7028 get_data (&evd
, file
, offset
, sizeof (evd
),
7029 1, _("version def"));
7031 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7032 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7033 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7035 offset
+= ivd
.vd_next
;
7037 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7038 && ivd
.vd_next
!= 0);
7040 offset
-= ivd
.vd_next
;
7041 offset
+= ivd
.vd_aux
;
7043 get_data (&evda
, file
, offset
, sizeof (evda
),
7044 1, _("version def aux"));
7046 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7048 if (psym
->st_name
!= ivda
.vda_name
)
7049 printf ((vers_data
& 0x8000)
7051 ivda
.vda_name
< strtab_size
7052 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7062 if (strtab
!= string_table
)
7068 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7070 if (do_histogram
&& buckets
!= NULL
)
7072 unsigned long *lengths
;
7073 unsigned long *counts
;
7076 unsigned long maxlength
= 0;
7077 unsigned long nzero_counts
= 0;
7078 unsigned long nsyms
= 0;
7080 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7081 (unsigned long) nbuckets
);
7082 printf (_(" Length Number %% of total Coverage\n"));
7084 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7085 if (lengths
== NULL
)
7087 error (_("Out of memory"));
7090 for (hn
= 0; hn
< nbuckets
; ++hn
)
7092 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7095 if (maxlength
< ++lengths
[hn
])
7100 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7103 error (_("Out of memory"));
7107 for (hn
= 0; hn
< nbuckets
; ++hn
)
7108 ++counts
[lengths
[hn
]];
7113 printf (" 0 %-10lu (%5.1f%%)\n",
7114 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7115 for (i
= 1; i
<= maxlength
; ++i
)
7117 nzero_counts
+= counts
[i
] * i
;
7118 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7119 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7120 (nzero_counts
* 100.0) / nsyms
);
7128 if (buckets
!= NULL
)
7138 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7142 if (dynamic_syminfo
== NULL
7144 /* No syminfo, this is ok. */
7147 /* There better should be a dynamic symbol section. */
7148 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7152 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7153 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7155 printf (_(" Num: Name BoundTo Flags\n"));
7156 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7158 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7160 printf ("%4d: ", i
);
7161 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7162 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7164 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7167 switch (dynamic_syminfo
[i
].si_boundto
)
7169 case SYMINFO_BT_SELF
:
7170 fputs ("SELF ", stdout
);
7172 case SYMINFO_BT_PARENT
:
7173 fputs ("PARENT ", stdout
);
7176 if (dynamic_syminfo
[i
].si_boundto
> 0
7177 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7178 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7180 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7184 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7188 if (flags
& SYMINFO_FLG_DIRECT
)
7190 if (flags
& SYMINFO_FLG_PASSTHRU
)
7191 printf (" PASSTHRU");
7192 if (flags
& SYMINFO_FLG_COPY
)
7194 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7195 printf (" LAZYLOAD");
7203 #ifdef SUPPORT_DISASSEMBLY
7205 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7207 printf (_("\nAssembly dump of section %s\n"),
7208 SECTION_NAME (section
));
7210 /* XXX -- to be done --- XXX */
7217 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7219 bfd_size_type bytes
;
7221 unsigned char *data
;
7222 unsigned char *start
;
7224 bytes
= section
->sh_size
;
7226 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7228 printf (_("\nSection '%s' has no data to dump.\n"),
7229 SECTION_NAME (section
));
7233 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7235 addr
= section
->sh_addr
;
7237 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7250 lbytes
= (bytes
> 16 ? 16 : bytes
);
7252 printf (" 0x%8.8lx ", (unsigned long) addr
);
7254 switch (elf_header
.e_ident
[EI_DATA
])
7258 for (j
= 15; j
>= 0; j
--)
7261 printf ("%2.2x", data
[j
]);
7271 for (j
= 0; j
< 16; j
++)
7274 printf ("%2.2x", data
[j
]);
7284 for (j
= 0; j
< lbytes
; j
++)
7287 if (k
>= ' ' && k
< 0x7f)
7305 /* Apply addends of RELA relocations. */
7308 debug_apply_rela_addends (void *file
,
7309 Elf_Internal_Shdr
*section
,
7310 unsigned char *start
)
7312 Elf_Internal_Shdr
*relsec
;
7313 unsigned char *end
= start
+ section
->sh_size
;
7314 /* FIXME: The relocation field size is relocation type dependent. */
7315 unsigned int reloc_size
= 4;
7317 if (!is_relocatable
)
7320 if (section
->sh_size
< reloc_size
)
7323 for (relsec
= section_headers
;
7324 relsec
< section_headers
+ elf_header
.e_shnum
;
7327 unsigned long nrelas
;
7328 Elf_Internal_Rela
*rela
, *rp
;
7329 Elf_Internal_Shdr
*symsec
;
7330 Elf_Internal_Sym
*symtab
;
7331 Elf_Internal_Sym
*sym
;
7333 if (relsec
->sh_type
!= SHT_RELA
7334 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7335 || SECTION_HEADER (relsec
->sh_info
) != section
7336 || relsec
->sh_size
== 0
7337 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7340 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7344 symsec
= SECTION_HEADER (relsec
->sh_link
);
7345 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7347 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7351 loc
= start
+ rp
->r_offset
;
7352 if ((loc
+ reloc_size
) > end
)
7354 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7355 (unsigned long) rp
->r_offset
,
7356 SECTION_NAME (section
));
7362 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7364 if (ELF32_R_SYM (rp
->r_info
) != 0
7365 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7366 /* Relocations against object symbols can happen,
7367 eg when referencing a global array. For an
7368 example of this see the _clz.o binary in libgcc.a. */
7369 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7371 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7372 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7373 SECTION_NAME (section
));
7379 /* In MIPS little-endian objects, r_info isn't really a
7380 64-bit little-endian value: it has a 32-bit little-endian
7381 symbol index followed by four individual byte fields.
7382 Reorder INFO accordingly. */
7383 if (elf_header
.e_machine
== EM_MIPS
7384 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7385 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7386 | ((rp
->r_info
>> 56) & 0xff)
7387 | ((rp
->r_info
>> 40) & 0xff00)
7388 | ((rp
->r_info
>> 24) & 0xff0000)
7389 | ((rp
->r_info
>> 8) & 0xff000000));
7391 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7393 if (ELF64_R_SYM (rp
->r_info
) != 0
7394 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7395 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7397 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7398 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7399 SECTION_NAME (section
));
7404 byte_put (loc
, rp
->r_addend
, reloc_size
);
7415 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
7417 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7418 Elf_Internal_Shdr
*sec
;
7421 /* If it is already loaded, do nothing. */
7422 if (section
->start
!= NULL
)
7425 /* Locate the debug section. */
7426 sec
= find_section (section
->name
);
7430 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
7431 section
->address
= sec
->sh_addr
;
7432 section
->size
= sec
->sh_size
;
7433 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7436 if (debug_displays
[debug
].relocate
)
7437 debug_apply_rela_addends (file
, sec
, section
->start
);
7439 return section
->start
!= NULL
;
7443 free_debug_section (enum dwarf_section_display_enum debug
)
7445 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7447 if (section
->start
== NULL
)
7450 free ((char *) section
->start
);
7451 section
->start
= NULL
;
7452 section
->address
= 0;
7457 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
7459 char *name
= SECTION_NAME (section
);
7460 bfd_size_type length
;
7462 enum dwarf_section_display_enum i
;
7464 length
= section
->sh_size
;
7467 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7471 if (strneq (name
, ".gnu.linkonce.wi.", 17))
7472 name
= ".debug_info";
7474 /* See if we know how to display the contents of this section. */
7475 for (i
= 0; i
< max
; i
++)
7476 if (streq (debug_displays
[i
].section
.name
, name
))
7478 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
7480 if (load_debug_section (i
, file
))
7482 result
&= debug_displays
[i
].display (sec
, file
);
7484 if (i
!= info
&& i
!= abbrev
)
7485 free_debug_section (i
);
7493 printf (_("Unrecognized debug section: %s\n"), name
);
7501 process_section_contents (FILE *file
)
7503 Elf_Internal_Shdr
*section
;
7509 for (i
= 0, section
= section_headers
;
7510 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7513 #ifdef SUPPORT_DISASSEMBLY
7514 if (dump_sects
[i
] & DISASS_DUMP
)
7515 disassemble_section (section
, file
);
7517 if (dump_sects
[i
] & HEX_DUMP
)
7518 dump_section (section
, file
);
7520 if (dump_sects
[i
] & DEBUG_DUMP
)
7521 display_debug_section (section
, file
);
7524 /* Check to see if the user requested a
7525 dump of a section that does not exist. */
7526 while (i
++ < num_dump_sects
)
7528 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
7532 process_mips_fpe_exception (int mask
)
7537 if (mask
& OEX_FPU_INEX
)
7538 fputs ("INEX", stdout
), first
= 0;
7539 if (mask
& OEX_FPU_UFLO
)
7540 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7541 if (mask
& OEX_FPU_OFLO
)
7542 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7543 if (mask
& OEX_FPU_DIV0
)
7544 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7545 if (mask
& OEX_FPU_INVAL
)
7546 printf ("%sINVAL", first
? "" : "|");
7549 fputs ("0", stdout
);
7552 /* ARM EABI attributes section. */
7557 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
7560 } arm_attr_public_tag
;
7562 static const char *arm_attr_tag_CPU_arch
[] =
7563 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
7565 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
7566 static const char *arm_attr_tag_THUMB_ISA_use
[] =
7567 {"No", "Thumb-1", "Thumb-2"};
7568 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2"};
7569 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
7570 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
7571 static const char *arm_attr_tag_ABI_PCS_config
[] =
7572 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
7573 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
7574 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
7575 {"V6", "SB", "TLS", "Unused"};
7576 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
7577 {"Absolute", "PC-relative", "SB-relative", "None"};
7578 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
7579 {"Absolute", "PC-relative", "None"};
7580 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
7581 {"None", "direct", "GOT-indirect"};
7582 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
7583 {"None", "??? 1", "2", "??? 3", "4"};
7584 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
7585 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
7586 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
7587 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
7588 static const char *arm_attr_tag_ABI_FP_number_model
[] =
7589 {"Unused", "Finite", "RTABI", "IEEE 754"};
7590 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
7591 static const char *arm_attr_tag_ABI_align8_preserved
[] =
7592 {"No", "Yes, except leaf SP", "Yes"};
7593 static const char *arm_attr_tag_ABI_enum_size
[] =
7594 {"Unused", "small", "int", "forced to int"};
7595 static const char *arm_attr_tag_ABI_HardFP_use
[] =
7596 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
7597 static const char *arm_attr_tag_ABI_VFP_args
[] =
7598 {"AAPCS", "VFP registers", "custom"};
7599 static const char *arm_attr_tag_ABI_WMMX_args
[] =
7600 {"AAPCS", "WMMX registers", "custom"};
7601 static const char *arm_attr_tag_ABI_optimization_goals
[] =
7602 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7603 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
7604 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
7605 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7606 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
7608 #define LOOKUP(id, name) \
7609 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
7610 static arm_attr_public_tag arm_attr_public_tags
[] =
7612 {4, "CPU_raw_name", 1, NULL
},
7613 {5, "CPU_name", 1, NULL
},
7614 LOOKUP(6, CPU_arch
),
7615 {7, "CPU_arch_profile", 0, NULL
},
7616 LOOKUP(8, ARM_ISA_use
),
7617 LOOKUP(9, THUMB_ISA_use
),
7618 LOOKUP(10, VFP_arch
),
7619 LOOKUP(11, WMMX_arch
),
7620 LOOKUP(12, NEON_arch
),
7621 LOOKUP(13, ABI_PCS_config
),
7622 LOOKUP(14, ABI_PCS_R9_use
),
7623 LOOKUP(15, ABI_PCS_RW_data
),
7624 LOOKUP(16, ABI_PCS_RO_DATA
),
7625 LOOKUP(17, ABI_PCS_GOT_use
),
7626 LOOKUP(18, ABI_PCS_wchar_t
),
7627 LOOKUP(19, ABI_FP_rounding
),
7628 LOOKUP(20, ABI_FP_denormal
),
7629 LOOKUP(21, ABI_FP_exceptions
),
7630 LOOKUP(22, ABI_FP_user_exceptions
),
7631 LOOKUP(23, ABI_FP_number_model
),
7632 LOOKUP(24, ABI_align8_needed
),
7633 LOOKUP(25, ABI_align8_preserved
),
7634 LOOKUP(26, ABI_enum_size
),
7635 LOOKUP(27, ABI_HardFP_use
),
7636 LOOKUP(28, ABI_VFP_args
),
7637 LOOKUP(29, ABI_WMMX_args
),
7638 LOOKUP(30, ABI_optimization_goals
),
7639 LOOKUP(31, ABI_FP_optimization_goals
),
7640 {32, "compatibility", 0, NULL
}
7644 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
7647 read_uleb128 (unsigned char *p
, unsigned int *plen
)
7661 val
|= ((unsigned int)c
& 0x7f) << shift
;
7670 static unsigned char *
7671 display_arm_attribute (unsigned char *p
)
7676 arm_attr_public_tag
*attr
;
7680 tag
= read_uleb128 (p
, &len
);
7683 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
7685 if (arm_attr_public_tags
[i
].tag
== tag
)
7687 attr
= &arm_attr_public_tags
[i
];
7694 printf (" Tag_%s: ", attr
->name
);
7700 case 7: /* Tag_CPU_arch_profile. */
7701 val
= read_uleb128 (p
, &len
);
7705 case 0: printf ("None\n"); break;
7706 case 'A': printf ("Application\n"); break;
7707 case 'R': printf ("Realtime\n"); break;
7708 case 'M': printf ("Microcontroller\n"); break;
7709 default: printf ("??? (%d)\n", val
); break;
7713 case 32: /* Tag_compatibility. */
7714 val
= read_uleb128 (p
, &len
);
7716 printf ("flag = %d, vendor = %s\n", val
, p
);
7717 p
+= strlen((char *)p
) + 1;
7731 assert (attr
->type
& 0x80);
7732 val
= read_uleb128 (p
, &len
);
7734 type
= attr
->type
& 0x7f;
7736 printf ("??? (%d)\n", val
);
7738 printf ("%s\n", attr
->table
[val
]);
7745 type
= 1; /* String. */
7747 type
= 2; /* uleb128. */
7748 printf (" Tag_unknown_%d: ", tag
);
7753 printf ("\"%s\"\n", p
);
7754 p
+= strlen((char *)p
) + 1;
7758 val
= read_uleb128 (p
, &len
);
7760 printf ("%d (0x%x)\n", val
, val
);
7767 process_arm_specific (FILE *file
)
7769 Elf_Internal_Shdr
*sect
;
7770 unsigned char *contents
;
7773 bfd_vma section_len
;
7777 /* Find the section header so that we get the size. */
7778 for (i
= 0, sect
= section_headers
;
7779 i
< elf_header
.e_shnum
;
7782 if (sect
->sh_type
!= SHT_ARM_ATTRIBUTES
)
7785 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
7793 len
= sect
->sh_size
- 1;
7798 bfd_boolean public_section
;
7800 section_len
= byte_get (p
, 4);
7802 if (section_len
> len
)
7804 printf (_("ERROR: Bad section length (%d > %d)\n"),
7805 (int)section_len
, (int)len
);
7809 printf ("Attribute Section: %s\n", p
);
7810 if (strcmp ((char *)p
, "aeabi") == 0)
7811 public_section
= TRUE
;
7813 public_section
= FALSE
;
7814 namelen
= strlen ((char *)p
) + 1;
7816 section_len
-= namelen
+ 4;
7817 while (section_len
> 0)
7822 size
= byte_get (p
, 4);
7823 if (size
> section_len
)
7825 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
7826 (int)size
, (int)section_len
);
7829 section_len
-= size
;
7835 printf ("File Attributes\n");
7838 printf ("Section Attributes:");
7841 printf ("Symbol Attributes:");
7846 val
= read_uleb128 (p
, &i
);
7850 printf (" %d", val
);
7855 printf ("Unknown tag: %d\n", tag
);
7856 public_section
= FALSE
;
7862 p
= display_arm_attribute(p
);
7866 /* ??? Do something sensible, like dump hex. */
7867 printf (" Unknown section contexts\n");
7875 printf (_("Unknown format '%c'\n"), *p
);
7884 process_mips_specific (FILE *file
)
7886 Elf_Internal_Dyn
*entry
;
7887 size_t liblist_offset
= 0;
7888 size_t liblistno
= 0;
7889 size_t conflictsno
= 0;
7890 size_t options_offset
= 0;
7891 size_t conflicts_offset
= 0;
7893 /* We have a lot of special sections. Thanks SGI! */
7894 if (dynamic_section
== NULL
)
7895 /* No information available. */
7898 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
7899 switch (entry
->d_tag
)
7901 case DT_MIPS_LIBLIST
:
7903 = offset_from_vma (file
, entry
->d_un
.d_val
,
7904 liblistno
* sizeof (Elf32_External_Lib
));
7906 case DT_MIPS_LIBLISTNO
:
7907 liblistno
= entry
->d_un
.d_val
;
7909 case DT_MIPS_OPTIONS
:
7910 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7912 case DT_MIPS_CONFLICT
:
7914 = offset_from_vma (file
, entry
->d_un
.d_val
,
7915 conflictsno
* sizeof (Elf32_External_Conflict
));
7917 case DT_MIPS_CONFLICTNO
:
7918 conflictsno
= entry
->d_un
.d_val
;
7924 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
7926 Elf32_External_Lib
*elib
;
7929 elib
= get_data (NULL
, file
, liblist_offset
,
7930 liblistno
, sizeof (Elf32_External_Lib
),
7934 printf ("\nSection '.liblist' contains %lu entries:\n",
7935 (unsigned long) liblistno
);
7936 fputs (" Library Time Stamp Checksum Version Flags\n",
7939 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
7946 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
7947 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
7948 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
7949 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
7950 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
7952 tmp
= gmtime (&time
);
7953 snprintf (timebuf
, sizeof (timebuf
),
7954 "%04u-%02u-%02uT%02u:%02u:%02u",
7955 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7956 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7958 printf ("%3lu: ", (unsigned long) cnt
);
7959 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
7960 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
7962 printf ("<corrupt: %9ld>", liblist
.l_name
);
7963 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
7966 if (liblist
.l_flags
== 0)
7977 { " EXACT_MATCH", LL_EXACT_MATCH
},
7978 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
7979 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
7980 { " EXPORTS", LL_EXPORTS
},
7981 { " DELAY_LOAD", LL_DELAY_LOAD
},
7982 { " DELTA", LL_DELTA
}
7984 int flags
= liblist
.l_flags
;
7988 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
7990 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
7992 fputs (l_flags_vals
[fcnt
].name
, stdout
);
7993 flags
^= l_flags_vals
[fcnt
].bit
;
7996 printf (" %#x", (unsigned int) flags
);
8006 if (options_offset
!= 0)
8008 Elf_External_Options
*eopt
;
8009 Elf_Internal_Shdr
*sect
= section_headers
;
8010 Elf_Internal_Options
*iopt
;
8011 Elf_Internal_Options
*option
;
8015 /* Find the section header so that we get the size. */
8016 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8019 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8023 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8026 error (_("Out of memory"));
8033 while (offset
< sect
->sh_size
)
8035 Elf_External_Options
*eoption
;
8037 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8039 option
->kind
= BYTE_GET (eoption
->kind
);
8040 option
->size
= BYTE_GET (eoption
->size
);
8041 option
->section
= BYTE_GET (eoption
->section
);
8042 option
->info
= BYTE_GET (eoption
->info
);
8044 offset
+= option
->size
;
8050 printf (_("\nSection '%s' contains %d entries:\n"),
8051 SECTION_NAME (sect
), cnt
);
8059 switch (option
->kind
)
8062 /* This shouldn't happen. */
8063 printf (" NULL %d %lx", option
->section
, option
->info
);
8066 printf (" REGINFO ");
8067 if (elf_header
.e_machine
== EM_MIPS
)
8070 Elf32_External_RegInfo
*ereg
;
8071 Elf32_RegInfo reginfo
;
8073 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8074 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8075 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8076 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8077 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8078 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8079 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8081 printf ("GPR %08lx GP 0x%lx\n",
8083 (unsigned long) reginfo
.ri_gp_value
);
8084 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8085 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8086 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8091 Elf64_External_RegInfo
*ereg
;
8092 Elf64_Internal_RegInfo reginfo
;
8094 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8095 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8096 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8097 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8098 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8099 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8100 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8102 printf ("GPR %08lx GP 0x",
8103 reginfo
.ri_gprmask
);
8104 printf_vma (reginfo
.ri_gp_value
);
8107 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8108 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8109 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8113 case ODK_EXCEPTIONS
:
8114 fputs (" EXCEPTIONS fpe_min(", stdout
);
8115 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8116 fputs (") fpe_max(", stdout
);
8117 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8118 fputs (")", stdout
);
8120 if (option
->info
& OEX_PAGE0
)
8121 fputs (" PAGE0", stdout
);
8122 if (option
->info
& OEX_SMM
)
8123 fputs (" SMM", stdout
);
8124 if (option
->info
& OEX_FPDBUG
)
8125 fputs (" FPDBUG", stdout
);
8126 if (option
->info
& OEX_DISMISS
)
8127 fputs (" DISMISS", stdout
);
8130 fputs (" PAD ", stdout
);
8131 if (option
->info
& OPAD_PREFIX
)
8132 fputs (" PREFIX", stdout
);
8133 if (option
->info
& OPAD_POSTFIX
)
8134 fputs (" POSTFIX", stdout
);
8135 if (option
->info
& OPAD_SYMBOL
)
8136 fputs (" SYMBOL", stdout
);
8139 fputs (" HWPATCH ", stdout
);
8140 if (option
->info
& OHW_R4KEOP
)
8141 fputs (" R4KEOP", stdout
);
8142 if (option
->info
& OHW_R8KPFETCH
)
8143 fputs (" R8KPFETCH", stdout
);
8144 if (option
->info
& OHW_R5KEOP
)
8145 fputs (" R5KEOP", stdout
);
8146 if (option
->info
& OHW_R5KCVTL
)
8147 fputs (" R5KCVTL", stdout
);
8150 fputs (" FILL ", stdout
);
8151 /* XXX Print content of info word? */
8154 fputs (" TAGS ", stdout
);
8155 /* XXX Print content of info word? */
8158 fputs (" HWAND ", stdout
);
8159 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8160 fputs (" R4KEOP_CHECKED", stdout
);
8161 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8162 fputs (" R4KEOP_CLEAN", stdout
);
8165 fputs (" HWOR ", stdout
);
8166 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8167 fputs (" R4KEOP_CHECKED", stdout
);
8168 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8169 fputs (" R4KEOP_CLEAN", stdout
);
8172 printf (" GP_GROUP %#06lx self-contained %#06lx",
8173 option
->info
& OGP_GROUP
,
8174 (option
->info
& OGP_SELF
) >> 16);
8177 printf (" IDENT %#06lx self-contained %#06lx",
8178 option
->info
& OGP_GROUP
,
8179 (option
->info
& OGP_SELF
) >> 16);
8182 /* This shouldn't happen. */
8183 printf (" %3d ??? %d %lx",
8184 option
->kind
, option
->section
, option
->info
);
8188 len
= sizeof (*eopt
);
8189 while (len
< option
->size
)
8190 if (((char *) option
)[len
] >= ' '
8191 && ((char *) option
)[len
] < 0x7f)
8192 printf ("%c", ((char *) option
)[len
++]);
8194 printf ("\\%03o", ((char *) option
)[len
++]);
8196 fputs ("\n", stdout
);
8204 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8206 Elf32_Conflict
*iconf
;
8209 if (dynamic_symbols
== NULL
)
8211 error (_("conflict list found without a dynamic symbol table"));
8215 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
8218 error (_("Out of memory"));
8224 Elf32_External_Conflict
*econf32
;
8226 econf32
= get_data (NULL
, file
, conflicts_offset
,
8227 conflictsno
, sizeof (*econf32
), _("conflict"));
8231 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8232 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8238 Elf64_External_Conflict
*econf64
;
8240 econf64
= get_data (NULL
, file
, conflicts_offset
,
8241 conflictsno
, sizeof (*econf64
), _("conflict"));
8245 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8246 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8251 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8252 (unsigned long) conflictsno
);
8253 puts (_(" Num: Index Value Name"));
8255 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8257 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
8259 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8260 print_vma (psym
->st_value
, FULL_HEX
);
8262 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8263 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8265 printf ("<corrupt: %14ld>", psym
->st_name
);
8276 process_gnu_liblist (FILE *file
)
8278 Elf_Internal_Shdr
*section
, *string_sec
;
8279 Elf32_External_Lib
*elib
;
8288 for (i
= 0, section
= section_headers
;
8289 i
< elf_header
.e_shnum
;
8292 switch (section
->sh_type
)
8294 case SHT_GNU_LIBLIST
:
8295 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
8298 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
8303 string_sec
= SECTION_HEADER (section
->sh_link
);
8305 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8306 string_sec
->sh_size
, _("liblist string table"));
8307 strtab_size
= string_sec
->sh_size
;
8310 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
8316 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8317 SECTION_NAME (section
),
8318 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
8320 puts (" Library Time Stamp Checksum Version Flags");
8322 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
8330 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8331 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8332 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8333 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8334 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8336 tmp
= gmtime (&time
);
8337 snprintf (timebuf
, sizeof (timebuf
),
8338 "%04u-%02u-%02uT%02u:%02u:%02u",
8339 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8340 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8342 printf ("%3lu: ", (unsigned long) cnt
);
8344 printf ("%-20s", liblist
.l_name
< strtab_size
8345 ? strtab
+ liblist
.l_name
: "<corrupt>");
8347 printf ("%-20.20s", liblist
.l_name
< strtab_size
8348 ? strtab
+ liblist
.l_name
: "<corrupt>");
8349 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
8350 liblist
.l_version
, liblist
.l_flags
);
8361 get_note_type (unsigned e_type
)
8363 static char buff
[64];
8365 if (elf_header
.e_type
== ET_CORE
)
8369 return _("NT_AUXV (auxiliary vector)");
8371 return _("NT_PRSTATUS (prstatus structure)");
8373 return _("NT_FPREGSET (floating point registers)");
8375 return _("NT_PRPSINFO (prpsinfo structure)");
8377 return _("NT_TASKSTRUCT (task structure)");
8379 return _("NT_PRXFPREG (user_xfpregs structure)");
8381 return _("NT_PSTATUS (pstatus structure)");
8383 return _("NT_FPREGS (floating point registers)");
8385 return _("NT_PSINFO (psinfo structure)");
8387 return _("NT_LWPSTATUS (lwpstatus_t structure)");
8389 return _("NT_LWPSINFO (lwpsinfo_t structure)");
8390 case NT_WIN32PSTATUS
:
8391 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8399 return _("NT_VERSION (version)");
8401 return _("NT_ARCH (architecture)");
8406 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8411 get_netbsd_elfcore_note_type (unsigned e_type
)
8413 static char buff
[64];
8415 if (e_type
== NT_NETBSDCORE_PROCINFO
)
8417 /* NetBSD core "procinfo" structure. */
8418 return _("NetBSD procinfo structure");
8421 /* As of Jan 2002 there are no other machine-independent notes
8422 defined for NetBSD core files. If the note type is less
8423 than the start of the machine-dependent note types, we don't
8426 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
8428 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8432 switch (elf_header
.e_machine
)
8434 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8435 and PT_GETFPREGS == mach+2. */
8440 case EM_SPARC32PLUS
:
8444 case NT_NETBSDCORE_FIRSTMACH
+0:
8445 return _("PT_GETREGS (reg structure)");
8446 case NT_NETBSDCORE_FIRSTMACH
+2:
8447 return _("PT_GETFPREGS (fpreg structure)");
8453 /* On all other arch's, PT_GETREGS == mach+1 and
8454 PT_GETFPREGS == mach+3. */
8458 case NT_NETBSDCORE_FIRSTMACH
+1:
8459 return _("PT_GETREGS (reg structure)");
8460 case NT_NETBSDCORE_FIRSTMACH
+3:
8461 return _("PT_GETFPREGS (fpreg structure)");
8467 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
8468 e_type
- NT_NETBSDCORE_FIRSTMACH
);
8472 /* Note that by the ELF standard, the name field is already null byte
8473 terminated, and namesz includes the terminating null byte.
8474 I.E. the value of namesz for the name "FSF" is 4.
8476 If the value of namesz is zero, there is no name present. */
8478 process_note (Elf_Internal_Note
*pnote
)
8482 if (pnote
->namesz
== 0)
8483 /* If there is no note name, then use the default set of
8484 note type strings. */
8485 nt
= get_note_type (pnote
->type
);
8487 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
8488 /* NetBSD-specific core file notes. */
8489 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
8492 /* Don't recognize this note name; just use the default set of
8493 note type strings. */
8494 nt
= get_note_type (pnote
->type
);
8496 printf (" %s\t\t0x%08lx\t%s\n",
8497 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8504 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
8506 Elf_External_Note
*pnotes
;
8507 Elf_External_Note
*external
;
8513 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
8519 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8520 (unsigned long) offset
, (unsigned long) length
);
8521 printf (_(" Owner\t\tData size\tDescription\n"));
8523 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8525 Elf_External_Note
*next
;
8526 Elf_Internal_Note inote
;
8529 inote
.type
= BYTE_GET (external
->type
);
8530 inote
.namesz
= BYTE_GET (external
->namesz
);
8531 inote
.namedata
= external
->name
;
8532 inote
.descsz
= BYTE_GET (external
->descsz
);
8533 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8534 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8536 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8538 if (((char *) next
) > (((char *) pnotes
) + length
))
8540 warn (_("corrupt note found at offset %lx into core notes\n"),
8541 (long)((char *)external
- (char *)pnotes
));
8542 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8543 inote
.type
, inote
.namesz
, inote
.descsz
);
8549 /* Verify that name is null terminated. It appears that at least
8550 one version of Linux (RedHat 6.0) generates corefiles that don't
8551 comply with the ELF spec by failing to include the null byte in
8553 if (inote
.namedata
[inote
.namesz
] != '\0')
8555 temp
= malloc (inote
.namesz
+ 1);
8559 error (_("Out of memory\n"));
8564 strncpy (temp
, inote
.namedata
, inote
.namesz
);
8565 temp
[inote
.namesz
] = 0;
8567 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8568 inote
.namedata
= temp
;
8571 res
&= process_note (& inote
);
8586 process_corefile_note_segments (FILE *file
)
8588 Elf_Internal_Phdr
*segment
;
8592 if (! get_program_headers (file
))
8595 for (i
= 0, segment
= program_headers
;
8596 i
< elf_header
.e_phnum
;
8599 if (segment
->p_type
== PT_NOTE
)
8600 res
&= process_corefile_note_segment (file
,
8601 (bfd_vma
) segment
->p_offset
,
8602 (bfd_vma
) segment
->p_filesz
);
8609 process_note_sections (FILE *file
)
8611 Elf_Internal_Shdr
*section
;
8615 for (i
= 0, section
= section_headers
;
8616 i
< elf_header
.e_shnum
;
8618 if (section
->sh_type
== SHT_NOTE
)
8619 res
&= process_corefile_note_segment (file
,
8620 (bfd_vma
) section
->sh_offset
,
8621 (bfd_vma
) section
->sh_size
);
8627 process_notes (FILE *file
)
8629 /* If we have not been asked to display the notes then do nothing. */
8633 if (elf_header
.e_type
!= ET_CORE
)
8634 return process_note_sections (file
);
8636 /* No program headers means no NOTE segment. */
8637 if (elf_header
.e_phnum
> 0)
8638 return process_corefile_note_segments (file
);
8640 printf (_("No note segments present in the core file.\n"));
8645 process_arch_specific (FILE *file
)
8650 switch (elf_header
.e_machine
)
8653 return process_arm_specific (file
);
8655 case EM_MIPS_RS3_LE
:
8656 return process_mips_specific (file
);
8665 get_file_header (FILE *file
)
8667 /* Read in the identity array. */
8668 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
8671 /* Determine how to read the rest of the header. */
8672 switch (elf_header
.e_ident
[EI_DATA
])
8674 default: /* fall through */
8675 case ELFDATANONE
: /* fall through */
8677 byte_get
= byte_get_little_endian
;
8678 byte_put
= byte_put_little_endian
;
8681 byte_get
= byte_get_big_endian
;
8682 byte_put
= byte_put_big_endian
;
8686 /* For now we only support 32 bit and 64 bit ELF files. */
8687 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
8689 /* Read in the rest of the header. */
8692 Elf32_External_Ehdr ehdr32
;
8694 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
8697 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
8698 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
8699 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
8700 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
8701 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
8702 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
8703 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
8704 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
8705 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
8706 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
8707 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
8708 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
8709 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
8713 Elf64_External_Ehdr ehdr64
;
8715 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8716 we will not be able to cope with the 64bit data found in
8717 64 ELF files. Detect this now and abort before we start
8718 overwriting things. */
8719 if (sizeof (bfd_vma
) < 8)
8721 error (_("This instance of readelf has been built without support for a\n\
8722 64 bit data type and so it cannot read 64 bit ELF files.\n"));
8726 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
8729 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
8730 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
8731 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
8732 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
8733 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
8734 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
8735 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
8736 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
8737 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
8738 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
8739 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
8740 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
8741 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
8744 if (elf_header
.e_shoff
)
8746 /* There may be some extensions in the first section header. Don't
8747 bomb if we can't read it. */
8749 get_32bit_section_headers (file
, 1);
8751 get_64bit_section_headers (file
, 1);
8754 is_relocatable
= elf_header
.e_type
== ET_REL
;
8759 /* Process one ELF object file according to the command line options.
8760 This file may actually be stored in an archive. The file is
8761 positioned at the start of the ELF object. */
8764 process_object (char *file_name
, FILE *file
)
8768 if (! get_file_header (file
))
8770 error (_("%s: Failed to read file header\n"), file_name
);
8774 /* Initialise per file variables. */
8775 for (i
= NUM_ELEM (version_info
); i
--;)
8776 version_info
[i
] = 0;
8778 for (i
= NUM_ELEM (dynamic_info
); i
--;)
8779 dynamic_info
[i
] = 0;
8781 /* Process the file. */
8783 printf (_("\nFile: %s\n"), file_name
);
8785 /* Initialise the dump_sects array from the cmdline_dump_sects array.
8786 Note we do this even if cmdline_dump_sects is empty because we
8787 must make sure that the dump_sets array is zeroed out before each
8788 object file is processed. */
8789 if (num_dump_sects
> num_cmdline_dump_sects
)
8790 memset (dump_sects
, 0, num_dump_sects
);
8792 if (num_cmdline_dump_sects
> 0)
8794 if (num_dump_sects
== 0)
8795 /* A sneaky way of allocating the dump_sects array. */
8796 request_dump (num_cmdline_dump_sects
, 0);
8798 assert (num_dump_sects
>= num_cmdline_dump_sects
);
8799 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
8802 if (! process_file_header ())
8805 if (! process_section_headers (file
))
8807 /* Without loaded section headers we cannot process lots of
8809 do_unwind
= do_version
= do_dump
= do_arch
= 0;
8811 if (! do_using_dynamic
)
8812 do_syms
= do_reloc
= 0;
8815 if (! process_section_groups (file
))
8817 /* Without loaded section groups we cannot process unwind. */
8821 if (process_program_headers (file
))
8822 process_dynamic_section (file
);
8824 process_relocs (file
);
8826 process_unwind (file
);
8828 process_symbol_table (file
);
8830 process_syminfo (file
);
8832 process_version_sections (file
);
8834 process_section_contents (file
);
8836 process_notes (file
);
8838 process_gnu_liblist (file
);
8840 process_arch_specific (file
);
8842 if (program_headers
)
8844 free (program_headers
);
8845 program_headers
= NULL
;
8848 if (section_headers
)
8850 free (section_headers
);
8851 section_headers
= NULL
;
8856 free (string_table
);
8857 string_table
= NULL
;
8858 string_table_length
= 0;
8861 if (dynamic_strings
)
8863 free (dynamic_strings
);
8864 dynamic_strings
= NULL
;
8865 dynamic_strings_length
= 0;
8868 if (dynamic_symbols
)
8870 free (dynamic_symbols
);
8871 dynamic_symbols
= NULL
;
8872 num_dynamic_syms
= 0;
8875 if (dynamic_syminfo
)
8877 free (dynamic_syminfo
);
8878 dynamic_syminfo
= NULL
;
8881 if (section_headers_groups
)
8883 free (section_headers_groups
);
8884 section_headers_groups
= NULL
;
8889 struct group_list
*g
, *next
;
8891 for (i
= 0; i
< group_count
; i
++)
8893 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
8900 free (section_groups
);
8901 section_groups
= NULL
;
8904 free_debug_memory ();
8909 /* Process an ELF archive. The file is positioned just after the
8913 process_archive (char *file_name
, FILE *file
)
8915 struct ar_hdr arhdr
;
8918 char *longnames
= NULL
;
8919 unsigned long longnames_size
= 0;
8920 size_t file_name_size
;
8925 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
8926 if (got
!= sizeof arhdr
)
8931 error (_("%s: failed to read archive header\n"), file_name
);
8935 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
8937 /* This is the archive symbol table. Skip it.
8938 FIXME: We should have an option to dump it. */
8939 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
8940 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
8942 error (_("%s: failed to skip archive symbol table\n"), file_name
);
8946 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
8947 if (got
!= sizeof arhdr
)
8952 error (_("%s: failed to read archive header\n"), file_name
);
8957 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
8959 /* This is the archive string table holding long member
8962 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
8964 longnames
= malloc (longnames_size
);
8965 if (longnames
== NULL
)
8967 error (_("Out of memory\n"));
8971 if (fread (longnames
, longnames_size
, 1, file
) != 1)
8974 error (_("%s: failed to read string table\n"), file_name
);
8978 if ((longnames_size
& 1) != 0)
8981 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
8982 if (got
!= sizeof arhdr
)
8989 error (_("%s: failed to read archive header\n"), file_name
);
8994 file_name_size
= strlen (file_name
);
9003 if (arhdr
.ar_name
[0] == '/')
9007 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
9008 if (off
>= longnames_size
)
9010 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
9015 name
= longnames
+ off
;
9016 nameend
= memchr (name
, '/', longnames_size
- off
);
9020 name
= arhdr
.ar_name
;
9021 nameend
= memchr (name
, '/', 16);
9024 if (nameend
== NULL
)
9026 error (_("%s: bad archive file name\n"), file_name
);
9031 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
9032 if (namealc
== NULL
)
9034 error (_("Out of memory\n"));
9039 memcpy (namealc
, file_name
, file_name_size
);
9040 namealc
[file_name_size
] = '(';
9041 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
9042 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
9043 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
9045 archive_file_offset
= ftell (file
);
9046 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9048 ret
|= process_object (namealc
, file
);
9053 (archive_file_offset
9055 + (archive_file_size
& 1)),
9058 error (_("%s: failed to seek to next archive header\n"), file_name
);
9063 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9064 if (got
!= sizeof arhdr
)
9069 error (_("%s: failed to read archive header\n"), file_name
);
9082 process_file (char *file_name
)
9085 struct stat statbuf
;
9089 if (stat (file_name
, &statbuf
) < 0)
9091 if (errno
== ENOENT
)
9092 error (_("'%s': No such file\n"), file_name
);
9094 error (_("Could not locate '%s'. System error message: %s\n"),
9095 file_name
, strerror (errno
));
9099 if (! S_ISREG (statbuf
.st_mode
))
9101 error (_("'%s' is not an ordinary file\n"), file_name
);
9105 file
= fopen (file_name
, "rb");
9108 error (_("Input file '%s' is not readable.\n"), file_name
);
9112 if (fread (armag
, SARMAG
, 1, file
) != 1)
9114 error (_("%s: Failed to read file header\n"), file_name
);
9119 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
9120 ret
= process_archive (file_name
, file
);
9124 archive_file_size
= archive_file_offset
= 0;
9125 ret
= process_object (file_name
, file
);
9133 #ifdef SUPPORT_DISASSEMBLY
9134 /* Needed by the i386 disassembler. For extra credit, someone could
9135 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9139 print_address (unsigned int addr
, FILE *outfile
)
9141 fprintf (outfile
,"0x%8.8x", addr
);
9144 /* Needed by the i386 disassembler. */
9146 db_task_printsym (unsigned int addr
)
9148 print_address (addr
, stderr
);
9153 main (int argc
, char **argv
)
9157 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9158 setlocale (LC_MESSAGES
, "");
9160 #if defined (HAVE_SETLOCALE)
9161 setlocale (LC_CTYPE
, "");
9163 bindtextdomain (PACKAGE
, LOCALEDIR
);
9164 textdomain (PACKAGE
);
9166 expandargv (&argc
, &argv
);
9168 parse_args (argc
, argv
);
9170 if (num_dump_sects
> 0)
9172 /* Make a copy of the dump_sects array. */
9173 cmdline_dump_sects
= malloc (num_dump_sects
);
9174 if (cmdline_dump_sects
== NULL
)
9175 error (_("Out of memory allocating dump request table."));
9178 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
9179 num_cmdline_dump_sects
= num_dump_sects
;
9183 if (optind
< (argc
- 1))
9187 while (optind
< argc
)
9188 err
|= process_file (argv
[optind
++]);
9190 if (dump_sects
!= NULL
)
9192 if (cmdline_dump_sects
!= NULL
)
9193 free (cmdline_dump_sects
);