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");
2021 char const *isa
= _("unknown");
2022 char const *mac
= _("unknown mac");
2023 char const *additional
= NULL
;
2025 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2027 case EF_M68K_CF_ISA_A_NODIV
:
2029 additional
= ", nodiv";
2031 case EF_M68K_CF_ISA_A
:
2034 case EF_M68K_CF_ISA_A_PLUS
:
2037 case EF_M68K_CF_ISA_B_NOUSP
:
2039 additional
= ", nousp";
2041 case EF_M68K_CF_ISA_B
:
2045 strcat (buf
, ", cf, isa ");
2048 strcat (buf
, additional
);
2049 if (e_flags
& EF_M68K_CF_FLOAT
)
2050 strcat (buf
, ", float");
2051 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2056 case EF_M68K_CF_MAC
:
2059 case EF_M68K_CF_EMAC
:
2072 if (e_flags
& EF_PPC_EMB
)
2073 strcat (buf
, ", emb");
2075 if (e_flags
& EF_PPC_RELOCATABLE
)
2076 strcat (buf
, ", relocatable");
2078 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2079 strcat (buf
, ", relocatable-lib");
2083 case EM_CYGNUS_V850
:
2084 switch (e_flags
& EF_V850_ARCH
)
2087 strcat (buf
, ", v850e1");
2090 strcat (buf
, ", v850e");
2093 strcat (buf
, ", v850");
2096 strcat (buf
, ", unknown v850 architecture variant");
2102 case EM_CYGNUS_M32R
:
2103 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2104 strcat (buf
, ", m32r");
2108 case EM_MIPS_RS3_LE
:
2109 if (e_flags
& EF_MIPS_NOREORDER
)
2110 strcat (buf
, ", noreorder");
2112 if (e_flags
& EF_MIPS_PIC
)
2113 strcat (buf
, ", pic");
2115 if (e_flags
& EF_MIPS_CPIC
)
2116 strcat (buf
, ", cpic");
2118 if (e_flags
& EF_MIPS_UCODE
)
2119 strcat (buf
, ", ugen_reserved");
2121 if (e_flags
& EF_MIPS_ABI2
)
2122 strcat (buf
, ", abi2");
2124 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2125 strcat (buf
, ", odk first");
2127 if (e_flags
& EF_MIPS_32BITMODE
)
2128 strcat (buf
, ", 32bitmode");
2130 switch ((e_flags
& EF_MIPS_MACH
))
2132 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2133 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2134 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2135 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2136 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2137 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2138 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2139 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2140 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2141 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2143 /* We simply ignore the field in this case to avoid confusion:
2144 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2147 default: strcat (buf
, ", unknown CPU"); break;
2150 switch ((e_flags
& EF_MIPS_ABI
))
2152 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2153 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2154 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2155 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2157 /* We simply ignore the field in this case to avoid confusion:
2158 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2159 This means it is likely to be an o32 file, but not for
2162 default: strcat (buf
, ", unknown ABI"); break;
2165 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2166 strcat (buf
, ", mdmx");
2168 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2169 strcat (buf
, ", mips16");
2171 switch ((e_flags
& EF_MIPS_ARCH
))
2173 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2174 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2175 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2176 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2177 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2178 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2179 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2180 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2181 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2182 default: strcat (buf
, ", unknown ISA"); break;
2188 switch ((e_flags
& EF_SH_MACH_MASK
))
2190 case EF_SH1
: strcat (buf
, ", sh1"); break;
2191 case EF_SH2
: strcat (buf
, ", sh2"); break;
2192 case EF_SH3
: strcat (buf
, ", sh3"); break;
2193 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2194 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2195 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2196 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2197 case EF_SH4
: strcat (buf
, ", sh4"); break;
2198 case EF_SH5
: strcat (buf
, ", sh5"); break;
2199 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2200 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2201 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2202 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2203 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2204 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2205 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2206 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2207 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2208 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2209 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2210 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2211 default: strcat (buf
, ", unknown ISA"); break;
2217 if (e_flags
& EF_SPARC_32PLUS
)
2218 strcat (buf
, ", v8+");
2220 if (e_flags
& EF_SPARC_SUN_US1
)
2221 strcat (buf
, ", ultrasparcI");
2223 if (e_flags
& EF_SPARC_SUN_US3
)
2224 strcat (buf
, ", ultrasparcIII");
2226 if (e_flags
& EF_SPARC_HAL_R1
)
2227 strcat (buf
, ", halr1");
2229 if (e_flags
& EF_SPARC_LEDATA
)
2230 strcat (buf
, ", ledata");
2232 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2233 strcat (buf
, ", tso");
2235 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2236 strcat (buf
, ", pso");
2238 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2239 strcat (buf
, ", rmo");
2243 switch (e_flags
& EF_PARISC_ARCH
)
2245 case EFA_PARISC_1_0
:
2246 strcpy (buf
, ", PA-RISC 1.0");
2248 case EFA_PARISC_1_1
:
2249 strcpy (buf
, ", PA-RISC 1.1");
2251 case EFA_PARISC_2_0
:
2252 strcpy (buf
, ", PA-RISC 2.0");
2257 if (e_flags
& EF_PARISC_TRAPNIL
)
2258 strcat (buf
, ", trapnil");
2259 if (e_flags
& EF_PARISC_EXT
)
2260 strcat (buf
, ", ext");
2261 if (e_flags
& EF_PARISC_LSB
)
2262 strcat (buf
, ", lsb");
2263 if (e_flags
& EF_PARISC_WIDE
)
2264 strcat (buf
, ", wide");
2265 if (e_flags
& EF_PARISC_NO_KABP
)
2266 strcat (buf
, ", no kabp");
2267 if (e_flags
& EF_PARISC_LAZYSWAP
)
2268 strcat (buf
, ", lazyswap");
2273 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2274 strcat (buf
, ", new calling convention");
2276 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2277 strcat (buf
, ", gnu calling convention");
2281 if ((e_flags
& EF_IA_64_ABI64
))
2282 strcat (buf
, ", 64-bit");
2284 strcat (buf
, ", 32-bit");
2285 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2286 strcat (buf
, ", reduced fp model");
2287 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2288 strcat (buf
, ", no function descriptors, constant gp");
2289 else if ((e_flags
& EF_IA_64_CONS_GP
))
2290 strcat (buf
, ", constant gp");
2291 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2292 strcat (buf
, ", absolute");
2296 if ((e_flags
& EF_VAX_NONPIC
))
2297 strcat (buf
, ", non-PIC");
2298 if ((e_flags
& EF_VAX_DFLOAT
))
2299 strcat (buf
, ", D-Float");
2300 if ((e_flags
& EF_VAX_GFLOAT
))
2301 strcat (buf
, ", G-Float");
2310 get_osabi_name (unsigned int osabi
)
2312 static char buff
[32];
2316 case ELFOSABI_NONE
: return "UNIX - System V";
2317 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2318 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2319 case ELFOSABI_LINUX
: return "UNIX - Linux";
2320 case ELFOSABI_HURD
: return "GNU/Hurd";
2321 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2322 case ELFOSABI_AIX
: return "UNIX - AIX";
2323 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2324 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2325 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2326 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2327 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2328 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2329 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2330 case ELFOSABI_AROS
: return "Amiga Research OS";
2331 case ELFOSABI_STANDALONE
: return _("Standalone App");
2332 case ELFOSABI_ARM
: return "ARM";
2334 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2340 get_arm_segment_type (unsigned long type
)
2354 get_mips_segment_type (unsigned long type
)
2358 case PT_MIPS_REGINFO
:
2360 case PT_MIPS_RTPROC
:
2362 case PT_MIPS_OPTIONS
:
2372 get_parisc_segment_type (unsigned long type
)
2376 case PT_HP_TLS
: return "HP_TLS";
2377 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2378 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2379 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2380 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2381 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2382 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2383 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2384 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2385 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2386 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2387 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2388 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2389 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2390 case PT_HP_STACK
: return "HP_STACK";
2391 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2392 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2393 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2394 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2403 get_ia64_segment_type (unsigned long type
)
2407 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2408 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2409 case PT_HP_TLS
: return "HP_TLS";
2410 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2411 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2412 case PT_IA_64_HP_STACK
: return "HP_STACK";
2421 get_segment_type (unsigned long p_type
)
2423 static char buff
[32];
2427 case PT_NULL
: return "NULL";
2428 case PT_LOAD
: return "LOAD";
2429 case PT_DYNAMIC
: return "DYNAMIC";
2430 case PT_INTERP
: return "INTERP";
2431 case PT_NOTE
: return "NOTE";
2432 case PT_SHLIB
: return "SHLIB";
2433 case PT_PHDR
: return "PHDR";
2434 case PT_TLS
: return "TLS";
2436 case PT_GNU_EH_FRAME
:
2437 return "GNU_EH_FRAME";
2438 case PT_GNU_STACK
: return "GNU_STACK";
2439 case PT_GNU_RELRO
: return "GNU_RELRO";
2442 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2446 switch (elf_header
.e_machine
)
2449 result
= get_arm_segment_type (p_type
);
2452 case EM_MIPS_RS3_LE
:
2453 result
= get_mips_segment_type (p_type
);
2456 result
= get_parisc_segment_type (p_type
);
2459 result
= get_ia64_segment_type (p_type
);
2469 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2471 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2475 switch (elf_header
.e_machine
)
2478 result
= get_parisc_segment_type (p_type
);
2481 result
= get_ia64_segment_type (p_type
);
2491 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2494 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2501 get_mips_section_type_name (unsigned int sh_type
)
2505 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2506 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2507 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2508 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2509 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2510 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2511 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2512 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2513 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2514 case SHT_MIPS_RELD
: return "MIPS_RELD";
2515 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2516 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2517 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2518 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2519 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2520 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2521 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2522 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2523 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2524 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2525 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2526 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2527 case SHT_MIPS_LINE
: return "MIPS_LINE";
2528 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2529 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2530 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2531 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2532 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2533 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2534 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2535 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2536 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2537 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2538 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2539 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2540 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2541 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2542 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2543 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2551 get_parisc_section_type_name (unsigned int sh_type
)
2555 case SHT_PARISC_EXT
: return "PARISC_EXT";
2556 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2557 case SHT_PARISC_DOC
: return "PARISC_DOC";
2558 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2559 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2560 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2561 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2569 get_ia64_section_type_name (unsigned int sh_type
)
2571 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2572 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2573 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2577 case SHT_IA_64_EXT
: return "IA_64_EXT";
2578 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2579 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2587 get_x86_64_section_type_name (unsigned int sh_type
)
2591 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2599 get_arm_section_type_name (unsigned int sh_type
)
2605 case SHT_ARM_PREEMPTMAP
:
2606 return "ARM_PREEMPTMAP";
2607 case SHT_ARM_ATTRIBUTES
:
2608 return "ARM_ATTRIBUTES";
2616 get_section_type_name (unsigned int sh_type
)
2618 static char buff
[32];
2622 case SHT_NULL
: return "NULL";
2623 case SHT_PROGBITS
: return "PROGBITS";
2624 case SHT_SYMTAB
: return "SYMTAB";
2625 case SHT_STRTAB
: return "STRTAB";
2626 case SHT_RELA
: return "RELA";
2627 case SHT_HASH
: return "HASH";
2628 case SHT_DYNAMIC
: return "DYNAMIC";
2629 case SHT_NOTE
: return "NOTE";
2630 case SHT_NOBITS
: return "NOBITS";
2631 case SHT_REL
: return "REL";
2632 case SHT_SHLIB
: return "SHLIB";
2633 case SHT_DYNSYM
: return "DYNSYM";
2634 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2635 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2636 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2637 case SHT_GNU_HASH
: return "GNU_HASH";
2638 case SHT_GROUP
: return "GROUP";
2639 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2640 case SHT_GNU_verdef
: return "VERDEF";
2641 case SHT_GNU_verneed
: return "VERNEED";
2642 case SHT_GNU_versym
: return "VERSYM";
2643 case 0x6ffffff0: return "VERSYM";
2644 case 0x6ffffffc: return "VERDEF";
2645 case 0x7ffffffd: return "AUXILIARY";
2646 case 0x7fffffff: return "FILTER";
2647 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2650 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2654 switch (elf_header
.e_machine
)
2657 case EM_MIPS_RS3_LE
:
2658 result
= get_mips_section_type_name (sh_type
);
2661 result
= get_parisc_section_type_name (sh_type
);
2664 result
= get_ia64_section_type_name (sh_type
);
2667 result
= get_x86_64_section_type_name (sh_type
);
2670 result
= get_arm_section_type_name (sh_type
);
2680 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2682 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2683 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2684 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2685 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2687 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2693 #define OPTION_DEBUG_DUMP 512
2695 static struct option options
[] =
2697 {"all", no_argument
, 0, 'a'},
2698 {"file-header", no_argument
, 0, 'h'},
2699 {"program-headers", no_argument
, 0, 'l'},
2700 {"headers", no_argument
, 0, 'e'},
2701 {"histogram", no_argument
, 0, 'I'},
2702 {"segments", no_argument
, 0, 'l'},
2703 {"sections", no_argument
, 0, 'S'},
2704 {"section-headers", no_argument
, 0, 'S'},
2705 {"section-groups", no_argument
, 0, 'g'},
2706 {"section-details", no_argument
, 0, 't'},
2707 {"full-section-name",no_argument
, 0, 'N'},
2708 {"symbols", no_argument
, 0, 's'},
2709 {"syms", no_argument
, 0, 's'},
2710 {"relocs", no_argument
, 0, 'r'},
2711 {"notes", no_argument
, 0, 'n'},
2712 {"dynamic", no_argument
, 0, 'd'},
2713 {"arch-specific", no_argument
, 0, 'A'},
2714 {"version-info", no_argument
, 0, 'V'},
2715 {"use-dynamic", no_argument
, 0, 'D'},
2716 {"hex-dump", required_argument
, 0, 'x'},
2717 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2718 {"unwind", no_argument
, 0, 'u'},
2719 #ifdef SUPPORT_DISASSEMBLY
2720 {"instruction-dump", required_argument
, 0, 'i'},
2723 {"version", no_argument
, 0, 'v'},
2724 {"wide", no_argument
, 0, 'W'},
2725 {"help", no_argument
, 0, 'H'},
2726 {0, no_argument
, 0, 0}
2732 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2733 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2734 fprintf (stdout
, _(" Options are:\n\
2735 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2736 -h --file-header Display the ELF file header\n\
2737 -l --program-headers Display the program headers\n\
2738 --segments An alias for --program-headers\n\
2739 -S --section-headers Display the sections' header\n\
2740 --sections An alias for --section-headers\n\
2741 -g --section-groups Display the section groups\n\
2742 -t --section-details Display the section details\n\
2743 -e --headers Equivalent to: -h -l -S\n\
2744 -s --syms Display the symbol table\n\
2745 --symbols An alias for --syms\n\
2746 -n --notes Display the core notes (if present)\n\
2747 -r --relocs Display the relocations (if present)\n\
2748 -u --unwind Display the unwind info (if present)\n\
2749 -d --dynamic Display the dynamic section (if present)\n\
2750 -V --version-info Display the version sections (if present)\n\
2751 -A --arch-specific Display architecture specific information (if any).\n\
2752 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2753 -x --hex-dump=<number> Dump the contents of section <number>\n\
2754 -w[liaprmfFsoR] or\n\
2755 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2756 Display the contents of DWARF2 debug sections\n"));
2757 #ifdef SUPPORT_DISASSEMBLY
2758 fprintf (stdout
, _("\
2759 -i --instruction-dump=<number>\n\
2760 Disassemble the contents of section <number>\n"));
2762 fprintf (stdout
, _("\
2763 -I --histogram Display histogram of bucket list lengths\n\
2764 -W --wide Allow output width to exceed 80 characters\n\
2765 @<file> Read options from <file>\n\
2766 -H --help Display this information\n\
2767 -v --version Display the version number of readelf\n"));
2768 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2773 /* Record the fact that the user wants the contents of section number
2774 SECTION to be displayed using the method(s) encoded as flags bits
2775 in TYPE. Note, TYPE can be zero if we are creating the array for
2779 request_dump (unsigned int section
, int type
)
2781 if (section
>= num_dump_sects
)
2783 char *new_dump_sects
;
2785 new_dump_sects
= calloc (section
+ 1, 1);
2787 if (new_dump_sects
== NULL
)
2788 error (_("Out of memory allocating dump request table."));
2791 /* Copy current flag settings. */
2792 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2796 dump_sects
= new_dump_sects
;
2797 num_dump_sects
= section
+ 1;
2802 dump_sects
[section
] |= type
;
2807 /* Request a dump by section name. */
2810 request_dump_byname (const char *section
, int type
)
2812 struct dump_list_entry
*new_request
;
2814 new_request
= malloc (sizeof (struct dump_list_entry
));
2816 error (_("Out of memory allocating dump request table."));
2818 new_request
->name
= strdup (section
);
2819 if (!new_request
->name
)
2820 error (_("Out of memory allocating dump request table."));
2822 new_request
->type
= type
;
2824 new_request
->next
= dump_sects_byname
;
2825 dump_sects_byname
= new_request
;
2829 parse_args (int argc
, char **argv
)
2836 while ((c
= getopt_long
2837 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2858 do_section_groups
++;
2866 do_section_groups
++;
2871 do_section_details
++;
2913 section
= strtoul (optarg
, & cp
, 0);
2914 if (! *cp
&& section
>= 0)
2915 request_dump (section
, HEX_DUMP
);
2917 request_dump_byname (optarg
, HEX_DUMP
);
2925 unsigned int index
= 0;
2929 while (optarg
[index
])
2930 switch (optarg
[index
++])
2939 do_debug_abbrevs
= 1;
2949 do_debug_pubnames
= 1;
2953 do_debug_aranges
= 1;
2957 do_debug_ranges
= 1;
2961 do_debug_frames_interp
= 1;
2963 do_debug_frames
= 1;
2968 do_debug_macinfo
= 1;
2982 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2987 case OPTION_DEBUG_DUMP
:
2995 const char * option
;
2998 debug_dump_long_opts
;
3000 debug_dump_long_opts opts_table
[] =
3002 /* Please keep this table alpha- sorted. */
3003 { "Ranges", & do_debug_ranges
},
3004 { "abbrev", & do_debug_abbrevs
},
3005 { "aranges", & do_debug_aranges
},
3006 { "frames", & do_debug_frames
},
3007 { "frames-interp", & do_debug_frames_interp
},
3008 { "info", & do_debug_info
},
3009 { "line", & do_debug_lines
},
3010 { "loc", & do_debug_loc
},
3011 { "macro", & do_debug_macinfo
},
3012 { "pubnames", & do_debug_pubnames
},
3013 /* This entry is for compatability
3014 with earlier versions of readelf. */
3015 { "ranges", & do_debug_aranges
},
3016 { "str", & do_debug_str
},
3027 debug_dump_long_opts
* entry
;
3029 for (entry
= opts_table
; entry
->option
; entry
++)
3031 size_t len
= strlen (entry
->option
);
3033 if (strneq (p
, entry
->option
, len
)
3034 && (p
[len
] == ',' || p
[len
] == '\0'))
3036 * entry
->variable
= 1;
3038 /* The --debug-dump=frames-interp option also
3039 enables the --debug-dump=frames option. */
3040 if (do_debug_frames_interp
)
3041 do_debug_frames
= 1;
3048 if (entry
->option
== NULL
)
3050 warn (_("Unrecognized debug option '%s'\n"), p
);
3051 p
= strchr (p
, ',');
3061 #ifdef SUPPORT_DISASSEMBLY
3064 section
= strtoul (optarg
, & cp
, 0);
3065 if (! *cp
&& section
>= 0)
3067 request_dump (section
, DISASS_DUMP
);
3073 print_version (program_name
);
3082 #ifdef SUPPORT_DISASSEMBLY
3085 /* xgettext:c-format */
3086 error (_("Invalid option '-%c'\n"), c
);
3093 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3094 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3095 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3096 && !do_section_groups
)
3100 warn (_("Nothing to do.\n"));
3106 get_elf_class (unsigned int elf_class
)
3108 static char buff
[32];
3112 case ELFCLASSNONE
: return _("none");
3113 case ELFCLASS32
: return "ELF32";
3114 case ELFCLASS64
: return "ELF64";
3116 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3122 get_data_encoding (unsigned int encoding
)
3124 static char buff
[32];
3128 case ELFDATANONE
: return _("none");
3129 case ELFDATA2LSB
: return _("2's complement, little endian");
3130 case ELFDATA2MSB
: return _("2's complement, big endian");
3132 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3137 /* Decode the data held in 'elf_header'. */
3140 process_file_header (void)
3142 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3143 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3144 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3145 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3148 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3156 printf (_("ELF Header:\n"));
3157 printf (_(" Magic: "));
3158 for (i
= 0; i
< EI_NIDENT
; i
++)
3159 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3161 printf (_(" Class: %s\n"),
3162 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3163 printf (_(" Data: %s\n"),
3164 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3165 printf (_(" Version: %d %s\n"),
3166 elf_header
.e_ident
[EI_VERSION
],
3167 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3169 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3172 printf (_(" OS/ABI: %s\n"),
3173 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3174 printf (_(" ABI Version: %d\n"),
3175 elf_header
.e_ident
[EI_ABIVERSION
]);
3176 printf (_(" Type: %s\n"),
3177 get_file_type (elf_header
.e_type
));
3178 printf (_(" Machine: %s\n"),
3179 get_machine_name (elf_header
.e_machine
));
3180 printf (_(" Version: 0x%lx\n"),
3181 (unsigned long) elf_header
.e_version
);
3183 printf (_(" Entry point address: "));
3184 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3185 printf (_("\n Start of program headers: "));
3186 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3187 printf (_(" (bytes into file)\n Start of section headers: "));
3188 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3189 printf (_(" (bytes into file)\n"));
3191 printf (_(" Flags: 0x%lx%s\n"),
3192 (unsigned long) elf_header
.e_flags
,
3193 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3194 printf (_(" Size of this header: %ld (bytes)\n"),
3195 (long) elf_header
.e_ehsize
);
3196 printf (_(" Size of program headers: %ld (bytes)\n"),
3197 (long) elf_header
.e_phentsize
);
3198 printf (_(" Number of program headers: %ld\n"),
3199 (long) elf_header
.e_phnum
);
3200 printf (_(" Size of section headers: %ld (bytes)\n"),
3201 (long) elf_header
.e_shentsize
);
3202 printf (_(" Number of section headers: %ld"),
3203 (long) elf_header
.e_shnum
);
3204 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3205 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3206 putc ('\n', stdout
);
3207 printf (_(" Section header string table index: %ld"),
3208 (long) elf_header
.e_shstrndx
);
3209 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3210 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3211 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3212 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3213 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3214 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3215 printf (" <corrupt: out of range>");
3216 putc ('\n', stdout
);
3219 if (section_headers
!= NULL
)
3221 if (elf_header
.e_shnum
== 0)
3222 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3223 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3224 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3225 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3226 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3227 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3228 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3229 elf_header
.e_shstrndx
= SHN_UNDEF
;
3230 free (section_headers
);
3231 section_headers
= NULL
;
3239 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3241 Elf32_External_Phdr
*phdrs
;
3242 Elf32_External_Phdr
*external
;
3243 Elf_Internal_Phdr
*internal
;
3246 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3247 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3248 _("program headers"));
3252 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3253 i
< elf_header
.e_phnum
;
3254 i
++, internal
++, external
++)
3256 internal
->p_type
= BYTE_GET (external
->p_type
);
3257 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3258 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3259 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3260 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3261 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3262 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3263 internal
->p_align
= BYTE_GET (external
->p_align
);
3272 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3274 Elf64_External_Phdr
*phdrs
;
3275 Elf64_External_Phdr
*external
;
3276 Elf_Internal_Phdr
*internal
;
3279 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3280 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3281 _("program headers"));
3285 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3286 i
< elf_header
.e_phnum
;
3287 i
++, internal
++, external
++)
3289 internal
->p_type
= BYTE_GET (external
->p_type
);
3290 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3291 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3292 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3293 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3294 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3295 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3296 internal
->p_align
= BYTE_GET (external
->p_align
);
3304 /* Returns 1 if the program headers were read into `program_headers'. */
3307 get_program_headers (FILE *file
)
3309 Elf_Internal_Phdr
*phdrs
;
3311 /* Check cache of prior read. */
3312 if (program_headers
!= NULL
)
3315 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3319 error (_("Out of memory\n"));
3324 ? get_32bit_program_headers (file
, phdrs
)
3325 : get_64bit_program_headers (file
, phdrs
))
3327 program_headers
= phdrs
;
3335 /* Returns 1 if the program headers were loaded. */
3338 process_program_headers (FILE *file
)
3340 Elf_Internal_Phdr
*segment
;
3343 if (elf_header
.e_phnum
== 0)
3346 printf (_("\nThere are no program headers in this file.\n"));
3350 if (do_segments
&& !do_header
)
3352 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3353 printf (_("Entry point "));
3354 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3355 printf (_("\nThere are %d program headers, starting at offset "),
3356 elf_header
.e_phnum
);
3357 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3361 if (! get_program_headers (file
))
3366 if (elf_header
.e_phnum
> 1)
3367 printf (_("\nProgram Headers:\n"));
3369 printf (_("\nProgram Headers:\n"));
3373 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3376 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3380 (_(" Type Offset VirtAddr PhysAddr\n"));
3382 (_(" FileSiz MemSiz Flags Align\n"));
3389 for (i
= 0, segment
= program_headers
;
3390 i
< elf_header
.e_phnum
;
3395 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3399 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3400 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3401 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3402 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3403 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3405 (segment
->p_flags
& PF_R
? 'R' : ' '),
3406 (segment
->p_flags
& PF_W
? 'W' : ' '),
3407 (segment
->p_flags
& PF_X
? 'E' : ' '));
3408 printf ("%#lx", (unsigned long) segment
->p_align
);
3412 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3413 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3416 print_vma (segment
->p_offset
, FULL_HEX
);
3420 print_vma (segment
->p_vaddr
, FULL_HEX
);
3422 print_vma (segment
->p_paddr
, FULL_HEX
);
3425 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3426 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3429 print_vma (segment
->p_filesz
, FULL_HEX
);
3433 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3434 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3437 print_vma (segment
->p_offset
, FULL_HEX
);
3441 (segment
->p_flags
& PF_R
? 'R' : ' '),
3442 (segment
->p_flags
& PF_W
? 'W' : ' '),
3443 (segment
->p_flags
& PF_X
? 'E' : ' '));
3445 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3446 printf ("%#lx", (unsigned long) segment
->p_align
);
3449 print_vma (segment
->p_align
, PREFIX_HEX
);
3454 print_vma (segment
->p_offset
, FULL_HEX
);
3456 print_vma (segment
->p_vaddr
, FULL_HEX
);
3458 print_vma (segment
->p_paddr
, FULL_HEX
);
3460 print_vma (segment
->p_filesz
, FULL_HEX
);
3462 print_vma (segment
->p_memsz
, FULL_HEX
);
3464 (segment
->p_flags
& PF_R
? 'R' : ' '),
3465 (segment
->p_flags
& PF_W
? 'W' : ' '),
3466 (segment
->p_flags
& PF_X
? 'E' : ' '));
3467 print_vma (segment
->p_align
, HEX
);
3471 switch (segment
->p_type
)
3475 error (_("more than one dynamic segment\n"));
3477 /* Try to locate the .dynamic section. If there is
3478 a section header table, we can easily locate it. */
3479 if (section_headers
!= NULL
)
3481 Elf_Internal_Shdr
*sec
;
3483 sec
= find_section (".dynamic");
3484 if (sec
== NULL
|| sec
->sh_size
== 0)
3486 error (_("no .dynamic section in the dynamic segment"));
3490 dynamic_addr
= sec
->sh_offset
;
3491 dynamic_size
= sec
->sh_size
;
3493 if (dynamic_addr
< segment
->p_offset
3494 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3495 warn (_("the .dynamic section is not contained within the dynamic segment"));
3496 else if (dynamic_addr
> segment
->p_offset
)
3497 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3501 /* Otherwise, we can only assume that the .dynamic
3502 section is the first section in the DYNAMIC segment. */
3503 dynamic_addr
= segment
->p_offset
;
3504 dynamic_size
= segment
->p_filesz
;
3509 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3511 error (_("Unable to find program interpreter name\n"));
3515 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3517 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3518 error (_("Internal error: failed to create format string to display program interpreter"));
3520 program_interpreter
[0] = 0;
3521 fscanf (file
, fmt
, program_interpreter
);
3524 printf (_("\n [Requesting program interpreter: %s]"),
3525 program_interpreter
);
3531 putc ('\n', stdout
);
3534 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3536 printf (_("\n Section to Segment mapping:\n"));
3537 printf (_(" Segment Sections...\n"));
3539 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3542 Elf_Internal_Shdr
*section
;
3544 segment
= program_headers
+ i
;
3545 section
= section_headers
;
3547 printf (" %2.2d ", i
);
3549 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3551 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3552 printf ("%s ", SECTION_NAME (section
));
3563 /* Find the file offset corresponding to VMA by using the program headers. */
3566 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3568 Elf_Internal_Phdr
*seg
;
3570 if (! get_program_headers (file
))
3572 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3576 for (seg
= program_headers
;
3577 seg
< program_headers
+ elf_header
.e_phnum
;
3580 if (seg
->p_type
!= PT_LOAD
)
3583 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3584 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3585 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3588 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3595 get_32bit_section_headers (FILE *file
, unsigned int num
)
3597 Elf32_External_Shdr
*shdrs
;
3598 Elf_Internal_Shdr
*internal
;
3601 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3602 elf_header
.e_shentsize
, num
, _("section headers"));
3606 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3608 if (section_headers
== NULL
)
3610 error (_("Out of memory\n"));
3614 for (i
= 0, internal
= section_headers
;
3618 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3619 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3620 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3621 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3622 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3623 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3624 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3625 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3626 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3627 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3636 get_64bit_section_headers (FILE *file
, unsigned int num
)
3638 Elf64_External_Shdr
*shdrs
;
3639 Elf_Internal_Shdr
*internal
;
3642 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3643 elf_header
.e_shentsize
, num
, _("section headers"));
3647 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3649 if (section_headers
== NULL
)
3651 error (_("Out of memory\n"));
3655 for (i
= 0, internal
= section_headers
;
3659 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3660 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3661 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3662 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3663 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3664 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3665 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3666 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3667 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3668 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3676 static Elf_Internal_Sym
*
3677 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3679 unsigned long number
;
3680 Elf32_External_Sym
*esyms
;
3681 Elf_External_Sym_Shndx
*shndx
;
3682 Elf_Internal_Sym
*isyms
;
3683 Elf_Internal_Sym
*psym
;
3686 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3692 if (symtab_shndx_hdr
!= NULL
3693 && (symtab_shndx_hdr
->sh_link
3694 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3696 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3697 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3705 number
= section
->sh_size
/ section
->sh_entsize
;
3706 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3710 error (_("Out of memory\n"));
3717 for (j
= 0, psym
= isyms
;
3721 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3722 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3723 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3724 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3725 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3727 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3728 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3729 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3739 static Elf_Internal_Sym
*
3740 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3742 unsigned long number
;
3743 Elf64_External_Sym
*esyms
;
3744 Elf_External_Sym_Shndx
*shndx
;
3745 Elf_Internal_Sym
*isyms
;
3746 Elf_Internal_Sym
*psym
;
3749 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3755 if (symtab_shndx_hdr
!= NULL
3756 && (symtab_shndx_hdr
->sh_link
3757 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3759 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3760 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3768 number
= section
->sh_size
/ section
->sh_entsize
;
3769 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3773 error (_("Out of memory\n"));
3780 for (j
= 0, psym
= isyms
;
3784 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3785 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3786 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3787 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3788 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3790 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3791 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3792 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3803 get_elf_section_flags (bfd_vma sh_flags
)
3805 static char buff
[1024];
3807 int field_size
= is_32bit_elf
? 8 : 16;
3808 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3809 bfd_vma os_flags
= 0;
3810 bfd_vma proc_flags
= 0;
3811 bfd_vma unknown_flags
= 0;
3825 { "LINK ORDER", 10 },
3826 { "OS NONCONF", 10 },
3831 if (do_section_details
)
3833 sprintf (buff
, "[%*.*lx]: ",
3834 field_size
, field_size
, (unsigned long) sh_flags
);
3835 p
+= field_size
+ 4;
3842 flag
= sh_flags
& - sh_flags
;
3845 if (do_section_details
)
3849 case SHF_WRITE
: index
= 0; break;
3850 case SHF_ALLOC
: index
= 1; break;
3851 case SHF_EXECINSTR
: index
= 2; break;
3852 case SHF_MERGE
: index
= 3; break;
3853 case SHF_STRINGS
: index
= 4; break;
3854 case SHF_INFO_LINK
: index
= 5; break;
3855 case SHF_LINK_ORDER
: index
= 6; break;
3856 case SHF_OS_NONCONFORMING
: index
= 7; break;
3857 case SHF_GROUP
: index
= 8; break;
3858 case SHF_TLS
: index
= 9; break;
3867 if (p
!= buff
+ field_size
+ 4)
3869 if (size
< (10 + 2))
3876 size
-= flags
[index
].len
;
3877 p
= stpcpy (p
, flags
[index
].str
);
3879 else if (flag
& SHF_MASKOS
)
3881 else if (flag
& SHF_MASKPROC
)
3884 unknown_flags
|= flag
;
3890 case SHF_WRITE
: *p
= 'W'; break;
3891 case SHF_ALLOC
: *p
= 'A'; break;
3892 case SHF_EXECINSTR
: *p
= 'X'; break;
3893 case SHF_MERGE
: *p
= 'M'; break;
3894 case SHF_STRINGS
: *p
= 'S'; break;
3895 case SHF_INFO_LINK
: *p
= 'I'; break;
3896 case SHF_LINK_ORDER
: *p
= 'L'; break;
3897 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3898 case SHF_GROUP
: *p
= 'G'; break;
3899 case SHF_TLS
: *p
= 'T'; break;
3902 if (elf_header
.e_machine
== EM_X86_64
3903 && flag
== SHF_X86_64_LARGE
)
3905 else if (flag
& SHF_MASKOS
)
3908 sh_flags
&= ~ SHF_MASKOS
;
3910 else if (flag
& SHF_MASKPROC
)
3913 sh_flags
&= ~ SHF_MASKPROC
;
3923 if (do_section_details
)
3927 size
-= 5 + field_size
;
3928 if (p
!= buff
+ field_size
+ 4)
3936 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3937 (unsigned long) os_flags
);
3938 p
+= 5 + field_size
;
3942 size
-= 7 + field_size
;
3943 if (p
!= buff
+ field_size
+ 4)
3951 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3952 (unsigned long) proc_flags
);
3953 p
+= 7 + field_size
;
3957 size
-= 10 + field_size
;
3958 if (p
!= buff
+ field_size
+ 4)
3966 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3967 (unsigned long) unknown_flags
);
3968 p
+= 10 + field_size
;
3977 process_section_headers (FILE *file
)
3979 Elf_Internal_Shdr
*section
;
3982 section_headers
= NULL
;
3984 if (elf_header
.e_shnum
== 0)
3987 printf (_("\nThere are no sections in this file.\n"));
3992 if (do_sections
&& !do_header
)
3993 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3994 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3998 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4001 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4004 /* Read in the string table, so that we have names to display. */
4005 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4006 && SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
4008 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
4010 if (section
->sh_size
!= 0)
4012 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4013 1, section
->sh_size
, _("string table"));
4015 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4019 /* Scan the sections for the dynamic symbol table
4020 and dynamic string table and debug sections. */
4021 dynamic_symbols
= NULL
;
4022 dynamic_strings
= NULL
;
4023 dynamic_syminfo
= NULL
;
4024 symtab_shndx_hdr
= NULL
;
4026 eh_addr_size
= is_32bit_elf
? 4 : 8;
4027 switch (elf_header
.e_machine
)
4030 case EM_MIPS_RS3_LE
:
4031 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4032 FDE addresses. However, the ABI also has a semi-official ILP32
4033 variant for which the normal FDE address size rules apply.
4035 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4036 section, where XX is the size of longs in bits. Unfortunately,
4037 earlier compilers provided no way of distinguishing ILP32 objects
4038 from LP64 objects, so if there's any doubt, we should assume that
4039 the official LP64 form is being used. */
4040 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4041 && find_section (".gcc_compiled_long32") == NULL
)
4047 switch (elf_header
.e_flags
& EF_H8_MACH
)
4049 case E_H8_MACH_H8300
:
4050 case E_H8_MACH_H8300HN
:
4051 case E_H8_MACH_H8300SN
:
4052 case E_H8_MACH_H8300SXN
:
4055 case E_H8_MACH_H8300H
:
4056 case E_H8_MACH_H8300S
:
4057 case E_H8_MACH_H8300SX
:
4063 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4066 size_t expected_entsize \
4067 = is_32bit_elf ? size32 : size64; \
4068 if (section->sh_entsize != expected_entsize) \
4069 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4070 i, (unsigned long int) section->sh_entsize, \
4071 (unsigned long int) expected_entsize); \
4072 section->sh_entsize = expected_entsize; \
4075 #define CHECK_ENTSIZE(section, i, type) \
4076 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4077 sizeof (Elf64_External_##type))
4079 for (i
= 0, section
= section_headers
;
4080 i
< elf_header
.e_shnum
;
4083 char *name
= SECTION_NAME (section
);
4085 if (section
->sh_type
== SHT_DYNSYM
)
4087 if (dynamic_symbols
!= NULL
)
4089 error (_("File contains multiple dynamic symbol tables\n"));
4093 CHECK_ENTSIZE (section
, i
, Sym
);
4094 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4095 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4097 else if (section
->sh_type
== SHT_STRTAB
4098 && streq (name
, ".dynstr"))
4100 if (dynamic_strings
!= NULL
)
4102 error (_("File contains multiple dynamic string tables\n"));
4106 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4107 1, section
->sh_size
, _("dynamic strings"));
4108 dynamic_strings_length
= section
->sh_size
;
4110 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4112 if (symtab_shndx_hdr
!= NULL
)
4114 error (_("File contains multiple symtab shndx tables\n"));
4117 symtab_shndx_hdr
= section
;
4119 else if (section
->sh_type
== SHT_SYMTAB
)
4120 CHECK_ENTSIZE (section
, i
, Sym
);
4121 else if (section
->sh_type
== SHT_GROUP
)
4122 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4123 else if (section
->sh_type
== SHT_REL
)
4124 CHECK_ENTSIZE (section
, i
, Rel
);
4125 else if (section
->sh_type
== SHT_RELA
)
4126 CHECK_ENTSIZE (section
, i
, Rela
);
4127 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4128 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4129 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4130 || do_debug_loc
|| do_debug_ranges
)
4131 && const_strneq (name
, ".debug_"))
4136 || (do_debug_info
&& streq (name
, "info"))
4137 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4138 || (do_debug_lines
&& streq (name
, "line"))
4139 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4140 || (do_debug_aranges
&& streq (name
, "aranges"))
4141 || (do_debug_ranges
&& streq (name
, "ranges"))
4142 || (do_debug_frames
&& streq (name
, "frame"))
4143 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4144 || (do_debug_str
&& streq (name
, "str"))
4145 || (do_debug_loc
&& streq (name
, "loc"))
4147 request_dump (i
, DEBUG_DUMP
);
4149 /* linkonce section to be combined with .debug_info at link time. */
4150 else if ((do_debugging
|| do_debug_info
)
4151 && const_strneq (name
, ".gnu.linkonce.wi."))
4152 request_dump (i
, DEBUG_DUMP
);
4153 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4154 request_dump (i
, DEBUG_DUMP
);
4160 if (elf_header
.e_shnum
> 1)
4161 printf (_("\nSection Headers:\n"));
4163 printf (_("\nSection Header:\n"));
4167 if (do_section_details
)
4169 printf (_(" [Nr] Name\n"));
4170 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4174 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4178 if (do_section_details
)
4180 printf (_(" [Nr] Name\n"));
4181 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4185 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4189 if (do_section_details
)
4191 printf (_(" [Nr] Name\n"));
4192 printf (_(" Type Address Offset Link\n"));
4193 printf (_(" Size EntSize Info Align\n"));
4197 printf (_(" [Nr] Name Type Address Offset\n"));
4198 printf (_(" Size EntSize Flags Link Info Align\n"));
4202 if (do_section_details
)
4203 printf (_(" Flags\n"));
4205 for (i
= 0, section
= section_headers
;
4206 i
< elf_header
.e_shnum
;
4209 if (do_section_details
)
4211 printf (" [%2u] %s\n",
4212 SECTION_HEADER_NUM (i
),
4213 SECTION_NAME (section
));
4214 if (is_32bit_elf
|| do_wide
)
4215 printf (" %-15.15s ",
4216 get_section_type_name (section
->sh_type
));
4219 printf (" [%2u] %-17.17s %-15.15s ",
4220 SECTION_HEADER_NUM (i
),
4221 SECTION_NAME (section
),
4222 get_section_type_name (section
->sh_type
));
4226 print_vma (section
->sh_addr
, LONG_HEX
);
4228 printf ( " %6.6lx %6.6lx %2.2lx",
4229 (unsigned long) section
->sh_offset
,
4230 (unsigned long) section
->sh_size
,
4231 (unsigned long) section
->sh_entsize
);
4233 if (do_section_details
)
4234 fputs (" ", stdout
);
4236 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4238 printf ("%2ld %3lu %2ld\n",
4239 (unsigned long) section
->sh_link
,
4240 (unsigned long) section
->sh_info
,
4241 (unsigned long) section
->sh_addralign
);
4245 print_vma (section
->sh_addr
, LONG_HEX
);
4247 if ((long) section
->sh_offset
== section
->sh_offset
)
4248 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4252 print_vma (section
->sh_offset
, LONG_HEX
);
4255 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4256 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4260 print_vma (section
->sh_size
, LONG_HEX
);
4263 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4264 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4268 print_vma (section
->sh_entsize
, LONG_HEX
);
4271 if (do_section_details
)
4272 fputs (" ", stdout
);
4274 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4276 printf ("%2ld %3lu ",
4277 (unsigned long) section
->sh_link
,
4278 (unsigned long) section
->sh_info
);
4280 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4281 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4284 print_vma (section
->sh_addralign
, DEC
);
4288 else if (do_section_details
)
4290 printf (" %-15.15s ",
4291 get_section_type_name (section
->sh_type
));
4292 print_vma (section
->sh_addr
, LONG_HEX
);
4293 if ((long) section
->sh_offset
== section
->sh_offset
)
4294 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4298 print_vma (section
->sh_offset
, LONG_HEX
);
4300 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4301 print_vma (section
->sh_size
, LONG_HEX
);
4303 print_vma (section
->sh_entsize
, LONG_HEX
);
4305 printf (" %-16lu %ld\n",
4306 (unsigned long) section
->sh_info
,
4307 (unsigned long) section
->sh_addralign
);
4312 print_vma (section
->sh_addr
, LONG_HEX
);
4313 if ((long) section
->sh_offset
== section
->sh_offset
)
4314 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4318 print_vma (section
->sh_offset
, LONG_HEX
);
4321 print_vma (section
->sh_size
, LONG_HEX
);
4323 print_vma (section
->sh_entsize
, LONG_HEX
);
4325 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4327 printf (" %2ld %3lu %ld\n",
4328 (unsigned long) section
->sh_link
,
4329 (unsigned long) section
->sh_info
,
4330 (unsigned long) section
->sh_addralign
);
4333 if (do_section_details
)
4334 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4337 if (!do_section_details
)
4338 printf (_("Key to Flags:\n\
4339 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4340 I (info), L (link order), G (group), x (unknown)\n\
4341 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4347 get_group_flags (unsigned int flags
)
4349 static char buff
[32];
4356 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4363 process_section_groups (FILE *file
)
4365 Elf_Internal_Shdr
*section
;
4367 struct group
*group
;
4368 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4369 Elf_Internal_Sym
*symtab
;
4373 /* Don't process section groups unless needed. */
4374 if (!do_unwind
&& !do_section_groups
)
4377 if (elf_header
.e_shnum
== 0)
4379 if (do_section_groups
)
4380 printf (_("\nThere are no sections in this file.\n"));
4385 if (section_headers
== NULL
)
4387 error (_("Section headers are not available!\n"));
4391 section_headers_groups
= calloc (elf_header
.e_shnum
,
4392 sizeof (struct group
*));
4394 if (section_headers_groups
== NULL
)
4396 error (_("Out of memory\n"));
4400 /* Scan the sections for the group section. */
4402 for (i
= 0, section
= section_headers
;
4403 i
< elf_header
.e_shnum
;
4405 if (section
->sh_type
== SHT_GROUP
)
4408 if (group_count
== 0)
4410 if (do_section_groups
)
4411 printf (_("\nThere are no section groups in this file.\n"));
4416 section_groups
= calloc (group_count
, sizeof (struct group
));
4418 if (section_groups
== NULL
)
4420 error (_("Out of memory\n"));
4429 for (i
= 0, section
= section_headers
, group
= section_groups
;
4430 i
< elf_header
.e_shnum
;
4433 if (section
->sh_type
== SHT_GROUP
)
4435 char *name
= SECTION_NAME (section
);
4437 unsigned char *start
, *indices
;
4438 unsigned int entry
, j
, size
;
4439 Elf_Internal_Shdr
*sec
;
4440 Elf_Internal_Sym
*sym
;
4442 /* Get the symbol table. */
4443 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4444 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4447 error (_("Bad sh_link in group section `%s'\n"), name
);
4451 if (symtab_sec
!= sec
)
4456 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4459 sym
= symtab
+ section
->sh_info
;
4461 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4463 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4466 error (_("Bad sh_info in group section `%s'\n"), name
);
4470 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4479 /* Get the string table. */
4480 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4481 >= elf_header
.e_shnum
)
4490 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4495 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4496 1, strtab_sec
->sh_size
,
4498 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4500 group_name
= sym
->st_name
< strtab_size
4501 ? strtab
+ sym
->st_name
: "<corrupt>";
4504 start
= get_data (NULL
, file
, section
->sh_offset
,
4505 1, section
->sh_size
, _("section data"));
4508 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4509 entry
= byte_get (indices
, 4);
4512 if (do_section_groups
)
4514 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4515 get_group_flags (entry
), i
, name
, group_name
, size
);
4517 printf (_(" [Index] Name\n"));
4520 group
->group_index
= i
;
4522 for (j
= 0; j
< size
; j
++)
4524 struct group_list
*g
;
4526 entry
= byte_get (indices
, 4);
4529 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4531 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4532 entry
, i
, elf_header
.e_shnum
- 1);
4535 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4537 error (_("invalid section [%5u] in group section [%5u]\n"),
4542 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4547 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4549 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4554 /* Intel C/C++ compiler may put section 0 in a
4555 section group. We just warn it the first time
4556 and ignore it afterwards. */
4557 static int warned
= 0;
4560 error (_("section 0 in group section [%5u]\n"),
4561 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4567 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4570 if (do_section_groups
)
4572 sec
= SECTION_HEADER (entry
);
4573 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4576 g
= xmalloc (sizeof (struct group_list
));
4577 g
->section_index
= entry
;
4578 g
->next
= group
->root
;
4602 } dynamic_relocations
[] =
4604 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4605 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4606 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4609 /* Process the reloc section. */
4612 process_relocs (FILE *file
)
4614 unsigned long rel_size
;
4615 unsigned long rel_offset
;
4621 if (do_using_dynamic
)
4625 int has_dynamic_reloc
;
4628 has_dynamic_reloc
= 0;
4630 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4632 is_rela
= dynamic_relocations
[i
].rela
;
4633 name
= dynamic_relocations
[i
].name
;
4634 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4635 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4637 has_dynamic_reloc
|= rel_size
;
4639 if (is_rela
== UNKNOWN
)
4641 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4642 switch (dynamic_info
[DT_PLTREL
])
4656 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4657 name
, rel_offset
, rel_size
);
4659 dump_relocations (file
,
4660 offset_from_vma (file
, rel_offset
, rel_size
),
4662 dynamic_symbols
, num_dynamic_syms
,
4663 dynamic_strings
, dynamic_strings_length
, is_rela
);
4667 if (! has_dynamic_reloc
)
4668 printf (_("\nThere are no dynamic relocations in this file.\n"));
4672 Elf_Internal_Shdr
*section
;
4676 for (i
= 0, section
= section_headers
;
4677 i
< elf_header
.e_shnum
;
4680 if ( section
->sh_type
!= SHT_RELA
4681 && section
->sh_type
!= SHT_REL
)
4684 rel_offset
= section
->sh_offset
;
4685 rel_size
= section
->sh_size
;
4689 Elf_Internal_Shdr
*strsec
;
4692 printf (_("\nRelocation section "));
4694 if (string_table
== NULL
)
4695 printf ("%d", section
->sh_name
);
4697 printf (_("'%s'"), SECTION_NAME (section
));
4699 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4700 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4702 is_rela
= section
->sh_type
== SHT_RELA
;
4704 if (section
->sh_link
4705 && SECTION_HEADER_INDEX (section
->sh_link
)
4706 < elf_header
.e_shnum
)
4708 Elf_Internal_Shdr
*symsec
;
4709 Elf_Internal_Sym
*symtab
;
4710 unsigned long nsyms
;
4711 unsigned long strtablen
= 0;
4712 char *strtab
= NULL
;
4714 symsec
= SECTION_HEADER (section
->sh_link
);
4715 if (symsec
->sh_type
!= SHT_SYMTAB
4716 && symsec
->sh_type
!= SHT_DYNSYM
)
4719 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4720 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4725 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4726 < elf_header
.e_shnum
)
4728 strsec
= SECTION_HEADER (symsec
->sh_link
);
4730 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4733 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4736 dump_relocations (file
, rel_offset
, rel_size
,
4737 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4743 dump_relocations (file
, rel_offset
, rel_size
,
4744 NULL
, 0, NULL
, 0, is_rela
);
4751 printf (_("\nThere are no relocations in this file.\n"));
4757 /* Process the unwind section. */
4759 #include "unwind-ia64.h"
4761 /* An absolute address consists of a section and an offset. If the
4762 section is NULL, the offset itself is the address, otherwise, the
4763 address equals to LOAD_ADDRESS(section) + offset. */
4767 unsigned short section
;
4771 #define ABSADDR(a) \
4773 ? section_headers [(a).section].sh_addr + (a).offset \
4776 struct ia64_unw_aux_info
4778 struct ia64_unw_table_entry
4780 struct absaddr start
;
4782 struct absaddr info
;
4784 *table
; /* Unwind table. */
4785 unsigned long table_len
; /* Length of unwind table. */
4786 unsigned char *info
; /* Unwind info. */
4787 unsigned long info_size
; /* Size of unwind info. */
4788 bfd_vma info_addr
; /* starting address of unwind info. */
4789 bfd_vma seg_base
; /* Starting address of segment. */
4790 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4791 unsigned long nsyms
; /* Number of symbols. */
4792 char *strtab
; /* The string table. */
4793 unsigned long strtab_size
; /* Size of string table. */
4797 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4798 unsigned long nsyms
,
4800 unsigned long strtab_size
,
4801 struct absaddr addr
,
4802 const char **symname
,
4805 bfd_vma dist
= 0x100000;
4806 Elf_Internal_Sym
*sym
, *best
= NULL
;
4809 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4811 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4812 && sym
->st_name
!= 0
4813 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4814 && addr
.offset
>= sym
->st_value
4815 && addr
.offset
- sym
->st_value
< dist
)
4818 dist
= addr
.offset
- sym
->st_value
;
4825 *symname
= (best
->st_name
>= strtab_size
4826 ? "<corrupt>" : strtab
+ best
->st_name
);
4831 *offset
= addr
.offset
;
4835 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4837 struct ia64_unw_table_entry
*tp
;
4840 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4844 const unsigned char *dp
;
4845 const unsigned char *head
;
4846 const char *procname
;
4848 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4849 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4851 fputs ("\n<", stdout
);
4855 fputs (procname
, stdout
);
4858 printf ("+%lx", (unsigned long) offset
);
4861 fputs (">: [", stdout
);
4862 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4863 fputc ('-', stdout
);
4864 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4865 printf ("], info at +0x%lx\n",
4866 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4868 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4869 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4871 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4872 (unsigned) UNW_VER (stamp
),
4873 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4874 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4875 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4876 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4878 if (UNW_VER (stamp
) != 1)
4880 printf ("\tUnknown version.\n");
4885 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4886 dp
= unw_decode (dp
, in_body
, & in_body
);
4891 slurp_ia64_unwind_table (FILE *file
,
4892 struct ia64_unw_aux_info
*aux
,
4893 Elf_Internal_Shdr
*sec
)
4895 unsigned long size
, nrelas
, i
;
4896 Elf_Internal_Phdr
*seg
;
4897 struct ia64_unw_table_entry
*tep
;
4898 Elf_Internal_Shdr
*relsec
;
4899 Elf_Internal_Rela
*rela
, *rp
;
4900 unsigned char *table
, *tp
;
4901 Elf_Internal_Sym
*sym
;
4902 const char *relname
;
4904 /* First, find the starting address of the segment that includes
4907 if (elf_header
.e_phnum
)
4909 if (! get_program_headers (file
))
4912 for (seg
= program_headers
;
4913 seg
< program_headers
+ elf_header
.e_phnum
;
4916 if (seg
->p_type
!= PT_LOAD
)
4919 if (sec
->sh_addr
>= seg
->p_vaddr
4920 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4922 aux
->seg_base
= seg
->p_vaddr
;
4928 /* Second, build the unwind table from the contents of the unwind section: */
4929 size
= sec
->sh_size
;
4930 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4934 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4936 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4938 tep
->start
.section
= SHN_UNDEF
;
4939 tep
->end
.section
= SHN_UNDEF
;
4940 tep
->info
.section
= SHN_UNDEF
;
4943 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4944 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4945 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4949 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4950 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4951 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4953 tep
->start
.offset
+= aux
->seg_base
;
4954 tep
->end
.offset
+= aux
->seg_base
;
4955 tep
->info
.offset
+= aux
->seg_base
;
4959 /* Third, apply any relocations to the unwind table: */
4961 for (relsec
= section_headers
;
4962 relsec
< section_headers
+ elf_header
.e_shnum
;
4965 if (relsec
->sh_type
!= SHT_RELA
4966 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4967 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4970 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4974 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4978 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4979 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4983 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4984 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4987 if (! const_strneq (relname
, "R_IA64_SEGREL"))
4989 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4993 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4995 switch (rp
->r_offset
/eh_addr_size
% 3)
4998 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4999 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5002 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5003 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5006 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5007 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5017 aux
->table_len
= size
/ (3 * eh_addr_size
);
5022 ia64_process_unwind (FILE *file
)
5024 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5025 unsigned long i
, unwcount
= 0, unwstart
= 0;
5026 struct ia64_unw_aux_info aux
;
5028 memset (& aux
, 0, sizeof (aux
));
5030 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5032 if (sec
->sh_type
== SHT_SYMTAB
5033 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5035 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5036 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5038 strsec
= SECTION_HEADER (sec
->sh_link
);
5039 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5040 1, strsec
->sh_size
, _("string table"));
5041 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5043 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5048 printf (_("\nThere are no unwind sections in this file.\n"));
5050 while (unwcount
-- > 0)
5055 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5056 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5057 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5064 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5066 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5068 /* We need to find which section group it is in. */
5069 struct group_list
*g
= section_headers_groups
[i
]->root
;
5071 for (; g
!= NULL
; g
= g
->next
)
5073 sec
= SECTION_HEADER (g
->section_index
);
5075 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5080 i
= elf_header
.e_shnum
;
5082 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5084 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5085 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5086 suffix
= SECTION_NAME (unwsec
) + len
;
5087 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5089 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5090 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5095 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5096 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5097 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5098 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5100 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5101 suffix
= SECTION_NAME (unwsec
) + len
;
5102 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5104 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5105 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5109 if (i
== elf_header
.e_shnum
)
5111 printf (_("\nCould not find unwind info section for "));
5113 if (string_table
== NULL
)
5114 printf ("%d", unwsec
->sh_name
);
5116 printf (_("'%s'"), SECTION_NAME (unwsec
));
5120 aux
.info_size
= sec
->sh_size
;
5121 aux
.info_addr
= sec
->sh_addr
;
5122 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5125 printf (_("\nUnwind section "));
5127 if (string_table
== NULL
)
5128 printf ("%d", unwsec
->sh_name
);
5130 printf (_("'%s'"), SECTION_NAME (unwsec
));
5132 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5133 (unsigned long) unwsec
->sh_offset
,
5134 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5136 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5138 if (aux
.table_len
> 0)
5139 dump_ia64_unwind (& aux
);
5142 free ((char *) aux
.table
);
5144 free ((char *) aux
.info
);
5153 free ((char *) aux
.strtab
);
5158 struct hppa_unw_aux_info
5160 struct hppa_unw_table_entry
5162 struct absaddr start
;
5164 unsigned int Cannot_unwind
:1; /* 0 */
5165 unsigned int Millicode
:1; /* 1 */
5166 unsigned int Millicode_save_sr0
:1; /* 2 */
5167 unsigned int Region_description
:2; /* 3..4 */
5168 unsigned int reserved1
:1; /* 5 */
5169 unsigned int Entry_SR
:1; /* 6 */
5170 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5171 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5172 unsigned int Args_stored
:1; /* 16 */
5173 unsigned int Variable_Frame
:1; /* 17 */
5174 unsigned int Separate_Package_Body
:1; /* 18 */
5175 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5176 unsigned int Stack_Overflow_Check
:1; /* 20 */
5177 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5178 unsigned int Ada_Region
:1; /* 22 */
5179 unsigned int cxx_info
:1; /* 23 */
5180 unsigned int cxx_try_catch
:1; /* 24 */
5181 unsigned int sched_entry_seq
:1; /* 25 */
5182 unsigned int reserved2
:1; /* 26 */
5183 unsigned int Save_SP
:1; /* 27 */
5184 unsigned int Save_RP
:1; /* 28 */
5185 unsigned int Save_MRP_in_frame
:1; /* 29 */
5186 unsigned int extn_ptr_defined
:1; /* 30 */
5187 unsigned int Cleanup_defined
:1; /* 31 */
5189 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5190 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5191 unsigned int Large_frame
:1; /* 2 */
5192 unsigned int Pseudo_SP_Set
:1; /* 3 */
5193 unsigned int reserved4
:1; /* 4 */
5194 unsigned int Total_frame_size
:27; /* 5..31 */
5196 *table
; /* Unwind table. */
5197 unsigned long table_len
; /* Length of unwind table. */
5198 bfd_vma seg_base
; /* Starting address of segment. */
5199 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5200 unsigned long nsyms
; /* Number of symbols. */
5201 char *strtab
; /* The string table. */
5202 unsigned long strtab_size
; /* Size of string table. */
5206 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5208 struct hppa_unw_table_entry
*tp
;
5210 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5213 const char *procname
;
5215 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5216 aux
->strtab_size
, tp
->start
, &procname
,
5219 fputs ("\n<", stdout
);
5223 fputs (procname
, stdout
);
5226 printf ("+%lx", (unsigned long) offset
);
5229 fputs (">: [", stdout
);
5230 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5231 fputc ('-', stdout
);
5232 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5235 #define PF(_m) if (tp->_m) printf (#_m " ");
5236 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5239 PF(Millicode_save_sr0
);
5240 /* PV(Region_description); */
5246 PF(Separate_Package_Body
);
5247 PF(Frame_Extension_Millicode
);
5248 PF(Stack_Overflow_Check
);
5249 PF(Two_Instruction_SP_Increment
);
5253 PF(sched_entry_seq
);
5256 PF(Save_MRP_in_frame
);
5257 PF(extn_ptr_defined
);
5258 PF(Cleanup_defined
);
5259 PF(MPE_XL_interrupt_marker
);
5260 PF(HP_UX_interrupt_marker
);
5263 PV(Total_frame_size
);
5272 slurp_hppa_unwind_table (FILE *file
,
5273 struct hppa_unw_aux_info
*aux
,
5274 Elf_Internal_Shdr
*sec
)
5276 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5277 Elf_Internal_Phdr
*seg
;
5278 struct hppa_unw_table_entry
*tep
;
5279 Elf_Internal_Shdr
*relsec
;
5280 Elf_Internal_Rela
*rela
, *rp
;
5281 unsigned char *table
, *tp
;
5282 Elf_Internal_Sym
*sym
;
5283 const char *relname
;
5285 /* First, find the starting address of the segment that includes
5288 if (elf_header
.e_phnum
)
5290 if (! get_program_headers (file
))
5293 for (seg
= program_headers
;
5294 seg
< program_headers
+ elf_header
.e_phnum
;
5297 if (seg
->p_type
!= PT_LOAD
)
5300 if (sec
->sh_addr
>= seg
->p_vaddr
5301 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5303 aux
->seg_base
= seg
->p_vaddr
;
5309 /* Second, build the unwind table from the contents of the unwind
5311 size
= sec
->sh_size
;
5312 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5317 nentries
= size
/ unw_ent_size
;
5318 size
= unw_ent_size
* nentries
;
5320 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5322 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5324 unsigned int tmp1
, tmp2
;
5326 tep
->start
.section
= SHN_UNDEF
;
5327 tep
->end
.section
= SHN_UNDEF
;
5329 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5330 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5331 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5332 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5334 tep
->start
.offset
+= aux
->seg_base
;
5335 tep
->end
.offset
+= aux
->seg_base
;
5337 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5338 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5339 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5340 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5341 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5342 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5343 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5344 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5345 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5346 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5347 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5348 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5349 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5350 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5351 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5352 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5353 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5354 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5355 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5356 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5357 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5358 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5359 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5360 tep
->Cleanup_defined
= tmp1
& 0x1;
5362 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5363 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5364 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5365 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5366 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5367 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5371 /* Third, apply any relocations to the unwind table. */
5373 for (relsec
= section_headers
;
5374 relsec
< section_headers
+ elf_header
.e_shnum
;
5377 if (relsec
->sh_type
!= SHT_RELA
5378 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5379 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5382 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5386 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5390 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5391 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5395 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5396 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5399 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5400 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5402 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5406 i
= rp
->r_offset
/ unw_ent_size
;
5408 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5411 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5412 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5415 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5416 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5426 aux
->table_len
= nentries
;
5432 hppa_process_unwind (FILE *file
)
5434 struct hppa_unw_aux_info aux
;
5435 Elf_Internal_Shdr
*unwsec
= NULL
;
5436 Elf_Internal_Shdr
*strsec
;
5437 Elf_Internal_Shdr
*sec
;
5440 memset (& aux
, 0, sizeof (aux
));
5442 if (string_table
== NULL
)
5445 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5447 if (sec
->sh_type
== SHT_SYMTAB
5448 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5450 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5451 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5453 strsec
= SECTION_HEADER (sec
->sh_link
);
5454 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5455 1, strsec
->sh_size
, _("string table"));
5456 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5458 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5463 printf (_("\nThere are no unwind sections in this file.\n"));
5465 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5467 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5469 printf (_("\nUnwind section "));
5470 printf (_("'%s'"), SECTION_NAME (sec
));
5472 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5473 (unsigned long) sec
->sh_offset
,
5474 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5476 slurp_hppa_unwind_table (file
, &aux
, sec
);
5477 if (aux
.table_len
> 0)
5478 dump_hppa_unwind (&aux
);
5481 free ((char *) aux
.table
);
5489 free ((char *) aux
.strtab
);
5495 process_unwind (FILE *file
)
5497 struct unwind_handler
{
5499 int (*handler
)(FILE *file
);
5501 { EM_IA_64
, ia64_process_unwind
},
5502 { EM_PARISC
, hppa_process_unwind
},
5510 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5511 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5512 return handlers
[i
].handler (file
);
5514 printf (_("\nThere are no unwind sections in this file.\n"));
5519 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5521 switch (entry
->d_tag
)
5524 if (entry
->d_un
.d_val
== 0)
5528 static const char * opts
[] =
5530 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5531 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5532 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5533 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5538 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5539 if (entry
->d_un
.d_val
& (1 << cnt
))
5541 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5548 case DT_MIPS_IVERSION
:
5549 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5550 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5552 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5555 case DT_MIPS_TIME_STAMP
:
5560 time_t time
= entry
->d_un
.d_val
;
5561 tmp
= gmtime (&time
);
5562 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5563 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5564 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5565 printf ("Time Stamp: %s\n", timebuf
);
5569 case DT_MIPS_RLD_VERSION
:
5570 case DT_MIPS_LOCAL_GOTNO
:
5571 case DT_MIPS_CONFLICTNO
:
5572 case DT_MIPS_LIBLISTNO
:
5573 case DT_MIPS_SYMTABNO
:
5574 case DT_MIPS_UNREFEXTNO
:
5575 case DT_MIPS_HIPAGENO
:
5576 case DT_MIPS_DELTA_CLASS_NO
:
5577 case DT_MIPS_DELTA_INSTANCE_NO
:
5578 case DT_MIPS_DELTA_RELOC_NO
:
5579 case DT_MIPS_DELTA_SYM_NO
:
5580 case DT_MIPS_DELTA_CLASSSYM_NO
:
5581 case DT_MIPS_COMPACT_SIZE
:
5582 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5586 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5592 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5594 switch (entry
->d_tag
)
5596 case DT_HP_DLD_FLAGS
:
5605 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5606 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5607 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5608 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5609 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5610 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5611 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5612 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5613 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5614 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5615 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5616 { DT_HP_GST
, "HP_GST" },
5617 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5618 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5619 { DT_HP_NODELETE
, "HP_NODELETE" },
5620 { DT_HP_GROUP
, "HP_GROUP" },
5621 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5625 bfd_vma val
= entry
->d_un
.d_val
;
5627 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5628 if (val
& flags
[cnt
].bit
)
5632 fputs (flags
[cnt
].str
, stdout
);
5634 val
^= flags
[cnt
].bit
;
5637 if (val
!= 0 || first
)
5641 print_vma (val
, HEX
);
5647 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5654 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5656 switch (entry
->d_tag
)
5658 case DT_IA_64_PLT_RESERVE
:
5659 /* First 3 slots reserved. */
5660 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5662 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5666 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5673 get_32bit_dynamic_section (FILE *file
)
5675 Elf32_External_Dyn
*edyn
, *ext
;
5676 Elf_Internal_Dyn
*entry
;
5678 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5679 _("dynamic section"));
5683 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5684 might not have the luxury of section headers. Look for the DT_NULL
5685 terminator to determine the number of entries. */
5686 for (ext
= edyn
, dynamic_nent
= 0;
5687 (char *) ext
< (char *) edyn
+ dynamic_size
;
5691 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5695 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5696 if (dynamic_section
== NULL
)
5698 error (_("Out of memory\n"));
5703 for (ext
= edyn
, entry
= dynamic_section
;
5704 entry
< dynamic_section
+ dynamic_nent
;
5707 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5708 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5717 get_64bit_dynamic_section (FILE *file
)
5719 Elf64_External_Dyn
*edyn
, *ext
;
5720 Elf_Internal_Dyn
*entry
;
5722 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5723 _("dynamic section"));
5727 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5728 might not have the luxury of section headers. Look for the DT_NULL
5729 terminator to determine the number of entries. */
5730 for (ext
= edyn
, dynamic_nent
= 0;
5731 (char *) ext
< (char *) edyn
+ dynamic_size
;
5735 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5739 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5740 if (dynamic_section
== NULL
)
5742 error (_("Out of memory\n"));
5747 for (ext
= edyn
, entry
= dynamic_section
;
5748 entry
< dynamic_section
+ dynamic_nent
;
5751 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5752 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5761 print_dynamic_flags (bfd_vma flags
)
5769 flag
= flags
& - flags
;
5779 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5780 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5781 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5782 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5783 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5784 default: fputs ("unknown", stdout
); break;
5790 /* Parse and display the contents of the dynamic section. */
5793 process_dynamic_section (FILE *file
)
5795 Elf_Internal_Dyn
*entry
;
5797 if (dynamic_size
== 0)
5800 printf (_("\nThere is no dynamic section in this file.\n"));
5807 if (! get_32bit_dynamic_section (file
))
5810 else if (! get_64bit_dynamic_section (file
))
5813 /* Find the appropriate symbol table. */
5814 if (dynamic_symbols
== NULL
)
5816 for (entry
= dynamic_section
;
5817 entry
< dynamic_section
+ dynamic_nent
;
5820 Elf_Internal_Shdr section
;
5822 if (entry
->d_tag
!= DT_SYMTAB
)
5825 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5827 /* Since we do not know how big the symbol table is,
5828 we default to reading in the entire file (!) and
5829 processing that. This is overkill, I know, but it
5831 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5833 if (archive_file_offset
!= 0)
5834 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5837 if (fseek (file
, 0, SEEK_END
))
5838 error (_("Unable to seek to end of file!"));
5840 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5844 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5846 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5848 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5849 if (num_dynamic_syms
< 1)
5851 error (_("Unable to determine the number of symbols to load\n"));
5855 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5859 /* Similarly find a string table. */
5860 if (dynamic_strings
== NULL
)
5862 for (entry
= dynamic_section
;
5863 entry
< dynamic_section
+ dynamic_nent
;
5866 unsigned long offset
;
5869 if (entry
->d_tag
!= DT_STRTAB
)
5872 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5874 /* Since we do not know how big the string table is,
5875 we default to reading in the entire file (!) and
5876 processing that. This is overkill, I know, but it
5879 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5881 if (archive_file_offset
!= 0)
5882 str_tab_len
= archive_file_size
- offset
;
5885 if (fseek (file
, 0, SEEK_END
))
5886 error (_("Unable to seek to end of file\n"));
5887 str_tab_len
= ftell (file
) - offset
;
5890 if (str_tab_len
< 1)
5893 (_("Unable to determine the length of the dynamic string table\n"));
5897 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5898 _("dynamic string table"));
5899 dynamic_strings_length
= str_tab_len
;
5904 /* And find the syminfo section if available. */
5905 if (dynamic_syminfo
== NULL
)
5907 unsigned long syminsz
= 0;
5909 for (entry
= dynamic_section
;
5910 entry
< dynamic_section
+ dynamic_nent
;
5913 if (entry
->d_tag
== DT_SYMINENT
)
5915 /* Note: these braces are necessary to avoid a syntax
5916 error from the SunOS4 C compiler. */
5917 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5919 else if (entry
->d_tag
== DT_SYMINSZ
)
5920 syminsz
= entry
->d_un
.d_val
;
5921 else if (entry
->d_tag
== DT_SYMINFO
)
5922 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5926 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5928 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5929 Elf_Internal_Syminfo
*syminfo
;
5931 /* There is a syminfo section. Read the data. */
5932 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5933 syminsz
, _("symbol information"));
5937 dynamic_syminfo
= malloc (syminsz
);
5938 if (dynamic_syminfo
== NULL
)
5940 error (_("Out of memory\n"));
5944 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5945 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5946 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5947 ++syminfo
, ++extsym
)
5949 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5950 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5957 if (do_dynamic
&& dynamic_addr
)
5958 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5959 dynamic_addr
, dynamic_nent
);
5961 printf (_(" Tag Type Name/Value\n"));
5963 for (entry
= dynamic_section
;
5964 entry
< dynamic_section
+ dynamic_nent
;
5972 print_vma (entry
->d_tag
, FULL_HEX
);
5973 dtype
= get_dynamic_type (entry
->d_tag
);
5974 printf (" (%s)%*s", dtype
,
5975 ((is_32bit_elf
? 27 : 19)
5976 - (int) strlen (dtype
)),
5980 switch (entry
->d_tag
)
5984 print_dynamic_flags (entry
->d_un
.d_val
);
5994 switch (entry
->d_tag
)
5997 printf (_("Auxiliary library"));
6001 printf (_("Filter library"));
6005 printf (_("Configuration file"));
6009 printf (_("Dependency audit library"));
6013 printf (_("Audit library"));
6017 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6018 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6022 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6031 printf (_("Flags:"));
6033 if (entry
->d_un
.d_val
== 0)
6034 printf (_(" None\n"));
6037 unsigned long int val
= entry
->d_un
.d_val
;
6039 if (val
& DTF_1_PARINIT
)
6041 printf (" PARINIT");
6042 val
^= DTF_1_PARINIT
;
6044 if (val
& DTF_1_CONFEXP
)
6046 printf (" CONFEXP");
6047 val
^= DTF_1_CONFEXP
;
6050 printf (" %lx", val
);
6059 printf (_("Flags:"));
6061 if (entry
->d_un
.d_val
== 0)
6062 printf (_(" None\n"));
6065 unsigned long int val
= entry
->d_un
.d_val
;
6067 if (val
& DF_P1_LAZYLOAD
)
6069 printf (" LAZYLOAD");
6070 val
^= DF_P1_LAZYLOAD
;
6072 if (val
& DF_P1_GROUPPERM
)
6074 printf (" GROUPPERM");
6075 val
^= DF_P1_GROUPPERM
;
6078 printf (" %lx", val
);
6087 printf (_("Flags:"));
6088 if (entry
->d_un
.d_val
== 0)
6089 printf (_(" None\n"));
6092 unsigned long int val
= entry
->d_un
.d_val
;
6099 if (val
& DF_1_GLOBAL
)
6104 if (val
& DF_1_GROUP
)
6109 if (val
& DF_1_NODELETE
)
6111 printf (" NODELETE");
6112 val
^= DF_1_NODELETE
;
6114 if (val
& DF_1_LOADFLTR
)
6116 printf (" LOADFLTR");
6117 val
^= DF_1_LOADFLTR
;
6119 if (val
& DF_1_INITFIRST
)
6121 printf (" INITFIRST");
6122 val
^= DF_1_INITFIRST
;
6124 if (val
& DF_1_NOOPEN
)
6129 if (val
& DF_1_ORIGIN
)
6134 if (val
& DF_1_DIRECT
)
6139 if (val
& DF_1_TRANS
)
6144 if (val
& DF_1_INTERPOSE
)
6146 printf (" INTERPOSE");
6147 val
^= DF_1_INTERPOSE
;
6149 if (val
& DF_1_NODEFLIB
)
6151 printf (" NODEFLIB");
6152 val
^= DF_1_NODEFLIB
;
6154 if (val
& DF_1_NODUMP
)
6159 if (val
& DF_1_CONLFAT
)
6161 printf (" CONLFAT");
6162 val
^= DF_1_CONLFAT
;
6165 printf (" %lx", val
);
6172 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6174 puts (get_dynamic_type (entry
->d_un
.d_val
));
6194 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6200 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6201 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6207 switch (entry
->d_tag
)
6210 printf (_("Shared library: [%s]"), name
);
6212 if (streq (name
, program_interpreter
))
6213 printf (_(" program interpreter"));
6217 printf (_("Library soname: [%s]"), name
);
6221 printf (_("Library rpath: [%s]"), name
);
6225 printf (_("Library runpath: [%s]"), name
);
6229 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6234 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6247 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6251 case DT_INIT_ARRAYSZ
:
6252 case DT_FINI_ARRAYSZ
:
6253 case DT_GNU_CONFLICTSZ
:
6254 case DT_GNU_LIBLISTSZ
:
6257 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6258 printf (" (bytes)\n");
6268 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6281 if (entry
->d_tag
== DT_USED
6282 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6284 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6288 printf (_("Not needed object: [%s]\n"), name
);
6293 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6299 /* The value of this entry is ignored. */
6304 case DT_GNU_PRELINKED
:
6308 time_t time
= entry
->d_un
.d_val
;
6310 tmp
= gmtime (&time
);
6311 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6312 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6313 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6319 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6322 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6328 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6329 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6334 switch (elf_header
.e_machine
)
6337 case EM_MIPS_RS3_LE
:
6338 dynamic_section_mips_val (entry
);
6341 dynamic_section_parisc_val (entry
);
6344 dynamic_section_ia64_val (entry
);
6347 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6359 get_ver_flags (unsigned int flags
)
6361 static char buff
[32];
6368 if (flags
& VER_FLG_BASE
)
6369 strcat (buff
, "BASE ");
6371 if (flags
& VER_FLG_WEAK
)
6373 if (flags
& VER_FLG_BASE
)
6374 strcat (buff
, "| ");
6376 strcat (buff
, "WEAK ");
6379 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6380 strcat (buff
, "| <unknown>");
6385 /* Display the contents of the version sections. */
6387 process_version_sections (FILE *file
)
6389 Elf_Internal_Shdr
*section
;
6396 for (i
= 0, section
= section_headers
;
6397 i
< elf_header
.e_shnum
;
6400 switch (section
->sh_type
)
6402 case SHT_GNU_verdef
:
6404 Elf_External_Verdef
*edefs
;
6411 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6412 SECTION_NAME (section
), section
->sh_info
);
6414 printf (_(" Addr: 0x"));
6415 printf_vma (section
->sh_addr
);
6416 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6417 (unsigned long) section
->sh_offset
, section
->sh_link
,
6418 SECTION_HEADER_INDEX (section
->sh_link
)
6419 < elf_header
.e_shnum
6420 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6423 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6425 _("version definition section"));
6429 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6432 Elf_External_Verdef
*edef
;
6433 Elf_Internal_Verdef ent
;
6434 Elf_External_Verdaux
*eaux
;
6435 Elf_Internal_Verdaux aux
;
6439 vstart
= ((char *) edefs
) + idx
;
6441 edef
= (Elf_External_Verdef
*) vstart
;
6443 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6444 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6445 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6446 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6447 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6448 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6449 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6451 printf (_(" %#06x: Rev: %d Flags: %s"),
6452 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6454 printf (_(" Index: %d Cnt: %d "),
6455 ent
.vd_ndx
, ent
.vd_cnt
);
6457 vstart
+= ent
.vd_aux
;
6459 eaux
= (Elf_External_Verdaux
*) vstart
;
6461 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6462 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6464 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6465 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6467 printf (_("Name index: %ld\n"), aux
.vda_name
);
6469 isum
= idx
+ ent
.vd_aux
;
6471 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6473 isum
+= aux
.vda_next
;
6474 vstart
+= aux
.vda_next
;
6476 eaux
= (Elf_External_Verdaux
*) vstart
;
6478 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6479 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6481 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6482 printf (_(" %#06x: Parent %d: %s\n"),
6483 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6485 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6486 isum
, j
, aux
.vda_name
);
6496 case SHT_GNU_verneed
:
6498 Elf_External_Verneed
*eneed
;
6504 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6505 SECTION_NAME (section
), section
->sh_info
);
6507 printf (_(" Addr: 0x"));
6508 printf_vma (section
->sh_addr
);
6509 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6510 (unsigned long) section
->sh_offset
, section
->sh_link
,
6511 SECTION_HEADER_INDEX (section
->sh_link
)
6512 < elf_header
.e_shnum
6513 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6516 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6518 _("version need section"));
6522 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6524 Elf_External_Verneed
*entry
;
6525 Elf_Internal_Verneed ent
;
6530 vstart
= ((char *) eneed
) + idx
;
6532 entry
= (Elf_External_Verneed
*) vstart
;
6534 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6535 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6536 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6537 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6538 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6540 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6542 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6543 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6545 printf (_(" File: %lx"), ent
.vn_file
);
6547 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6549 vstart
+= ent
.vn_aux
;
6551 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6553 Elf_External_Vernaux
*eaux
;
6554 Elf_Internal_Vernaux aux
;
6556 eaux
= (Elf_External_Vernaux
*) vstart
;
6558 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6559 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6560 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6561 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6562 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6564 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6565 printf (_(" %#06x: Name: %s"),
6566 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6568 printf (_(" %#06x: Name index: %lx"),
6569 isum
, aux
.vna_name
);
6571 printf (_(" Flags: %s Version: %d\n"),
6572 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6574 isum
+= aux
.vna_next
;
6575 vstart
+= aux
.vna_next
;
6585 case SHT_GNU_versym
:
6587 Elf_Internal_Shdr
*link_section
;
6590 unsigned char *edata
;
6591 unsigned short *data
;
6593 Elf_Internal_Sym
*symbols
;
6594 Elf_Internal_Shdr
*string_sec
;
6597 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6600 link_section
= SECTION_HEADER (section
->sh_link
);
6601 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6603 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6604 >= elf_header
.e_shnum
)
6609 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6611 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6613 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6614 string_sec
->sh_size
, _("version string table"));
6618 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6619 SECTION_NAME (section
), total
);
6621 printf (_(" Addr: "));
6622 printf_vma (section
->sh_addr
);
6623 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6624 (unsigned long) section
->sh_offset
, section
->sh_link
,
6625 SECTION_NAME (link_section
));
6627 off
= offset_from_vma (file
,
6628 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6629 total
* sizeof (short));
6630 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6631 _("version symbol data"));
6638 data
= cmalloc (total
, sizeof (short));
6640 for (cnt
= total
; cnt
--;)
6641 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6646 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6649 int check_def
, check_need
;
6652 printf (" %03x:", cnt
);
6654 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6655 switch (data
[cnt
+ j
])
6658 fputs (_(" 0 (*local*) "), stdout
);
6662 fputs (_(" 1 (*global*) "), stdout
);
6666 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6667 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6671 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6672 >= elf_header
.e_shnum
6673 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6676 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6683 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6685 Elf_Internal_Verneed ivn
;
6686 unsigned long offset
;
6688 offset
= offset_from_vma
6689 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6690 sizeof (Elf_External_Verneed
));
6694 Elf_Internal_Vernaux ivna
;
6695 Elf_External_Verneed evn
;
6696 Elf_External_Vernaux evna
;
6697 unsigned long a_off
;
6699 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6702 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6703 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6705 a_off
= offset
+ ivn
.vn_aux
;
6709 get_data (&evna
, file
, a_off
, sizeof (evna
),
6710 1, _("version need aux (2)"));
6712 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6713 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6715 a_off
+= ivna
.vna_next
;
6717 while (ivna
.vna_other
!= data
[cnt
+ j
]
6718 && ivna
.vna_next
!= 0);
6720 if (ivna
.vna_other
== data
[cnt
+ j
])
6722 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6724 name
= strtab
+ ivna
.vna_name
;
6725 nn
+= printf ("(%s%-*s",
6727 12 - (int) strlen (name
),
6733 offset
+= ivn
.vn_next
;
6735 while (ivn
.vn_next
);
6738 if (check_def
&& data
[cnt
+ j
] != 0x8001
6739 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6741 Elf_Internal_Verdef ivd
;
6742 Elf_External_Verdef evd
;
6743 unsigned long offset
;
6745 offset
= offset_from_vma
6746 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6751 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6754 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6755 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6757 offset
+= ivd
.vd_next
;
6759 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6760 && ivd
.vd_next
!= 0);
6762 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6764 Elf_External_Verdaux evda
;
6765 Elf_Internal_Verdaux ivda
;
6767 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6769 get_data (&evda
, file
,
6770 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6772 _("version def aux"));
6774 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6776 name
= strtab
+ ivda
.vda_name
;
6777 nn
+= printf ("(%s%-*s",
6779 12 - (int) strlen (name
),
6785 printf ("%*c", 18 - nn
, ' ');
6803 printf (_("\nNo version information found in this file.\n"));
6809 get_symbol_binding (unsigned int binding
)
6811 static char buff
[32];
6815 case STB_LOCAL
: return "LOCAL";
6816 case STB_GLOBAL
: return "GLOBAL";
6817 case STB_WEAK
: return "WEAK";
6819 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6820 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6822 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6823 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6825 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6831 get_symbol_type (unsigned int type
)
6833 static char buff
[32];
6837 case STT_NOTYPE
: return "NOTYPE";
6838 case STT_OBJECT
: return "OBJECT";
6839 case STT_FUNC
: return "FUNC";
6840 case STT_SECTION
: return "SECTION";
6841 case STT_FILE
: return "FILE";
6842 case STT_COMMON
: return "COMMON";
6843 case STT_TLS
: return "TLS";
6845 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6847 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6848 return "THUMB_FUNC";
6850 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6853 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6854 return "PARISC_MILLI";
6856 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6858 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6860 if (elf_header
.e_machine
== EM_PARISC
)
6862 if (type
== STT_HP_OPAQUE
)
6864 if (type
== STT_HP_STUB
)
6868 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6871 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6877 get_symbol_visibility (unsigned int visibility
)
6881 case STV_DEFAULT
: return "DEFAULT";
6882 case STV_INTERNAL
: return "INTERNAL";
6883 case STV_HIDDEN
: return "HIDDEN";
6884 case STV_PROTECTED
: return "PROTECTED";
6890 get_mips_symbol_other (unsigned int other
)
6894 case STO_OPTIONAL
: return "OPTIONAL";
6895 case STO_MIPS16
: return "MIPS16";
6896 default: return NULL
;
6901 get_symbol_other (unsigned int other
)
6903 const char * result
= NULL
;
6904 static char buff
[32];
6909 switch (elf_header
.e_machine
)
6912 result
= get_mips_symbol_other (other
);
6920 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6925 get_symbol_index_type (unsigned int type
)
6927 static char buff
[32];
6931 case SHN_UNDEF
: return "UND";
6932 case SHN_ABS
: return "ABS";
6933 case SHN_COMMON
: return "COM";
6935 if (type
== SHN_IA_64_ANSI_COMMON
6936 && elf_header
.e_machine
== EM_IA_64
6937 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6939 else if (elf_header
.e_machine
== EM_X86_64
6940 && type
== SHN_X86_64_LCOMMON
)
6942 else if (type
== SHN_MIPS_SCOMMON
6943 && elf_header
.e_machine
== EM_MIPS
)
6945 else if (type
== SHN_MIPS_SUNDEFINED
6946 && elf_header
.e_machine
== EM_MIPS
)
6948 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6949 sprintf (buff
, "PRC[0x%04x]", type
);
6950 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6951 sprintf (buff
, "OS [0x%04x]", type
);
6952 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6953 sprintf (buff
, "RSV[0x%04x]", type
);
6955 sprintf (buff
, "%3d", type
);
6963 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6965 unsigned char *e_data
;
6968 e_data
= cmalloc (number
, ent_size
);
6972 error (_("Out of memory\n"));
6976 if (fread (e_data
, ent_size
, number
, file
) != number
)
6978 error (_("Unable to read in dynamic data\n"));
6982 i_data
= cmalloc (number
, sizeof (*i_data
));
6986 error (_("Out of memory\n"));
6992 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6999 /* Dump the symbol table. */
7001 process_symbol_table (FILE *file
)
7003 Elf_Internal_Shdr
*section
;
7004 bfd_vma nbuckets
= 0;
7005 bfd_vma nchains
= 0;
7006 bfd_vma
*buckets
= NULL
;
7007 bfd_vma
*chains
= NULL
;
7008 bfd_vma ngnubuckets
= 0;
7009 bfd_vma
*gnubuckets
= NULL
;
7010 bfd_vma
*gnuchains
= NULL
;
7012 if (! do_syms
&& !do_histogram
)
7015 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
7018 unsigned char nb
[8];
7019 unsigned char nc
[8];
7020 int hash_ent_size
= 4;
7022 if ((elf_header
.e_machine
== EM_ALPHA
7023 || elf_header
.e_machine
== EM_S390
7024 || elf_header
.e_machine
== EM_S390_OLD
)
7025 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7029 (archive_file_offset
7030 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7031 sizeof nb
+ sizeof nc
)),
7034 error (_("Unable to seek to start of dynamic information"));
7038 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7040 error (_("Failed to read in number of buckets\n"));
7044 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7046 error (_("Failed to read in number of chains\n"));
7050 nbuckets
= byte_get (nb
, hash_ent_size
);
7051 nchains
= byte_get (nc
, hash_ent_size
);
7053 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7054 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7056 if (buckets
== NULL
|| chains
== NULL
)
7061 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
7066 printf (_("\nSymbol table for image:\n"));
7068 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7070 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7072 for (hn
= 0; hn
< nbuckets
; hn
++)
7077 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7079 Elf_Internal_Sym
*psym
;
7082 psym
= dynamic_symbols
+ si
;
7084 n
= print_vma (si
, DEC_5
);
7086 fputs (" " + n
, stdout
);
7087 printf (" %3lu: ", hn
);
7088 print_vma (psym
->st_value
, LONG_HEX
);
7090 print_vma (psym
->st_size
, DEC_5
);
7092 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7093 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7094 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7095 /* Check to see if any other bits in the st_other field are set.
7096 Note - displaying this information disrupts the layout of the
7097 table being generated, but for the moment this case is very rare. */
7098 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7099 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7100 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7101 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7102 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7104 printf (" <corrupt: %14ld>", psym
->st_name
);
7109 else if (do_syms
&& !do_using_dynamic
)
7113 for (i
= 0, section
= section_headers
;
7114 i
< elf_header
.e_shnum
;
7118 char *strtab
= NULL
;
7119 unsigned long int strtab_size
= 0;
7120 Elf_Internal_Sym
*symtab
;
7121 Elf_Internal_Sym
*psym
;
7124 if ( section
->sh_type
!= SHT_SYMTAB
7125 && section
->sh_type
!= SHT_DYNSYM
)
7128 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7129 SECTION_NAME (section
),
7130 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7132 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7134 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7136 symtab
= GET_ELF_SYMBOLS (file
, section
);
7140 if (section
->sh_link
== elf_header
.e_shstrndx
)
7142 strtab
= string_table
;
7143 strtab_size
= string_table_length
;
7145 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7147 Elf_Internal_Shdr
*string_sec
;
7149 string_sec
= SECTION_HEADER (section
->sh_link
);
7151 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7152 1, string_sec
->sh_size
, _("string table"));
7153 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7156 for (si
= 0, psym
= symtab
;
7157 si
< section
->sh_size
/ section
->sh_entsize
;
7160 printf ("%6d: ", si
);
7161 print_vma (psym
->st_value
, LONG_HEX
);
7163 print_vma (psym
->st_size
, DEC_5
);
7164 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7165 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7166 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7167 /* Check to see if any other bits in the st_other field are set.
7168 Note - displaying this information disrupts the layout of the
7169 table being generated, but for the moment this case is very rare. */
7170 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7171 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7172 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7173 print_symbol (25, psym
->st_name
< strtab_size
7174 ? strtab
+ psym
->st_name
: "<corrupt>");
7176 if (section
->sh_type
== SHT_DYNSYM
&&
7177 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7179 unsigned char data
[2];
7180 unsigned short vers_data
;
7181 unsigned long offset
;
7185 offset
= offset_from_vma
7186 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7187 sizeof data
+ si
* sizeof (vers_data
));
7189 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7190 sizeof (data
), 1, _("version data"));
7192 vers_data
= byte_get (data
, 2);
7194 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7195 < elf_header
.e_shnum
7196 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7199 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7201 if ((vers_data
& 0x8000) || vers_data
> 1)
7203 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7204 && (is_nobits
|| ! check_def
))
7206 Elf_External_Verneed evn
;
7207 Elf_Internal_Verneed ivn
;
7208 Elf_Internal_Vernaux ivna
;
7210 /* We must test both. */
7211 offset
= offset_from_vma
7212 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7217 unsigned long vna_off
;
7219 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7222 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7223 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7225 vna_off
= offset
+ ivn
.vn_aux
;
7229 Elf_External_Vernaux evna
;
7231 get_data (&evna
, file
, vna_off
,
7233 _("version need aux (3)"));
7235 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7236 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7237 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7239 vna_off
+= ivna
.vna_next
;
7241 while (ivna
.vna_other
!= vers_data
7242 && ivna
.vna_next
!= 0);
7244 if (ivna
.vna_other
== vers_data
)
7247 offset
+= ivn
.vn_next
;
7249 while (ivn
.vn_next
!= 0);
7251 if (ivna
.vna_other
== vers_data
)
7254 ivna
.vna_name
< strtab_size
7255 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7259 else if (! is_nobits
)
7260 error (_("bad dynamic symbol"));
7267 if (vers_data
!= 0x8001
7268 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7270 Elf_Internal_Verdef ivd
;
7271 Elf_Internal_Verdaux ivda
;
7272 Elf_External_Verdaux evda
;
7273 unsigned long offset
;
7275 offset
= offset_from_vma
7277 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7278 sizeof (Elf_External_Verdef
));
7282 Elf_External_Verdef evd
;
7284 get_data (&evd
, file
, offset
, sizeof (evd
),
7285 1, _("version def"));
7287 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7288 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7289 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7291 offset
+= ivd
.vd_next
;
7293 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7294 && ivd
.vd_next
!= 0);
7296 offset
-= ivd
.vd_next
;
7297 offset
+= ivd
.vd_aux
;
7299 get_data (&evda
, file
, offset
, sizeof (evda
),
7300 1, _("version def aux"));
7302 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7304 if (psym
->st_name
!= ivda
.vda_name
)
7305 printf ((vers_data
& 0x8000)
7307 ivda
.vda_name
< strtab_size
7308 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7318 if (strtab
!= string_table
)
7324 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7326 if (do_histogram
&& buckets
!= NULL
)
7328 unsigned long *lengths
;
7329 unsigned long *counts
;
7332 unsigned long maxlength
= 0;
7333 unsigned long nzero_counts
= 0;
7334 unsigned long nsyms
= 0;
7336 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7337 (unsigned long) nbuckets
);
7338 printf (_(" Length Number %% of total Coverage\n"));
7340 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7341 if (lengths
== NULL
)
7343 error (_("Out of memory"));
7346 for (hn
= 0; hn
< nbuckets
; ++hn
)
7348 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7351 if (maxlength
< ++lengths
[hn
])
7356 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7359 error (_("Out of memory"));
7363 for (hn
= 0; hn
< nbuckets
; ++hn
)
7364 ++counts
[lengths
[hn
]];
7369 printf (" 0 %-10lu (%5.1f%%)\n",
7370 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7371 for (i
= 1; i
<= maxlength
; ++i
)
7373 nzero_counts
+= counts
[i
] * i
;
7374 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7375 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7376 (nzero_counts
* 100.0) / nsyms
);
7384 if (buckets
!= NULL
)
7390 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7392 unsigned char nb
[16];
7393 bfd_vma i
, maxchain
= 0xffffffff, symidx
, bitmaskwords
;
7394 unsigned long *lengths
;
7395 unsigned long *counts
;
7397 unsigned long maxlength
= 0;
7398 unsigned long nzero_counts
= 0;
7399 unsigned long nsyms
= 0;
7400 bfd_vma buckets_vma
;
7403 (archive_file_offset
7404 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7408 error (_("Unable to seek to start of dynamic information"));
7412 if (fread (nb
, 16, 1, file
) != 1)
7414 error (_("Failed to read in number of buckets\n"));
7418 ngnubuckets
= byte_get (nb
, 4);
7419 symidx
= byte_get (nb
+ 4, 4);
7420 bitmaskwords
= byte_get (nb
+ 8, 4);
7421 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7423 buckets_vma
+= bitmaskwords
* 4;
7425 buckets_vma
+= bitmaskwords
* 8;
7428 (archive_file_offset
7429 + offset_from_vma (file
, buckets_vma
, 4)),
7432 error (_("Unable to seek to start of dynamic information"));
7436 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7438 if (gnubuckets
== NULL
)
7441 for (i
= 0; i
< ngnubuckets
; i
++)
7442 if (gnubuckets
[i
] != 0)
7444 if (gnubuckets
[i
] < symidx
)
7447 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7448 maxchain
= gnubuckets
[i
];
7451 if (maxchain
== 0xffffffff)
7457 (archive_file_offset
7458 + offset_from_vma (file
, buckets_vma
7459 + 4 * (ngnubuckets
+ maxchain
), 4)),
7462 error (_("Unable to seek to start of dynamic information"));
7468 if (fread (nb
, 4, 1, file
) != 1)
7470 error (_("Failed to determine last chain length\n"));
7474 if (maxchain
+ 1 == 0)
7479 while ((byte_get (nb
, 4) & 1) == 0);
7482 (archive_file_offset
7483 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7486 error (_("Unable to seek to start of dynamic information"));
7490 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7492 if (gnuchains
== NULL
)
7495 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7496 if (lengths
== NULL
)
7498 error (_("Out of memory"));
7502 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7503 (unsigned long) ngnubuckets
);
7504 printf (_(" Length Number %% of total Coverage\n"));
7506 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7507 if (gnubuckets
[hn
] != 0)
7509 bfd_vma off
, length
= 1;
7511 for (off
= gnubuckets
[hn
] - symidx
;
7512 (gnuchains
[off
] & 1) == 0; ++off
)
7514 lengths
[hn
] = length
;
7515 if (length
> maxlength
)
7520 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7523 error (_("Out of memory"));
7527 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7528 ++counts
[lengths
[hn
]];
7530 if (ngnubuckets
> 0)
7533 printf (" 0 %-10lu (%5.1f%%)\n",
7534 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7535 for (j
= 1; j
<= maxlength
; ++j
)
7537 nzero_counts
+= counts
[j
] * j
;
7538 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7539 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7540 (nzero_counts
* 100.0) / nsyms
);
7554 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7558 if (dynamic_syminfo
== NULL
7560 /* No syminfo, this is ok. */
7563 /* There better should be a dynamic symbol section. */
7564 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7568 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7569 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7571 printf (_(" Num: Name BoundTo Flags\n"));
7572 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7574 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7576 printf ("%4d: ", i
);
7577 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7578 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7580 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7583 switch (dynamic_syminfo
[i
].si_boundto
)
7585 case SYMINFO_BT_SELF
:
7586 fputs ("SELF ", stdout
);
7588 case SYMINFO_BT_PARENT
:
7589 fputs ("PARENT ", stdout
);
7592 if (dynamic_syminfo
[i
].si_boundto
> 0
7593 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7594 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7596 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7600 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7604 if (flags
& SYMINFO_FLG_DIRECT
)
7606 if (flags
& SYMINFO_FLG_PASSTHRU
)
7607 printf (" PASSTHRU");
7608 if (flags
& SYMINFO_FLG_COPY
)
7610 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7611 printf (" LAZYLOAD");
7619 #ifdef SUPPORT_DISASSEMBLY
7621 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7623 printf (_("\nAssembly dump of section %s\n"),
7624 SECTION_NAME (section
));
7626 /* XXX -- to be done --- XXX */
7633 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7635 bfd_size_type bytes
;
7637 unsigned char *data
;
7638 unsigned char *start
;
7640 bytes
= section
->sh_size
;
7642 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7644 printf (_("\nSection '%s' has no data to dump.\n"),
7645 SECTION_NAME (section
));
7649 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7651 addr
= section
->sh_addr
;
7653 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7666 lbytes
= (bytes
> 16 ? 16 : bytes
);
7668 printf (" 0x%8.8lx ", (unsigned long) addr
);
7670 switch (elf_header
.e_ident
[EI_DATA
])
7674 for (j
= 15; j
>= 0; j
--)
7677 printf ("%2.2x", data
[j
]);
7687 for (j
= 0; j
< 16; j
++)
7690 printf ("%2.2x", data
[j
]);
7700 for (j
= 0; j
< lbytes
; j
++)
7703 if (k
>= ' ' && k
< 0x7f)
7721 /* Apply addends of RELA relocations. */
7724 debug_apply_rela_addends (void *file
,
7725 Elf_Internal_Shdr
*section
,
7726 unsigned char *start
)
7728 Elf_Internal_Shdr
*relsec
;
7729 unsigned char *end
= start
+ section
->sh_size
;
7730 /* FIXME: The relocation field size is relocation type dependent. */
7731 unsigned int reloc_size
= 4;
7733 if (!is_relocatable
)
7736 if (section
->sh_size
< reloc_size
)
7739 for (relsec
= section_headers
;
7740 relsec
< section_headers
+ elf_header
.e_shnum
;
7743 unsigned long nrelas
;
7744 Elf_Internal_Rela
*rela
, *rp
;
7745 Elf_Internal_Shdr
*symsec
;
7746 Elf_Internal_Sym
*symtab
;
7747 Elf_Internal_Sym
*sym
;
7749 if (relsec
->sh_type
!= SHT_RELA
7750 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7751 || SECTION_HEADER (relsec
->sh_info
) != section
7752 || relsec
->sh_size
== 0
7753 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7756 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7760 symsec
= SECTION_HEADER (relsec
->sh_link
);
7761 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7763 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7767 loc
= start
+ rp
->r_offset
;
7768 if ((loc
+ reloc_size
) > end
)
7770 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7771 (unsigned long) rp
->r_offset
,
7772 SECTION_NAME (section
));
7778 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7780 if (ELF32_R_SYM (rp
->r_info
) != 0
7781 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7782 /* Relocations against symbols without type can happen.
7783 Gcc -feliminate-dwarf2-dups may generate symbols
7784 without type for debug info. */
7785 && ELF32_ST_TYPE (sym
->st_info
) != STT_NOTYPE
7786 /* Relocations against object symbols can happen,
7787 eg when referencing a global array. For an
7788 example of this see the _clz.o binary in libgcc.a. */
7789 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7791 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7792 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7793 SECTION_NAME (section
));
7799 /* In MIPS little-endian objects, r_info isn't really a
7800 64-bit little-endian value: it has a 32-bit little-endian
7801 symbol index followed by four individual byte fields.
7802 Reorder INFO accordingly. */
7803 if (elf_header
.e_machine
== EM_MIPS
7804 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7805 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7806 | ((rp
->r_info
>> 56) & 0xff)
7807 | ((rp
->r_info
>> 40) & 0xff00)
7808 | ((rp
->r_info
>> 24) & 0xff0000)
7809 | ((rp
->r_info
>> 8) & 0xff000000));
7811 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7813 if (ELF64_R_SYM (rp
->r_info
) != 0
7814 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7815 && ELF64_ST_TYPE (sym
->st_info
) != STT_NOTYPE
7816 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7818 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7819 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7820 SECTION_NAME (section
));
7825 byte_put (loc
, rp
->r_addend
, reloc_size
);
7836 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
7838 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7839 Elf_Internal_Shdr
*sec
;
7842 /* If it is already loaded, do nothing. */
7843 if (section
->start
!= NULL
)
7846 /* Locate the debug section. */
7847 sec
= find_section (section
->name
);
7851 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
7852 section
->address
= sec
->sh_addr
;
7853 section
->size
= sec
->sh_size
;
7854 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7857 if (debug_displays
[debug
].relocate
)
7858 debug_apply_rela_addends (file
, sec
, section
->start
);
7860 return section
->start
!= NULL
;
7864 free_debug_section (enum dwarf_section_display_enum debug
)
7866 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7868 if (section
->start
== NULL
)
7871 free ((char *) section
->start
);
7872 section
->start
= NULL
;
7873 section
->address
= 0;
7878 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
7880 char *name
= SECTION_NAME (section
);
7881 bfd_size_type length
;
7883 enum dwarf_section_display_enum i
;
7885 length
= section
->sh_size
;
7888 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7892 if (const_strneq (name
, ".gnu.linkonce.wi."))
7893 name
= ".debug_info";
7895 /* See if we know how to display the contents of this section. */
7896 for (i
= 0; i
< max
; i
++)
7897 if (streq (debug_displays
[i
].section
.name
, name
))
7899 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
7901 if (load_debug_section (i
, file
))
7903 result
&= debug_displays
[i
].display (sec
, file
);
7905 if (i
!= info
&& i
!= abbrev
)
7906 free_debug_section (i
);
7914 printf (_("Unrecognized debug section: %s\n"), name
);
7921 /* Set DUMP_SECTS for all sections where dumps were requested
7922 based on section name. */
7925 initialise_dumps_byname (void)
7927 struct dump_list_entry
*cur
;
7929 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
7934 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
7935 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
7937 request_dump (i
, cur
->type
);
7942 warn (_("Section '%s' was not dumped because it does not exist!\n"),
7948 process_section_contents (FILE *file
)
7950 Elf_Internal_Shdr
*section
;
7956 initialise_dumps_byname ();
7958 for (i
= 0, section
= section_headers
;
7959 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7962 #ifdef SUPPORT_DISASSEMBLY
7963 if (dump_sects
[i
] & DISASS_DUMP
)
7964 disassemble_section (section
, file
);
7966 if (dump_sects
[i
] & HEX_DUMP
)
7967 dump_section (section
, file
);
7969 if (dump_sects
[i
] & DEBUG_DUMP
)
7970 display_debug_section (section
, file
);
7973 /* Check to see if the user requested a
7974 dump of a section that does not exist. */
7975 while (i
++ < num_dump_sects
)
7977 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
7981 process_mips_fpe_exception (int mask
)
7986 if (mask
& OEX_FPU_INEX
)
7987 fputs ("INEX", stdout
), first
= 0;
7988 if (mask
& OEX_FPU_UFLO
)
7989 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7990 if (mask
& OEX_FPU_OFLO
)
7991 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7992 if (mask
& OEX_FPU_DIV0
)
7993 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7994 if (mask
& OEX_FPU_INVAL
)
7995 printf ("%sINVAL", first
? "" : "|");
7998 fputs ("0", stdout
);
8001 /* ARM EABI attributes section. */
8006 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8009 } arm_attr_public_tag
;
8011 static const char *arm_attr_tag_CPU_arch
[] =
8012 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8014 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8015 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8016 {"No", "Thumb-1", "Thumb-2"};
8017 /* FIXME: VFPv3 encoding was extrapolated! */
8018 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8019 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8020 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8021 static const char *arm_attr_tag_ABI_PCS_config
[] =
8022 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8023 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8024 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8025 {"V6", "SB", "TLS", "Unused"};
8026 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8027 {"Absolute", "PC-relative", "SB-relative", "None"};
8028 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8029 {"Absolute", "PC-relative", "None"};
8030 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8031 {"None", "direct", "GOT-indirect"};
8032 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8033 {"None", "??? 1", "2", "??? 3", "4"};
8034 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8035 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8036 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8037 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8038 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8039 {"Unused", "Finite", "RTABI", "IEEE 754"};
8040 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8041 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8042 {"No", "Yes, except leaf SP", "Yes"};
8043 static const char *arm_attr_tag_ABI_enum_size
[] =
8044 {"Unused", "small", "int", "forced to int"};
8045 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8046 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8047 static const char *arm_attr_tag_ABI_VFP_args
[] =
8048 {"AAPCS", "VFP registers", "custom"};
8049 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8050 {"AAPCS", "WMMX registers", "custom"};
8051 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8052 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8053 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8054 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8055 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8056 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8058 #define LOOKUP(id, name) \
8059 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8060 static arm_attr_public_tag arm_attr_public_tags
[] =
8062 {4, "CPU_raw_name", 1, NULL
},
8063 {5, "CPU_name", 1, NULL
},
8064 LOOKUP(6, CPU_arch
),
8065 {7, "CPU_arch_profile", 0, NULL
},
8066 LOOKUP(8, ARM_ISA_use
),
8067 LOOKUP(9, THUMB_ISA_use
),
8068 LOOKUP(10, VFP_arch
),
8069 LOOKUP(11, WMMX_arch
),
8070 LOOKUP(12, NEON_arch
),
8071 LOOKUP(13, ABI_PCS_config
),
8072 LOOKUP(14, ABI_PCS_R9_use
),
8073 LOOKUP(15, ABI_PCS_RW_data
),
8074 LOOKUP(16, ABI_PCS_RO_DATA
),
8075 LOOKUP(17, ABI_PCS_GOT_use
),
8076 LOOKUP(18, ABI_PCS_wchar_t
),
8077 LOOKUP(19, ABI_FP_rounding
),
8078 LOOKUP(20, ABI_FP_denormal
),
8079 LOOKUP(21, ABI_FP_exceptions
),
8080 LOOKUP(22, ABI_FP_user_exceptions
),
8081 LOOKUP(23, ABI_FP_number_model
),
8082 LOOKUP(24, ABI_align8_needed
),
8083 LOOKUP(25, ABI_align8_preserved
),
8084 LOOKUP(26, ABI_enum_size
),
8085 LOOKUP(27, ABI_HardFP_use
),
8086 LOOKUP(28, ABI_VFP_args
),
8087 LOOKUP(29, ABI_WMMX_args
),
8088 LOOKUP(30, ABI_optimization_goals
),
8089 LOOKUP(31, ABI_FP_optimization_goals
),
8090 {32, "compatibility", 0, NULL
}
8094 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8097 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8111 val
|= ((unsigned int)c
& 0x7f) << shift
;
8120 static unsigned char *
8121 display_arm_attribute (unsigned char *p
)
8126 arm_attr_public_tag
*attr
;
8130 tag
= read_uleb128 (p
, &len
);
8133 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8135 if (arm_attr_public_tags
[i
].tag
== tag
)
8137 attr
= &arm_attr_public_tags
[i
];
8144 printf (" Tag_%s: ", attr
->name
);
8150 case 7: /* Tag_CPU_arch_profile. */
8151 val
= read_uleb128 (p
, &len
);
8155 case 0: printf ("None\n"); break;
8156 case 'A': printf ("Application\n"); break;
8157 case 'R': printf ("Realtime\n"); break;
8158 case 'M': printf ("Microcontroller\n"); break;
8159 default: printf ("??? (%d)\n", val
); break;
8163 case 32: /* Tag_compatibility. */
8164 val
= read_uleb128 (p
, &len
);
8166 printf ("flag = %d, vendor = %s\n", val
, p
);
8167 p
+= strlen((char *)p
) + 1;
8181 assert (attr
->type
& 0x80);
8182 val
= read_uleb128 (p
, &len
);
8184 type
= attr
->type
& 0x7f;
8186 printf ("??? (%d)\n", val
);
8188 printf ("%s\n", attr
->table
[val
]);
8195 type
= 1; /* String. */
8197 type
= 2; /* uleb128. */
8198 printf (" Tag_unknown_%d: ", tag
);
8203 printf ("\"%s\"\n", p
);
8204 p
+= strlen((char *)p
) + 1;
8208 val
= read_uleb128 (p
, &len
);
8210 printf ("%d (0x%x)\n", val
, val
);
8217 process_arm_specific (FILE *file
)
8219 Elf_Internal_Shdr
*sect
;
8220 unsigned char *contents
;
8223 bfd_vma section_len
;
8227 /* Find the section header so that we get the size. */
8228 for (i
= 0, sect
= section_headers
;
8229 i
< elf_header
.e_shnum
;
8232 if (sect
->sh_type
!= SHT_ARM_ATTRIBUTES
)
8235 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
8243 len
= sect
->sh_size
- 1;
8248 bfd_boolean public_section
;
8250 section_len
= byte_get (p
, 4);
8252 if (section_len
> len
)
8254 printf (_("ERROR: Bad section length (%d > %d)\n"),
8255 (int)section_len
, (int)len
);
8259 printf ("Attribute Section: %s\n", p
);
8260 if (strcmp ((char *)p
, "aeabi") == 0)
8261 public_section
= TRUE
;
8263 public_section
= FALSE
;
8264 namelen
= strlen ((char *)p
) + 1;
8266 section_len
-= namelen
+ 4;
8267 while (section_len
> 0)
8272 size
= byte_get (p
, 4);
8273 if (size
> section_len
)
8275 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8276 (int)size
, (int)section_len
);
8279 section_len
-= size
;
8285 printf ("File Attributes\n");
8288 printf ("Section Attributes:");
8291 printf ("Symbol Attributes:");
8296 val
= read_uleb128 (p
, &i
);
8300 printf (" %d", val
);
8305 printf ("Unknown tag: %d\n", tag
);
8306 public_section
= FALSE
;
8312 p
= display_arm_attribute(p
);
8316 /* ??? Do something sensible, like dump hex. */
8317 printf (" Unknown section contexts\n");
8325 printf (_("Unknown format '%c'\n"), *p
);
8334 process_mips_specific (FILE *file
)
8336 Elf_Internal_Dyn
*entry
;
8337 size_t liblist_offset
= 0;
8338 size_t liblistno
= 0;
8339 size_t conflictsno
= 0;
8340 size_t options_offset
= 0;
8341 size_t conflicts_offset
= 0;
8343 /* We have a lot of special sections. Thanks SGI! */
8344 if (dynamic_section
== NULL
)
8345 /* No information available. */
8348 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
8349 switch (entry
->d_tag
)
8351 case DT_MIPS_LIBLIST
:
8353 = offset_from_vma (file
, entry
->d_un
.d_val
,
8354 liblistno
* sizeof (Elf32_External_Lib
));
8356 case DT_MIPS_LIBLISTNO
:
8357 liblistno
= entry
->d_un
.d_val
;
8359 case DT_MIPS_OPTIONS
:
8360 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8362 case DT_MIPS_CONFLICT
:
8364 = offset_from_vma (file
, entry
->d_un
.d_val
,
8365 conflictsno
* sizeof (Elf32_External_Conflict
));
8367 case DT_MIPS_CONFLICTNO
:
8368 conflictsno
= entry
->d_un
.d_val
;
8374 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8376 Elf32_External_Lib
*elib
;
8379 elib
= get_data (NULL
, file
, liblist_offset
,
8380 liblistno
, sizeof (Elf32_External_Lib
),
8384 printf ("\nSection '.liblist' contains %lu entries:\n",
8385 (unsigned long) liblistno
);
8386 fputs (" Library Time Stamp Checksum Version Flags\n",
8389 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8396 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8397 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8398 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8399 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8400 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8402 tmp
= gmtime (&time
);
8403 snprintf (timebuf
, sizeof (timebuf
),
8404 "%04u-%02u-%02uT%02u:%02u:%02u",
8405 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8406 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8408 printf ("%3lu: ", (unsigned long) cnt
);
8409 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
8410 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
8412 printf ("<corrupt: %9ld>", liblist
.l_name
);
8413 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8416 if (liblist
.l_flags
== 0)
8427 { " EXACT_MATCH", LL_EXACT_MATCH
},
8428 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8429 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8430 { " EXPORTS", LL_EXPORTS
},
8431 { " DELAY_LOAD", LL_DELAY_LOAD
},
8432 { " DELTA", LL_DELTA
}
8434 int flags
= liblist
.l_flags
;
8438 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
8440 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8442 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8443 flags
^= l_flags_vals
[fcnt
].bit
;
8446 printf (" %#x", (unsigned int) flags
);
8456 if (options_offset
!= 0)
8458 Elf_External_Options
*eopt
;
8459 Elf_Internal_Shdr
*sect
= section_headers
;
8460 Elf_Internal_Options
*iopt
;
8461 Elf_Internal_Options
*option
;
8465 /* Find the section header so that we get the size. */
8466 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8469 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8473 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8476 error (_("Out of memory"));
8483 while (offset
< sect
->sh_size
)
8485 Elf_External_Options
*eoption
;
8487 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8489 option
->kind
= BYTE_GET (eoption
->kind
);
8490 option
->size
= BYTE_GET (eoption
->size
);
8491 option
->section
= BYTE_GET (eoption
->section
);
8492 option
->info
= BYTE_GET (eoption
->info
);
8494 offset
+= option
->size
;
8500 printf (_("\nSection '%s' contains %d entries:\n"),
8501 SECTION_NAME (sect
), cnt
);
8509 switch (option
->kind
)
8512 /* This shouldn't happen. */
8513 printf (" NULL %d %lx", option
->section
, option
->info
);
8516 printf (" REGINFO ");
8517 if (elf_header
.e_machine
== EM_MIPS
)
8520 Elf32_External_RegInfo
*ereg
;
8521 Elf32_RegInfo reginfo
;
8523 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8524 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8525 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8526 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8527 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8528 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8529 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8531 printf ("GPR %08lx GP 0x%lx\n",
8533 (unsigned long) reginfo
.ri_gp_value
);
8534 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8535 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8536 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8541 Elf64_External_RegInfo
*ereg
;
8542 Elf64_Internal_RegInfo reginfo
;
8544 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8545 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8546 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8547 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8548 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8549 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8550 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8552 printf ("GPR %08lx GP 0x",
8553 reginfo
.ri_gprmask
);
8554 printf_vma (reginfo
.ri_gp_value
);
8557 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8558 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8559 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8563 case ODK_EXCEPTIONS
:
8564 fputs (" EXCEPTIONS fpe_min(", stdout
);
8565 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8566 fputs (") fpe_max(", stdout
);
8567 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8568 fputs (")", stdout
);
8570 if (option
->info
& OEX_PAGE0
)
8571 fputs (" PAGE0", stdout
);
8572 if (option
->info
& OEX_SMM
)
8573 fputs (" SMM", stdout
);
8574 if (option
->info
& OEX_FPDBUG
)
8575 fputs (" FPDBUG", stdout
);
8576 if (option
->info
& OEX_DISMISS
)
8577 fputs (" DISMISS", stdout
);
8580 fputs (" PAD ", stdout
);
8581 if (option
->info
& OPAD_PREFIX
)
8582 fputs (" PREFIX", stdout
);
8583 if (option
->info
& OPAD_POSTFIX
)
8584 fputs (" POSTFIX", stdout
);
8585 if (option
->info
& OPAD_SYMBOL
)
8586 fputs (" SYMBOL", stdout
);
8589 fputs (" HWPATCH ", stdout
);
8590 if (option
->info
& OHW_R4KEOP
)
8591 fputs (" R4KEOP", stdout
);
8592 if (option
->info
& OHW_R8KPFETCH
)
8593 fputs (" R8KPFETCH", stdout
);
8594 if (option
->info
& OHW_R5KEOP
)
8595 fputs (" R5KEOP", stdout
);
8596 if (option
->info
& OHW_R5KCVTL
)
8597 fputs (" R5KCVTL", stdout
);
8600 fputs (" FILL ", stdout
);
8601 /* XXX Print content of info word? */
8604 fputs (" TAGS ", stdout
);
8605 /* XXX Print content of info word? */
8608 fputs (" HWAND ", stdout
);
8609 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8610 fputs (" R4KEOP_CHECKED", stdout
);
8611 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8612 fputs (" R4KEOP_CLEAN", stdout
);
8615 fputs (" HWOR ", stdout
);
8616 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8617 fputs (" R4KEOP_CHECKED", stdout
);
8618 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8619 fputs (" R4KEOP_CLEAN", stdout
);
8622 printf (" GP_GROUP %#06lx self-contained %#06lx",
8623 option
->info
& OGP_GROUP
,
8624 (option
->info
& OGP_SELF
) >> 16);
8627 printf (" IDENT %#06lx self-contained %#06lx",
8628 option
->info
& OGP_GROUP
,
8629 (option
->info
& OGP_SELF
) >> 16);
8632 /* This shouldn't happen. */
8633 printf (" %3d ??? %d %lx",
8634 option
->kind
, option
->section
, option
->info
);
8638 len
= sizeof (*eopt
);
8639 while (len
< option
->size
)
8640 if (((char *) option
)[len
] >= ' '
8641 && ((char *) option
)[len
] < 0x7f)
8642 printf ("%c", ((char *) option
)[len
++]);
8644 printf ("\\%03o", ((char *) option
)[len
++]);
8646 fputs ("\n", stdout
);
8654 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8656 Elf32_Conflict
*iconf
;
8659 if (dynamic_symbols
== NULL
)
8661 error (_("conflict list found without a dynamic symbol table"));
8665 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
8668 error (_("Out of memory"));
8674 Elf32_External_Conflict
*econf32
;
8676 econf32
= get_data (NULL
, file
, conflicts_offset
,
8677 conflictsno
, sizeof (*econf32
), _("conflict"));
8681 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8682 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8688 Elf64_External_Conflict
*econf64
;
8690 econf64
= get_data (NULL
, file
, conflicts_offset
,
8691 conflictsno
, sizeof (*econf64
), _("conflict"));
8695 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8696 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8701 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8702 (unsigned long) conflictsno
);
8703 puts (_(" Num: Index Value Name"));
8705 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8707 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
8709 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8710 print_vma (psym
->st_value
, FULL_HEX
);
8712 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8713 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8715 printf ("<corrupt: %14ld>", psym
->st_name
);
8726 process_gnu_liblist (FILE *file
)
8728 Elf_Internal_Shdr
*section
, *string_sec
;
8729 Elf32_External_Lib
*elib
;
8738 for (i
= 0, section
= section_headers
;
8739 i
< elf_header
.e_shnum
;
8742 switch (section
->sh_type
)
8744 case SHT_GNU_LIBLIST
:
8745 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
8748 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
8753 string_sec
= SECTION_HEADER (section
->sh_link
);
8755 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8756 string_sec
->sh_size
, _("liblist string table"));
8757 strtab_size
= string_sec
->sh_size
;
8760 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
8766 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8767 SECTION_NAME (section
),
8768 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
8770 puts (" Library Time Stamp Checksum Version Flags");
8772 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
8780 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8781 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8782 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8783 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8784 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8786 tmp
= gmtime (&time
);
8787 snprintf (timebuf
, sizeof (timebuf
),
8788 "%04u-%02u-%02uT%02u:%02u:%02u",
8789 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8790 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8792 printf ("%3lu: ", (unsigned long) cnt
);
8794 printf ("%-20s", liblist
.l_name
< strtab_size
8795 ? strtab
+ liblist
.l_name
: "<corrupt>");
8797 printf ("%-20.20s", liblist
.l_name
< strtab_size
8798 ? strtab
+ liblist
.l_name
: "<corrupt>");
8799 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
8800 liblist
.l_version
, liblist
.l_flags
);
8811 get_note_type (unsigned e_type
)
8813 static char buff
[64];
8815 if (elf_header
.e_type
== ET_CORE
)
8819 return _("NT_AUXV (auxiliary vector)");
8821 return _("NT_PRSTATUS (prstatus structure)");
8823 return _("NT_FPREGSET (floating point registers)");
8825 return _("NT_PRPSINFO (prpsinfo structure)");
8827 return _("NT_TASKSTRUCT (task structure)");
8829 return _("NT_PRXFPREG (user_xfpregs structure)");
8831 return _("NT_PSTATUS (pstatus structure)");
8833 return _("NT_FPREGS (floating point registers)");
8835 return _("NT_PSINFO (psinfo structure)");
8837 return _("NT_LWPSTATUS (lwpstatus_t structure)");
8839 return _("NT_LWPSINFO (lwpsinfo_t structure)");
8840 case NT_WIN32PSTATUS
:
8841 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8849 return _("NT_VERSION (version)");
8851 return _("NT_ARCH (architecture)");
8856 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8861 get_netbsd_elfcore_note_type (unsigned e_type
)
8863 static char buff
[64];
8865 if (e_type
== NT_NETBSDCORE_PROCINFO
)
8867 /* NetBSD core "procinfo" structure. */
8868 return _("NetBSD procinfo structure");
8871 /* As of Jan 2002 there are no other machine-independent notes
8872 defined for NetBSD core files. If the note type is less
8873 than the start of the machine-dependent note types, we don't
8876 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
8878 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8882 switch (elf_header
.e_machine
)
8884 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8885 and PT_GETFPREGS == mach+2. */
8890 case EM_SPARC32PLUS
:
8894 case NT_NETBSDCORE_FIRSTMACH
+0:
8895 return _("PT_GETREGS (reg structure)");
8896 case NT_NETBSDCORE_FIRSTMACH
+2:
8897 return _("PT_GETFPREGS (fpreg structure)");
8903 /* On all other arch's, PT_GETREGS == mach+1 and
8904 PT_GETFPREGS == mach+3. */
8908 case NT_NETBSDCORE_FIRSTMACH
+1:
8909 return _("PT_GETREGS (reg structure)");
8910 case NT_NETBSDCORE_FIRSTMACH
+3:
8911 return _("PT_GETFPREGS (fpreg structure)");
8917 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
8918 e_type
- NT_NETBSDCORE_FIRSTMACH
);
8922 /* Note that by the ELF standard, the name field is already null byte
8923 terminated, and namesz includes the terminating null byte.
8924 I.E. the value of namesz for the name "FSF" is 4.
8926 If the value of namesz is zero, there is no name present. */
8928 process_note (Elf_Internal_Note
*pnote
)
8932 if (pnote
->namesz
== 0)
8933 /* If there is no note name, then use the default set of
8934 note type strings. */
8935 nt
= get_note_type (pnote
->type
);
8937 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
8938 /* NetBSD-specific core file notes. */
8939 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
8942 /* Don't recognize this note name; just use the default set of
8943 note type strings. */
8944 nt
= get_note_type (pnote
->type
);
8946 printf (" %s\t\t0x%08lx\t%s\n",
8947 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8954 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
8956 Elf_External_Note
*pnotes
;
8957 Elf_External_Note
*external
;
8963 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
8969 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8970 (unsigned long) offset
, (unsigned long) length
);
8971 printf (_(" Owner\t\tData size\tDescription\n"));
8973 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8975 Elf_External_Note
*next
;
8976 Elf_Internal_Note inote
;
8979 inote
.type
= BYTE_GET (external
->type
);
8980 inote
.namesz
= BYTE_GET (external
->namesz
);
8981 inote
.namedata
= external
->name
;
8982 inote
.descsz
= BYTE_GET (external
->descsz
);
8983 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8984 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8986 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8988 if (((char *) next
) > (((char *) pnotes
) + length
))
8990 warn (_("corrupt note found at offset %lx into core notes\n"),
8991 (long)((char *)external
- (char *)pnotes
));
8992 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8993 inote
.type
, inote
.namesz
, inote
.descsz
);
8999 /* Verify that name is null terminated. It appears that at least
9000 one version of Linux (RedHat 6.0) generates corefiles that don't
9001 comply with the ELF spec by failing to include the null byte in
9003 if (inote
.namedata
[inote
.namesz
] != '\0')
9005 temp
= malloc (inote
.namesz
+ 1);
9009 error (_("Out of memory\n"));
9014 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9015 temp
[inote
.namesz
] = 0;
9017 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9018 inote
.namedata
= temp
;
9021 res
&= process_note (& inote
);
9036 process_corefile_note_segments (FILE *file
)
9038 Elf_Internal_Phdr
*segment
;
9042 if (! get_program_headers (file
))
9045 for (i
= 0, segment
= program_headers
;
9046 i
< elf_header
.e_phnum
;
9049 if (segment
->p_type
== PT_NOTE
)
9050 res
&= process_corefile_note_segment (file
,
9051 (bfd_vma
) segment
->p_offset
,
9052 (bfd_vma
) segment
->p_filesz
);
9059 process_note_sections (FILE *file
)
9061 Elf_Internal_Shdr
*section
;
9065 for (i
= 0, section
= section_headers
;
9066 i
< elf_header
.e_shnum
;
9068 if (section
->sh_type
== SHT_NOTE
)
9069 res
&= process_corefile_note_segment (file
,
9070 (bfd_vma
) section
->sh_offset
,
9071 (bfd_vma
) section
->sh_size
);
9077 process_notes (FILE *file
)
9079 /* If we have not been asked to display the notes then do nothing. */
9083 if (elf_header
.e_type
!= ET_CORE
)
9084 return process_note_sections (file
);
9086 /* No program headers means no NOTE segment. */
9087 if (elf_header
.e_phnum
> 0)
9088 return process_corefile_note_segments (file
);
9090 printf (_("No note segments present in the core file.\n"));
9095 process_arch_specific (FILE *file
)
9100 switch (elf_header
.e_machine
)
9103 return process_arm_specific (file
);
9105 case EM_MIPS_RS3_LE
:
9106 return process_mips_specific (file
);
9115 get_file_header (FILE *file
)
9117 /* Read in the identity array. */
9118 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9121 /* Determine how to read the rest of the header. */
9122 switch (elf_header
.e_ident
[EI_DATA
])
9124 default: /* fall through */
9125 case ELFDATANONE
: /* fall through */
9127 byte_get
= byte_get_little_endian
;
9128 byte_put
= byte_put_little_endian
;
9131 byte_get
= byte_get_big_endian
;
9132 byte_put
= byte_put_big_endian
;
9136 /* For now we only support 32 bit and 64 bit ELF files. */
9137 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9139 /* Read in the rest of the header. */
9142 Elf32_External_Ehdr ehdr32
;
9144 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9147 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9148 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9149 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9150 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9151 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9152 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9153 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9154 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9155 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9156 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9157 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9158 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9159 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9163 Elf64_External_Ehdr ehdr64
;
9165 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9166 we will not be able to cope with the 64bit data found in
9167 64 ELF files. Detect this now and abort before we start
9168 overwriting things. */
9169 if (sizeof (bfd_vma
) < 8)
9171 error (_("This instance of readelf has been built without support for a\n\
9172 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9176 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9179 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9180 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9181 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9182 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
9183 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
9184 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
9185 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9186 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9187 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9188 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9189 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9190 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9191 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9194 if (elf_header
.e_shoff
)
9196 /* There may be some extensions in the first section header. Don't
9197 bomb if we can't read it. */
9199 get_32bit_section_headers (file
, 1);
9201 get_64bit_section_headers (file
, 1);
9204 is_relocatable
= elf_header
.e_type
== ET_REL
;
9209 /* Process one ELF object file according to the command line options.
9210 This file may actually be stored in an archive. The file is
9211 positioned at the start of the ELF object. */
9214 process_object (char *file_name
, FILE *file
)
9218 if (! get_file_header (file
))
9220 error (_("%s: Failed to read file header\n"), file_name
);
9224 /* Initialise per file variables. */
9225 for (i
= NUM_ELEM (version_info
); i
--;)
9226 version_info
[i
] = 0;
9228 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9229 dynamic_info
[i
] = 0;
9231 /* Process the file. */
9233 printf (_("\nFile: %s\n"), file_name
);
9235 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9236 Note we do this even if cmdline_dump_sects is empty because we
9237 must make sure that the dump_sets array is zeroed out before each
9238 object file is processed. */
9239 if (num_dump_sects
> num_cmdline_dump_sects
)
9240 memset (dump_sects
, 0, num_dump_sects
);
9242 if (num_cmdline_dump_sects
> 0)
9244 if (num_dump_sects
== 0)
9245 /* A sneaky way of allocating the dump_sects array. */
9246 request_dump (num_cmdline_dump_sects
, 0);
9248 assert (num_dump_sects
>= num_cmdline_dump_sects
);
9249 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
9252 if (! process_file_header ())
9255 if (! process_section_headers (file
))
9257 /* Without loaded section headers we cannot process lots of
9259 do_unwind
= do_version
= do_dump
= do_arch
= 0;
9261 if (! do_using_dynamic
)
9262 do_syms
= do_reloc
= 0;
9265 if (! process_section_groups (file
))
9267 /* Without loaded section groups we cannot process unwind. */
9271 if (process_program_headers (file
))
9272 process_dynamic_section (file
);
9274 process_relocs (file
);
9276 process_unwind (file
);
9278 process_symbol_table (file
);
9280 process_syminfo (file
);
9282 process_version_sections (file
);
9284 process_section_contents (file
);
9286 process_notes (file
);
9288 process_gnu_liblist (file
);
9290 process_arch_specific (file
);
9292 if (program_headers
)
9294 free (program_headers
);
9295 program_headers
= NULL
;
9298 if (section_headers
)
9300 free (section_headers
);
9301 section_headers
= NULL
;
9306 free (string_table
);
9307 string_table
= NULL
;
9308 string_table_length
= 0;
9311 if (dynamic_strings
)
9313 free (dynamic_strings
);
9314 dynamic_strings
= NULL
;
9315 dynamic_strings_length
= 0;
9318 if (dynamic_symbols
)
9320 free (dynamic_symbols
);
9321 dynamic_symbols
= NULL
;
9322 num_dynamic_syms
= 0;
9325 if (dynamic_syminfo
)
9327 free (dynamic_syminfo
);
9328 dynamic_syminfo
= NULL
;
9331 if (section_headers_groups
)
9333 free (section_headers_groups
);
9334 section_headers_groups
= NULL
;
9339 struct group_list
*g
, *next
;
9341 for (i
= 0; i
< group_count
; i
++)
9343 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
9350 free (section_groups
);
9351 section_groups
= NULL
;
9354 free_debug_memory ();
9359 /* Process an ELF archive. The file is positioned just after the
9363 process_archive (char *file_name
, FILE *file
)
9365 struct ar_hdr arhdr
;
9368 char *longnames
= NULL
;
9369 unsigned long longnames_size
= 0;
9370 size_t file_name_size
;
9375 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9376 if (got
!= sizeof arhdr
)
9381 error (_("%s: failed to read archive header\n"), file_name
);
9385 if (const_strneq (arhdr
.ar_name
, "/ "))
9387 /* This is the archive symbol table. Skip it.
9388 FIXME: We should have an option to dump it. */
9389 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9390 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
9392 error (_("%s: failed to skip archive symbol table\n"), file_name
);
9396 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9397 if (got
!= sizeof arhdr
)
9402 error (_("%s: failed to read archive header\n"), file_name
);
9407 if (const_strneq (arhdr
.ar_name
, "// "))
9409 /* This is the archive string table holding long member
9412 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9414 longnames
= malloc (longnames_size
);
9415 if (longnames
== NULL
)
9417 error (_("Out of memory\n"));
9421 if (fread (longnames
, longnames_size
, 1, file
) != 1)
9424 error (_("%s: failed to read string table\n"), file_name
);
9428 if ((longnames_size
& 1) != 0)
9431 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9432 if (got
!= sizeof arhdr
)
9439 error (_("%s: failed to read archive header\n"), file_name
);
9444 file_name_size
= strlen (file_name
);
9453 if (arhdr
.ar_name
[0] == '/')
9457 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
9458 if (off
>= longnames_size
)
9460 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
9465 name
= longnames
+ off
;
9466 nameend
= memchr (name
, '/', longnames_size
- off
);
9470 name
= arhdr
.ar_name
;
9471 nameend
= memchr (name
, '/', 16);
9474 if (nameend
== NULL
)
9476 error (_("%s: bad archive file name\n"), file_name
);
9481 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
9482 if (namealc
== NULL
)
9484 error (_("Out of memory\n"));
9489 memcpy (namealc
, file_name
, file_name_size
);
9490 namealc
[file_name_size
] = '(';
9491 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
9492 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
9493 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
9495 archive_file_offset
= ftell (file
);
9496 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9498 ret
|= process_object (namealc
, file
);
9503 (archive_file_offset
9505 + (archive_file_size
& 1)),
9508 error (_("%s: failed to seek to next archive header\n"), file_name
);
9513 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9514 if (got
!= sizeof arhdr
)
9519 error (_("%s: failed to read archive header\n"), file_name
);
9532 process_file (char *file_name
)
9535 struct stat statbuf
;
9539 if (stat (file_name
, &statbuf
) < 0)
9541 if (errno
== ENOENT
)
9542 error (_("'%s': No such file\n"), file_name
);
9544 error (_("Could not locate '%s'. System error message: %s\n"),
9545 file_name
, strerror (errno
));
9549 if (! S_ISREG (statbuf
.st_mode
))
9551 error (_("'%s' is not an ordinary file\n"), file_name
);
9555 file
= fopen (file_name
, "rb");
9558 error (_("Input file '%s' is not readable.\n"), file_name
);
9562 if (fread (armag
, SARMAG
, 1, file
) != 1)
9564 error (_("%s: Failed to read file header\n"), file_name
);
9569 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
9570 ret
= process_archive (file_name
, file
);
9574 archive_file_size
= archive_file_offset
= 0;
9575 ret
= process_object (file_name
, file
);
9583 #ifdef SUPPORT_DISASSEMBLY
9584 /* Needed by the i386 disassembler. For extra credit, someone could
9585 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9589 print_address (unsigned int addr
, FILE *outfile
)
9591 fprintf (outfile
,"0x%8.8x", addr
);
9594 /* Needed by the i386 disassembler. */
9596 db_task_printsym (unsigned int addr
)
9598 print_address (addr
, stderr
);
9603 main (int argc
, char **argv
)
9607 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9608 setlocale (LC_MESSAGES
, "");
9610 #if defined (HAVE_SETLOCALE)
9611 setlocale (LC_CTYPE
, "");
9613 bindtextdomain (PACKAGE
, LOCALEDIR
);
9614 textdomain (PACKAGE
);
9616 expandargv (&argc
, &argv
);
9618 parse_args (argc
, argv
);
9620 if (num_dump_sects
> 0)
9622 /* Make a copy of the dump_sects array. */
9623 cmdline_dump_sects
= malloc (num_dump_sects
);
9624 if (cmdline_dump_sects
== NULL
)
9625 error (_("Out of memory allocating dump request table."));
9628 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
9629 num_cmdline_dump_sects
= num_dump_sects
;
9633 if (optind
< (argc
- 1))
9637 while (optind
< argc
)
9638 err
|= process_file (argv
[optind
++]);
9640 if (dump_sects
!= NULL
)
9642 if (cmdline_dump_sects
!= NULL
)
9643 free (cmdline_dump_sects
);