1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
45 #include <sys/types.h>
57 # ifdef HAVE_SYS_PARAM_H
58 # include <sys/param.h>
62 # define PATH_MAX MAXPATHLEN
64 # define PATH_MAX 1024
70 /* Define BFD64 here, even if our default architecture is 32 bit ELF
71 as this will allow us to read in and parse 64bit and 32bit ELF files.
72 Only do this if we believe that the compiler can support a 64 bit
73 data type. For now we only rely on GCC being able to do this. */
79 #include "elf/common.h"
80 #include "elf/external.h"
81 #include "elf/internal.h"
83 /* The following headers use the elf/reloc-macros.h file to
84 automatically generate relocation recognition functions
85 such as elf_mips_reloc_type() */
87 #define RELOC_MACROS_GEN_FUNC
89 #include "elf/alpha.h"
102 #include "elf/hppa.h"
103 #include "elf/i386.h"
104 #include "elf/i370.h"
105 #include "elf/i860.h"
106 #include "elf/i960.h"
107 #include "elf/ia64.h"
108 #include "elf/ip2k.h"
109 #include "elf/iq2000.h"
110 #include "elf/m32c.h"
111 #include "elf/m32r.h"
112 #include "elf/m68k.h"
113 #include "elf/m68hc11.h"
114 #include "elf/mcore.h"
115 #include "elf/mips.h"
116 #include "elf/mmix.h"
117 #include "elf/mn10200.h"
118 #include "elf/mn10300.h"
120 #include "elf/msp430.h"
121 #include "elf/or32.h"
124 #include "elf/ppc64.h"
125 #include "elf/s390.h"
126 #include "elf/score.h"
128 #include "elf/sparc.h"
130 #include "elf/v850.h"
132 #include "elf/x86-64.h"
133 #include "elf/xstormy16.h"
134 #include "elf/xtensa.h"
140 #include "libiberty.h"
142 char *program_name
= "readelf";
143 static long archive_file_offset
;
144 static unsigned long archive_file_size
;
145 static unsigned long dynamic_addr
;
146 static bfd_size_type dynamic_size
;
147 static unsigned int dynamic_nent
;
148 static char *dynamic_strings
;
149 static unsigned long dynamic_strings_length
;
150 static char *string_table
;
151 static unsigned long string_table_length
;
152 static unsigned long num_dynamic_syms
;
153 static Elf_Internal_Sym
*dynamic_symbols
;
154 static Elf_Internal_Syminfo
*dynamic_syminfo
;
155 static unsigned long dynamic_syminfo_offset
;
156 static unsigned int dynamic_syminfo_nent
;
157 static char program_interpreter
[PATH_MAX
];
158 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
159 static bfd_vma dynamic_info_DT_GNU_HASH
;
160 static bfd_vma version_info
[16];
161 static Elf_Internal_Ehdr elf_header
;
162 static Elf_Internal_Shdr
*section_headers
;
163 static Elf_Internal_Phdr
*program_headers
;
164 static Elf_Internal_Dyn
*dynamic_section
;
165 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
166 static int show_name
;
167 static int do_dynamic
;
170 static int do_sections
;
171 static int do_section_groups
;
172 static int do_section_details
;
173 static int do_segments
;
174 static int do_unwind
;
175 static int do_using_dynamic
;
176 static int do_header
;
178 static int do_version
;
180 static int do_histogram
;
181 static int do_debugging
;
184 static int is_32bit_elf
;
188 struct group_list
*next
;
189 unsigned int section_index
;
194 struct group_list
*root
;
195 unsigned int group_index
;
198 static size_t group_count
;
199 static struct group
*section_groups
;
200 static struct group
**section_headers_groups
;
202 /* A linked list of the section names for which dumps were requested
204 struct dump_list_entry
208 struct dump_list_entry
*next
;
210 static struct dump_list_entry
*dump_sects_byname
;
212 /* A dynamic array of flags indicating for which sections a hex dump
213 has been requested (via the -x switch) and/or a disassembly dump
214 (via the -i switch). */
215 char *cmdline_dump_sects
= NULL
;
216 unsigned num_cmdline_dump_sects
= 0;
218 /* A dynamic array of flags indicating for which sections a dump of
219 some kind has been requested. It is reset on a per-object file
220 basis and then initialised from the cmdline_dump_sects array,
221 the results of interpreting the -w switch, and the
222 dump_sects_byname list. */
223 char *dump_sects
= NULL
;
224 unsigned int num_dump_sects
= 0;
226 #define HEX_DUMP (1 << 0)
227 #define DISASS_DUMP (1 << 1)
228 #define DEBUG_DUMP (1 << 2)
230 /* How to print a vma value. */
231 typedef enum print_mode
243 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
247 #define SECTION_NAME(X) \
248 ((X) == NULL ? "<none>" \
249 : string_table == NULL ? "<no-name>" \
250 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
251 : string_table + (X)->sh_name))
253 /* Given st_shndx I, map to section_headers index. */
254 #define SECTION_HEADER_INDEX(I) \
255 ((I) < SHN_LORESERVE \
257 : ((I) <= SHN_HIRESERVE \
259 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
261 /* Reverse of the above. */
262 #define SECTION_HEADER_NUM(N) \
263 ((N) < SHN_LORESERVE \
265 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
267 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
269 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
271 #define BYTE_GET(field) byte_get (field, sizeof (field))
273 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
275 #define GET_ELF_SYMBOLS(file, section) \
276 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
277 : get_64bit_elf_symbols (file, section))
279 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
280 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
281 already been called and verified that the string exists. */
282 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
284 /* This is just a bit of syntatic sugar. */
285 #define streq(a,b) (strcmp ((a), (b)) == 0)
286 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
287 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
290 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
295 if (size
== 0 || nmemb
== 0)
298 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
300 error (_("Unable to seek to 0x%lx for %s\n"),
301 archive_file_offset
+ offset
, reason
);
308 /* Check for overflow. */
309 if (nmemb
< (~(size_t) 0 - 1) / size
)
310 /* + 1 so that we can '\0' terminate invalid string table sections. */
311 mvar
= malloc (size
* nmemb
+ 1);
315 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
316 (unsigned long)(size
* nmemb
), reason
);
320 ((char *) mvar
)[size
* nmemb
] = '\0';
323 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
325 error (_("Unable to read in 0x%lx bytes of %s\n"),
326 (unsigned long)(size
* nmemb
), reason
);
336 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
341 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
342 field
[6] = ((value
>> 24) >> 24) & 0xff;
343 field
[5] = ((value
>> 24) >> 16) & 0xff;
344 field
[4] = ((value
>> 24) >> 8) & 0xff;
347 field
[3] = (value
>> 24) & 0xff;
348 field
[2] = (value
>> 16) & 0xff;
351 field
[1] = (value
>> 8) & 0xff;
354 field
[0] = value
& 0xff;
358 error (_("Unhandled data length: %d\n"), size
);
363 #if defined BFD64 && !BFD_HOST_64BIT_LONG
365 print_dec_vma (bfd_vma vma
, int is_signed
)
371 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
380 *bufp
++ = '0' + vma
% 10;
392 print_hex_vma (bfd_vma vma
)
400 char digit
= '0' + (vma
& 0x0f);
402 digit
+= 'a' - '0' - 10;
415 /* Print a VMA value. */
417 print_vma (bfd_vma vma
, print_mode mode
)
426 return printf ("0x%8.8lx", (unsigned long) vma
);
429 return printf ("%8.8lx", (unsigned long) vma
);
433 return printf ("%5ld", (long) vma
);
437 return printf ("0x%lx", (unsigned long) vma
);
440 return printf ("%lx", (unsigned long) vma
);
443 return printf ("%ld", (unsigned long) vma
);
446 return printf ("%lu", (unsigned long) vma
);
469 #if BFD_HOST_64BIT_LONG
470 return nc
+ printf ("%lx", vma
);
472 return nc
+ print_hex_vma (vma
);
476 #if BFD_HOST_64BIT_LONG
477 return printf ("%ld", vma
);
479 return print_dec_vma (vma
, 1);
483 #if BFD_HOST_64BIT_LONG
485 return printf ("%5ld", vma
);
487 return printf ("%#lx", vma
);
490 return printf ("%5ld", _bfd_int64_low (vma
));
492 return print_hex_vma (vma
);
496 #if BFD_HOST_64BIT_LONG
497 return printf ("%lu", vma
);
499 return print_dec_vma (vma
, 0);
507 /* Display a symbol on stdout. If do_wide is not true then
508 format the symbol to be at most WIDTH characters,
509 truncating as necessary. If WIDTH is negative then
510 format the string to be exactly - WIDTH characters,
511 truncating or padding as necessary. */
514 print_symbol (int width
, const char *symbol
)
517 printf ("%s", symbol
);
519 printf ("%-*.*s", width
, width
, symbol
);
521 printf ("%-.*s", width
, symbol
);
525 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
530 field
[7] = value
& 0xff;
531 field
[6] = (value
>> 8) & 0xff;
532 field
[5] = (value
>> 16) & 0xff;
533 field
[4] = (value
>> 24) & 0xff;
538 field
[3] = value
& 0xff;
539 field
[2] = (value
>> 8) & 0xff;
543 field
[1] = value
& 0xff;
547 field
[0] = value
& 0xff;
551 error (_("Unhandled data length: %d\n"), size
);
556 /* Return a pointer to section NAME, or NULL if no such section exists. */
558 static Elf_Internal_Shdr
*
559 find_section (const char *name
)
563 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
564 if (streq (SECTION_NAME (section_headers
+ i
), name
))
565 return section_headers
+ i
;
570 /* Guess the relocation size commonly used by the specific machines. */
573 guess_is_rela (unsigned long e_machine
)
577 /* Targets that use REL relocations. */
593 /* Targets that use RELA relocations. */
597 case EM_ALTERA_NIOS2
:
620 case EM_CYGNUS_MN10200
:
622 case EM_CYGNUS_MN10300
:
663 warn (_("Don't know about relocations on this machine architecture\n"));
669 slurp_rela_relocs (FILE *file
,
670 unsigned long rel_offset
,
671 unsigned long rel_size
,
672 Elf_Internal_Rela
**relasp
,
673 unsigned long *nrelasp
)
675 Elf_Internal_Rela
*relas
;
676 unsigned long nrelas
;
681 Elf32_External_Rela
*erelas
;
683 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
687 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
689 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
694 error (_("out of memory parsing relocs"));
698 for (i
= 0; i
< nrelas
; i
++)
700 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
701 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
702 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
709 Elf64_External_Rela
*erelas
;
711 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
715 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
717 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
722 error (_("out of memory parsing relocs"));
726 for (i
= 0; i
< nrelas
; i
++)
728 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
729 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
730 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
741 slurp_rel_relocs (FILE *file
,
742 unsigned long rel_offset
,
743 unsigned long rel_size
,
744 Elf_Internal_Rela
**relsp
,
745 unsigned long *nrelsp
)
747 Elf_Internal_Rela
*rels
;
753 Elf32_External_Rel
*erels
;
755 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
759 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
761 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
766 error (_("out of memory parsing relocs"));
770 for (i
= 0; i
< nrels
; i
++)
772 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
773 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
774 rels
[i
].r_addend
= 0;
781 Elf64_External_Rel
*erels
;
783 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
787 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
789 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
794 error (_("out of memory parsing relocs"));
798 for (i
= 0; i
< nrels
; i
++)
800 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
801 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
802 rels
[i
].r_addend
= 0;
812 /* Display the contents of the relocation data found at the specified
816 dump_relocations (FILE *file
,
817 unsigned long rel_offset
,
818 unsigned long rel_size
,
819 Elf_Internal_Sym
*symtab
,
822 unsigned long strtablen
,
826 Elf_Internal_Rela
*rels
;
829 if (is_rela
== UNKNOWN
)
830 is_rela
= guess_is_rela (elf_header
.e_machine
);
834 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
839 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
848 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
850 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
855 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
857 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
865 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
867 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
872 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
874 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
878 for (i
= 0; i
< rel_size
; i
++)
881 const char *rtype2
= NULL
;
882 const char *rtype3
= NULL
;
885 bfd_vma symtab_index
;
890 offset
= rels
[i
].r_offset
;
891 info
= rels
[i
].r_info
;
895 type
= ELF32_R_TYPE (info
);
896 symtab_index
= ELF32_R_SYM (info
);
900 /* The #ifdef BFD64 below is to prevent a compile time warning.
901 We know that if we do not have a 64 bit data type that we
902 will never execute this code anyway. */
904 if (elf_header
.e_machine
== EM_MIPS
)
906 /* In little-endian objects, r_info isn't really a 64-bit
907 little-endian value: it has a 32-bit little-endian
908 symbol index followed by four individual byte fields.
909 Reorder INFO accordingly. */
910 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
911 info
= (((info
& 0xffffffff) << 32)
912 | ((info
>> 56) & 0xff)
913 | ((info
>> 40) & 0xff00)
914 | ((info
>> 24) & 0xff0000)
915 | ((info
>> 8) & 0xff000000));
916 type
= ELF64_MIPS_R_TYPE (info
);
917 type2
= ELF64_MIPS_R_TYPE2 (info
);
918 type3
= ELF64_MIPS_R_TYPE3 (info
);
920 else if (elf_header
.e_machine
== EM_SPARCV9
)
921 type
= ELF64_R_TYPE_ID (info
);
923 type
= ELF64_R_TYPE (info
);
925 symtab_index
= ELF64_R_SYM (info
);
931 #ifdef _bfd_int64_low
932 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
934 printf ("%8.8lx %8.8lx ", offset
, info
);
939 #ifdef _bfd_int64_low
941 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
942 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
943 _bfd_int64_high (offset
),
944 _bfd_int64_low (offset
),
945 _bfd_int64_high (info
),
946 _bfd_int64_low (info
));
949 ? "%16.16lx %16.16lx "
950 : "%12.12lx %12.12lx ",
955 switch (elf_header
.e_machine
)
963 rtype
= elf_m32r_reloc_type (type
);
968 rtype
= elf_i386_reloc_type (type
);
973 rtype
= elf_m68hc11_reloc_type (type
);
977 rtype
= elf_m68k_reloc_type (type
);
981 rtype
= elf_i960_reloc_type (type
);
986 rtype
= elf_avr_reloc_type (type
);
993 rtype
= elf_sparc_reloc_type (type
);
997 rtype
= elf_spu_reloc_type (type
);
1001 case EM_CYGNUS_V850
:
1002 rtype
= v850_reloc_type (type
);
1006 case EM_CYGNUS_D10V
:
1007 rtype
= elf_d10v_reloc_type (type
);
1011 case EM_CYGNUS_D30V
:
1012 rtype
= elf_d30v_reloc_type (type
);
1016 rtype
= elf_dlx_reloc_type (type
);
1020 rtype
= elf_sh_reloc_type (type
);
1024 case EM_CYGNUS_MN10300
:
1025 rtype
= elf_mn10300_reloc_type (type
);
1029 case EM_CYGNUS_MN10200
:
1030 rtype
= elf_mn10200_reloc_type (type
);
1034 case EM_CYGNUS_FR30
:
1035 rtype
= elf_fr30_reloc_type (type
);
1039 rtype
= elf_frv_reloc_type (type
);
1043 rtype
= elf_mcore_reloc_type (type
);
1047 rtype
= elf_mmix_reloc_type (type
);
1052 rtype
= elf_msp430_reloc_type (type
);
1056 rtype
= elf_ppc_reloc_type (type
);
1060 rtype
= elf_ppc64_reloc_type (type
);
1064 case EM_MIPS_RS3_LE
:
1065 rtype
= elf_mips_reloc_type (type
);
1068 rtype2
= elf_mips_reloc_type (type2
);
1069 rtype3
= elf_mips_reloc_type (type3
);
1074 rtype
= elf_alpha_reloc_type (type
);
1078 rtype
= elf_arm_reloc_type (type
);
1082 rtype
= elf_arc_reloc_type (type
);
1086 rtype
= elf_hppa_reloc_type (type
);
1092 rtype
= elf_h8_reloc_type (type
);
1097 rtype
= elf_or32_reloc_type (type
);
1102 rtype
= elf_pj_reloc_type (type
);
1105 rtype
= elf_ia64_reloc_type (type
);
1109 rtype
= elf_cris_reloc_type (type
);
1113 rtype
= elf_i860_reloc_type (type
);
1117 rtype
= elf_x86_64_reloc_type (type
);
1121 rtype
= i370_reloc_type (type
);
1126 rtype
= elf_s390_reloc_type (type
);
1130 rtype
= elf_score_reloc_type (type
);
1134 rtype
= elf_xstormy16_reloc_type (type
);
1138 rtype
= elf_crx_reloc_type (type
);
1142 rtype
= elf_vax_reloc_type (type
);
1147 rtype
= elf_ip2k_reloc_type (type
);
1151 rtype
= elf_iq2000_reloc_type (type
);
1156 rtype
= elf_xtensa_reloc_type (type
);
1160 rtype
= elf_m32c_reloc_type (type
);
1164 rtype
= elf_mt_reloc_type (type
);
1168 rtype
= elf_bfin_reloc_type (type
);
1173 #ifdef _bfd_int64_low
1174 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1176 printf (_("unrecognized: %-7lx"), type
);
1179 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1181 if (elf_header
.e_machine
== EM_ALPHA
1183 && streq (rtype
, "R_ALPHA_LITUSE")
1186 switch (rels
[i
].r_addend
)
1188 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1189 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1190 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1191 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1192 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1193 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1194 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1195 default: rtype
= NULL
;
1198 printf (" (%s)", rtype
);
1202 printf (_("<unknown addend: %lx>"),
1203 (unsigned long) rels
[i
].r_addend
);
1206 else if (symtab_index
)
1208 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1209 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1212 Elf_Internal_Sym
*psym
;
1214 psym
= symtab
+ symtab_index
;
1217 print_vma (psym
->st_value
, LONG_HEX
);
1218 printf (is_32bit_elf
? " " : " ");
1220 if (psym
->st_name
== 0)
1222 const char *sec_name
= "<null>";
1225 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1227 bfd_vma sec_index
= (bfd_vma
) -1;
1229 if (psym
->st_shndx
< SHN_LORESERVE
)
1230 sec_index
= psym
->st_shndx
;
1231 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1232 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1235 if (sec_index
!= (bfd_vma
) -1)
1236 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1237 else if (psym
->st_shndx
== SHN_ABS
)
1239 else if (psym
->st_shndx
== SHN_COMMON
)
1240 sec_name
= "COMMON";
1241 else if (elf_header
.e_machine
== EM_MIPS
1242 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1243 sec_name
= "SCOMMON";
1244 else if (elf_header
.e_machine
== EM_MIPS
1245 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1246 sec_name
= "SUNDEF";
1247 else if (elf_header
.e_machine
== EM_X86_64
1248 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1249 sec_name
= "LARGE_COMMON";
1250 else if (elf_header
.e_machine
== EM_IA_64
1251 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1252 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1253 sec_name
= "ANSI_COM";
1256 sprintf (name_buf
, "<section 0x%x>",
1257 (unsigned int) psym
->st_shndx
);
1258 sec_name
= name_buf
;
1261 print_symbol (22, sec_name
);
1263 else if (strtab
== NULL
)
1264 printf (_("<string table index: %3ld>"), psym
->st_name
);
1265 else if (psym
->st_name
>= strtablen
)
1266 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1268 print_symbol (22, strtab
+ psym
->st_name
);
1271 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1276 printf ("%*c", is_32bit_elf
?
1277 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1278 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1281 if (elf_header
.e_machine
== EM_SPARCV9
1283 && streq (rtype
, "R_SPARC_OLO10"))
1284 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1288 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1290 printf (" Type2: ");
1293 #ifdef _bfd_int64_low
1294 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1296 printf (_("unrecognized: %-7lx"), type2
);
1299 printf ("%-17.17s", rtype2
);
1301 printf ("\n Type3: ");
1304 #ifdef _bfd_int64_low
1305 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1307 printf (_("unrecognized: %-7lx"), type3
);
1310 printf ("%-17.17s", rtype3
);
1322 get_mips_dynamic_type (unsigned long type
)
1326 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1327 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1328 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1329 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1330 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1331 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1332 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1333 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1334 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1335 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1336 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1337 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1338 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1339 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1340 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1341 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1342 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1343 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1344 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1345 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1346 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1347 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1348 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1349 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1350 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1351 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1352 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1353 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1354 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1355 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1356 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1357 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1358 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1359 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1360 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1361 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1362 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1363 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1364 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1365 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1366 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1367 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1368 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1375 get_sparc64_dynamic_type (unsigned long type
)
1379 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1386 get_ppc_dynamic_type (unsigned long type
)
1390 case DT_PPC_GOT
: return "PPC_GOT";
1397 get_ppc64_dynamic_type (unsigned long type
)
1401 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1402 case DT_PPC64_OPD
: return "PPC64_OPD";
1403 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1410 get_parisc_dynamic_type (unsigned long type
)
1414 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1415 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1416 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1417 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1418 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1419 case DT_HP_PREINIT
: return "HP_PREINIT";
1420 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1421 case DT_HP_NEEDED
: return "HP_NEEDED";
1422 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1423 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1424 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1425 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1426 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1427 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1428 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1429 case DT_HP_FILTERED
: return "HP_FILTERED";
1430 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1431 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1432 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1433 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1434 case DT_PLT
: return "PLT";
1435 case DT_PLT_SIZE
: return "PLT_SIZE";
1436 case DT_DLT
: return "DLT";
1437 case DT_DLT_SIZE
: return "DLT_SIZE";
1444 get_ia64_dynamic_type (unsigned long type
)
1448 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1455 get_alpha_dynamic_type (unsigned long type
)
1459 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1466 get_score_dynamic_type (unsigned long type
)
1470 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1471 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1472 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1473 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1474 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1475 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1483 get_dynamic_type (unsigned long type
)
1485 static char buff
[64];
1489 case DT_NULL
: return "NULL";
1490 case DT_NEEDED
: return "NEEDED";
1491 case DT_PLTRELSZ
: return "PLTRELSZ";
1492 case DT_PLTGOT
: return "PLTGOT";
1493 case DT_HASH
: return "HASH";
1494 case DT_STRTAB
: return "STRTAB";
1495 case DT_SYMTAB
: return "SYMTAB";
1496 case DT_RELA
: return "RELA";
1497 case DT_RELASZ
: return "RELASZ";
1498 case DT_RELAENT
: return "RELAENT";
1499 case DT_STRSZ
: return "STRSZ";
1500 case DT_SYMENT
: return "SYMENT";
1501 case DT_INIT
: return "INIT";
1502 case DT_FINI
: return "FINI";
1503 case DT_SONAME
: return "SONAME";
1504 case DT_RPATH
: return "RPATH";
1505 case DT_SYMBOLIC
: return "SYMBOLIC";
1506 case DT_REL
: return "REL";
1507 case DT_RELSZ
: return "RELSZ";
1508 case DT_RELENT
: return "RELENT";
1509 case DT_PLTREL
: return "PLTREL";
1510 case DT_DEBUG
: return "DEBUG";
1511 case DT_TEXTREL
: return "TEXTREL";
1512 case DT_JMPREL
: return "JMPREL";
1513 case DT_BIND_NOW
: return "BIND_NOW";
1514 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1515 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1516 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1517 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1518 case DT_RUNPATH
: return "RUNPATH";
1519 case DT_FLAGS
: return "FLAGS";
1521 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1522 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1524 case DT_CHECKSUM
: return "CHECKSUM";
1525 case DT_PLTPADSZ
: return "PLTPADSZ";
1526 case DT_MOVEENT
: return "MOVEENT";
1527 case DT_MOVESZ
: return "MOVESZ";
1528 case DT_FEATURE
: return "FEATURE";
1529 case DT_POSFLAG_1
: return "POSFLAG_1";
1530 case DT_SYMINSZ
: return "SYMINSZ";
1531 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1533 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1534 case DT_CONFIG
: return "CONFIG";
1535 case DT_DEPAUDIT
: return "DEPAUDIT";
1536 case DT_AUDIT
: return "AUDIT";
1537 case DT_PLTPAD
: return "PLTPAD";
1538 case DT_MOVETAB
: return "MOVETAB";
1539 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1541 case DT_VERSYM
: return "VERSYM";
1543 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1544 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1545 case DT_RELACOUNT
: return "RELACOUNT";
1546 case DT_RELCOUNT
: return "RELCOUNT";
1547 case DT_FLAGS_1
: return "FLAGS_1";
1548 case DT_VERDEF
: return "VERDEF";
1549 case DT_VERDEFNUM
: return "VERDEFNUM";
1550 case DT_VERNEED
: return "VERNEED";
1551 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1553 case DT_AUXILIARY
: return "AUXILIARY";
1554 case DT_USED
: return "USED";
1555 case DT_FILTER
: return "FILTER";
1557 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1558 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1559 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1560 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1561 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1562 case DT_GNU_HASH
: return "GNU_HASH";
1565 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1569 switch (elf_header
.e_machine
)
1572 case EM_MIPS_RS3_LE
:
1573 result
= get_mips_dynamic_type (type
);
1576 result
= get_sparc64_dynamic_type (type
);
1579 result
= get_ppc_dynamic_type (type
);
1582 result
= get_ppc64_dynamic_type (type
);
1585 result
= get_ia64_dynamic_type (type
);
1588 result
= get_alpha_dynamic_type (type
);
1591 result
= get_score_dynamic_type (type
);
1601 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1603 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1604 || (elf_header
.e_machine
== EM_PARISC
1605 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1609 switch (elf_header
.e_machine
)
1612 result
= get_parisc_dynamic_type (type
);
1622 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1626 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1633 get_file_type (unsigned e_type
)
1635 static char buff
[32];
1639 case ET_NONE
: return _("NONE (None)");
1640 case ET_REL
: return _("REL (Relocatable file)");
1641 case ET_EXEC
: return _("EXEC (Executable file)");
1642 case ET_DYN
: return _("DYN (Shared object file)");
1643 case ET_CORE
: return _("CORE (Core file)");
1646 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1647 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1648 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1649 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1651 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1657 get_machine_name (unsigned e_machine
)
1659 static char buff
[64]; /* XXX */
1663 case EM_NONE
: return _("None");
1664 case EM_M32
: return "WE32100";
1665 case EM_SPARC
: return "Sparc";
1666 case EM_SPU
: return "SPU";
1667 case EM_386
: return "Intel 80386";
1668 case EM_68K
: return "MC68000";
1669 case EM_88K
: return "MC88000";
1670 case EM_486
: return "Intel 80486";
1671 case EM_860
: return "Intel 80860";
1672 case EM_MIPS
: return "MIPS R3000";
1673 case EM_S370
: return "IBM System/370";
1674 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1675 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1676 case EM_PARISC
: return "HPPA";
1677 case EM_PPC_OLD
: return "Power PC (old)";
1678 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1679 case EM_960
: return "Intel 90860";
1680 case EM_PPC
: return "PowerPC";
1681 case EM_PPC64
: return "PowerPC64";
1682 case EM_V800
: return "NEC V800";
1683 case EM_FR20
: return "Fujitsu FR20";
1684 case EM_RH32
: return "TRW RH32";
1685 case EM_MCORE
: return "MCORE";
1686 case EM_ARM
: return "ARM";
1687 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1688 case EM_SH
: return "Renesas / SuperH SH";
1689 case EM_SPARCV9
: return "Sparc v9";
1690 case EM_TRICORE
: return "Siemens Tricore";
1691 case EM_ARC
: return "ARC";
1692 case EM_H8_300
: return "Renesas H8/300";
1693 case EM_H8_300H
: return "Renesas H8/300H";
1694 case EM_H8S
: return "Renesas H8S";
1695 case EM_H8_500
: return "Renesas H8/500";
1696 case EM_IA_64
: return "Intel IA-64";
1697 case EM_MIPS_X
: return "Stanford MIPS-X";
1698 case EM_COLDFIRE
: return "Motorola Coldfire";
1699 case EM_68HC12
: return "Motorola M68HC12";
1700 case EM_ALPHA
: return "Alpha";
1701 case EM_CYGNUS_D10V
:
1702 case EM_D10V
: return "d10v";
1703 case EM_CYGNUS_D30V
:
1704 case EM_D30V
: return "d30v";
1705 case EM_CYGNUS_M32R
:
1706 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1707 case EM_CYGNUS_V850
:
1708 case EM_V850
: return "NEC v850";
1709 case EM_CYGNUS_MN10300
:
1710 case EM_MN10300
: return "mn10300";
1711 case EM_CYGNUS_MN10200
:
1712 case EM_MN10200
: return "mn10200";
1713 case EM_CYGNUS_FR30
:
1714 case EM_FR30
: return "Fujitsu FR30";
1715 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1717 case EM_PJ
: return "picoJava";
1718 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1719 case EM_PCP
: return "Siemens PCP";
1720 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1721 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1722 case EM_STARCORE
: return "Motorola Star*Core processor";
1723 case EM_ME16
: return "Toyota ME16 processor";
1724 case EM_ST100
: return "STMicroelectronics ST100 processor";
1725 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1726 case EM_FX66
: return "Siemens FX66 microcontroller";
1727 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1728 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1729 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1730 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1731 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1732 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1733 case EM_SVX
: return "Silicon Graphics SVx";
1734 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1735 case EM_VAX
: return "Digital VAX";
1737 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1738 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1739 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1740 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1741 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1742 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1743 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1744 case EM_PRISM
: return "Vitesse Prism";
1745 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1747 case EM_S390
: return "IBM S/390";
1748 case EM_SCORE
: return "SUNPLUS S+Core";
1749 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1751 case EM_OR32
: return "OpenRISC";
1752 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1753 case EM_DLX
: return "OpenDLX";
1755 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1756 case EM_IQ2000
: return "Vitesse IQ2000";
1758 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1759 case EM_M32C
: return "Renesas M32c";
1760 case EM_MT
: return "Morpho Techologies MT processor";
1761 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1762 case EM_NIOS32
: return "Altera Nios";
1763 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1764 case EM_XC16X
: return "Infineon Technologies xc16x";
1766 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1772 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1777 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1778 e_flags
&= ~ EF_ARM_EABIMASK
;
1780 /* Handle "generic" ARM flags. */
1781 if (e_flags
& EF_ARM_RELEXEC
)
1783 strcat (buf
, ", relocatable executable");
1784 e_flags
&= ~ EF_ARM_RELEXEC
;
1787 if (e_flags
& EF_ARM_HASENTRY
)
1789 strcat (buf
, ", has entry point");
1790 e_flags
&= ~ EF_ARM_HASENTRY
;
1793 /* Now handle EABI specific flags. */
1797 strcat (buf
, ", <unrecognized EABI>");
1802 case EF_ARM_EABI_VER1
:
1803 strcat (buf
, ", Version1 EABI");
1808 /* Process flags one bit at a time. */
1809 flag
= e_flags
& - e_flags
;
1814 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1815 strcat (buf
, ", sorted symbol tables");
1825 case EF_ARM_EABI_VER2
:
1826 strcat (buf
, ", Version2 EABI");
1831 /* Process flags one bit at a time. */
1832 flag
= e_flags
& - e_flags
;
1837 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1838 strcat (buf
, ", sorted symbol tables");
1841 case EF_ARM_DYNSYMSUSESEGIDX
:
1842 strcat (buf
, ", dynamic symbols use segment index");
1845 case EF_ARM_MAPSYMSFIRST
:
1846 strcat (buf
, ", mapping symbols precede others");
1856 case EF_ARM_EABI_VER3
:
1857 strcat (buf
, ", Version3 EABI");
1860 case EF_ARM_EABI_VER4
:
1861 strcat (buf
, ", Version4 EABI");
1864 case EF_ARM_EABI_VER5
:
1865 strcat (buf
, ", Version5 EABI");
1871 /* Process flags one bit at a time. */
1872 flag
= e_flags
& - e_flags
;
1878 strcat (buf
, ", BE8");
1882 strcat (buf
, ", LE8");
1892 case EF_ARM_EABI_UNKNOWN
:
1893 strcat (buf
, ", GNU EABI");
1898 /* Process flags one bit at a time. */
1899 flag
= e_flags
& - e_flags
;
1904 case EF_ARM_INTERWORK
:
1905 strcat (buf
, ", interworking enabled");
1908 case EF_ARM_APCS_26
:
1909 strcat (buf
, ", uses APCS/26");
1912 case EF_ARM_APCS_FLOAT
:
1913 strcat (buf
, ", uses APCS/float");
1917 strcat (buf
, ", position independent");
1921 strcat (buf
, ", 8 bit structure alignment");
1924 case EF_ARM_NEW_ABI
:
1925 strcat (buf
, ", uses new ABI");
1928 case EF_ARM_OLD_ABI
:
1929 strcat (buf
, ", uses old ABI");
1932 case EF_ARM_SOFT_FLOAT
:
1933 strcat (buf
, ", software FP");
1936 case EF_ARM_VFP_FLOAT
:
1937 strcat (buf
, ", VFP");
1940 case EF_ARM_MAVERICK_FLOAT
:
1941 strcat (buf
, ", Maverick FP");
1952 strcat (buf
,", <unknown>");
1956 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1958 static char buf
[1024];
1970 decode_ARM_machine_flags (e_flags
, buf
);
1974 switch (e_flags
& EF_FRV_CPU_MASK
)
1976 case EF_FRV_CPU_GENERIC
:
1980 strcat (buf
, ", fr???");
1983 case EF_FRV_CPU_FR300
:
1984 strcat (buf
, ", fr300");
1987 case EF_FRV_CPU_FR400
:
1988 strcat (buf
, ", fr400");
1990 case EF_FRV_CPU_FR405
:
1991 strcat (buf
, ", fr405");
1994 case EF_FRV_CPU_FR450
:
1995 strcat (buf
, ", fr450");
1998 case EF_FRV_CPU_FR500
:
1999 strcat (buf
, ", fr500");
2001 case EF_FRV_CPU_FR550
:
2002 strcat (buf
, ", fr550");
2005 case EF_FRV_CPU_SIMPLE
:
2006 strcat (buf
, ", simple");
2008 case EF_FRV_CPU_TOMCAT
:
2009 strcat (buf
, ", tomcat");
2015 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2016 strcat (buf
, ", m68000");
2017 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2018 strcat (buf
, ", cpu32");
2019 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2020 strcat (buf
, ", fido_a");
2023 char const *isa
= _("unknown");
2024 char const *mac
= _("unknown mac");
2025 char const *additional
= NULL
;
2027 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2029 case EF_M68K_CF_ISA_A_NODIV
:
2031 additional
= ", nodiv";
2033 case EF_M68K_CF_ISA_A
:
2036 case EF_M68K_CF_ISA_A_PLUS
:
2039 case EF_M68K_CF_ISA_B_NOUSP
:
2041 additional
= ", nousp";
2043 case EF_M68K_CF_ISA_B
:
2047 strcat (buf
, ", cf, isa ");
2050 strcat (buf
, additional
);
2051 if (e_flags
& EF_M68K_CF_FLOAT
)
2052 strcat (buf
, ", float");
2053 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2058 case EF_M68K_CF_MAC
:
2061 case EF_M68K_CF_EMAC
:
2074 if (e_flags
& EF_PPC_EMB
)
2075 strcat (buf
, ", emb");
2077 if (e_flags
& EF_PPC_RELOCATABLE
)
2078 strcat (buf
, ", relocatable");
2080 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2081 strcat (buf
, ", relocatable-lib");
2085 case EM_CYGNUS_V850
:
2086 switch (e_flags
& EF_V850_ARCH
)
2089 strcat (buf
, ", v850e1");
2092 strcat (buf
, ", v850e");
2095 strcat (buf
, ", v850");
2098 strcat (buf
, ", unknown v850 architecture variant");
2104 case EM_CYGNUS_M32R
:
2105 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2106 strcat (buf
, ", m32r");
2110 case EM_MIPS_RS3_LE
:
2111 if (e_flags
& EF_MIPS_NOREORDER
)
2112 strcat (buf
, ", noreorder");
2114 if (e_flags
& EF_MIPS_PIC
)
2115 strcat (buf
, ", pic");
2117 if (e_flags
& EF_MIPS_CPIC
)
2118 strcat (buf
, ", cpic");
2120 if (e_flags
& EF_MIPS_UCODE
)
2121 strcat (buf
, ", ugen_reserved");
2123 if (e_flags
& EF_MIPS_ABI2
)
2124 strcat (buf
, ", abi2");
2126 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2127 strcat (buf
, ", odk first");
2129 if (e_flags
& EF_MIPS_32BITMODE
)
2130 strcat (buf
, ", 32bitmode");
2132 switch ((e_flags
& EF_MIPS_MACH
))
2134 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2135 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2136 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2137 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2138 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2139 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2140 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2141 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2142 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2143 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2145 /* We simply ignore the field in this case to avoid confusion:
2146 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2149 default: strcat (buf
, ", unknown CPU"); break;
2152 switch ((e_flags
& EF_MIPS_ABI
))
2154 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2155 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2156 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2157 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2159 /* We simply ignore the field in this case to avoid confusion:
2160 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2161 This means it is likely to be an o32 file, but not for
2164 default: strcat (buf
, ", unknown ABI"); break;
2167 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2168 strcat (buf
, ", mdmx");
2170 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2171 strcat (buf
, ", mips16");
2173 switch ((e_flags
& EF_MIPS_ARCH
))
2175 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2176 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2177 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2178 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2179 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2180 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2181 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2182 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2183 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2184 default: strcat (buf
, ", unknown ISA"); break;
2190 switch ((e_flags
& EF_SH_MACH_MASK
))
2192 case EF_SH1
: strcat (buf
, ", sh1"); break;
2193 case EF_SH2
: strcat (buf
, ", sh2"); break;
2194 case EF_SH3
: strcat (buf
, ", sh3"); break;
2195 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2196 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2197 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2198 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2199 case EF_SH4
: strcat (buf
, ", sh4"); break;
2200 case EF_SH5
: strcat (buf
, ", sh5"); break;
2201 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2202 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2203 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2204 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2205 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2206 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2207 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2208 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2209 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2210 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2211 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2212 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2213 default: strcat (buf
, ", unknown ISA"); break;
2219 if (e_flags
& EF_SPARC_32PLUS
)
2220 strcat (buf
, ", v8+");
2222 if (e_flags
& EF_SPARC_SUN_US1
)
2223 strcat (buf
, ", ultrasparcI");
2225 if (e_flags
& EF_SPARC_SUN_US3
)
2226 strcat (buf
, ", ultrasparcIII");
2228 if (e_flags
& EF_SPARC_HAL_R1
)
2229 strcat (buf
, ", halr1");
2231 if (e_flags
& EF_SPARC_LEDATA
)
2232 strcat (buf
, ", ledata");
2234 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2235 strcat (buf
, ", tso");
2237 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2238 strcat (buf
, ", pso");
2240 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2241 strcat (buf
, ", rmo");
2245 switch (e_flags
& EF_PARISC_ARCH
)
2247 case EFA_PARISC_1_0
:
2248 strcpy (buf
, ", PA-RISC 1.0");
2250 case EFA_PARISC_1_1
:
2251 strcpy (buf
, ", PA-RISC 1.1");
2253 case EFA_PARISC_2_0
:
2254 strcpy (buf
, ", PA-RISC 2.0");
2259 if (e_flags
& EF_PARISC_TRAPNIL
)
2260 strcat (buf
, ", trapnil");
2261 if (e_flags
& EF_PARISC_EXT
)
2262 strcat (buf
, ", ext");
2263 if (e_flags
& EF_PARISC_LSB
)
2264 strcat (buf
, ", lsb");
2265 if (e_flags
& EF_PARISC_WIDE
)
2266 strcat (buf
, ", wide");
2267 if (e_flags
& EF_PARISC_NO_KABP
)
2268 strcat (buf
, ", no kabp");
2269 if (e_flags
& EF_PARISC_LAZYSWAP
)
2270 strcat (buf
, ", lazyswap");
2275 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2276 strcat (buf
, ", new calling convention");
2278 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2279 strcat (buf
, ", gnu calling convention");
2283 if ((e_flags
& EF_IA_64_ABI64
))
2284 strcat (buf
, ", 64-bit");
2286 strcat (buf
, ", 32-bit");
2287 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2288 strcat (buf
, ", reduced fp model");
2289 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2290 strcat (buf
, ", no function descriptors, constant gp");
2291 else if ((e_flags
& EF_IA_64_CONS_GP
))
2292 strcat (buf
, ", constant gp");
2293 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2294 strcat (buf
, ", absolute");
2298 if ((e_flags
& EF_VAX_NONPIC
))
2299 strcat (buf
, ", non-PIC");
2300 if ((e_flags
& EF_VAX_DFLOAT
))
2301 strcat (buf
, ", D-Float");
2302 if ((e_flags
& EF_VAX_GFLOAT
))
2303 strcat (buf
, ", G-Float");
2312 get_osabi_name (unsigned int osabi
)
2314 static char buff
[32];
2318 case ELFOSABI_NONE
: return "UNIX - System V";
2319 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2320 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2321 case ELFOSABI_LINUX
: return "UNIX - Linux";
2322 case ELFOSABI_HURD
: return "GNU/Hurd";
2323 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2324 case ELFOSABI_AIX
: return "UNIX - AIX";
2325 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2326 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2327 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2328 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2329 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2330 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2331 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2332 case ELFOSABI_AROS
: return "Amiga Research OS";
2333 case ELFOSABI_STANDALONE
: return _("Standalone App");
2334 case ELFOSABI_ARM
: return "ARM";
2336 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2342 get_arm_segment_type (unsigned long type
)
2356 get_mips_segment_type (unsigned long type
)
2360 case PT_MIPS_REGINFO
:
2362 case PT_MIPS_RTPROC
:
2364 case PT_MIPS_OPTIONS
:
2374 get_parisc_segment_type (unsigned long type
)
2378 case PT_HP_TLS
: return "HP_TLS";
2379 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2380 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2381 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2382 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2383 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2384 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2385 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2386 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2387 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2388 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2389 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2390 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2391 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2392 case PT_HP_STACK
: return "HP_STACK";
2393 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2394 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2395 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2396 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2405 get_ia64_segment_type (unsigned long type
)
2409 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2410 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2411 case PT_HP_TLS
: return "HP_TLS";
2412 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2413 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2414 case PT_IA_64_HP_STACK
: return "HP_STACK";
2423 get_segment_type (unsigned long p_type
)
2425 static char buff
[32];
2429 case PT_NULL
: return "NULL";
2430 case PT_LOAD
: return "LOAD";
2431 case PT_DYNAMIC
: return "DYNAMIC";
2432 case PT_INTERP
: return "INTERP";
2433 case PT_NOTE
: return "NOTE";
2434 case PT_SHLIB
: return "SHLIB";
2435 case PT_PHDR
: return "PHDR";
2436 case PT_TLS
: return "TLS";
2438 case PT_GNU_EH_FRAME
:
2439 return "GNU_EH_FRAME";
2440 case PT_GNU_STACK
: return "GNU_STACK";
2441 case PT_GNU_RELRO
: return "GNU_RELRO";
2444 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2448 switch (elf_header
.e_machine
)
2451 result
= get_arm_segment_type (p_type
);
2454 case EM_MIPS_RS3_LE
:
2455 result
= get_mips_segment_type (p_type
);
2458 result
= get_parisc_segment_type (p_type
);
2461 result
= get_ia64_segment_type (p_type
);
2471 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2473 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2477 switch (elf_header
.e_machine
)
2480 result
= get_parisc_segment_type (p_type
);
2483 result
= get_ia64_segment_type (p_type
);
2493 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2496 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2503 get_mips_section_type_name (unsigned int sh_type
)
2507 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2508 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2509 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2510 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2511 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2512 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2513 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2514 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2515 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2516 case SHT_MIPS_RELD
: return "MIPS_RELD";
2517 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2518 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2519 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2520 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2521 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2522 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2523 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2524 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2525 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2526 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2527 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2528 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2529 case SHT_MIPS_LINE
: return "MIPS_LINE";
2530 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2531 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2532 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2533 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2534 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2535 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2536 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2537 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2538 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2539 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2540 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2541 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2542 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2543 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2544 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2545 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2553 get_parisc_section_type_name (unsigned int sh_type
)
2557 case SHT_PARISC_EXT
: return "PARISC_EXT";
2558 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2559 case SHT_PARISC_DOC
: return "PARISC_DOC";
2560 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2561 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2562 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2563 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2571 get_ia64_section_type_name (unsigned int sh_type
)
2573 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2574 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2575 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2579 case SHT_IA_64_EXT
: return "IA_64_EXT";
2580 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2581 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2589 get_x86_64_section_type_name (unsigned int sh_type
)
2593 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2601 get_arm_section_type_name (unsigned int sh_type
)
2607 case SHT_ARM_PREEMPTMAP
:
2608 return "ARM_PREEMPTMAP";
2609 case SHT_ARM_ATTRIBUTES
:
2610 return "ARM_ATTRIBUTES";
2618 get_section_type_name (unsigned int sh_type
)
2620 static char buff
[32];
2624 case SHT_NULL
: return "NULL";
2625 case SHT_PROGBITS
: return "PROGBITS";
2626 case SHT_SYMTAB
: return "SYMTAB";
2627 case SHT_STRTAB
: return "STRTAB";
2628 case SHT_RELA
: return "RELA";
2629 case SHT_HASH
: return "HASH";
2630 case SHT_DYNAMIC
: return "DYNAMIC";
2631 case SHT_NOTE
: return "NOTE";
2632 case SHT_NOBITS
: return "NOBITS";
2633 case SHT_REL
: return "REL";
2634 case SHT_SHLIB
: return "SHLIB";
2635 case SHT_DYNSYM
: return "DYNSYM";
2636 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2637 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2638 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2639 case SHT_GNU_HASH
: return "GNU_HASH";
2640 case SHT_GROUP
: return "GROUP";
2641 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2642 case SHT_GNU_verdef
: return "VERDEF";
2643 case SHT_GNU_verneed
: return "VERNEED";
2644 case SHT_GNU_versym
: return "VERSYM";
2645 case 0x6ffffff0: return "VERSYM";
2646 case 0x6ffffffc: return "VERDEF";
2647 case 0x7ffffffd: return "AUXILIARY";
2648 case 0x7fffffff: return "FILTER";
2649 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2652 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2656 switch (elf_header
.e_machine
)
2659 case EM_MIPS_RS3_LE
:
2660 result
= get_mips_section_type_name (sh_type
);
2663 result
= get_parisc_section_type_name (sh_type
);
2666 result
= get_ia64_section_type_name (sh_type
);
2669 result
= get_x86_64_section_type_name (sh_type
);
2672 result
= get_arm_section_type_name (sh_type
);
2682 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2684 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2685 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2686 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2687 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2689 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2695 #define OPTION_DEBUG_DUMP 512
2697 static struct option options
[] =
2699 {"all", no_argument
, 0, 'a'},
2700 {"file-header", no_argument
, 0, 'h'},
2701 {"program-headers", no_argument
, 0, 'l'},
2702 {"headers", no_argument
, 0, 'e'},
2703 {"histogram", no_argument
, 0, 'I'},
2704 {"segments", no_argument
, 0, 'l'},
2705 {"sections", no_argument
, 0, 'S'},
2706 {"section-headers", no_argument
, 0, 'S'},
2707 {"section-groups", no_argument
, 0, 'g'},
2708 {"section-details", no_argument
, 0, 't'},
2709 {"full-section-name",no_argument
, 0, 'N'},
2710 {"symbols", no_argument
, 0, 's'},
2711 {"syms", no_argument
, 0, 's'},
2712 {"relocs", no_argument
, 0, 'r'},
2713 {"notes", no_argument
, 0, 'n'},
2714 {"dynamic", no_argument
, 0, 'd'},
2715 {"arch-specific", no_argument
, 0, 'A'},
2716 {"version-info", no_argument
, 0, 'V'},
2717 {"use-dynamic", no_argument
, 0, 'D'},
2718 {"hex-dump", required_argument
, 0, 'x'},
2719 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2720 {"unwind", no_argument
, 0, 'u'},
2721 #ifdef SUPPORT_DISASSEMBLY
2722 {"instruction-dump", required_argument
, 0, 'i'},
2725 {"version", no_argument
, 0, 'v'},
2726 {"wide", no_argument
, 0, 'W'},
2727 {"help", no_argument
, 0, 'H'},
2728 {0, no_argument
, 0, 0}
2734 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2735 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2736 fprintf (stdout
, _(" Options are:\n\
2737 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2738 -h --file-header Display the ELF file header\n\
2739 -l --program-headers Display the program headers\n\
2740 --segments An alias for --program-headers\n\
2741 -S --section-headers Display the sections' header\n\
2742 --sections An alias for --section-headers\n\
2743 -g --section-groups Display the section groups\n\
2744 -t --section-details Display the section details\n\
2745 -e --headers Equivalent to: -h -l -S\n\
2746 -s --syms Display the symbol table\n\
2747 --symbols An alias for --syms\n\
2748 -n --notes Display the core notes (if present)\n\
2749 -r --relocs Display the relocations (if present)\n\
2750 -u --unwind Display the unwind info (if present)\n\
2751 -d --dynamic Display the dynamic section (if present)\n\
2752 -V --version-info Display the version sections (if present)\n\
2753 -A --arch-specific Display architecture specific information (if any).\n\
2754 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2755 -x --hex-dump=<number> Dump the contents of section <number>\n\
2756 -w[liaprmfFsoR] or\n\
2757 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2758 Display the contents of DWARF2 debug sections\n"));
2759 #ifdef SUPPORT_DISASSEMBLY
2760 fprintf (stdout
, _("\
2761 -i --instruction-dump=<number>\n\
2762 Disassemble the contents of section <number>\n"));
2764 fprintf (stdout
, _("\
2765 -I --histogram Display histogram of bucket list lengths\n\
2766 -W --wide Allow output width to exceed 80 characters\n\
2767 @<file> Read options from <file>\n\
2768 -H --help Display this information\n\
2769 -v --version Display the version number of readelf\n"));
2770 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2775 /* Record the fact that the user wants the contents of section number
2776 SECTION to be displayed using the method(s) encoded as flags bits
2777 in TYPE. Note, TYPE can be zero if we are creating the array for
2781 request_dump (unsigned int section
, int type
)
2783 if (section
>= num_dump_sects
)
2785 char *new_dump_sects
;
2787 new_dump_sects
= calloc (section
+ 1, 1);
2789 if (new_dump_sects
== NULL
)
2790 error (_("Out of memory allocating dump request table."));
2793 /* Copy current flag settings. */
2794 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2798 dump_sects
= new_dump_sects
;
2799 num_dump_sects
= section
+ 1;
2804 dump_sects
[section
] |= type
;
2809 /* Request a dump by section name. */
2812 request_dump_byname (const char *section
, int type
)
2814 struct dump_list_entry
*new_request
;
2816 new_request
= malloc (sizeof (struct dump_list_entry
));
2818 error (_("Out of memory allocating dump request table."));
2820 new_request
->name
= strdup (section
);
2821 if (!new_request
->name
)
2822 error (_("Out of memory allocating dump request table."));
2824 new_request
->type
= type
;
2826 new_request
->next
= dump_sects_byname
;
2827 dump_sects_byname
= new_request
;
2831 parse_args (int argc
, char **argv
)
2838 while ((c
= getopt_long
2839 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2860 do_section_groups
++;
2868 do_section_groups
++;
2873 do_section_details
++;
2915 section
= strtoul (optarg
, & cp
, 0);
2916 if (! *cp
&& section
>= 0)
2917 request_dump (section
, HEX_DUMP
);
2919 request_dump_byname (optarg
, HEX_DUMP
);
2927 unsigned int index
= 0;
2931 while (optarg
[index
])
2932 switch (optarg
[index
++])
2941 do_debug_abbrevs
= 1;
2951 do_debug_pubnames
= 1;
2955 do_debug_aranges
= 1;
2959 do_debug_ranges
= 1;
2963 do_debug_frames_interp
= 1;
2965 do_debug_frames
= 1;
2970 do_debug_macinfo
= 1;
2984 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2989 case OPTION_DEBUG_DUMP
:
2997 const char * option
;
3000 debug_dump_long_opts
;
3002 debug_dump_long_opts opts_table
[] =
3004 /* Please keep this table alpha- sorted. */
3005 { "Ranges", & do_debug_ranges
},
3006 { "abbrev", & do_debug_abbrevs
},
3007 { "aranges", & do_debug_aranges
},
3008 { "frames", & do_debug_frames
},
3009 { "frames-interp", & do_debug_frames_interp
},
3010 { "info", & do_debug_info
},
3011 { "line", & do_debug_lines
},
3012 { "loc", & do_debug_loc
},
3013 { "macro", & do_debug_macinfo
},
3014 { "pubnames", & do_debug_pubnames
},
3015 /* This entry is for compatability
3016 with earlier versions of readelf. */
3017 { "ranges", & do_debug_aranges
},
3018 { "str", & do_debug_str
},
3029 debug_dump_long_opts
* entry
;
3031 for (entry
= opts_table
; entry
->option
; entry
++)
3033 size_t len
= strlen (entry
->option
);
3035 if (strneq (p
, entry
->option
, len
)
3036 && (p
[len
] == ',' || p
[len
] == '\0'))
3038 * entry
->variable
= 1;
3040 /* The --debug-dump=frames-interp option also
3041 enables the --debug-dump=frames option. */
3042 if (do_debug_frames_interp
)
3043 do_debug_frames
= 1;
3050 if (entry
->option
== NULL
)
3052 warn (_("Unrecognized debug option '%s'\n"), p
);
3053 p
= strchr (p
, ',');
3063 #ifdef SUPPORT_DISASSEMBLY
3066 section
= strtoul (optarg
, & cp
, 0);
3067 if (! *cp
&& section
>= 0)
3069 request_dump (section
, DISASS_DUMP
);
3075 print_version (program_name
);
3084 #ifdef SUPPORT_DISASSEMBLY
3087 /* xgettext:c-format */
3088 error (_("Invalid option '-%c'\n"), c
);
3095 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3096 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3097 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3098 && !do_section_groups
)
3102 warn (_("Nothing to do.\n"));
3108 get_elf_class (unsigned int elf_class
)
3110 static char buff
[32];
3114 case ELFCLASSNONE
: return _("none");
3115 case ELFCLASS32
: return "ELF32";
3116 case ELFCLASS64
: return "ELF64";
3118 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3124 get_data_encoding (unsigned int encoding
)
3126 static char buff
[32];
3130 case ELFDATANONE
: return _("none");
3131 case ELFDATA2LSB
: return _("2's complement, little endian");
3132 case ELFDATA2MSB
: return _("2's complement, big endian");
3134 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3139 /* Decode the data held in 'elf_header'. */
3142 process_file_header (void)
3144 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3145 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3146 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3147 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3150 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3158 printf (_("ELF Header:\n"));
3159 printf (_(" Magic: "));
3160 for (i
= 0; i
< EI_NIDENT
; i
++)
3161 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3163 printf (_(" Class: %s\n"),
3164 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3165 printf (_(" Data: %s\n"),
3166 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3167 printf (_(" Version: %d %s\n"),
3168 elf_header
.e_ident
[EI_VERSION
],
3169 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3171 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3174 printf (_(" OS/ABI: %s\n"),
3175 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3176 printf (_(" ABI Version: %d\n"),
3177 elf_header
.e_ident
[EI_ABIVERSION
]);
3178 printf (_(" Type: %s\n"),
3179 get_file_type (elf_header
.e_type
));
3180 printf (_(" Machine: %s\n"),
3181 get_machine_name (elf_header
.e_machine
));
3182 printf (_(" Version: 0x%lx\n"),
3183 (unsigned long) elf_header
.e_version
);
3185 printf (_(" Entry point address: "));
3186 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3187 printf (_("\n Start of program headers: "));
3188 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3189 printf (_(" (bytes into file)\n Start of section headers: "));
3190 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3191 printf (_(" (bytes into file)\n"));
3193 printf (_(" Flags: 0x%lx%s\n"),
3194 (unsigned long) elf_header
.e_flags
,
3195 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3196 printf (_(" Size of this header: %ld (bytes)\n"),
3197 (long) elf_header
.e_ehsize
);
3198 printf (_(" Size of program headers: %ld (bytes)\n"),
3199 (long) elf_header
.e_phentsize
);
3200 printf (_(" Number of program headers: %ld\n"),
3201 (long) elf_header
.e_phnum
);
3202 printf (_(" Size of section headers: %ld (bytes)\n"),
3203 (long) elf_header
.e_shentsize
);
3204 printf (_(" Number of section headers: %ld"),
3205 (long) elf_header
.e_shnum
);
3206 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3207 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3208 putc ('\n', stdout
);
3209 printf (_(" Section header string table index: %ld"),
3210 (long) elf_header
.e_shstrndx
);
3211 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3212 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3213 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3214 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3215 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3216 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3217 printf (" <corrupt: out of range>");
3218 putc ('\n', stdout
);
3221 if (section_headers
!= NULL
)
3223 if (elf_header
.e_shnum
== 0)
3224 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3225 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3226 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3227 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3228 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3229 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3230 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3231 elf_header
.e_shstrndx
= SHN_UNDEF
;
3232 free (section_headers
);
3233 section_headers
= NULL
;
3241 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3243 Elf32_External_Phdr
*phdrs
;
3244 Elf32_External_Phdr
*external
;
3245 Elf_Internal_Phdr
*internal
;
3248 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3249 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3250 _("program headers"));
3254 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3255 i
< elf_header
.e_phnum
;
3256 i
++, internal
++, external
++)
3258 internal
->p_type
= BYTE_GET (external
->p_type
);
3259 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3260 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3261 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3262 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3263 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3264 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3265 internal
->p_align
= BYTE_GET (external
->p_align
);
3274 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3276 Elf64_External_Phdr
*phdrs
;
3277 Elf64_External_Phdr
*external
;
3278 Elf_Internal_Phdr
*internal
;
3281 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3282 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3283 _("program headers"));
3287 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3288 i
< elf_header
.e_phnum
;
3289 i
++, internal
++, external
++)
3291 internal
->p_type
= BYTE_GET (external
->p_type
);
3292 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3293 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3294 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3295 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3296 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3297 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3298 internal
->p_align
= BYTE_GET (external
->p_align
);
3306 /* Returns 1 if the program headers were read into `program_headers'. */
3309 get_program_headers (FILE *file
)
3311 Elf_Internal_Phdr
*phdrs
;
3313 /* Check cache of prior read. */
3314 if (program_headers
!= NULL
)
3317 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3321 error (_("Out of memory\n"));
3326 ? get_32bit_program_headers (file
, phdrs
)
3327 : get_64bit_program_headers (file
, phdrs
))
3329 program_headers
= phdrs
;
3337 /* Returns 1 if the program headers were loaded. */
3340 process_program_headers (FILE *file
)
3342 Elf_Internal_Phdr
*segment
;
3345 if (elf_header
.e_phnum
== 0)
3348 printf (_("\nThere are no program headers in this file.\n"));
3352 if (do_segments
&& !do_header
)
3354 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3355 printf (_("Entry point "));
3356 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3357 printf (_("\nThere are %d program headers, starting at offset "),
3358 elf_header
.e_phnum
);
3359 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3363 if (! get_program_headers (file
))
3368 if (elf_header
.e_phnum
> 1)
3369 printf (_("\nProgram Headers:\n"));
3371 printf (_("\nProgram Headers:\n"));
3375 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3378 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3382 (_(" Type Offset VirtAddr PhysAddr\n"));
3384 (_(" FileSiz MemSiz Flags Align\n"));
3391 for (i
= 0, segment
= program_headers
;
3392 i
< elf_header
.e_phnum
;
3397 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3401 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3402 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3403 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3404 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3405 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3407 (segment
->p_flags
& PF_R
? 'R' : ' '),
3408 (segment
->p_flags
& PF_W
? 'W' : ' '),
3409 (segment
->p_flags
& PF_X
? 'E' : ' '));
3410 printf ("%#lx", (unsigned long) segment
->p_align
);
3414 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3415 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3418 print_vma (segment
->p_offset
, FULL_HEX
);
3422 print_vma (segment
->p_vaddr
, FULL_HEX
);
3424 print_vma (segment
->p_paddr
, FULL_HEX
);
3427 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3428 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3431 print_vma (segment
->p_filesz
, FULL_HEX
);
3435 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3436 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3439 print_vma (segment
->p_offset
, FULL_HEX
);
3443 (segment
->p_flags
& PF_R
? 'R' : ' '),
3444 (segment
->p_flags
& PF_W
? 'W' : ' '),
3445 (segment
->p_flags
& PF_X
? 'E' : ' '));
3447 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3448 printf ("%#lx", (unsigned long) segment
->p_align
);
3451 print_vma (segment
->p_align
, PREFIX_HEX
);
3456 print_vma (segment
->p_offset
, FULL_HEX
);
3458 print_vma (segment
->p_vaddr
, FULL_HEX
);
3460 print_vma (segment
->p_paddr
, FULL_HEX
);
3462 print_vma (segment
->p_filesz
, FULL_HEX
);
3464 print_vma (segment
->p_memsz
, FULL_HEX
);
3466 (segment
->p_flags
& PF_R
? 'R' : ' '),
3467 (segment
->p_flags
& PF_W
? 'W' : ' '),
3468 (segment
->p_flags
& PF_X
? 'E' : ' '));
3469 print_vma (segment
->p_align
, HEX
);
3473 switch (segment
->p_type
)
3477 error (_("more than one dynamic segment\n"));
3479 /* Try to locate the .dynamic section. If there is
3480 a section header table, we can easily locate it. */
3481 if (section_headers
!= NULL
)
3483 Elf_Internal_Shdr
*sec
;
3485 sec
= find_section (".dynamic");
3486 if (sec
== NULL
|| sec
->sh_size
== 0)
3488 error (_("no .dynamic section in the dynamic segment"));
3492 dynamic_addr
= sec
->sh_offset
;
3493 dynamic_size
= sec
->sh_size
;
3495 if (dynamic_addr
< segment
->p_offset
3496 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3497 warn (_("the .dynamic section is not contained within the dynamic segment"));
3498 else if (dynamic_addr
> segment
->p_offset
)
3499 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3503 /* Otherwise, we can only assume that the .dynamic
3504 section is the first section in the DYNAMIC segment. */
3505 dynamic_addr
= segment
->p_offset
;
3506 dynamic_size
= segment
->p_filesz
;
3511 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3513 error (_("Unable to find program interpreter name\n"));
3517 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3519 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3520 error (_("Internal error: failed to create format string to display program interpreter"));
3522 program_interpreter
[0] = 0;
3523 fscanf (file
, fmt
, program_interpreter
);
3526 printf (_("\n [Requesting program interpreter: %s]"),
3527 program_interpreter
);
3533 putc ('\n', stdout
);
3536 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3538 printf (_("\n Section to Segment mapping:\n"));
3539 printf (_(" Segment Sections...\n"));
3541 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3544 Elf_Internal_Shdr
*section
;
3546 segment
= program_headers
+ i
;
3547 section
= section_headers
;
3549 printf (" %2.2d ", i
);
3551 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3553 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3554 printf ("%s ", SECTION_NAME (section
));
3565 /* Find the file offset corresponding to VMA by using the program headers. */
3568 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3570 Elf_Internal_Phdr
*seg
;
3572 if (! get_program_headers (file
))
3574 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3578 for (seg
= program_headers
;
3579 seg
< program_headers
+ elf_header
.e_phnum
;
3582 if (seg
->p_type
!= PT_LOAD
)
3585 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3586 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3587 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3590 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3597 get_32bit_section_headers (FILE *file
, unsigned int num
)
3599 Elf32_External_Shdr
*shdrs
;
3600 Elf_Internal_Shdr
*internal
;
3603 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3604 elf_header
.e_shentsize
, num
, _("section headers"));
3608 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3610 if (section_headers
== NULL
)
3612 error (_("Out of memory\n"));
3616 for (i
= 0, internal
= section_headers
;
3620 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3621 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3622 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3623 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3624 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3625 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3626 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3627 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3628 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3629 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3638 get_64bit_section_headers (FILE *file
, unsigned int num
)
3640 Elf64_External_Shdr
*shdrs
;
3641 Elf_Internal_Shdr
*internal
;
3644 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3645 elf_header
.e_shentsize
, num
, _("section headers"));
3649 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3651 if (section_headers
== NULL
)
3653 error (_("Out of memory\n"));
3657 for (i
= 0, internal
= section_headers
;
3661 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3662 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3663 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3664 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3665 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3666 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3667 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3668 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3669 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3670 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3678 static Elf_Internal_Sym
*
3679 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3681 unsigned long number
;
3682 Elf32_External_Sym
*esyms
;
3683 Elf_External_Sym_Shndx
*shndx
;
3684 Elf_Internal_Sym
*isyms
;
3685 Elf_Internal_Sym
*psym
;
3688 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3694 if (symtab_shndx_hdr
!= NULL
3695 && (symtab_shndx_hdr
->sh_link
3696 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3698 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3699 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3707 number
= section
->sh_size
/ section
->sh_entsize
;
3708 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3712 error (_("Out of memory\n"));
3719 for (j
= 0, psym
= isyms
;
3723 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3724 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3725 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3726 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3727 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3729 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3730 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3731 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3741 static Elf_Internal_Sym
*
3742 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3744 unsigned long number
;
3745 Elf64_External_Sym
*esyms
;
3746 Elf_External_Sym_Shndx
*shndx
;
3747 Elf_Internal_Sym
*isyms
;
3748 Elf_Internal_Sym
*psym
;
3751 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3757 if (symtab_shndx_hdr
!= NULL
3758 && (symtab_shndx_hdr
->sh_link
3759 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3761 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3762 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3770 number
= section
->sh_size
/ section
->sh_entsize
;
3771 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3775 error (_("Out of memory\n"));
3782 for (j
= 0, psym
= isyms
;
3786 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3787 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3788 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3789 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3790 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3792 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3793 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3794 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3805 get_elf_section_flags (bfd_vma sh_flags
)
3807 static char buff
[1024];
3809 int field_size
= is_32bit_elf
? 8 : 16;
3810 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3811 bfd_vma os_flags
= 0;
3812 bfd_vma proc_flags
= 0;
3813 bfd_vma unknown_flags
= 0;
3827 { "LINK ORDER", 10 },
3828 { "OS NONCONF", 10 },
3833 if (do_section_details
)
3835 sprintf (buff
, "[%*.*lx]: ",
3836 field_size
, field_size
, (unsigned long) sh_flags
);
3837 p
+= field_size
+ 4;
3844 flag
= sh_flags
& - sh_flags
;
3847 if (do_section_details
)
3851 case SHF_WRITE
: index
= 0; break;
3852 case SHF_ALLOC
: index
= 1; break;
3853 case SHF_EXECINSTR
: index
= 2; break;
3854 case SHF_MERGE
: index
= 3; break;
3855 case SHF_STRINGS
: index
= 4; break;
3856 case SHF_INFO_LINK
: index
= 5; break;
3857 case SHF_LINK_ORDER
: index
= 6; break;
3858 case SHF_OS_NONCONFORMING
: index
= 7; break;
3859 case SHF_GROUP
: index
= 8; break;
3860 case SHF_TLS
: index
= 9; break;
3869 if (p
!= buff
+ field_size
+ 4)
3871 if (size
< (10 + 2))
3878 size
-= flags
[index
].len
;
3879 p
= stpcpy (p
, flags
[index
].str
);
3881 else if (flag
& SHF_MASKOS
)
3883 else if (flag
& SHF_MASKPROC
)
3886 unknown_flags
|= flag
;
3892 case SHF_WRITE
: *p
= 'W'; break;
3893 case SHF_ALLOC
: *p
= 'A'; break;
3894 case SHF_EXECINSTR
: *p
= 'X'; break;
3895 case SHF_MERGE
: *p
= 'M'; break;
3896 case SHF_STRINGS
: *p
= 'S'; break;
3897 case SHF_INFO_LINK
: *p
= 'I'; break;
3898 case SHF_LINK_ORDER
: *p
= 'L'; break;
3899 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3900 case SHF_GROUP
: *p
= 'G'; break;
3901 case SHF_TLS
: *p
= 'T'; break;
3904 if (elf_header
.e_machine
== EM_X86_64
3905 && flag
== SHF_X86_64_LARGE
)
3907 else if (flag
& SHF_MASKOS
)
3910 sh_flags
&= ~ SHF_MASKOS
;
3912 else if (flag
& SHF_MASKPROC
)
3915 sh_flags
&= ~ SHF_MASKPROC
;
3925 if (do_section_details
)
3929 size
-= 5 + field_size
;
3930 if (p
!= buff
+ field_size
+ 4)
3938 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3939 (unsigned long) os_flags
);
3940 p
+= 5 + field_size
;
3944 size
-= 7 + field_size
;
3945 if (p
!= buff
+ field_size
+ 4)
3953 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3954 (unsigned long) proc_flags
);
3955 p
+= 7 + field_size
;
3959 size
-= 10 + field_size
;
3960 if (p
!= buff
+ field_size
+ 4)
3968 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3969 (unsigned long) unknown_flags
);
3970 p
+= 10 + field_size
;
3979 process_section_headers (FILE *file
)
3981 Elf_Internal_Shdr
*section
;
3984 section_headers
= NULL
;
3986 if (elf_header
.e_shnum
== 0)
3989 printf (_("\nThere are no sections in this file.\n"));
3994 if (do_sections
&& !do_header
)
3995 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3996 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4000 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4003 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4006 /* Read in the string table, so that we have names to display. */
4007 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4008 && SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
4010 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
4012 if (section
->sh_size
!= 0)
4014 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4015 1, section
->sh_size
, _("string table"));
4017 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4021 /* Scan the sections for the dynamic symbol table
4022 and dynamic string table and debug sections. */
4023 dynamic_symbols
= NULL
;
4024 dynamic_strings
= NULL
;
4025 dynamic_syminfo
= NULL
;
4026 symtab_shndx_hdr
= NULL
;
4028 eh_addr_size
= is_32bit_elf
? 4 : 8;
4029 switch (elf_header
.e_machine
)
4032 case EM_MIPS_RS3_LE
:
4033 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4034 FDE addresses. However, the ABI also has a semi-official ILP32
4035 variant for which the normal FDE address size rules apply.
4037 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4038 section, where XX is the size of longs in bits. Unfortunately,
4039 earlier compilers provided no way of distinguishing ILP32 objects
4040 from LP64 objects, so if there's any doubt, we should assume that
4041 the official LP64 form is being used. */
4042 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4043 && find_section (".gcc_compiled_long32") == NULL
)
4049 switch (elf_header
.e_flags
& EF_H8_MACH
)
4051 case E_H8_MACH_H8300
:
4052 case E_H8_MACH_H8300HN
:
4053 case E_H8_MACH_H8300SN
:
4054 case E_H8_MACH_H8300SXN
:
4057 case E_H8_MACH_H8300H
:
4058 case E_H8_MACH_H8300S
:
4059 case E_H8_MACH_H8300SX
:
4065 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4068 size_t expected_entsize \
4069 = is_32bit_elf ? size32 : size64; \
4070 if (section->sh_entsize != expected_entsize) \
4071 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4072 i, (unsigned long int) section->sh_entsize, \
4073 (unsigned long int) expected_entsize); \
4074 section->sh_entsize = expected_entsize; \
4077 #define CHECK_ENTSIZE(section, i, type) \
4078 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4079 sizeof (Elf64_External_##type))
4081 for (i
= 0, section
= section_headers
;
4082 i
< elf_header
.e_shnum
;
4085 char *name
= SECTION_NAME (section
);
4087 if (section
->sh_type
== SHT_DYNSYM
)
4089 if (dynamic_symbols
!= NULL
)
4091 error (_("File contains multiple dynamic symbol tables\n"));
4095 CHECK_ENTSIZE (section
, i
, Sym
);
4096 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4097 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4099 else if (section
->sh_type
== SHT_STRTAB
4100 && streq (name
, ".dynstr"))
4102 if (dynamic_strings
!= NULL
)
4104 error (_("File contains multiple dynamic string tables\n"));
4108 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4109 1, section
->sh_size
, _("dynamic strings"));
4110 dynamic_strings_length
= section
->sh_size
;
4112 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4114 if (symtab_shndx_hdr
!= NULL
)
4116 error (_("File contains multiple symtab shndx tables\n"));
4119 symtab_shndx_hdr
= section
;
4121 else if (section
->sh_type
== SHT_SYMTAB
)
4122 CHECK_ENTSIZE (section
, i
, Sym
);
4123 else if (section
->sh_type
== SHT_GROUP
)
4124 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4125 else if (section
->sh_type
== SHT_REL
)
4126 CHECK_ENTSIZE (section
, i
, Rel
);
4127 else if (section
->sh_type
== SHT_RELA
)
4128 CHECK_ENTSIZE (section
, i
, Rela
);
4129 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4130 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4131 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4132 || do_debug_loc
|| do_debug_ranges
)
4133 && const_strneq (name
, ".debug_"))
4138 || (do_debug_info
&& streq (name
, "info"))
4139 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4140 || (do_debug_lines
&& streq (name
, "line"))
4141 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4142 || (do_debug_aranges
&& streq (name
, "aranges"))
4143 || (do_debug_ranges
&& streq (name
, "ranges"))
4144 || (do_debug_frames
&& streq (name
, "frame"))
4145 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4146 || (do_debug_str
&& streq (name
, "str"))
4147 || (do_debug_loc
&& streq (name
, "loc"))
4149 request_dump (i
, DEBUG_DUMP
);
4151 /* linkonce section to be combined with .debug_info at link time. */
4152 else if ((do_debugging
|| do_debug_info
)
4153 && const_strneq (name
, ".gnu.linkonce.wi."))
4154 request_dump (i
, DEBUG_DUMP
);
4155 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4156 request_dump (i
, DEBUG_DUMP
);
4162 if (elf_header
.e_shnum
> 1)
4163 printf (_("\nSection Headers:\n"));
4165 printf (_("\nSection Header:\n"));
4169 if (do_section_details
)
4171 printf (_(" [Nr] Name\n"));
4172 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4176 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4180 if (do_section_details
)
4182 printf (_(" [Nr] Name\n"));
4183 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4187 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4191 if (do_section_details
)
4193 printf (_(" [Nr] Name\n"));
4194 printf (_(" Type Address Offset Link\n"));
4195 printf (_(" Size EntSize Info Align\n"));
4199 printf (_(" [Nr] Name Type Address Offset\n"));
4200 printf (_(" Size EntSize Flags Link Info Align\n"));
4204 if (do_section_details
)
4205 printf (_(" Flags\n"));
4207 for (i
= 0, section
= section_headers
;
4208 i
< elf_header
.e_shnum
;
4211 if (do_section_details
)
4213 printf (" [%2u] %s\n",
4214 SECTION_HEADER_NUM (i
),
4215 SECTION_NAME (section
));
4216 if (is_32bit_elf
|| do_wide
)
4217 printf (" %-15.15s ",
4218 get_section_type_name (section
->sh_type
));
4221 printf (" [%2u] %-17.17s %-15.15s ",
4222 SECTION_HEADER_NUM (i
),
4223 SECTION_NAME (section
),
4224 get_section_type_name (section
->sh_type
));
4228 print_vma (section
->sh_addr
, LONG_HEX
);
4230 printf ( " %6.6lx %6.6lx %2.2lx",
4231 (unsigned long) section
->sh_offset
,
4232 (unsigned long) section
->sh_size
,
4233 (unsigned long) section
->sh_entsize
);
4235 if (do_section_details
)
4236 fputs (" ", stdout
);
4238 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4240 printf ("%2ld %3lu %2ld\n",
4241 (unsigned long) section
->sh_link
,
4242 (unsigned long) section
->sh_info
,
4243 (unsigned long) section
->sh_addralign
);
4247 print_vma (section
->sh_addr
, LONG_HEX
);
4249 if ((long) section
->sh_offset
== section
->sh_offset
)
4250 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4254 print_vma (section
->sh_offset
, LONG_HEX
);
4257 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4258 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4262 print_vma (section
->sh_size
, LONG_HEX
);
4265 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4266 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4270 print_vma (section
->sh_entsize
, LONG_HEX
);
4273 if (do_section_details
)
4274 fputs (" ", stdout
);
4276 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4278 printf ("%2ld %3lu ",
4279 (unsigned long) section
->sh_link
,
4280 (unsigned long) section
->sh_info
);
4282 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4283 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4286 print_vma (section
->sh_addralign
, DEC
);
4290 else if (do_section_details
)
4292 printf (" %-15.15s ",
4293 get_section_type_name (section
->sh_type
));
4294 print_vma (section
->sh_addr
, LONG_HEX
);
4295 if ((long) section
->sh_offset
== section
->sh_offset
)
4296 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4300 print_vma (section
->sh_offset
, LONG_HEX
);
4302 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4303 print_vma (section
->sh_size
, LONG_HEX
);
4305 print_vma (section
->sh_entsize
, LONG_HEX
);
4307 printf (" %-16lu %ld\n",
4308 (unsigned long) section
->sh_info
,
4309 (unsigned long) section
->sh_addralign
);
4314 print_vma (section
->sh_addr
, LONG_HEX
);
4315 if ((long) section
->sh_offset
== section
->sh_offset
)
4316 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4320 print_vma (section
->sh_offset
, LONG_HEX
);
4323 print_vma (section
->sh_size
, LONG_HEX
);
4325 print_vma (section
->sh_entsize
, LONG_HEX
);
4327 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4329 printf (" %2ld %3lu %ld\n",
4330 (unsigned long) section
->sh_link
,
4331 (unsigned long) section
->sh_info
,
4332 (unsigned long) section
->sh_addralign
);
4335 if (do_section_details
)
4336 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4339 if (!do_section_details
)
4340 printf (_("Key to Flags:\n\
4341 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4342 I (info), L (link order), G (group), x (unknown)\n\
4343 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4349 get_group_flags (unsigned int flags
)
4351 static char buff
[32];
4358 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4365 process_section_groups (FILE *file
)
4367 Elf_Internal_Shdr
*section
;
4369 struct group
*group
;
4370 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4371 Elf_Internal_Sym
*symtab
;
4375 /* Don't process section groups unless needed. */
4376 if (!do_unwind
&& !do_section_groups
)
4379 if (elf_header
.e_shnum
== 0)
4381 if (do_section_groups
)
4382 printf (_("\nThere are no sections in this file.\n"));
4387 if (section_headers
== NULL
)
4389 error (_("Section headers are not available!\n"));
4393 section_headers_groups
= calloc (elf_header
.e_shnum
,
4394 sizeof (struct group
*));
4396 if (section_headers_groups
== NULL
)
4398 error (_("Out of memory\n"));
4402 /* Scan the sections for the group section. */
4404 for (i
= 0, section
= section_headers
;
4405 i
< elf_header
.e_shnum
;
4407 if (section
->sh_type
== SHT_GROUP
)
4410 if (group_count
== 0)
4412 if (do_section_groups
)
4413 printf (_("\nThere are no section groups in this file.\n"));
4418 section_groups
= calloc (group_count
, sizeof (struct group
));
4420 if (section_groups
== NULL
)
4422 error (_("Out of memory\n"));
4431 for (i
= 0, section
= section_headers
, group
= section_groups
;
4432 i
< elf_header
.e_shnum
;
4435 if (section
->sh_type
== SHT_GROUP
)
4437 char *name
= SECTION_NAME (section
);
4439 unsigned char *start
, *indices
;
4440 unsigned int entry
, j
, size
;
4441 Elf_Internal_Shdr
*sec
;
4442 Elf_Internal_Sym
*sym
;
4444 /* Get the symbol table. */
4445 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4446 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4449 error (_("Bad sh_link in group section `%s'\n"), name
);
4453 if (symtab_sec
!= sec
)
4458 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4461 sym
= symtab
+ section
->sh_info
;
4463 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4465 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4468 error (_("Bad sh_info in group section `%s'\n"), name
);
4472 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4481 /* Get the string table. */
4482 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4483 >= elf_header
.e_shnum
)
4492 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4497 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4498 1, strtab_sec
->sh_size
,
4500 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4502 group_name
= sym
->st_name
< strtab_size
4503 ? strtab
+ sym
->st_name
: "<corrupt>";
4506 start
= get_data (NULL
, file
, section
->sh_offset
,
4507 1, section
->sh_size
, _("section data"));
4510 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4511 entry
= byte_get (indices
, 4);
4514 if (do_section_groups
)
4516 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4517 get_group_flags (entry
), i
, name
, group_name
, size
);
4519 printf (_(" [Index] Name\n"));
4522 group
->group_index
= i
;
4524 for (j
= 0; j
< size
; j
++)
4526 struct group_list
*g
;
4528 entry
= byte_get (indices
, 4);
4531 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4533 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4534 entry
, i
, elf_header
.e_shnum
- 1);
4537 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4539 error (_("invalid section [%5u] in group section [%5u]\n"),
4544 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4549 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4551 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4556 /* Intel C/C++ compiler may put section 0 in a
4557 section group. We just warn it the first time
4558 and ignore it afterwards. */
4559 static int warned
= 0;
4562 error (_("section 0 in group section [%5u]\n"),
4563 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4569 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4572 if (do_section_groups
)
4574 sec
= SECTION_HEADER (entry
);
4575 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4578 g
= xmalloc (sizeof (struct group_list
));
4579 g
->section_index
= entry
;
4580 g
->next
= group
->root
;
4604 } dynamic_relocations
[] =
4606 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4607 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4608 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4611 /* Process the reloc section. */
4614 process_relocs (FILE *file
)
4616 unsigned long rel_size
;
4617 unsigned long rel_offset
;
4623 if (do_using_dynamic
)
4627 int has_dynamic_reloc
;
4630 has_dynamic_reloc
= 0;
4632 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4634 is_rela
= dynamic_relocations
[i
].rela
;
4635 name
= dynamic_relocations
[i
].name
;
4636 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4637 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4639 has_dynamic_reloc
|= rel_size
;
4641 if (is_rela
== UNKNOWN
)
4643 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4644 switch (dynamic_info
[DT_PLTREL
])
4658 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4659 name
, rel_offset
, rel_size
);
4661 dump_relocations (file
,
4662 offset_from_vma (file
, rel_offset
, rel_size
),
4664 dynamic_symbols
, num_dynamic_syms
,
4665 dynamic_strings
, dynamic_strings_length
, is_rela
);
4669 if (! has_dynamic_reloc
)
4670 printf (_("\nThere are no dynamic relocations in this file.\n"));
4674 Elf_Internal_Shdr
*section
;
4678 for (i
= 0, section
= section_headers
;
4679 i
< elf_header
.e_shnum
;
4682 if ( section
->sh_type
!= SHT_RELA
4683 && section
->sh_type
!= SHT_REL
)
4686 rel_offset
= section
->sh_offset
;
4687 rel_size
= section
->sh_size
;
4691 Elf_Internal_Shdr
*strsec
;
4694 printf (_("\nRelocation section "));
4696 if (string_table
== NULL
)
4697 printf ("%d", section
->sh_name
);
4699 printf (_("'%s'"), SECTION_NAME (section
));
4701 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4702 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4704 is_rela
= section
->sh_type
== SHT_RELA
;
4706 if (section
->sh_link
4707 && SECTION_HEADER_INDEX (section
->sh_link
)
4708 < elf_header
.e_shnum
)
4710 Elf_Internal_Shdr
*symsec
;
4711 Elf_Internal_Sym
*symtab
;
4712 unsigned long nsyms
;
4713 unsigned long strtablen
= 0;
4714 char *strtab
= NULL
;
4716 symsec
= SECTION_HEADER (section
->sh_link
);
4717 if (symsec
->sh_type
!= SHT_SYMTAB
4718 && symsec
->sh_type
!= SHT_DYNSYM
)
4721 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4722 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4727 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4728 < elf_header
.e_shnum
)
4730 strsec
= SECTION_HEADER (symsec
->sh_link
);
4732 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4735 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4738 dump_relocations (file
, rel_offset
, rel_size
,
4739 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4745 dump_relocations (file
, rel_offset
, rel_size
,
4746 NULL
, 0, NULL
, 0, is_rela
);
4753 printf (_("\nThere are no relocations in this file.\n"));
4759 /* Process the unwind section. */
4761 #include "unwind-ia64.h"
4763 /* An absolute address consists of a section and an offset. If the
4764 section is NULL, the offset itself is the address, otherwise, the
4765 address equals to LOAD_ADDRESS(section) + offset. */
4769 unsigned short section
;
4773 #define ABSADDR(a) \
4775 ? section_headers [(a).section].sh_addr + (a).offset \
4778 struct ia64_unw_aux_info
4780 struct ia64_unw_table_entry
4782 struct absaddr start
;
4784 struct absaddr info
;
4786 *table
; /* Unwind table. */
4787 unsigned long table_len
; /* Length of unwind table. */
4788 unsigned char *info
; /* Unwind info. */
4789 unsigned long info_size
; /* Size of unwind info. */
4790 bfd_vma info_addr
; /* starting address of unwind info. */
4791 bfd_vma seg_base
; /* Starting address of segment. */
4792 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4793 unsigned long nsyms
; /* Number of symbols. */
4794 char *strtab
; /* The string table. */
4795 unsigned long strtab_size
; /* Size of string table. */
4799 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4800 unsigned long nsyms
,
4802 unsigned long strtab_size
,
4803 struct absaddr addr
,
4804 const char **symname
,
4807 bfd_vma dist
= 0x100000;
4808 Elf_Internal_Sym
*sym
, *best
= NULL
;
4811 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4813 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4814 && sym
->st_name
!= 0
4815 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4816 && addr
.offset
>= sym
->st_value
4817 && addr
.offset
- sym
->st_value
< dist
)
4820 dist
= addr
.offset
- sym
->st_value
;
4827 *symname
= (best
->st_name
>= strtab_size
4828 ? "<corrupt>" : strtab
+ best
->st_name
);
4833 *offset
= addr
.offset
;
4837 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4839 struct ia64_unw_table_entry
*tp
;
4842 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4846 const unsigned char *dp
;
4847 const unsigned char *head
;
4848 const char *procname
;
4850 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4851 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4853 fputs ("\n<", stdout
);
4857 fputs (procname
, stdout
);
4860 printf ("+%lx", (unsigned long) offset
);
4863 fputs (">: [", stdout
);
4864 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4865 fputc ('-', stdout
);
4866 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4867 printf ("], info at +0x%lx\n",
4868 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4870 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4871 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4873 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4874 (unsigned) UNW_VER (stamp
),
4875 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4876 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4877 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4878 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4880 if (UNW_VER (stamp
) != 1)
4882 printf ("\tUnknown version.\n");
4887 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4888 dp
= unw_decode (dp
, in_body
, & in_body
);
4893 slurp_ia64_unwind_table (FILE *file
,
4894 struct ia64_unw_aux_info
*aux
,
4895 Elf_Internal_Shdr
*sec
)
4897 unsigned long size
, nrelas
, i
;
4898 Elf_Internal_Phdr
*seg
;
4899 struct ia64_unw_table_entry
*tep
;
4900 Elf_Internal_Shdr
*relsec
;
4901 Elf_Internal_Rela
*rela
, *rp
;
4902 unsigned char *table
, *tp
;
4903 Elf_Internal_Sym
*sym
;
4904 const char *relname
;
4906 /* First, find the starting address of the segment that includes
4909 if (elf_header
.e_phnum
)
4911 if (! get_program_headers (file
))
4914 for (seg
= program_headers
;
4915 seg
< program_headers
+ elf_header
.e_phnum
;
4918 if (seg
->p_type
!= PT_LOAD
)
4921 if (sec
->sh_addr
>= seg
->p_vaddr
4922 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4924 aux
->seg_base
= seg
->p_vaddr
;
4930 /* Second, build the unwind table from the contents of the unwind section: */
4931 size
= sec
->sh_size
;
4932 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4936 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4938 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4940 tep
->start
.section
= SHN_UNDEF
;
4941 tep
->end
.section
= SHN_UNDEF
;
4942 tep
->info
.section
= SHN_UNDEF
;
4945 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4946 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4947 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4951 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4952 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4953 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4955 tep
->start
.offset
+= aux
->seg_base
;
4956 tep
->end
.offset
+= aux
->seg_base
;
4957 tep
->info
.offset
+= aux
->seg_base
;
4961 /* Third, apply any relocations to the unwind table: */
4963 for (relsec
= section_headers
;
4964 relsec
< section_headers
+ elf_header
.e_shnum
;
4967 if (relsec
->sh_type
!= SHT_RELA
4968 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4969 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4972 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4976 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4980 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4981 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4985 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4986 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4989 if (! const_strneq (relname
, "R_IA64_SEGREL"))
4991 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4995 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4997 switch (rp
->r_offset
/eh_addr_size
% 3)
5000 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5001 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5004 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5005 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5008 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5009 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5019 aux
->table_len
= size
/ (3 * eh_addr_size
);
5024 ia64_process_unwind (FILE *file
)
5026 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5027 unsigned long i
, unwcount
= 0, unwstart
= 0;
5028 struct ia64_unw_aux_info aux
;
5030 memset (& aux
, 0, sizeof (aux
));
5032 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5034 if (sec
->sh_type
== SHT_SYMTAB
5035 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5037 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5038 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5040 strsec
= SECTION_HEADER (sec
->sh_link
);
5041 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5042 1, strsec
->sh_size
, _("string table"));
5043 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5045 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5050 printf (_("\nThere are no unwind sections in this file.\n"));
5052 while (unwcount
-- > 0)
5057 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5058 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5059 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5066 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5068 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5070 /* We need to find which section group it is in. */
5071 struct group_list
*g
= section_headers_groups
[i
]->root
;
5073 for (; g
!= NULL
; g
= g
->next
)
5075 sec
= SECTION_HEADER (g
->section_index
);
5077 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5082 i
= elf_header
.e_shnum
;
5084 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5086 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5087 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5088 suffix
= SECTION_NAME (unwsec
) + len
;
5089 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5091 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5092 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5097 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5098 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5099 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5100 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5102 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5103 suffix
= SECTION_NAME (unwsec
) + len
;
5104 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5106 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5107 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5111 if (i
== elf_header
.e_shnum
)
5113 printf (_("\nCould not find unwind info section for "));
5115 if (string_table
== NULL
)
5116 printf ("%d", unwsec
->sh_name
);
5118 printf (_("'%s'"), SECTION_NAME (unwsec
));
5122 aux
.info_size
= sec
->sh_size
;
5123 aux
.info_addr
= sec
->sh_addr
;
5124 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5127 printf (_("\nUnwind section "));
5129 if (string_table
== NULL
)
5130 printf ("%d", unwsec
->sh_name
);
5132 printf (_("'%s'"), SECTION_NAME (unwsec
));
5134 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5135 (unsigned long) unwsec
->sh_offset
,
5136 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5138 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5140 if (aux
.table_len
> 0)
5141 dump_ia64_unwind (& aux
);
5144 free ((char *) aux
.table
);
5146 free ((char *) aux
.info
);
5155 free ((char *) aux
.strtab
);
5160 struct hppa_unw_aux_info
5162 struct hppa_unw_table_entry
5164 struct absaddr start
;
5166 unsigned int Cannot_unwind
:1; /* 0 */
5167 unsigned int Millicode
:1; /* 1 */
5168 unsigned int Millicode_save_sr0
:1; /* 2 */
5169 unsigned int Region_description
:2; /* 3..4 */
5170 unsigned int reserved1
:1; /* 5 */
5171 unsigned int Entry_SR
:1; /* 6 */
5172 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5173 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5174 unsigned int Args_stored
:1; /* 16 */
5175 unsigned int Variable_Frame
:1; /* 17 */
5176 unsigned int Separate_Package_Body
:1; /* 18 */
5177 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5178 unsigned int Stack_Overflow_Check
:1; /* 20 */
5179 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5180 unsigned int Ada_Region
:1; /* 22 */
5181 unsigned int cxx_info
:1; /* 23 */
5182 unsigned int cxx_try_catch
:1; /* 24 */
5183 unsigned int sched_entry_seq
:1; /* 25 */
5184 unsigned int reserved2
:1; /* 26 */
5185 unsigned int Save_SP
:1; /* 27 */
5186 unsigned int Save_RP
:1; /* 28 */
5187 unsigned int Save_MRP_in_frame
:1; /* 29 */
5188 unsigned int extn_ptr_defined
:1; /* 30 */
5189 unsigned int Cleanup_defined
:1; /* 31 */
5191 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5192 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5193 unsigned int Large_frame
:1; /* 2 */
5194 unsigned int Pseudo_SP_Set
:1; /* 3 */
5195 unsigned int reserved4
:1; /* 4 */
5196 unsigned int Total_frame_size
:27; /* 5..31 */
5198 *table
; /* Unwind table. */
5199 unsigned long table_len
; /* Length of unwind table. */
5200 bfd_vma seg_base
; /* Starting address of segment. */
5201 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5202 unsigned long nsyms
; /* Number of symbols. */
5203 char *strtab
; /* The string table. */
5204 unsigned long strtab_size
; /* Size of string table. */
5208 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5210 struct hppa_unw_table_entry
*tp
;
5212 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5215 const char *procname
;
5217 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5218 aux
->strtab_size
, tp
->start
, &procname
,
5221 fputs ("\n<", stdout
);
5225 fputs (procname
, stdout
);
5228 printf ("+%lx", (unsigned long) offset
);
5231 fputs (">: [", stdout
);
5232 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5233 fputc ('-', stdout
);
5234 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5237 #define PF(_m) if (tp->_m) printf (#_m " ");
5238 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5241 PF(Millicode_save_sr0
);
5242 /* PV(Region_description); */
5248 PF(Separate_Package_Body
);
5249 PF(Frame_Extension_Millicode
);
5250 PF(Stack_Overflow_Check
);
5251 PF(Two_Instruction_SP_Increment
);
5255 PF(sched_entry_seq
);
5258 PF(Save_MRP_in_frame
);
5259 PF(extn_ptr_defined
);
5260 PF(Cleanup_defined
);
5261 PF(MPE_XL_interrupt_marker
);
5262 PF(HP_UX_interrupt_marker
);
5265 PV(Total_frame_size
);
5274 slurp_hppa_unwind_table (FILE *file
,
5275 struct hppa_unw_aux_info
*aux
,
5276 Elf_Internal_Shdr
*sec
)
5278 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5279 Elf_Internal_Phdr
*seg
;
5280 struct hppa_unw_table_entry
*tep
;
5281 Elf_Internal_Shdr
*relsec
;
5282 Elf_Internal_Rela
*rela
, *rp
;
5283 unsigned char *table
, *tp
;
5284 Elf_Internal_Sym
*sym
;
5285 const char *relname
;
5287 /* First, find the starting address of the segment that includes
5290 if (elf_header
.e_phnum
)
5292 if (! get_program_headers (file
))
5295 for (seg
= program_headers
;
5296 seg
< program_headers
+ elf_header
.e_phnum
;
5299 if (seg
->p_type
!= PT_LOAD
)
5302 if (sec
->sh_addr
>= seg
->p_vaddr
5303 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5305 aux
->seg_base
= seg
->p_vaddr
;
5311 /* Second, build the unwind table from the contents of the unwind
5313 size
= sec
->sh_size
;
5314 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5319 nentries
= size
/ unw_ent_size
;
5320 size
= unw_ent_size
* nentries
;
5322 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5324 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5326 unsigned int tmp1
, tmp2
;
5328 tep
->start
.section
= SHN_UNDEF
;
5329 tep
->end
.section
= SHN_UNDEF
;
5331 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5332 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5333 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5334 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5336 tep
->start
.offset
+= aux
->seg_base
;
5337 tep
->end
.offset
+= aux
->seg_base
;
5339 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5340 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5341 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5342 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5343 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5344 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5345 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5346 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5347 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5348 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5349 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5350 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5351 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5352 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5353 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5354 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5355 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5356 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5357 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5358 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5359 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5360 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5361 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5362 tep
->Cleanup_defined
= tmp1
& 0x1;
5364 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5365 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5366 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5367 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5368 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5369 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5373 /* Third, apply any relocations to the unwind table. */
5375 for (relsec
= section_headers
;
5376 relsec
< section_headers
+ elf_header
.e_shnum
;
5379 if (relsec
->sh_type
!= SHT_RELA
5380 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5381 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5384 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5388 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5392 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5393 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5397 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5398 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5401 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5402 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5404 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5408 i
= rp
->r_offset
/ unw_ent_size
;
5410 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5413 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5414 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5417 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5418 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5428 aux
->table_len
= nentries
;
5434 hppa_process_unwind (FILE *file
)
5436 struct hppa_unw_aux_info aux
;
5437 Elf_Internal_Shdr
*unwsec
= NULL
;
5438 Elf_Internal_Shdr
*strsec
;
5439 Elf_Internal_Shdr
*sec
;
5442 memset (& aux
, 0, sizeof (aux
));
5444 if (string_table
== NULL
)
5447 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5449 if (sec
->sh_type
== SHT_SYMTAB
5450 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5452 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5453 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5455 strsec
= SECTION_HEADER (sec
->sh_link
);
5456 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5457 1, strsec
->sh_size
, _("string table"));
5458 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5460 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5465 printf (_("\nThere are no unwind sections in this file.\n"));
5467 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5469 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5471 printf (_("\nUnwind section "));
5472 printf (_("'%s'"), SECTION_NAME (sec
));
5474 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5475 (unsigned long) sec
->sh_offset
,
5476 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5478 slurp_hppa_unwind_table (file
, &aux
, sec
);
5479 if (aux
.table_len
> 0)
5480 dump_hppa_unwind (&aux
);
5483 free ((char *) aux
.table
);
5491 free ((char *) aux
.strtab
);
5497 process_unwind (FILE *file
)
5499 struct unwind_handler
{
5501 int (*handler
)(FILE *file
);
5503 { EM_IA_64
, ia64_process_unwind
},
5504 { EM_PARISC
, hppa_process_unwind
},
5512 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5513 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5514 return handlers
[i
].handler (file
);
5516 printf (_("\nThere are no unwind sections in this file.\n"));
5521 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5523 switch (entry
->d_tag
)
5526 if (entry
->d_un
.d_val
== 0)
5530 static const char * opts
[] =
5532 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5533 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5534 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5535 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5540 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5541 if (entry
->d_un
.d_val
& (1 << cnt
))
5543 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5550 case DT_MIPS_IVERSION
:
5551 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5552 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5554 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5557 case DT_MIPS_TIME_STAMP
:
5562 time_t time
= entry
->d_un
.d_val
;
5563 tmp
= gmtime (&time
);
5564 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5565 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5566 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5567 printf ("Time Stamp: %s\n", timebuf
);
5571 case DT_MIPS_RLD_VERSION
:
5572 case DT_MIPS_LOCAL_GOTNO
:
5573 case DT_MIPS_CONFLICTNO
:
5574 case DT_MIPS_LIBLISTNO
:
5575 case DT_MIPS_SYMTABNO
:
5576 case DT_MIPS_UNREFEXTNO
:
5577 case DT_MIPS_HIPAGENO
:
5578 case DT_MIPS_DELTA_CLASS_NO
:
5579 case DT_MIPS_DELTA_INSTANCE_NO
:
5580 case DT_MIPS_DELTA_RELOC_NO
:
5581 case DT_MIPS_DELTA_SYM_NO
:
5582 case DT_MIPS_DELTA_CLASSSYM_NO
:
5583 case DT_MIPS_COMPACT_SIZE
:
5584 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5588 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5594 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5596 switch (entry
->d_tag
)
5598 case DT_HP_DLD_FLAGS
:
5607 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5608 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5609 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5610 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5611 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5612 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5613 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5614 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5615 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5616 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5617 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5618 { DT_HP_GST
, "HP_GST" },
5619 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5620 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5621 { DT_HP_NODELETE
, "HP_NODELETE" },
5622 { DT_HP_GROUP
, "HP_GROUP" },
5623 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5627 bfd_vma val
= entry
->d_un
.d_val
;
5629 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5630 if (val
& flags
[cnt
].bit
)
5634 fputs (flags
[cnt
].str
, stdout
);
5636 val
^= flags
[cnt
].bit
;
5639 if (val
!= 0 || first
)
5643 print_vma (val
, HEX
);
5649 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5656 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5658 switch (entry
->d_tag
)
5660 case DT_IA_64_PLT_RESERVE
:
5661 /* First 3 slots reserved. */
5662 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5664 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5668 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5675 get_32bit_dynamic_section (FILE *file
)
5677 Elf32_External_Dyn
*edyn
, *ext
;
5678 Elf_Internal_Dyn
*entry
;
5680 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5681 _("dynamic section"));
5685 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5686 might not have the luxury of section headers. Look for the DT_NULL
5687 terminator to determine the number of entries. */
5688 for (ext
= edyn
, dynamic_nent
= 0;
5689 (char *) ext
< (char *) edyn
+ dynamic_size
;
5693 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5697 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5698 if (dynamic_section
== NULL
)
5700 error (_("Out of memory\n"));
5705 for (ext
= edyn
, entry
= dynamic_section
;
5706 entry
< dynamic_section
+ dynamic_nent
;
5709 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5710 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5719 get_64bit_dynamic_section (FILE *file
)
5721 Elf64_External_Dyn
*edyn
, *ext
;
5722 Elf_Internal_Dyn
*entry
;
5724 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5725 _("dynamic section"));
5729 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5730 might not have the luxury of section headers. Look for the DT_NULL
5731 terminator to determine the number of entries. */
5732 for (ext
= edyn
, dynamic_nent
= 0;
5733 (char *) ext
< (char *) edyn
+ dynamic_size
;
5737 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5741 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5742 if (dynamic_section
== NULL
)
5744 error (_("Out of memory\n"));
5749 for (ext
= edyn
, entry
= dynamic_section
;
5750 entry
< dynamic_section
+ dynamic_nent
;
5753 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5754 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5763 print_dynamic_flags (bfd_vma flags
)
5771 flag
= flags
& - flags
;
5781 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5782 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5783 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5784 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5785 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5786 default: fputs ("unknown", stdout
); break;
5792 /* Parse and display the contents of the dynamic section. */
5795 process_dynamic_section (FILE *file
)
5797 Elf_Internal_Dyn
*entry
;
5799 if (dynamic_size
== 0)
5802 printf (_("\nThere is no dynamic section in this file.\n"));
5809 if (! get_32bit_dynamic_section (file
))
5812 else if (! get_64bit_dynamic_section (file
))
5815 /* Find the appropriate symbol table. */
5816 if (dynamic_symbols
== NULL
)
5818 for (entry
= dynamic_section
;
5819 entry
< dynamic_section
+ dynamic_nent
;
5822 Elf_Internal_Shdr section
;
5824 if (entry
->d_tag
!= DT_SYMTAB
)
5827 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5829 /* Since we do not know how big the symbol table is,
5830 we default to reading in the entire file (!) and
5831 processing that. This is overkill, I know, but it
5833 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5835 if (archive_file_offset
!= 0)
5836 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5839 if (fseek (file
, 0, SEEK_END
))
5840 error (_("Unable to seek to end of file!"));
5842 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5846 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5848 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5850 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5851 if (num_dynamic_syms
< 1)
5853 error (_("Unable to determine the number of symbols to load\n"));
5857 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5861 /* Similarly find a string table. */
5862 if (dynamic_strings
== NULL
)
5864 for (entry
= dynamic_section
;
5865 entry
< dynamic_section
+ dynamic_nent
;
5868 unsigned long offset
;
5871 if (entry
->d_tag
!= DT_STRTAB
)
5874 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5876 /* Since we do not know how big the string table is,
5877 we default to reading in the entire file (!) and
5878 processing that. This is overkill, I know, but it
5881 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5883 if (archive_file_offset
!= 0)
5884 str_tab_len
= archive_file_size
- offset
;
5887 if (fseek (file
, 0, SEEK_END
))
5888 error (_("Unable to seek to end of file\n"));
5889 str_tab_len
= ftell (file
) - offset
;
5892 if (str_tab_len
< 1)
5895 (_("Unable to determine the length of the dynamic string table\n"));
5899 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5900 _("dynamic string table"));
5901 dynamic_strings_length
= str_tab_len
;
5906 /* And find the syminfo section if available. */
5907 if (dynamic_syminfo
== NULL
)
5909 unsigned long syminsz
= 0;
5911 for (entry
= dynamic_section
;
5912 entry
< dynamic_section
+ dynamic_nent
;
5915 if (entry
->d_tag
== DT_SYMINENT
)
5917 /* Note: these braces are necessary to avoid a syntax
5918 error from the SunOS4 C compiler. */
5919 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5921 else if (entry
->d_tag
== DT_SYMINSZ
)
5922 syminsz
= entry
->d_un
.d_val
;
5923 else if (entry
->d_tag
== DT_SYMINFO
)
5924 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5928 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5930 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5931 Elf_Internal_Syminfo
*syminfo
;
5933 /* There is a syminfo section. Read the data. */
5934 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5935 syminsz
, _("symbol information"));
5939 dynamic_syminfo
= malloc (syminsz
);
5940 if (dynamic_syminfo
== NULL
)
5942 error (_("Out of memory\n"));
5946 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5947 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5948 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5949 ++syminfo
, ++extsym
)
5951 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5952 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5959 if (do_dynamic
&& dynamic_addr
)
5960 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5961 dynamic_addr
, dynamic_nent
);
5963 printf (_(" Tag Type Name/Value\n"));
5965 for (entry
= dynamic_section
;
5966 entry
< dynamic_section
+ dynamic_nent
;
5974 print_vma (entry
->d_tag
, FULL_HEX
);
5975 dtype
= get_dynamic_type (entry
->d_tag
);
5976 printf (" (%s)%*s", dtype
,
5977 ((is_32bit_elf
? 27 : 19)
5978 - (int) strlen (dtype
)),
5982 switch (entry
->d_tag
)
5986 print_dynamic_flags (entry
->d_un
.d_val
);
5996 switch (entry
->d_tag
)
5999 printf (_("Auxiliary library"));
6003 printf (_("Filter library"));
6007 printf (_("Configuration file"));
6011 printf (_("Dependency audit library"));
6015 printf (_("Audit library"));
6019 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6020 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6024 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6033 printf (_("Flags:"));
6035 if (entry
->d_un
.d_val
== 0)
6036 printf (_(" None\n"));
6039 unsigned long int val
= entry
->d_un
.d_val
;
6041 if (val
& DTF_1_PARINIT
)
6043 printf (" PARINIT");
6044 val
^= DTF_1_PARINIT
;
6046 if (val
& DTF_1_CONFEXP
)
6048 printf (" CONFEXP");
6049 val
^= DTF_1_CONFEXP
;
6052 printf (" %lx", val
);
6061 printf (_("Flags:"));
6063 if (entry
->d_un
.d_val
== 0)
6064 printf (_(" None\n"));
6067 unsigned long int val
= entry
->d_un
.d_val
;
6069 if (val
& DF_P1_LAZYLOAD
)
6071 printf (" LAZYLOAD");
6072 val
^= DF_P1_LAZYLOAD
;
6074 if (val
& DF_P1_GROUPPERM
)
6076 printf (" GROUPPERM");
6077 val
^= DF_P1_GROUPPERM
;
6080 printf (" %lx", val
);
6089 printf (_("Flags:"));
6090 if (entry
->d_un
.d_val
== 0)
6091 printf (_(" None\n"));
6094 unsigned long int val
= entry
->d_un
.d_val
;
6101 if (val
& DF_1_GLOBAL
)
6106 if (val
& DF_1_GROUP
)
6111 if (val
& DF_1_NODELETE
)
6113 printf (" NODELETE");
6114 val
^= DF_1_NODELETE
;
6116 if (val
& DF_1_LOADFLTR
)
6118 printf (" LOADFLTR");
6119 val
^= DF_1_LOADFLTR
;
6121 if (val
& DF_1_INITFIRST
)
6123 printf (" INITFIRST");
6124 val
^= DF_1_INITFIRST
;
6126 if (val
& DF_1_NOOPEN
)
6131 if (val
& DF_1_ORIGIN
)
6136 if (val
& DF_1_DIRECT
)
6141 if (val
& DF_1_TRANS
)
6146 if (val
& DF_1_INTERPOSE
)
6148 printf (" INTERPOSE");
6149 val
^= DF_1_INTERPOSE
;
6151 if (val
& DF_1_NODEFLIB
)
6153 printf (" NODEFLIB");
6154 val
^= DF_1_NODEFLIB
;
6156 if (val
& DF_1_NODUMP
)
6161 if (val
& DF_1_CONLFAT
)
6163 printf (" CONLFAT");
6164 val
^= DF_1_CONLFAT
;
6167 printf (" %lx", val
);
6174 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6176 puts (get_dynamic_type (entry
->d_un
.d_val
));
6196 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6202 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6203 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6209 switch (entry
->d_tag
)
6212 printf (_("Shared library: [%s]"), name
);
6214 if (streq (name
, program_interpreter
))
6215 printf (_(" program interpreter"));
6219 printf (_("Library soname: [%s]"), name
);
6223 printf (_("Library rpath: [%s]"), name
);
6227 printf (_("Library runpath: [%s]"), name
);
6231 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6236 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6249 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6253 case DT_INIT_ARRAYSZ
:
6254 case DT_FINI_ARRAYSZ
:
6255 case DT_GNU_CONFLICTSZ
:
6256 case DT_GNU_LIBLISTSZ
:
6259 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6260 printf (" (bytes)\n");
6270 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6283 if (entry
->d_tag
== DT_USED
6284 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6286 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6290 printf (_("Not needed object: [%s]\n"), name
);
6295 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6301 /* The value of this entry is ignored. */
6306 case DT_GNU_PRELINKED
:
6310 time_t time
= entry
->d_un
.d_val
;
6312 tmp
= gmtime (&time
);
6313 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6314 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6315 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6321 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6324 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6330 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6331 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6336 switch (elf_header
.e_machine
)
6339 case EM_MIPS_RS3_LE
:
6340 dynamic_section_mips_val (entry
);
6343 dynamic_section_parisc_val (entry
);
6346 dynamic_section_ia64_val (entry
);
6349 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6361 get_ver_flags (unsigned int flags
)
6363 static char buff
[32];
6370 if (flags
& VER_FLG_BASE
)
6371 strcat (buff
, "BASE ");
6373 if (flags
& VER_FLG_WEAK
)
6375 if (flags
& VER_FLG_BASE
)
6376 strcat (buff
, "| ");
6378 strcat (buff
, "WEAK ");
6381 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6382 strcat (buff
, "| <unknown>");
6387 /* Display the contents of the version sections. */
6389 process_version_sections (FILE *file
)
6391 Elf_Internal_Shdr
*section
;
6398 for (i
= 0, section
= section_headers
;
6399 i
< elf_header
.e_shnum
;
6402 switch (section
->sh_type
)
6404 case SHT_GNU_verdef
:
6406 Elf_External_Verdef
*edefs
;
6413 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6414 SECTION_NAME (section
), section
->sh_info
);
6416 printf (_(" Addr: 0x"));
6417 printf_vma (section
->sh_addr
);
6418 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6419 (unsigned long) section
->sh_offset
, section
->sh_link
,
6420 SECTION_HEADER_INDEX (section
->sh_link
)
6421 < elf_header
.e_shnum
6422 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6425 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6427 _("version definition section"));
6431 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6434 Elf_External_Verdef
*edef
;
6435 Elf_Internal_Verdef ent
;
6436 Elf_External_Verdaux
*eaux
;
6437 Elf_Internal_Verdaux aux
;
6441 vstart
= ((char *) edefs
) + idx
;
6443 edef
= (Elf_External_Verdef
*) vstart
;
6445 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6446 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6447 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6448 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6449 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6450 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6451 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6453 printf (_(" %#06x: Rev: %d Flags: %s"),
6454 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6456 printf (_(" Index: %d Cnt: %d "),
6457 ent
.vd_ndx
, ent
.vd_cnt
);
6459 vstart
+= ent
.vd_aux
;
6461 eaux
= (Elf_External_Verdaux
*) vstart
;
6463 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6464 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6466 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6467 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6469 printf (_("Name index: %ld\n"), aux
.vda_name
);
6471 isum
= idx
+ ent
.vd_aux
;
6473 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6475 isum
+= aux
.vda_next
;
6476 vstart
+= aux
.vda_next
;
6478 eaux
= (Elf_External_Verdaux
*) vstart
;
6480 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6481 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6483 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6484 printf (_(" %#06x: Parent %d: %s\n"),
6485 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6487 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6488 isum
, j
, aux
.vda_name
);
6498 case SHT_GNU_verneed
:
6500 Elf_External_Verneed
*eneed
;
6506 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6507 SECTION_NAME (section
), section
->sh_info
);
6509 printf (_(" Addr: 0x"));
6510 printf_vma (section
->sh_addr
);
6511 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6512 (unsigned long) section
->sh_offset
, section
->sh_link
,
6513 SECTION_HEADER_INDEX (section
->sh_link
)
6514 < elf_header
.e_shnum
6515 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6518 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6520 _("version need section"));
6524 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6526 Elf_External_Verneed
*entry
;
6527 Elf_Internal_Verneed ent
;
6532 vstart
= ((char *) eneed
) + idx
;
6534 entry
= (Elf_External_Verneed
*) vstart
;
6536 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6537 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6538 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6539 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6540 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6542 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6544 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6545 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6547 printf (_(" File: %lx"), ent
.vn_file
);
6549 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6551 vstart
+= ent
.vn_aux
;
6553 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6555 Elf_External_Vernaux
*eaux
;
6556 Elf_Internal_Vernaux aux
;
6558 eaux
= (Elf_External_Vernaux
*) vstart
;
6560 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6561 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6562 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6563 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6564 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6566 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6567 printf (_(" %#06x: Name: %s"),
6568 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6570 printf (_(" %#06x: Name index: %lx"),
6571 isum
, aux
.vna_name
);
6573 printf (_(" Flags: %s Version: %d\n"),
6574 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6576 isum
+= aux
.vna_next
;
6577 vstart
+= aux
.vna_next
;
6587 case SHT_GNU_versym
:
6589 Elf_Internal_Shdr
*link_section
;
6592 unsigned char *edata
;
6593 unsigned short *data
;
6595 Elf_Internal_Sym
*symbols
;
6596 Elf_Internal_Shdr
*string_sec
;
6599 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6602 link_section
= SECTION_HEADER (section
->sh_link
);
6603 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6605 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6606 >= elf_header
.e_shnum
)
6611 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6613 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6615 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6616 string_sec
->sh_size
, _("version string table"));
6620 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6621 SECTION_NAME (section
), total
);
6623 printf (_(" Addr: "));
6624 printf_vma (section
->sh_addr
);
6625 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6626 (unsigned long) section
->sh_offset
, section
->sh_link
,
6627 SECTION_NAME (link_section
));
6629 off
= offset_from_vma (file
,
6630 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6631 total
* sizeof (short));
6632 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6633 _("version symbol data"));
6640 data
= cmalloc (total
, sizeof (short));
6642 for (cnt
= total
; cnt
--;)
6643 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6648 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6651 int check_def
, check_need
;
6654 printf (" %03x:", cnt
);
6656 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6657 switch (data
[cnt
+ j
])
6660 fputs (_(" 0 (*local*) "), stdout
);
6664 fputs (_(" 1 (*global*) "), stdout
);
6668 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6669 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6673 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6674 >= elf_header
.e_shnum
6675 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6678 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6685 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6687 Elf_Internal_Verneed ivn
;
6688 unsigned long offset
;
6690 offset
= offset_from_vma
6691 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6692 sizeof (Elf_External_Verneed
));
6696 Elf_Internal_Vernaux ivna
;
6697 Elf_External_Verneed evn
;
6698 Elf_External_Vernaux evna
;
6699 unsigned long a_off
;
6701 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6704 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6705 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6707 a_off
= offset
+ ivn
.vn_aux
;
6711 get_data (&evna
, file
, a_off
, sizeof (evna
),
6712 1, _("version need aux (2)"));
6714 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6715 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6717 a_off
+= ivna
.vna_next
;
6719 while (ivna
.vna_other
!= data
[cnt
+ j
]
6720 && ivna
.vna_next
!= 0);
6722 if (ivna
.vna_other
== data
[cnt
+ j
])
6724 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6726 name
= strtab
+ ivna
.vna_name
;
6727 nn
+= printf ("(%s%-*s",
6729 12 - (int) strlen (name
),
6735 offset
+= ivn
.vn_next
;
6737 while (ivn
.vn_next
);
6740 if (check_def
&& data
[cnt
+ j
] != 0x8001
6741 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6743 Elf_Internal_Verdef ivd
;
6744 Elf_External_Verdef evd
;
6745 unsigned long offset
;
6747 offset
= offset_from_vma
6748 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6753 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6756 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6757 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6759 offset
+= ivd
.vd_next
;
6761 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6762 && ivd
.vd_next
!= 0);
6764 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6766 Elf_External_Verdaux evda
;
6767 Elf_Internal_Verdaux ivda
;
6769 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6771 get_data (&evda
, file
,
6772 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6774 _("version def aux"));
6776 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6778 name
= strtab
+ ivda
.vda_name
;
6779 nn
+= printf ("(%s%-*s",
6781 12 - (int) strlen (name
),
6787 printf ("%*c", 18 - nn
, ' ');
6805 printf (_("\nNo version information found in this file.\n"));
6811 get_symbol_binding (unsigned int binding
)
6813 static char buff
[32];
6817 case STB_LOCAL
: return "LOCAL";
6818 case STB_GLOBAL
: return "GLOBAL";
6819 case STB_WEAK
: return "WEAK";
6821 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6822 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6824 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6825 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6827 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6833 get_symbol_type (unsigned int type
)
6835 static char buff
[32];
6839 case STT_NOTYPE
: return "NOTYPE";
6840 case STT_OBJECT
: return "OBJECT";
6841 case STT_FUNC
: return "FUNC";
6842 case STT_SECTION
: return "SECTION";
6843 case STT_FILE
: return "FILE";
6844 case STT_COMMON
: return "COMMON";
6845 case STT_TLS
: return "TLS";
6847 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6849 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6850 return "THUMB_FUNC";
6852 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6855 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6856 return "PARISC_MILLI";
6858 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6860 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6862 if (elf_header
.e_machine
== EM_PARISC
)
6864 if (type
== STT_HP_OPAQUE
)
6866 if (type
== STT_HP_STUB
)
6870 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6873 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6879 get_symbol_visibility (unsigned int visibility
)
6883 case STV_DEFAULT
: return "DEFAULT";
6884 case STV_INTERNAL
: return "INTERNAL";
6885 case STV_HIDDEN
: return "HIDDEN";
6886 case STV_PROTECTED
: return "PROTECTED";
6892 get_mips_symbol_other (unsigned int other
)
6896 case STO_OPTIONAL
: return "OPTIONAL";
6897 case STO_MIPS16
: return "MIPS16";
6898 default: return NULL
;
6903 get_symbol_other (unsigned int other
)
6905 const char * result
= NULL
;
6906 static char buff
[32];
6911 switch (elf_header
.e_machine
)
6914 result
= get_mips_symbol_other (other
);
6922 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6927 get_symbol_index_type (unsigned int type
)
6929 static char buff
[32];
6933 case SHN_UNDEF
: return "UND";
6934 case SHN_ABS
: return "ABS";
6935 case SHN_COMMON
: return "COM";
6937 if (type
== SHN_IA_64_ANSI_COMMON
6938 && elf_header
.e_machine
== EM_IA_64
6939 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6941 else if (elf_header
.e_machine
== EM_X86_64
6942 && type
== SHN_X86_64_LCOMMON
)
6944 else if (type
== SHN_MIPS_SCOMMON
6945 && elf_header
.e_machine
== EM_MIPS
)
6947 else if (type
== SHN_MIPS_SUNDEFINED
6948 && elf_header
.e_machine
== EM_MIPS
)
6950 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6951 sprintf (buff
, "PRC[0x%04x]", type
);
6952 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6953 sprintf (buff
, "OS [0x%04x]", type
);
6954 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6955 sprintf (buff
, "RSV[0x%04x]", type
);
6957 sprintf (buff
, "%3d", type
);
6965 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6967 unsigned char *e_data
;
6970 e_data
= cmalloc (number
, ent_size
);
6974 error (_("Out of memory\n"));
6978 if (fread (e_data
, ent_size
, number
, file
) != number
)
6980 error (_("Unable to read in dynamic data\n"));
6984 i_data
= cmalloc (number
, sizeof (*i_data
));
6988 error (_("Out of memory\n"));
6994 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7001 /* Dump the symbol table. */
7003 process_symbol_table (FILE *file
)
7005 Elf_Internal_Shdr
*section
;
7006 bfd_vma nbuckets
= 0;
7007 bfd_vma nchains
= 0;
7008 bfd_vma
*buckets
= NULL
;
7009 bfd_vma
*chains
= NULL
;
7010 bfd_vma ngnubuckets
= 0;
7011 bfd_vma
*gnubuckets
= NULL
;
7012 bfd_vma
*gnuchains
= NULL
;
7014 if (! do_syms
&& !do_histogram
)
7017 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
7020 unsigned char nb
[8];
7021 unsigned char nc
[8];
7022 int hash_ent_size
= 4;
7024 if ((elf_header
.e_machine
== EM_ALPHA
7025 || elf_header
.e_machine
== EM_S390
7026 || elf_header
.e_machine
== EM_S390_OLD
)
7027 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7031 (archive_file_offset
7032 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7033 sizeof nb
+ sizeof nc
)),
7036 error (_("Unable to seek to start of dynamic information"));
7040 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7042 error (_("Failed to read in number of buckets\n"));
7046 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7048 error (_("Failed to read in number of chains\n"));
7052 nbuckets
= byte_get (nb
, hash_ent_size
);
7053 nchains
= byte_get (nc
, hash_ent_size
);
7055 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7056 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7058 if (buckets
== NULL
|| chains
== NULL
)
7063 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
7068 printf (_("\nSymbol table for image:\n"));
7070 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7072 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7074 for (hn
= 0; hn
< nbuckets
; hn
++)
7079 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7081 Elf_Internal_Sym
*psym
;
7084 psym
= dynamic_symbols
+ si
;
7086 n
= print_vma (si
, DEC_5
);
7088 fputs (" " + n
, stdout
);
7089 printf (" %3lu: ", hn
);
7090 print_vma (psym
->st_value
, LONG_HEX
);
7092 print_vma (psym
->st_size
, DEC_5
);
7094 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7095 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7096 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7097 /* Check to see if any other bits in the st_other field are set.
7098 Note - displaying this information disrupts the layout of the
7099 table being generated, but for the moment this case is very rare. */
7100 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7101 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7102 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7103 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7104 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7106 printf (" <corrupt: %14ld>", psym
->st_name
);
7111 else if (do_syms
&& !do_using_dynamic
)
7115 for (i
= 0, section
= section_headers
;
7116 i
< elf_header
.e_shnum
;
7120 char *strtab
= NULL
;
7121 unsigned long int strtab_size
= 0;
7122 Elf_Internal_Sym
*symtab
;
7123 Elf_Internal_Sym
*psym
;
7126 if ( section
->sh_type
!= SHT_SYMTAB
7127 && section
->sh_type
!= SHT_DYNSYM
)
7130 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7131 SECTION_NAME (section
),
7132 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7134 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7136 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7138 symtab
= GET_ELF_SYMBOLS (file
, section
);
7142 if (section
->sh_link
== elf_header
.e_shstrndx
)
7144 strtab
= string_table
;
7145 strtab_size
= string_table_length
;
7147 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7149 Elf_Internal_Shdr
*string_sec
;
7151 string_sec
= SECTION_HEADER (section
->sh_link
);
7153 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7154 1, string_sec
->sh_size
, _("string table"));
7155 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7158 for (si
= 0, psym
= symtab
;
7159 si
< section
->sh_size
/ section
->sh_entsize
;
7162 printf ("%6d: ", si
);
7163 print_vma (psym
->st_value
, LONG_HEX
);
7165 print_vma (psym
->st_size
, DEC_5
);
7166 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7167 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7168 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7169 /* Check to see if any other bits in the st_other field are set.
7170 Note - displaying this information disrupts the layout of the
7171 table being generated, but for the moment this case is very rare. */
7172 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7173 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7174 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7175 print_symbol (25, psym
->st_name
< strtab_size
7176 ? strtab
+ psym
->st_name
: "<corrupt>");
7178 if (section
->sh_type
== SHT_DYNSYM
&&
7179 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7181 unsigned char data
[2];
7182 unsigned short vers_data
;
7183 unsigned long offset
;
7187 offset
= offset_from_vma
7188 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7189 sizeof data
+ si
* sizeof (vers_data
));
7191 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7192 sizeof (data
), 1, _("version data"));
7194 vers_data
= byte_get (data
, 2);
7196 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7197 < elf_header
.e_shnum
7198 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7201 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7203 if ((vers_data
& 0x8000) || vers_data
> 1)
7205 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7206 && (is_nobits
|| ! check_def
))
7208 Elf_External_Verneed evn
;
7209 Elf_Internal_Verneed ivn
;
7210 Elf_Internal_Vernaux ivna
;
7212 /* We must test both. */
7213 offset
= offset_from_vma
7214 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7219 unsigned long vna_off
;
7221 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7224 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7225 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7227 vna_off
= offset
+ ivn
.vn_aux
;
7231 Elf_External_Vernaux evna
;
7233 get_data (&evna
, file
, vna_off
,
7235 _("version need aux (3)"));
7237 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7238 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7239 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7241 vna_off
+= ivna
.vna_next
;
7243 while (ivna
.vna_other
!= vers_data
7244 && ivna
.vna_next
!= 0);
7246 if (ivna
.vna_other
== vers_data
)
7249 offset
+= ivn
.vn_next
;
7251 while (ivn
.vn_next
!= 0);
7253 if (ivna
.vna_other
== vers_data
)
7256 ivna
.vna_name
< strtab_size
7257 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7261 else if (! is_nobits
)
7262 error (_("bad dynamic symbol"));
7269 if (vers_data
!= 0x8001
7270 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7272 Elf_Internal_Verdef ivd
;
7273 Elf_Internal_Verdaux ivda
;
7274 Elf_External_Verdaux evda
;
7275 unsigned long offset
;
7277 offset
= offset_from_vma
7279 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7280 sizeof (Elf_External_Verdef
));
7284 Elf_External_Verdef evd
;
7286 get_data (&evd
, file
, offset
, sizeof (evd
),
7287 1, _("version def"));
7289 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7290 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7291 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7293 offset
+= ivd
.vd_next
;
7295 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7296 && ivd
.vd_next
!= 0);
7298 offset
-= ivd
.vd_next
;
7299 offset
+= ivd
.vd_aux
;
7301 get_data (&evda
, file
, offset
, sizeof (evda
),
7302 1, _("version def aux"));
7304 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7306 if (psym
->st_name
!= ivda
.vda_name
)
7307 printf ((vers_data
& 0x8000)
7309 ivda
.vda_name
< strtab_size
7310 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7320 if (strtab
!= string_table
)
7326 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7328 if (do_histogram
&& buckets
!= NULL
)
7330 unsigned long *lengths
;
7331 unsigned long *counts
;
7334 unsigned long maxlength
= 0;
7335 unsigned long nzero_counts
= 0;
7336 unsigned long nsyms
= 0;
7338 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7339 (unsigned long) nbuckets
);
7340 printf (_(" Length Number %% of total Coverage\n"));
7342 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7343 if (lengths
== NULL
)
7345 error (_("Out of memory"));
7348 for (hn
= 0; hn
< nbuckets
; ++hn
)
7350 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7353 if (maxlength
< ++lengths
[hn
])
7358 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7361 error (_("Out of memory"));
7365 for (hn
= 0; hn
< nbuckets
; ++hn
)
7366 ++counts
[lengths
[hn
]];
7371 printf (" 0 %-10lu (%5.1f%%)\n",
7372 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7373 for (i
= 1; i
<= maxlength
; ++i
)
7375 nzero_counts
+= counts
[i
] * i
;
7376 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7377 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7378 (nzero_counts
* 100.0) / nsyms
);
7386 if (buckets
!= NULL
)
7392 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7394 unsigned char nb
[16];
7395 bfd_vma i
, maxchain
= 0xffffffff, symidx
, bitmaskwords
;
7396 unsigned long *lengths
;
7397 unsigned long *counts
;
7399 unsigned long maxlength
= 0;
7400 unsigned long nzero_counts
= 0;
7401 unsigned long nsyms
= 0;
7402 bfd_vma buckets_vma
;
7405 (archive_file_offset
7406 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7410 error (_("Unable to seek to start of dynamic information"));
7414 if (fread (nb
, 16, 1, file
) != 1)
7416 error (_("Failed to read in number of buckets\n"));
7420 ngnubuckets
= byte_get (nb
, 4);
7421 symidx
= byte_get (nb
+ 4, 4);
7422 bitmaskwords
= byte_get (nb
+ 8, 4);
7423 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7425 buckets_vma
+= bitmaskwords
* 4;
7427 buckets_vma
+= bitmaskwords
* 8;
7430 (archive_file_offset
7431 + offset_from_vma (file
, buckets_vma
, 4)),
7434 error (_("Unable to seek to start of dynamic information"));
7438 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7440 if (gnubuckets
== NULL
)
7443 for (i
= 0; i
< ngnubuckets
; i
++)
7444 if (gnubuckets
[i
] != 0)
7446 if (gnubuckets
[i
] < symidx
)
7449 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7450 maxchain
= gnubuckets
[i
];
7453 if (maxchain
== 0xffffffff)
7459 (archive_file_offset
7460 + offset_from_vma (file
, buckets_vma
7461 + 4 * (ngnubuckets
+ maxchain
), 4)),
7464 error (_("Unable to seek to start of dynamic information"));
7470 if (fread (nb
, 4, 1, file
) != 1)
7472 error (_("Failed to determine last chain length\n"));
7476 if (maxchain
+ 1 == 0)
7481 while ((byte_get (nb
, 4) & 1) == 0);
7484 (archive_file_offset
7485 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7488 error (_("Unable to seek to start of dynamic information"));
7492 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7494 if (gnuchains
== NULL
)
7497 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7498 if (lengths
== NULL
)
7500 error (_("Out of memory"));
7504 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7505 (unsigned long) ngnubuckets
);
7506 printf (_(" Length Number %% of total Coverage\n"));
7508 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7509 if (gnubuckets
[hn
] != 0)
7511 bfd_vma off
, length
= 1;
7513 for (off
= gnubuckets
[hn
] - symidx
;
7514 (gnuchains
[off
] & 1) == 0; ++off
)
7516 lengths
[hn
] = length
;
7517 if (length
> maxlength
)
7522 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7525 error (_("Out of memory"));
7529 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7530 ++counts
[lengths
[hn
]];
7532 if (ngnubuckets
> 0)
7535 printf (" 0 %-10lu (%5.1f%%)\n",
7536 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7537 for (j
= 1; j
<= maxlength
; ++j
)
7539 nzero_counts
+= counts
[j
] * j
;
7540 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7541 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7542 (nzero_counts
* 100.0) / nsyms
);
7556 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7560 if (dynamic_syminfo
== NULL
7562 /* No syminfo, this is ok. */
7565 /* There better should be a dynamic symbol section. */
7566 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7570 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7571 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7573 printf (_(" Num: Name BoundTo Flags\n"));
7574 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7576 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7578 printf ("%4d: ", i
);
7579 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7580 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7582 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7585 switch (dynamic_syminfo
[i
].si_boundto
)
7587 case SYMINFO_BT_SELF
:
7588 fputs ("SELF ", stdout
);
7590 case SYMINFO_BT_PARENT
:
7591 fputs ("PARENT ", stdout
);
7594 if (dynamic_syminfo
[i
].si_boundto
> 0
7595 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7596 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7598 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7602 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7606 if (flags
& SYMINFO_FLG_DIRECT
)
7608 if (flags
& SYMINFO_FLG_PASSTHRU
)
7609 printf (" PASSTHRU");
7610 if (flags
& SYMINFO_FLG_COPY
)
7612 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7613 printf (" LAZYLOAD");
7621 #ifdef SUPPORT_DISASSEMBLY
7623 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7625 printf (_("\nAssembly dump of section %s\n"),
7626 SECTION_NAME (section
));
7628 /* XXX -- to be done --- XXX */
7635 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7637 bfd_size_type bytes
;
7639 unsigned char *data
;
7640 unsigned char *start
;
7642 bytes
= section
->sh_size
;
7644 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7646 printf (_("\nSection '%s' has no data to dump.\n"),
7647 SECTION_NAME (section
));
7651 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7653 addr
= section
->sh_addr
;
7655 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7668 lbytes
= (bytes
> 16 ? 16 : bytes
);
7670 printf (" 0x%8.8lx ", (unsigned long) addr
);
7672 for (j
= 0; j
< 16; j
++)
7675 printf ("%2.2x", data
[j
]);
7683 for (j
= 0; j
< lbytes
; j
++)
7686 if (k
>= ' ' && k
< 0x7f)
7704 /* Apply addends of RELA relocations. */
7707 debug_apply_rela_addends (void *file
,
7708 Elf_Internal_Shdr
*section
,
7709 unsigned char *start
)
7711 Elf_Internal_Shdr
*relsec
;
7712 unsigned char *end
= start
+ section
->sh_size
;
7713 /* FIXME: The relocation field size is relocation type dependent. */
7714 unsigned int reloc_size
= 4;
7716 if (!is_relocatable
)
7719 if (section
->sh_size
< reloc_size
)
7722 for (relsec
= section_headers
;
7723 relsec
< section_headers
+ elf_header
.e_shnum
;
7726 unsigned long nrelas
;
7727 Elf_Internal_Rela
*rela
, *rp
;
7728 Elf_Internal_Shdr
*symsec
;
7729 Elf_Internal_Sym
*symtab
;
7730 Elf_Internal_Sym
*sym
;
7732 if (relsec
->sh_type
!= SHT_RELA
7733 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7734 || SECTION_HEADER (relsec
->sh_info
) != section
7735 || relsec
->sh_size
== 0
7736 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7739 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7743 symsec
= SECTION_HEADER (relsec
->sh_link
);
7744 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7746 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7750 loc
= start
+ rp
->r_offset
;
7751 if ((loc
+ reloc_size
) > end
)
7753 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7754 (unsigned long) rp
->r_offset
,
7755 SECTION_NAME (section
));
7761 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7763 if (ELF32_R_SYM (rp
->r_info
) != 0
7764 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7765 /* Relocations against symbols without type can happen.
7766 Gcc -feliminate-dwarf2-dups may generate symbols
7767 without type for debug info. */
7768 && ELF32_ST_TYPE (sym
->st_info
) != STT_NOTYPE
7769 /* Relocations against object symbols can happen,
7770 eg when referencing a global array. For an
7771 example of this see the _clz.o binary in libgcc.a. */
7772 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7774 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7775 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7776 SECTION_NAME (section
));
7782 /* In MIPS little-endian objects, r_info isn't really a
7783 64-bit little-endian value: it has a 32-bit little-endian
7784 symbol index followed by four individual byte fields.
7785 Reorder INFO accordingly. */
7786 if (elf_header
.e_machine
== EM_MIPS
7787 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7788 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7789 | ((rp
->r_info
>> 56) & 0xff)
7790 | ((rp
->r_info
>> 40) & 0xff00)
7791 | ((rp
->r_info
>> 24) & 0xff0000)
7792 | ((rp
->r_info
>> 8) & 0xff000000));
7794 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7796 if (ELF64_R_SYM (rp
->r_info
) != 0
7797 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7798 && ELF64_ST_TYPE (sym
->st_info
) != STT_NOTYPE
7799 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7801 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7802 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7803 SECTION_NAME (section
));
7808 byte_put (loc
, rp
->r_addend
, reloc_size
);
7819 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
7821 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7822 Elf_Internal_Shdr
*sec
;
7825 /* If it is already loaded, do nothing. */
7826 if (section
->start
!= NULL
)
7829 /* Locate the debug section. */
7830 sec
= find_section (section
->name
);
7834 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
7835 section
->address
= sec
->sh_addr
;
7836 section
->size
= sec
->sh_size
;
7837 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7840 if (debug_displays
[debug
].relocate
)
7841 debug_apply_rela_addends (file
, sec
, section
->start
);
7843 return section
->start
!= NULL
;
7847 free_debug_section (enum dwarf_section_display_enum debug
)
7849 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7851 if (section
->start
== NULL
)
7854 free ((char *) section
->start
);
7855 section
->start
= NULL
;
7856 section
->address
= 0;
7861 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
7863 char *name
= SECTION_NAME (section
);
7864 bfd_size_type length
;
7866 enum dwarf_section_display_enum i
;
7868 length
= section
->sh_size
;
7871 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7875 if (const_strneq (name
, ".gnu.linkonce.wi."))
7876 name
= ".debug_info";
7878 /* See if we know how to display the contents of this section. */
7879 for (i
= 0; i
< max
; i
++)
7880 if (streq (debug_displays
[i
].section
.name
, name
))
7882 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
7884 if (load_debug_section (i
, file
))
7886 result
&= debug_displays
[i
].display (sec
, file
);
7888 if (i
!= info
&& i
!= abbrev
)
7889 free_debug_section (i
);
7897 printf (_("Unrecognized debug section: %s\n"), name
);
7904 /* Set DUMP_SECTS for all sections where dumps were requested
7905 based on section name. */
7908 initialise_dumps_byname (void)
7910 struct dump_list_entry
*cur
;
7912 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
7917 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
7918 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
7920 request_dump (i
, cur
->type
);
7925 warn (_("Section '%s' was not dumped because it does not exist!\n"),
7931 process_section_contents (FILE *file
)
7933 Elf_Internal_Shdr
*section
;
7939 initialise_dumps_byname ();
7941 for (i
= 0, section
= section_headers
;
7942 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7945 #ifdef SUPPORT_DISASSEMBLY
7946 if (dump_sects
[i
] & DISASS_DUMP
)
7947 disassemble_section (section
, file
);
7949 if (dump_sects
[i
] & HEX_DUMP
)
7950 dump_section (section
, file
);
7952 if (dump_sects
[i
] & DEBUG_DUMP
)
7953 display_debug_section (section
, file
);
7956 /* Check to see if the user requested a
7957 dump of a section that does not exist. */
7958 while (i
++ < num_dump_sects
)
7960 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
7964 process_mips_fpe_exception (int mask
)
7969 if (mask
& OEX_FPU_INEX
)
7970 fputs ("INEX", stdout
), first
= 0;
7971 if (mask
& OEX_FPU_UFLO
)
7972 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7973 if (mask
& OEX_FPU_OFLO
)
7974 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7975 if (mask
& OEX_FPU_DIV0
)
7976 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7977 if (mask
& OEX_FPU_INVAL
)
7978 printf ("%sINVAL", first
? "" : "|");
7981 fputs ("0", stdout
);
7984 /* ARM EABI attributes section. */
7989 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
7992 } arm_attr_public_tag
;
7994 static const char *arm_attr_tag_CPU_arch
[] =
7995 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
7997 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
7998 static const char *arm_attr_tag_THUMB_ISA_use
[] =
7999 {"No", "Thumb-1", "Thumb-2"};
8000 /* FIXME: VFPv3 encoding was extrapolated! */
8001 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8002 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8003 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8004 static const char *arm_attr_tag_ABI_PCS_config
[] =
8005 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8006 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8007 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8008 {"V6", "SB", "TLS", "Unused"};
8009 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8010 {"Absolute", "PC-relative", "SB-relative", "None"};
8011 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8012 {"Absolute", "PC-relative", "None"};
8013 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8014 {"None", "direct", "GOT-indirect"};
8015 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8016 {"None", "??? 1", "2", "??? 3", "4"};
8017 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8018 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8019 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8020 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8021 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8022 {"Unused", "Finite", "RTABI", "IEEE 754"};
8023 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8024 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8025 {"No", "Yes, except leaf SP", "Yes"};
8026 static const char *arm_attr_tag_ABI_enum_size
[] =
8027 {"Unused", "small", "int", "forced to int"};
8028 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8029 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8030 static const char *arm_attr_tag_ABI_VFP_args
[] =
8031 {"AAPCS", "VFP registers", "custom"};
8032 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8033 {"AAPCS", "WMMX registers", "custom"};
8034 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8035 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8036 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8037 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8038 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8039 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8041 #define LOOKUP(id, name) \
8042 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8043 static arm_attr_public_tag arm_attr_public_tags
[] =
8045 {4, "CPU_raw_name", 1, NULL
},
8046 {5, "CPU_name", 1, NULL
},
8047 LOOKUP(6, CPU_arch
),
8048 {7, "CPU_arch_profile", 0, NULL
},
8049 LOOKUP(8, ARM_ISA_use
),
8050 LOOKUP(9, THUMB_ISA_use
),
8051 LOOKUP(10, VFP_arch
),
8052 LOOKUP(11, WMMX_arch
),
8053 LOOKUP(12, NEON_arch
),
8054 LOOKUP(13, ABI_PCS_config
),
8055 LOOKUP(14, ABI_PCS_R9_use
),
8056 LOOKUP(15, ABI_PCS_RW_data
),
8057 LOOKUP(16, ABI_PCS_RO_DATA
),
8058 LOOKUP(17, ABI_PCS_GOT_use
),
8059 LOOKUP(18, ABI_PCS_wchar_t
),
8060 LOOKUP(19, ABI_FP_rounding
),
8061 LOOKUP(20, ABI_FP_denormal
),
8062 LOOKUP(21, ABI_FP_exceptions
),
8063 LOOKUP(22, ABI_FP_user_exceptions
),
8064 LOOKUP(23, ABI_FP_number_model
),
8065 LOOKUP(24, ABI_align8_needed
),
8066 LOOKUP(25, ABI_align8_preserved
),
8067 LOOKUP(26, ABI_enum_size
),
8068 LOOKUP(27, ABI_HardFP_use
),
8069 LOOKUP(28, ABI_VFP_args
),
8070 LOOKUP(29, ABI_WMMX_args
),
8071 LOOKUP(30, ABI_optimization_goals
),
8072 LOOKUP(31, ABI_FP_optimization_goals
),
8073 {32, "compatibility", 0, NULL
}
8077 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8080 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8094 val
|= ((unsigned int)c
& 0x7f) << shift
;
8103 static unsigned char *
8104 display_arm_attribute (unsigned char *p
)
8109 arm_attr_public_tag
*attr
;
8113 tag
= read_uleb128 (p
, &len
);
8116 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8118 if (arm_attr_public_tags
[i
].tag
== tag
)
8120 attr
= &arm_attr_public_tags
[i
];
8127 printf (" Tag_%s: ", attr
->name
);
8133 case 7: /* Tag_CPU_arch_profile. */
8134 val
= read_uleb128 (p
, &len
);
8138 case 0: printf ("None\n"); break;
8139 case 'A': printf ("Application\n"); break;
8140 case 'R': printf ("Realtime\n"); break;
8141 case 'M': printf ("Microcontroller\n"); break;
8142 default: printf ("??? (%d)\n", val
); break;
8146 case 32: /* Tag_compatibility. */
8147 val
= read_uleb128 (p
, &len
);
8149 printf ("flag = %d, vendor = %s\n", val
, p
);
8150 p
+= strlen((char *)p
) + 1;
8164 assert (attr
->type
& 0x80);
8165 val
= read_uleb128 (p
, &len
);
8167 type
= attr
->type
& 0x7f;
8169 printf ("??? (%d)\n", val
);
8171 printf ("%s\n", attr
->table
[val
]);
8178 type
= 1; /* String. */
8180 type
= 2; /* uleb128. */
8181 printf (" Tag_unknown_%d: ", tag
);
8186 printf ("\"%s\"\n", p
);
8187 p
+= strlen((char *)p
) + 1;
8191 val
= read_uleb128 (p
, &len
);
8193 printf ("%d (0x%x)\n", val
, val
);
8200 process_arm_specific (FILE *file
)
8202 Elf_Internal_Shdr
*sect
;
8203 unsigned char *contents
;
8206 bfd_vma section_len
;
8210 /* Find the section header so that we get the size. */
8211 for (i
= 0, sect
= section_headers
;
8212 i
< elf_header
.e_shnum
;
8215 if (sect
->sh_type
!= SHT_ARM_ATTRIBUTES
)
8218 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
8226 len
= sect
->sh_size
- 1;
8231 bfd_boolean public_section
;
8233 section_len
= byte_get (p
, 4);
8235 if (section_len
> len
)
8237 printf (_("ERROR: Bad section length (%d > %d)\n"),
8238 (int)section_len
, (int)len
);
8242 printf ("Attribute Section: %s\n", p
);
8243 if (strcmp ((char *)p
, "aeabi") == 0)
8244 public_section
= TRUE
;
8246 public_section
= FALSE
;
8247 namelen
= strlen ((char *)p
) + 1;
8249 section_len
-= namelen
+ 4;
8250 while (section_len
> 0)
8255 size
= byte_get (p
, 4);
8256 if (size
> section_len
)
8258 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8259 (int)size
, (int)section_len
);
8262 section_len
-= size
;
8268 printf ("File Attributes\n");
8271 printf ("Section Attributes:");
8274 printf ("Symbol Attributes:");
8279 val
= read_uleb128 (p
, &i
);
8283 printf (" %d", val
);
8288 printf ("Unknown tag: %d\n", tag
);
8289 public_section
= FALSE
;
8295 p
= display_arm_attribute(p
);
8299 /* ??? Do something sensible, like dump hex. */
8300 printf (" Unknown section contexts\n");
8308 printf (_("Unknown format '%c'\n"), *p
);
8317 process_mips_specific (FILE *file
)
8319 Elf_Internal_Dyn
*entry
;
8320 size_t liblist_offset
= 0;
8321 size_t liblistno
= 0;
8322 size_t conflictsno
= 0;
8323 size_t options_offset
= 0;
8324 size_t conflicts_offset
= 0;
8326 /* We have a lot of special sections. Thanks SGI! */
8327 if (dynamic_section
== NULL
)
8328 /* No information available. */
8331 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
8332 switch (entry
->d_tag
)
8334 case DT_MIPS_LIBLIST
:
8336 = offset_from_vma (file
, entry
->d_un
.d_val
,
8337 liblistno
* sizeof (Elf32_External_Lib
));
8339 case DT_MIPS_LIBLISTNO
:
8340 liblistno
= entry
->d_un
.d_val
;
8342 case DT_MIPS_OPTIONS
:
8343 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8345 case DT_MIPS_CONFLICT
:
8347 = offset_from_vma (file
, entry
->d_un
.d_val
,
8348 conflictsno
* sizeof (Elf32_External_Conflict
));
8350 case DT_MIPS_CONFLICTNO
:
8351 conflictsno
= entry
->d_un
.d_val
;
8357 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8359 Elf32_External_Lib
*elib
;
8362 elib
= get_data (NULL
, file
, liblist_offset
,
8363 liblistno
, sizeof (Elf32_External_Lib
),
8367 printf ("\nSection '.liblist' contains %lu entries:\n",
8368 (unsigned long) liblistno
);
8369 fputs (" Library Time Stamp Checksum Version Flags\n",
8372 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8379 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8380 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8381 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8382 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8383 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8385 tmp
= gmtime (&time
);
8386 snprintf (timebuf
, sizeof (timebuf
),
8387 "%04u-%02u-%02uT%02u:%02u:%02u",
8388 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8389 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8391 printf ("%3lu: ", (unsigned long) cnt
);
8392 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
8393 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
8395 printf ("<corrupt: %9ld>", liblist
.l_name
);
8396 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8399 if (liblist
.l_flags
== 0)
8410 { " EXACT_MATCH", LL_EXACT_MATCH
},
8411 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8412 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8413 { " EXPORTS", LL_EXPORTS
},
8414 { " DELAY_LOAD", LL_DELAY_LOAD
},
8415 { " DELTA", LL_DELTA
}
8417 int flags
= liblist
.l_flags
;
8421 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
8423 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8425 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8426 flags
^= l_flags_vals
[fcnt
].bit
;
8429 printf (" %#x", (unsigned int) flags
);
8439 if (options_offset
!= 0)
8441 Elf_External_Options
*eopt
;
8442 Elf_Internal_Shdr
*sect
= section_headers
;
8443 Elf_Internal_Options
*iopt
;
8444 Elf_Internal_Options
*option
;
8448 /* Find the section header so that we get the size. */
8449 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8452 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8456 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8459 error (_("Out of memory"));
8466 while (offset
< sect
->sh_size
)
8468 Elf_External_Options
*eoption
;
8470 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8472 option
->kind
= BYTE_GET (eoption
->kind
);
8473 option
->size
= BYTE_GET (eoption
->size
);
8474 option
->section
= BYTE_GET (eoption
->section
);
8475 option
->info
= BYTE_GET (eoption
->info
);
8477 offset
+= option
->size
;
8483 printf (_("\nSection '%s' contains %d entries:\n"),
8484 SECTION_NAME (sect
), cnt
);
8492 switch (option
->kind
)
8495 /* This shouldn't happen. */
8496 printf (" NULL %d %lx", option
->section
, option
->info
);
8499 printf (" REGINFO ");
8500 if (elf_header
.e_machine
== EM_MIPS
)
8503 Elf32_External_RegInfo
*ereg
;
8504 Elf32_RegInfo reginfo
;
8506 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8507 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8508 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8509 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8510 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8511 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8512 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8514 printf ("GPR %08lx GP 0x%lx\n",
8516 (unsigned long) reginfo
.ri_gp_value
);
8517 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8518 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8519 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8524 Elf64_External_RegInfo
*ereg
;
8525 Elf64_Internal_RegInfo reginfo
;
8527 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8528 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8529 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8530 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8531 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8532 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8533 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8535 printf ("GPR %08lx GP 0x",
8536 reginfo
.ri_gprmask
);
8537 printf_vma (reginfo
.ri_gp_value
);
8540 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8541 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8542 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8546 case ODK_EXCEPTIONS
:
8547 fputs (" EXCEPTIONS fpe_min(", stdout
);
8548 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8549 fputs (") fpe_max(", stdout
);
8550 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8551 fputs (")", stdout
);
8553 if (option
->info
& OEX_PAGE0
)
8554 fputs (" PAGE0", stdout
);
8555 if (option
->info
& OEX_SMM
)
8556 fputs (" SMM", stdout
);
8557 if (option
->info
& OEX_FPDBUG
)
8558 fputs (" FPDBUG", stdout
);
8559 if (option
->info
& OEX_DISMISS
)
8560 fputs (" DISMISS", stdout
);
8563 fputs (" PAD ", stdout
);
8564 if (option
->info
& OPAD_PREFIX
)
8565 fputs (" PREFIX", stdout
);
8566 if (option
->info
& OPAD_POSTFIX
)
8567 fputs (" POSTFIX", stdout
);
8568 if (option
->info
& OPAD_SYMBOL
)
8569 fputs (" SYMBOL", stdout
);
8572 fputs (" HWPATCH ", stdout
);
8573 if (option
->info
& OHW_R4KEOP
)
8574 fputs (" R4KEOP", stdout
);
8575 if (option
->info
& OHW_R8KPFETCH
)
8576 fputs (" R8KPFETCH", stdout
);
8577 if (option
->info
& OHW_R5KEOP
)
8578 fputs (" R5KEOP", stdout
);
8579 if (option
->info
& OHW_R5KCVTL
)
8580 fputs (" R5KCVTL", stdout
);
8583 fputs (" FILL ", stdout
);
8584 /* XXX Print content of info word? */
8587 fputs (" TAGS ", stdout
);
8588 /* XXX Print content of info word? */
8591 fputs (" HWAND ", stdout
);
8592 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8593 fputs (" R4KEOP_CHECKED", stdout
);
8594 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8595 fputs (" R4KEOP_CLEAN", stdout
);
8598 fputs (" HWOR ", stdout
);
8599 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8600 fputs (" R4KEOP_CHECKED", stdout
);
8601 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8602 fputs (" R4KEOP_CLEAN", stdout
);
8605 printf (" GP_GROUP %#06lx self-contained %#06lx",
8606 option
->info
& OGP_GROUP
,
8607 (option
->info
& OGP_SELF
) >> 16);
8610 printf (" IDENT %#06lx self-contained %#06lx",
8611 option
->info
& OGP_GROUP
,
8612 (option
->info
& OGP_SELF
) >> 16);
8615 /* This shouldn't happen. */
8616 printf (" %3d ??? %d %lx",
8617 option
->kind
, option
->section
, option
->info
);
8621 len
= sizeof (*eopt
);
8622 while (len
< option
->size
)
8623 if (((char *) option
)[len
] >= ' '
8624 && ((char *) option
)[len
] < 0x7f)
8625 printf ("%c", ((char *) option
)[len
++]);
8627 printf ("\\%03o", ((char *) option
)[len
++]);
8629 fputs ("\n", stdout
);
8637 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8639 Elf32_Conflict
*iconf
;
8642 if (dynamic_symbols
== NULL
)
8644 error (_("conflict list found without a dynamic symbol table"));
8648 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
8651 error (_("Out of memory"));
8657 Elf32_External_Conflict
*econf32
;
8659 econf32
= get_data (NULL
, file
, conflicts_offset
,
8660 conflictsno
, sizeof (*econf32
), _("conflict"));
8664 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8665 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8671 Elf64_External_Conflict
*econf64
;
8673 econf64
= get_data (NULL
, file
, conflicts_offset
,
8674 conflictsno
, sizeof (*econf64
), _("conflict"));
8678 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8679 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8684 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8685 (unsigned long) conflictsno
);
8686 puts (_(" Num: Index Value Name"));
8688 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8690 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
8692 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8693 print_vma (psym
->st_value
, FULL_HEX
);
8695 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8696 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8698 printf ("<corrupt: %14ld>", psym
->st_name
);
8709 process_gnu_liblist (FILE *file
)
8711 Elf_Internal_Shdr
*section
, *string_sec
;
8712 Elf32_External_Lib
*elib
;
8721 for (i
= 0, section
= section_headers
;
8722 i
< elf_header
.e_shnum
;
8725 switch (section
->sh_type
)
8727 case SHT_GNU_LIBLIST
:
8728 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
8731 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
8736 string_sec
= SECTION_HEADER (section
->sh_link
);
8738 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8739 string_sec
->sh_size
, _("liblist string table"));
8740 strtab_size
= string_sec
->sh_size
;
8743 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
8749 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8750 SECTION_NAME (section
),
8751 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
8753 puts (" Library Time Stamp Checksum Version Flags");
8755 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
8763 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8764 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8765 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8766 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8767 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8769 tmp
= gmtime (&time
);
8770 snprintf (timebuf
, sizeof (timebuf
),
8771 "%04u-%02u-%02uT%02u:%02u:%02u",
8772 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8773 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8775 printf ("%3lu: ", (unsigned long) cnt
);
8777 printf ("%-20s", liblist
.l_name
< strtab_size
8778 ? strtab
+ liblist
.l_name
: "<corrupt>");
8780 printf ("%-20.20s", liblist
.l_name
< strtab_size
8781 ? strtab
+ liblist
.l_name
: "<corrupt>");
8782 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
8783 liblist
.l_version
, liblist
.l_flags
);
8794 get_note_type (unsigned e_type
)
8796 static char buff
[64];
8798 if (elf_header
.e_type
== ET_CORE
)
8802 return _("NT_AUXV (auxiliary vector)");
8804 return _("NT_PRSTATUS (prstatus structure)");
8806 return _("NT_FPREGSET (floating point registers)");
8808 return _("NT_PRPSINFO (prpsinfo structure)");
8810 return _("NT_TASKSTRUCT (task structure)");
8812 return _("NT_PRXFPREG (user_xfpregs structure)");
8814 return _("NT_PSTATUS (pstatus structure)");
8816 return _("NT_FPREGS (floating point registers)");
8818 return _("NT_PSINFO (psinfo structure)");
8820 return _("NT_LWPSTATUS (lwpstatus_t structure)");
8822 return _("NT_LWPSINFO (lwpsinfo_t structure)");
8823 case NT_WIN32PSTATUS
:
8824 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8832 return _("NT_VERSION (version)");
8834 return _("NT_ARCH (architecture)");
8839 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8844 get_netbsd_elfcore_note_type (unsigned e_type
)
8846 static char buff
[64];
8848 if (e_type
== NT_NETBSDCORE_PROCINFO
)
8850 /* NetBSD core "procinfo" structure. */
8851 return _("NetBSD procinfo structure");
8854 /* As of Jan 2002 there are no other machine-independent notes
8855 defined for NetBSD core files. If the note type is less
8856 than the start of the machine-dependent note types, we don't
8859 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
8861 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8865 switch (elf_header
.e_machine
)
8867 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8868 and PT_GETFPREGS == mach+2. */
8873 case EM_SPARC32PLUS
:
8877 case NT_NETBSDCORE_FIRSTMACH
+0:
8878 return _("PT_GETREGS (reg structure)");
8879 case NT_NETBSDCORE_FIRSTMACH
+2:
8880 return _("PT_GETFPREGS (fpreg structure)");
8886 /* On all other arch's, PT_GETREGS == mach+1 and
8887 PT_GETFPREGS == mach+3. */
8891 case NT_NETBSDCORE_FIRSTMACH
+1:
8892 return _("PT_GETREGS (reg structure)");
8893 case NT_NETBSDCORE_FIRSTMACH
+3:
8894 return _("PT_GETFPREGS (fpreg structure)");
8900 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
8901 e_type
- NT_NETBSDCORE_FIRSTMACH
);
8905 /* Note that by the ELF standard, the name field is already null byte
8906 terminated, and namesz includes the terminating null byte.
8907 I.E. the value of namesz for the name "FSF" is 4.
8909 If the value of namesz is zero, there is no name present. */
8911 process_note (Elf_Internal_Note
*pnote
)
8915 if (pnote
->namesz
== 0)
8916 /* If there is no note name, then use the default set of
8917 note type strings. */
8918 nt
= get_note_type (pnote
->type
);
8920 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
8921 /* NetBSD-specific core file notes. */
8922 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
8925 /* Don't recognize this note name; just use the default set of
8926 note type strings. */
8927 nt
= get_note_type (pnote
->type
);
8929 printf (" %s\t\t0x%08lx\t%s\n",
8930 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8937 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
8939 Elf_External_Note
*pnotes
;
8940 Elf_External_Note
*external
;
8946 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
8952 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8953 (unsigned long) offset
, (unsigned long) length
);
8954 printf (_(" Owner\t\tData size\tDescription\n"));
8956 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8958 Elf_External_Note
*next
;
8959 Elf_Internal_Note inote
;
8962 inote
.type
= BYTE_GET (external
->type
);
8963 inote
.namesz
= BYTE_GET (external
->namesz
);
8964 inote
.namedata
= external
->name
;
8965 inote
.descsz
= BYTE_GET (external
->descsz
);
8966 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8967 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8969 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8971 if (((char *) next
) > (((char *) pnotes
) + length
))
8973 warn (_("corrupt note found at offset %lx into core notes\n"),
8974 (long)((char *)external
- (char *)pnotes
));
8975 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8976 inote
.type
, inote
.namesz
, inote
.descsz
);
8982 /* Verify that name is null terminated. It appears that at least
8983 one version of Linux (RedHat 6.0) generates corefiles that don't
8984 comply with the ELF spec by failing to include the null byte in
8986 if (inote
.namedata
[inote
.namesz
] != '\0')
8988 temp
= malloc (inote
.namesz
+ 1);
8992 error (_("Out of memory\n"));
8997 strncpy (temp
, inote
.namedata
, inote
.namesz
);
8998 temp
[inote
.namesz
] = 0;
9000 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9001 inote
.namedata
= temp
;
9004 res
&= process_note (& inote
);
9019 process_corefile_note_segments (FILE *file
)
9021 Elf_Internal_Phdr
*segment
;
9025 if (! get_program_headers (file
))
9028 for (i
= 0, segment
= program_headers
;
9029 i
< elf_header
.e_phnum
;
9032 if (segment
->p_type
== PT_NOTE
)
9033 res
&= process_corefile_note_segment (file
,
9034 (bfd_vma
) segment
->p_offset
,
9035 (bfd_vma
) segment
->p_filesz
);
9042 process_note_sections (FILE *file
)
9044 Elf_Internal_Shdr
*section
;
9048 for (i
= 0, section
= section_headers
;
9049 i
< elf_header
.e_shnum
;
9051 if (section
->sh_type
== SHT_NOTE
)
9052 res
&= process_corefile_note_segment (file
,
9053 (bfd_vma
) section
->sh_offset
,
9054 (bfd_vma
) section
->sh_size
);
9060 process_notes (FILE *file
)
9062 /* If we have not been asked to display the notes then do nothing. */
9066 if (elf_header
.e_type
!= ET_CORE
)
9067 return process_note_sections (file
);
9069 /* No program headers means no NOTE segment. */
9070 if (elf_header
.e_phnum
> 0)
9071 return process_corefile_note_segments (file
);
9073 printf (_("No note segments present in the core file.\n"));
9078 process_arch_specific (FILE *file
)
9083 switch (elf_header
.e_machine
)
9086 return process_arm_specific (file
);
9088 case EM_MIPS_RS3_LE
:
9089 return process_mips_specific (file
);
9098 get_file_header (FILE *file
)
9100 /* Read in the identity array. */
9101 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9104 /* Determine how to read the rest of the header. */
9105 switch (elf_header
.e_ident
[EI_DATA
])
9107 default: /* fall through */
9108 case ELFDATANONE
: /* fall through */
9110 byte_get
= byte_get_little_endian
;
9111 byte_put
= byte_put_little_endian
;
9114 byte_get
= byte_get_big_endian
;
9115 byte_put
= byte_put_big_endian
;
9119 /* For now we only support 32 bit and 64 bit ELF files. */
9120 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9122 /* Read in the rest of the header. */
9125 Elf32_External_Ehdr ehdr32
;
9127 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9130 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9131 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9132 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9133 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9134 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9135 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9136 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9137 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9138 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9139 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9140 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9141 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9142 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9146 Elf64_External_Ehdr ehdr64
;
9148 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9149 we will not be able to cope with the 64bit data found in
9150 64 ELF files. Detect this now and abort before we start
9151 overwriting things. */
9152 if (sizeof (bfd_vma
) < 8)
9154 error (_("This instance of readelf has been built without support for a\n\
9155 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9159 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9162 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9163 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9164 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9165 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
9166 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
9167 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
9168 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9169 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9170 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9171 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9172 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9173 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9174 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9177 if (elf_header
.e_shoff
)
9179 /* There may be some extensions in the first section header. Don't
9180 bomb if we can't read it. */
9182 get_32bit_section_headers (file
, 1);
9184 get_64bit_section_headers (file
, 1);
9187 is_relocatable
= elf_header
.e_type
== ET_REL
;
9192 /* Process one ELF object file according to the command line options.
9193 This file may actually be stored in an archive. The file is
9194 positioned at the start of the ELF object. */
9197 process_object (char *file_name
, FILE *file
)
9201 if (! get_file_header (file
))
9203 error (_("%s: Failed to read file header\n"), file_name
);
9207 /* Initialise per file variables. */
9208 for (i
= NUM_ELEM (version_info
); i
--;)
9209 version_info
[i
] = 0;
9211 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9212 dynamic_info
[i
] = 0;
9214 /* Process the file. */
9216 printf (_("\nFile: %s\n"), file_name
);
9218 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9219 Note we do this even if cmdline_dump_sects is empty because we
9220 must make sure that the dump_sets array is zeroed out before each
9221 object file is processed. */
9222 if (num_dump_sects
> num_cmdline_dump_sects
)
9223 memset (dump_sects
, 0, num_dump_sects
);
9225 if (num_cmdline_dump_sects
> 0)
9227 if (num_dump_sects
== 0)
9228 /* A sneaky way of allocating the dump_sects array. */
9229 request_dump (num_cmdline_dump_sects
, 0);
9231 assert (num_dump_sects
>= num_cmdline_dump_sects
);
9232 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
9235 if (! process_file_header ())
9238 if (! process_section_headers (file
))
9240 /* Without loaded section headers we cannot process lots of
9242 do_unwind
= do_version
= do_dump
= do_arch
= 0;
9244 if (! do_using_dynamic
)
9245 do_syms
= do_reloc
= 0;
9248 if (! process_section_groups (file
))
9250 /* Without loaded section groups we cannot process unwind. */
9254 if (process_program_headers (file
))
9255 process_dynamic_section (file
);
9257 process_relocs (file
);
9259 process_unwind (file
);
9261 process_symbol_table (file
);
9263 process_syminfo (file
);
9265 process_version_sections (file
);
9267 process_section_contents (file
);
9269 process_notes (file
);
9271 process_gnu_liblist (file
);
9273 process_arch_specific (file
);
9275 if (program_headers
)
9277 free (program_headers
);
9278 program_headers
= NULL
;
9281 if (section_headers
)
9283 free (section_headers
);
9284 section_headers
= NULL
;
9289 free (string_table
);
9290 string_table
= NULL
;
9291 string_table_length
= 0;
9294 if (dynamic_strings
)
9296 free (dynamic_strings
);
9297 dynamic_strings
= NULL
;
9298 dynamic_strings_length
= 0;
9301 if (dynamic_symbols
)
9303 free (dynamic_symbols
);
9304 dynamic_symbols
= NULL
;
9305 num_dynamic_syms
= 0;
9308 if (dynamic_syminfo
)
9310 free (dynamic_syminfo
);
9311 dynamic_syminfo
= NULL
;
9314 if (section_headers_groups
)
9316 free (section_headers_groups
);
9317 section_headers_groups
= NULL
;
9322 struct group_list
*g
, *next
;
9324 for (i
= 0; i
< group_count
; i
++)
9326 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
9333 free (section_groups
);
9334 section_groups
= NULL
;
9337 free_debug_memory ();
9342 /* Process an ELF archive. The file is positioned just after the
9346 process_archive (char *file_name
, FILE *file
)
9348 struct ar_hdr arhdr
;
9351 char *longnames
= NULL
;
9352 unsigned long longnames_size
= 0;
9353 size_t file_name_size
;
9358 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9359 if (got
!= sizeof arhdr
)
9364 error (_("%s: failed to read archive header\n"), file_name
);
9368 if (const_strneq (arhdr
.ar_name
, "/ "))
9370 /* This is the archive symbol table. Skip it.
9371 FIXME: We should have an option to dump it. */
9372 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9373 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
9375 error (_("%s: failed to skip archive symbol table\n"), file_name
);
9379 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9380 if (got
!= sizeof arhdr
)
9385 error (_("%s: failed to read archive header\n"), file_name
);
9390 if (const_strneq (arhdr
.ar_name
, "// "))
9392 /* This is the archive string table holding long member
9395 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9397 longnames
= malloc (longnames_size
);
9398 if (longnames
== NULL
)
9400 error (_("Out of memory\n"));
9404 if (fread (longnames
, longnames_size
, 1, file
) != 1)
9407 error (_("%s: failed to read string table\n"), file_name
);
9411 if ((longnames_size
& 1) != 0)
9414 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9415 if (got
!= sizeof arhdr
)
9422 error (_("%s: failed to read archive header\n"), file_name
);
9427 file_name_size
= strlen (file_name
);
9436 if (arhdr
.ar_name
[0] == '/')
9440 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
9441 if (off
>= longnames_size
)
9443 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
9448 name
= longnames
+ off
;
9449 nameend
= memchr (name
, '/', longnames_size
- off
);
9453 name
= arhdr
.ar_name
;
9454 nameend
= memchr (name
, '/', 16);
9457 if (nameend
== NULL
)
9459 error (_("%s: bad archive file name\n"), file_name
);
9464 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
9465 if (namealc
== NULL
)
9467 error (_("Out of memory\n"));
9472 memcpy (namealc
, file_name
, file_name_size
);
9473 namealc
[file_name_size
] = '(';
9474 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
9475 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
9476 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
9478 archive_file_offset
= ftell (file
);
9479 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9481 ret
|= process_object (namealc
, file
);
9486 (archive_file_offset
9488 + (archive_file_size
& 1)),
9491 error (_("%s: failed to seek to next archive header\n"), file_name
);
9496 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9497 if (got
!= sizeof arhdr
)
9502 error (_("%s: failed to read archive header\n"), file_name
);
9515 process_file (char *file_name
)
9518 struct stat statbuf
;
9522 if (stat (file_name
, &statbuf
) < 0)
9524 if (errno
== ENOENT
)
9525 error (_("'%s': No such file\n"), file_name
);
9527 error (_("Could not locate '%s'. System error message: %s\n"),
9528 file_name
, strerror (errno
));
9532 if (! S_ISREG (statbuf
.st_mode
))
9534 error (_("'%s' is not an ordinary file\n"), file_name
);
9538 file
= fopen (file_name
, "rb");
9541 error (_("Input file '%s' is not readable.\n"), file_name
);
9545 if (fread (armag
, SARMAG
, 1, file
) != 1)
9547 error (_("%s: Failed to read file header\n"), file_name
);
9552 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
9553 ret
= process_archive (file_name
, file
);
9557 archive_file_size
= archive_file_offset
= 0;
9558 ret
= process_object (file_name
, file
);
9566 #ifdef SUPPORT_DISASSEMBLY
9567 /* Needed by the i386 disassembler. For extra credit, someone could
9568 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9572 print_address (unsigned int addr
, FILE *outfile
)
9574 fprintf (outfile
,"0x%8.8x", addr
);
9577 /* Needed by the i386 disassembler. */
9579 db_task_printsym (unsigned int addr
)
9581 print_address (addr
, stderr
);
9586 main (int argc
, char **argv
)
9590 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9591 setlocale (LC_MESSAGES
, "");
9593 #if defined (HAVE_SETLOCALE)
9594 setlocale (LC_CTYPE
, "");
9596 bindtextdomain (PACKAGE
, LOCALEDIR
);
9597 textdomain (PACKAGE
);
9599 expandargv (&argc
, &argv
);
9601 parse_args (argc
, argv
);
9603 if (num_dump_sects
> 0)
9605 /* Make a copy of the dump_sects array. */
9606 cmdline_dump_sects
= malloc (num_dump_sects
);
9607 if (cmdline_dump_sects
== NULL
)
9608 error (_("Out of memory allocating dump request table."));
9611 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
9612 num_cmdline_dump_sects
= num_dump_sects
;
9616 if (optind
< (argc
- 1))
9620 while (optind
< argc
)
9621 err
|= process_file (argv
[optind
++]);
9623 if (dump_sects
!= NULL
)
9625 if (cmdline_dump_sects
!= NULL
)
9626 free (cmdline_dump_sects
);