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
)
2019 strcat (buf
, ", cpu32");
2020 if (e_flags
& EF_M68K_CPU32_FIDO_A
)
2021 strcat (buf
, ", fido_a");
2025 char const *isa
= _("unknown");
2026 char const *mac
= _("unknown mac");
2027 char const *additional
= NULL
;
2029 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2031 case EF_M68K_CF_ISA_A_NODIV
:
2033 additional
= ", nodiv";
2035 case EF_M68K_CF_ISA_A
:
2038 case EF_M68K_CF_ISA_A_PLUS
:
2041 case EF_M68K_CF_ISA_B_NOUSP
:
2043 additional
= ", nousp";
2045 case EF_M68K_CF_ISA_B
:
2049 strcat (buf
, ", cf, isa ");
2052 strcat (buf
, additional
);
2053 if (e_flags
& EF_M68K_CF_FLOAT
)
2054 strcat (buf
, ", float");
2055 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2060 case EF_M68K_CF_MAC
:
2063 case EF_M68K_CF_EMAC
:
2076 if (e_flags
& EF_PPC_EMB
)
2077 strcat (buf
, ", emb");
2079 if (e_flags
& EF_PPC_RELOCATABLE
)
2080 strcat (buf
, ", relocatable");
2082 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2083 strcat (buf
, ", relocatable-lib");
2087 case EM_CYGNUS_V850
:
2088 switch (e_flags
& EF_V850_ARCH
)
2091 strcat (buf
, ", v850e1");
2094 strcat (buf
, ", v850e");
2097 strcat (buf
, ", v850");
2100 strcat (buf
, ", unknown v850 architecture variant");
2106 case EM_CYGNUS_M32R
:
2107 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2108 strcat (buf
, ", m32r");
2112 case EM_MIPS_RS3_LE
:
2113 if (e_flags
& EF_MIPS_NOREORDER
)
2114 strcat (buf
, ", noreorder");
2116 if (e_flags
& EF_MIPS_PIC
)
2117 strcat (buf
, ", pic");
2119 if (e_flags
& EF_MIPS_CPIC
)
2120 strcat (buf
, ", cpic");
2122 if (e_flags
& EF_MIPS_UCODE
)
2123 strcat (buf
, ", ugen_reserved");
2125 if (e_flags
& EF_MIPS_ABI2
)
2126 strcat (buf
, ", abi2");
2128 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2129 strcat (buf
, ", odk first");
2131 if (e_flags
& EF_MIPS_32BITMODE
)
2132 strcat (buf
, ", 32bitmode");
2134 switch ((e_flags
& EF_MIPS_MACH
))
2136 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2137 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2138 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2139 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2140 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2141 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2142 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2143 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2144 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2145 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2147 /* We simply ignore the field in this case to avoid confusion:
2148 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2151 default: strcat (buf
, ", unknown CPU"); break;
2154 switch ((e_flags
& EF_MIPS_ABI
))
2156 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2157 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2158 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2159 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2161 /* We simply ignore the field in this case to avoid confusion:
2162 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2163 This means it is likely to be an o32 file, but not for
2166 default: strcat (buf
, ", unknown ABI"); break;
2169 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2170 strcat (buf
, ", mdmx");
2172 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2173 strcat (buf
, ", mips16");
2175 switch ((e_flags
& EF_MIPS_ARCH
))
2177 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2178 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2179 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2180 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2181 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2182 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2183 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2184 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2185 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2186 default: strcat (buf
, ", unknown ISA"); break;
2192 switch ((e_flags
& EF_SH_MACH_MASK
))
2194 case EF_SH1
: strcat (buf
, ", sh1"); break;
2195 case EF_SH2
: strcat (buf
, ", sh2"); break;
2196 case EF_SH3
: strcat (buf
, ", sh3"); break;
2197 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2198 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2199 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2200 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2201 case EF_SH4
: strcat (buf
, ", sh4"); break;
2202 case EF_SH5
: strcat (buf
, ", sh5"); break;
2203 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2204 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2205 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2206 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2207 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2208 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2209 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2210 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2211 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2212 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2213 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2214 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2215 default: strcat (buf
, ", unknown ISA"); break;
2221 if (e_flags
& EF_SPARC_32PLUS
)
2222 strcat (buf
, ", v8+");
2224 if (e_flags
& EF_SPARC_SUN_US1
)
2225 strcat (buf
, ", ultrasparcI");
2227 if (e_flags
& EF_SPARC_SUN_US3
)
2228 strcat (buf
, ", ultrasparcIII");
2230 if (e_flags
& EF_SPARC_HAL_R1
)
2231 strcat (buf
, ", halr1");
2233 if (e_flags
& EF_SPARC_LEDATA
)
2234 strcat (buf
, ", ledata");
2236 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2237 strcat (buf
, ", tso");
2239 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2240 strcat (buf
, ", pso");
2242 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2243 strcat (buf
, ", rmo");
2247 switch (e_flags
& EF_PARISC_ARCH
)
2249 case EFA_PARISC_1_0
:
2250 strcpy (buf
, ", PA-RISC 1.0");
2252 case EFA_PARISC_1_1
:
2253 strcpy (buf
, ", PA-RISC 1.1");
2255 case EFA_PARISC_2_0
:
2256 strcpy (buf
, ", PA-RISC 2.0");
2261 if (e_flags
& EF_PARISC_TRAPNIL
)
2262 strcat (buf
, ", trapnil");
2263 if (e_flags
& EF_PARISC_EXT
)
2264 strcat (buf
, ", ext");
2265 if (e_flags
& EF_PARISC_LSB
)
2266 strcat (buf
, ", lsb");
2267 if (e_flags
& EF_PARISC_WIDE
)
2268 strcat (buf
, ", wide");
2269 if (e_flags
& EF_PARISC_NO_KABP
)
2270 strcat (buf
, ", no kabp");
2271 if (e_flags
& EF_PARISC_LAZYSWAP
)
2272 strcat (buf
, ", lazyswap");
2277 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2278 strcat (buf
, ", new calling convention");
2280 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2281 strcat (buf
, ", gnu calling convention");
2285 if ((e_flags
& EF_IA_64_ABI64
))
2286 strcat (buf
, ", 64-bit");
2288 strcat (buf
, ", 32-bit");
2289 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2290 strcat (buf
, ", reduced fp model");
2291 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2292 strcat (buf
, ", no function descriptors, constant gp");
2293 else if ((e_flags
& EF_IA_64_CONS_GP
))
2294 strcat (buf
, ", constant gp");
2295 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2296 strcat (buf
, ", absolute");
2300 if ((e_flags
& EF_VAX_NONPIC
))
2301 strcat (buf
, ", non-PIC");
2302 if ((e_flags
& EF_VAX_DFLOAT
))
2303 strcat (buf
, ", D-Float");
2304 if ((e_flags
& EF_VAX_GFLOAT
))
2305 strcat (buf
, ", G-Float");
2314 get_osabi_name (unsigned int osabi
)
2316 static char buff
[32];
2320 case ELFOSABI_NONE
: return "UNIX - System V";
2321 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2322 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2323 case ELFOSABI_LINUX
: return "UNIX - Linux";
2324 case ELFOSABI_HURD
: return "GNU/Hurd";
2325 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2326 case ELFOSABI_AIX
: return "UNIX - AIX";
2327 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2328 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2329 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2330 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2331 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2332 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2333 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2334 case ELFOSABI_AROS
: return "Amiga Research OS";
2335 case ELFOSABI_STANDALONE
: return _("Standalone App");
2336 case ELFOSABI_ARM
: return "ARM";
2338 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2344 get_arm_segment_type (unsigned long type
)
2358 get_mips_segment_type (unsigned long type
)
2362 case PT_MIPS_REGINFO
:
2364 case PT_MIPS_RTPROC
:
2366 case PT_MIPS_OPTIONS
:
2376 get_parisc_segment_type (unsigned long type
)
2380 case PT_HP_TLS
: return "HP_TLS";
2381 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2382 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2383 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2384 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2385 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2386 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2387 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2388 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2389 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2390 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2391 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2392 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2393 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2394 case PT_HP_STACK
: return "HP_STACK";
2395 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2396 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2397 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2398 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2407 get_ia64_segment_type (unsigned long type
)
2411 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2412 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2413 case PT_HP_TLS
: return "HP_TLS";
2414 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2415 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2416 case PT_IA_64_HP_STACK
: return "HP_STACK";
2425 get_segment_type (unsigned long p_type
)
2427 static char buff
[32];
2431 case PT_NULL
: return "NULL";
2432 case PT_LOAD
: return "LOAD";
2433 case PT_DYNAMIC
: return "DYNAMIC";
2434 case PT_INTERP
: return "INTERP";
2435 case PT_NOTE
: return "NOTE";
2436 case PT_SHLIB
: return "SHLIB";
2437 case PT_PHDR
: return "PHDR";
2438 case PT_TLS
: return "TLS";
2440 case PT_GNU_EH_FRAME
:
2441 return "GNU_EH_FRAME";
2442 case PT_GNU_STACK
: return "GNU_STACK";
2443 case PT_GNU_RELRO
: return "GNU_RELRO";
2446 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2450 switch (elf_header
.e_machine
)
2453 result
= get_arm_segment_type (p_type
);
2456 case EM_MIPS_RS3_LE
:
2457 result
= get_mips_segment_type (p_type
);
2460 result
= get_parisc_segment_type (p_type
);
2463 result
= get_ia64_segment_type (p_type
);
2473 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2475 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2479 switch (elf_header
.e_machine
)
2482 result
= get_parisc_segment_type (p_type
);
2485 result
= get_ia64_segment_type (p_type
);
2495 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2498 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2505 get_mips_section_type_name (unsigned int sh_type
)
2509 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2510 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2511 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2512 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2513 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2514 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2515 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2516 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2517 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2518 case SHT_MIPS_RELD
: return "MIPS_RELD";
2519 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2520 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2521 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2522 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2523 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2524 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2525 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2526 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2527 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2528 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2529 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2530 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2531 case SHT_MIPS_LINE
: return "MIPS_LINE";
2532 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2533 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2534 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2535 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2536 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2537 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2538 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2539 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2540 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2541 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2542 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2543 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2544 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2545 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2546 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2547 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2555 get_parisc_section_type_name (unsigned int sh_type
)
2559 case SHT_PARISC_EXT
: return "PARISC_EXT";
2560 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2561 case SHT_PARISC_DOC
: return "PARISC_DOC";
2562 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2563 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2564 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2565 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2573 get_ia64_section_type_name (unsigned int sh_type
)
2575 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2576 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2577 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2581 case SHT_IA_64_EXT
: return "IA_64_EXT";
2582 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2583 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2591 get_x86_64_section_type_name (unsigned int sh_type
)
2595 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2603 get_arm_section_type_name (unsigned int sh_type
)
2609 case SHT_ARM_PREEMPTMAP
:
2610 return "ARM_PREEMPTMAP";
2611 case SHT_ARM_ATTRIBUTES
:
2612 return "ARM_ATTRIBUTES";
2620 get_section_type_name (unsigned int sh_type
)
2622 static char buff
[32];
2626 case SHT_NULL
: return "NULL";
2627 case SHT_PROGBITS
: return "PROGBITS";
2628 case SHT_SYMTAB
: return "SYMTAB";
2629 case SHT_STRTAB
: return "STRTAB";
2630 case SHT_RELA
: return "RELA";
2631 case SHT_HASH
: return "HASH";
2632 case SHT_DYNAMIC
: return "DYNAMIC";
2633 case SHT_NOTE
: return "NOTE";
2634 case SHT_NOBITS
: return "NOBITS";
2635 case SHT_REL
: return "REL";
2636 case SHT_SHLIB
: return "SHLIB";
2637 case SHT_DYNSYM
: return "DYNSYM";
2638 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2639 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2640 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2641 case SHT_GNU_HASH
: return "GNU_HASH";
2642 case SHT_GROUP
: return "GROUP";
2643 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2644 case SHT_GNU_verdef
: return "VERDEF";
2645 case SHT_GNU_verneed
: return "VERNEED";
2646 case SHT_GNU_versym
: return "VERSYM";
2647 case 0x6ffffff0: return "VERSYM";
2648 case 0x6ffffffc: return "VERDEF";
2649 case 0x7ffffffd: return "AUXILIARY";
2650 case 0x7fffffff: return "FILTER";
2651 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2654 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2658 switch (elf_header
.e_machine
)
2661 case EM_MIPS_RS3_LE
:
2662 result
= get_mips_section_type_name (sh_type
);
2665 result
= get_parisc_section_type_name (sh_type
);
2668 result
= get_ia64_section_type_name (sh_type
);
2671 result
= get_x86_64_section_type_name (sh_type
);
2674 result
= get_arm_section_type_name (sh_type
);
2684 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2686 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2687 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2688 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2689 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2691 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2697 #define OPTION_DEBUG_DUMP 512
2699 static struct option options
[] =
2701 {"all", no_argument
, 0, 'a'},
2702 {"file-header", no_argument
, 0, 'h'},
2703 {"program-headers", no_argument
, 0, 'l'},
2704 {"headers", no_argument
, 0, 'e'},
2705 {"histogram", no_argument
, 0, 'I'},
2706 {"segments", no_argument
, 0, 'l'},
2707 {"sections", no_argument
, 0, 'S'},
2708 {"section-headers", no_argument
, 0, 'S'},
2709 {"section-groups", no_argument
, 0, 'g'},
2710 {"section-details", no_argument
, 0, 't'},
2711 {"full-section-name",no_argument
, 0, 'N'},
2712 {"symbols", no_argument
, 0, 's'},
2713 {"syms", no_argument
, 0, 's'},
2714 {"relocs", no_argument
, 0, 'r'},
2715 {"notes", no_argument
, 0, 'n'},
2716 {"dynamic", no_argument
, 0, 'd'},
2717 {"arch-specific", no_argument
, 0, 'A'},
2718 {"version-info", no_argument
, 0, 'V'},
2719 {"use-dynamic", no_argument
, 0, 'D'},
2720 {"hex-dump", required_argument
, 0, 'x'},
2721 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2722 {"unwind", no_argument
, 0, 'u'},
2723 #ifdef SUPPORT_DISASSEMBLY
2724 {"instruction-dump", required_argument
, 0, 'i'},
2727 {"version", no_argument
, 0, 'v'},
2728 {"wide", no_argument
, 0, 'W'},
2729 {"help", no_argument
, 0, 'H'},
2730 {0, no_argument
, 0, 0}
2736 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2737 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2738 fprintf (stdout
, _(" Options are:\n\
2739 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2740 -h --file-header Display the ELF file header\n\
2741 -l --program-headers Display the program headers\n\
2742 --segments An alias for --program-headers\n\
2743 -S --section-headers Display the sections' header\n\
2744 --sections An alias for --section-headers\n\
2745 -g --section-groups Display the section groups\n\
2746 -t --section-details Display the section details\n\
2747 -e --headers Equivalent to: -h -l -S\n\
2748 -s --syms Display the symbol table\n\
2749 --symbols An alias for --syms\n\
2750 -n --notes Display the core notes (if present)\n\
2751 -r --relocs Display the relocations (if present)\n\
2752 -u --unwind Display the unwind info (if present)\n\
2753 -d --dynamic Display the dynamic section (if present)\n\
2754 -V --version-info Display the version sections (if present)\n\
2755 -A --arch-specific Display architecture specific information (if any).\n\
2756 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2757 -x --hex-dump=<number> Dump the contents of section <number>\n\
2758 -w[liaprmfFsoR] or\n\
2759 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2760 Display the contents of DWARF2 debug sections\n"));
2761 #ifdef SUPPORT_DISASSEMBLY
2762 fprintf (stdout
, _("\
2763 -i --instruction-dump=<number>\n\
2764 Disassemble the contents of section <number>\n"));
2766 fprintf (stdout
, _("\
2767 -I --histogram Display histogram of bucket list lengths\n\
2768 -W --wide Allow output width to exceed 80 characters\n\
2769 @<file> Read options from <file>\n\
2770 -H --help Display this information\n\
2771 -v --version Display the version number of readelf\n"));
2772 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2777 /* Record the fact that the user wants the contents of section number
2778 SECTION to be displayed using the method(s) encoded as flags bits
2779 in TYPE. Note, TYPE can be zero if we are creating the array for
2783 request_dump (unsigned int section
, int type
)
2785 if (section
>= num_dump_sects
)
2787 char *new_dump_sects
;
2789 new_dump_sects
= calloc (section
+ 1, 1);
2791 if (new_dump_sects
== NULL
)
2792 error (_("Out of memory allocating dump request table."));
2795 /* Copy current flag settings. */
2796 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2800 dump_sects
= new_dump_sects
;
2801 num_dump_sects
= section
+ 1;
2806 dump_sects
[section
] |= type
;
2811 /* Request a dump by section name. */
2814 request_dump_byname (const char *section
, int type
)
2816 struct dump_list_entry
*new_request
;
2818 new_request
= malloc (sizeof (struct dump_list_entry
));
2820 error (_("Out of memory allocating dump request table."));
2822 new_request
->name
= strdup (section
);
2823 if (!new_request
->name
)
2824 error (_("Out of memory allocating dump request table."));
2826 new_request
->type
= type
;
2828 new_request
->next
= dump_sects_byname
;
2829 dump_sects_byname
= new_request
;
2833 parse_args (int argc
, char **argv
)
2840 while ((c
= getopt_long
2841 (argc
, argv
, "ersuahnldSDAINtgw::x:i:vVWH", options
, NULL
)) != EOF
)
2862 do_section_groups
++;
2870 do_section_groups
++;
2875 do_section_details
++;
2917 section
= strtoul (optarg
, & cp
, 0);
2918 if (! *cp
&& section
>= 0)
2919 request_dump (section
, HEX_DUMP
);
2921 request_dump_byname (optarg
, HEX_DUMP
);
2929 unsigned int index
= 0;
2933 while (optarg
[index
])
2934 switch (optarg
[index
++])
2943 do_debug_abbrevs
= 1;
2953 do_debug_pubnames
= 1;
2957 do_debug_aranges
= 1;
2961 do_debug_ranges
= 1;
2965 do_debug_frames_interp
= 1;
2967 do_debug_frames
= 1;
2972 do_debug_macinfo
= 1;
2986 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2991 case OPTION_DEBUG_DUMP
:
2999 const char * option
;
3002 debug_dump_long_opts
;
3004 debug_dump_long_opts opts_table
[] =
3006 /* Please keep this table alpha- sorted. */
3007 { "Ranges", & do_debug_ranges
},
3008 { "abbrev", & do_debug_abbrevs
},
3009 { "aranges", & do_debug_aranges
},
3010 { "frames", & do_debug_frames
},
3011 { "frames-interp", & do_debug_frames_interp
},
3012 { "info", & do_debug_info
},
3013 { "line", & do_debug_lines
},
3014 { "loc", & do_debug_loc
},
3015 { "macro", & do_debug_macinfo
},
3016 { "pubnames", & do_debug_pubnames
},
3017 /* This entry is for compatability
3018 with earlier versions of readelf. */
3019 { "ranges", & do_debug_aranges
},
3020 { "str", & do_debug_str
},
3031 debug_dump_long_opts
* entry
;
3033 for (entry
= opts_table
; entry
->option
; entry
++)
3035 size_t len
= strlen (entry
->option
);
3037 if (strneq (p
, entry
->option
, len
)
3038 && (p
[len
] == ',' || p
[len
] == '\0'))
3040 * entry
->variable
= 1;
3042 /* The --debug-dump=frames-interp option also
3043 enables the --debug-dump=frames option. */
3044 if (do_debug_frames_interp
)
3045 do_debug_frames
= 1;
3052 if (entry
->option
== NULL
)
3054 warn (_("Unrecognized debug option '%s'\n"), p
);
3055 p
= strchr (p
, ',');
3065 #ifdef SUPPORT_DISASSEMBLY
3068 section
= strtoul (optarg
, & cp
, 0);
3069 if (! *cp
&& section
>= 0)
3071 request_dump (section
, DISASS_DUMP
);
3077 print_version (program_name
);
3086 #ifdef SUPPORT_DISASSEMBLY
3089 /* xgettext:c-format */
3090 error (_("Invalid option '-%c'\n"), c
);
3097 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3098 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3099 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3100 && !do_section_groups
)
3104 warn (_("Nothing to do.\n"));
3110 get_elf_class (unsigned int elf_class
)
3112 static char buff
[32];
3116 case ELFCLASSNONE
: return _("none");
3117 case ELFCLASS32
: return "ELF32";
3118 case ELFCLASS64
: return "ELF64";
3120 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3126 get_data_encoding (unsigned int encoding
)
3128 static char buff
[32];
3132 case ELFDATANONE
: return _("none");
3133 case ELFDATA2LSB
: return _("2's complement, little endian");
3134 case ELFDATA2MSB
: return _("2's complement, big endian");
3136 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3141 /* Decode the data held in 'elf_header'. */
3144 process_file_header (void)
3146 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3147 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3148 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3149 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3152 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3160 printf (_("ELF Header:\n"));
3161 printf (_(" Magic: "));
3162 for (i
= 0; i
< EI_NIDENT
; i
++)
3163 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3165 printf (_(" Class: %s\n"),
3166 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3167 printf (_(" Data: %s\n"),
3168 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3169 printf (_(" Version: %d %s\n"),
3170 elf_header
.e_ident
[EI_VERSION
],
3171 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3173 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3176 printf (_(" OS/ABI: %s\n"),
3177 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3178 printf (_(" ABI Version: %d\n"),
3179 elf_header
.e_ident
[EI_ABIVERSION
]);
3180 printf (_(" Type: %s\n"),
3181 get_file_type (elf_header
.e_type
));
3182 printf (_(" Machine: %s\n"),
3183 get_machine_name (elf_header
.e_machine
));
3184 printf (_(" Version: 0x%lx\n"),
3185 (unsigned long) elf_header
.e_version
);
3187 printf (_(" Entry point address: "));
3188 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3189 printf (_("\n Start of program headers: "));
3190 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3191 printf (_(" (bytes into file)\n Start of section headers: "));
3192 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3193 printf (_(" (bytes into file)\n"));
3195 printf (_(" Flags: 0x%lx%s\n"),
3196 (unsigned long) elf_header
.e_flags
,
3197 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3198 printf (_(" Size of this header: %ld (bytes)\n"),
3199 (long) elf_header
.e_ehsize
);
3200 printf (_(" Size of program headers: %ld (bytes)\n"),
3201 (long) elf_header
.e_phentsize
);
3202 printf (_(" Number of program headers: %ld\n"),
3203 (long) elf_header
.e_phnum
);
3204 printf (_(" Size of section headers: %ld (bytes)\n"),
3205 (long) elf_header
.e_shentsize
);
3206 printf (_(" Number of section headers: %ld"),
3207 (long) elf_header
.e_shnum
);
3208 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3209 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3210 putc ('\n', stdout
);
3211 printf (_(" Section header string table index: %ld"),
3212 (long) elf_header
.e_shstrndx
);
3213 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3214 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3215 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3216 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3217 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3218 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3219 printf (" <corrupt: out of range>");
3220 putc ('\n', stdout
);
3223 if (section_headers
!= NULL
)
3225 if (elf_header
.e_shnum
== 0)
3226 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3227 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3228 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3229 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3230 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3231 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3232 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3233 elf_header
.e_shstrndx
= SHN_UNDEF
;
3234 free (section_headers
);
3235 section_headers
= NULL
;
3243 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3245 Elf32_External_Phdr
*phdrs
;
3246 Elf32_External_Phdr
*external
;
3247 Elf_Internal_Phdr
*internal
;
3250 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3251 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3252 _("program headers"));
3256 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3257 i
< elf_header
.e_phnum
;
3258 i
++, internal
++, external
++)
3260 internal
->p_type
= BYTE_GET (external
->p_type
);
3261 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3262 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3263 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3264 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3265 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3266 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3267 internal
->p_align
= BYTE_GET (external
->p_align
);
3276 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3278 Elf64_External_Phdr
*phdrs
;
3279 Elf64_External_Phdr
*external
;
3280 Elf_Internal_Phdr
*internal
;
3283 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3284 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3285 _("program headers"));
3289 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3290 i
< elf_header
.e_phnum
;
3291 i
++, internal
++, external
++)
3293 internal
->p_type
= BYTE_GET (external
->p_type
);
3294 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3295 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3296 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3297 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3298 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3299 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3300 internal
->p_align
= BYTE_GET (external
->p_align
);
3308 /* Returns 1 if the program headers were read into `program_headers'. */
3311 get_program_headers (FILE *file
)
3313 Elf_Internal_Phdr
*phdrs
;
3315 /* Check cache of prior read. */
3316 if (program_headers
!= NULL
)
3319 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3323 error (_("Out of memory\n"));
3328 ? get_32bit_program_headers (file
, phdrs
)
3329 : get_64bit_program_headers (file
, phdrs
))
3331 program_headers
= phdrs
;
3339 /* Returns 1 if the program headers were loaded. */
3342 process_program_headers (FILE *file
)
3344 Elf_Internal_Phdr
*segment
;
3347 if (elf_header
.e_phnum
== 0)
3350 printf (_("\nThere are no program headers in this file.\n"));
3354 if (do_segments
&& !do_header
)
3356 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3357 printf (_("Entry point "));
3358 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3359 printf (_("\nThere are %d program headers, starting at offset "),
3360 elf_header
.e_phnum
);
3361 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3365 if (! get_program_headers (file
))
3370 if (elf_header
.e_phnum
> 1)
3371 printf (_("\nProgram Headers:\n"));
3373 printf (_("\nProgram Headers:\n"));
3377 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3380 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3384 (_(" Type Offset VirtAddr PhysAddr\n"));
3386 (_(" FileSiz MemSiz Flags Align\n"));
3393 for (i
= 0, segment
= program_headers
;
3394 i
< elf_header
.e_phnum
;
3399 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3403 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3404 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3405 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3406 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3407 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3409 (segment
->p_flags
& PF_R
? 'R' : ' '),
3410 (segment
->p_flags
& PF_W
? 'W' : ' '),
3411 (segment
->p_flags
& PF_X
? 'E' : ' '));
3412 printf ("%#lx", (unsigned long) segment
->p_align
);
3416 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3417 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3420 print_vma (segment
->p_offset
, FULL_HEX
);
3424 print_vma (segment
->p_vaddr
, FULL_HEX
);
3426 print_vma (segment
->p_paddr
, FULL_HEX
);
3429 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3430 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3433 print_vma (segment
->p_filesz
, FULL_HEX
);
3437 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3438 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3441 print_vma (segment
->p_offset
, FULL_HEX
);
3445 (segment
->p_flags
& PF_R
? 'R' : ' '),
3446 (segment
->p_flags
& PF_W
? 'W' : ' '),
3447 (segment
->p_flags
& PF_X
? 'E' : ' '));
3449 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3450 printf ("%#lx", (unsigned long) segment
->p_align
);
3453 print_vma (segment
->p_align
, PREFIX_HEX
);
3458 print_vma (segment
->p_offset
, FULL_HEX
);
3460 print_vma (segment
->p_vaddr
, FULL_HEX
);
3462 print_vma (segment
->p_paddr
, FULL_HEX
);
3464 print_vma (segment
->p_filesz
, FULL_HEX
);
3466 print_vma (segment
->p_memsz
, FULL_HEX
);
3468 (segment
->p_flags
& PF_R
? 'R' : ' '),
3469 (segment
->p_flags
& PF_W
? 'W' : ' '),
3470 (segment
->p_flags
& PF_X
? 'E' : ' '));
3471 print_vma (segment
->p_align
, HEX
);
3475 switch (segment
->p_type
)
3479 error (_("more than one dynamic segment\n"));
3481 /* Try to locate the .dynamic section. If there is
3482 a section header table, we can easily locate it. */
3483 if (section_headers
!= NULL
)
3485 Elf_Internal_Shdr
*sec
;
3487 sec
= find_section (".dynamic");
3488 if (sec
== NULL
|| sec
->sh_size
== 0)
3490 error (_("no .dynamic section in the dynamic segment"));
3494 dynamic_addr
= sec
->sh_offset
;
3495 dynamic_size
= sec
->sh_size
;
3497 if (dynamic_addr
< segment
->p_offset
3498 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3499 warn (_("the .dynamic section is not contained within the dynamic segment"));
3500 else if (dynamic_addr
> segment
->p_offset
)
3501 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3505 /* Otherwise, we can only assume that the .dynamic
3506 section is the first section in the DYNAMIC segment. */
3507 dynamic_addr
= segment
->p_offset
;
3508 dynamic_size
= segment
->p_filesz
;
3513 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3515 error (_("Unable to find program interpreter name\n"));
3519 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3521 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3522 error (_("Internal error: failed to create format string to display program interpreter"));
3524 program_interpreter
[0] = 0;
3525 fscanf (file
, fmt
, program_interpreter
);
3528 printf (_("\n [Requesting program interpreter: %s]"),
3529 program_interpreter
);
3535 putc ('\n', stdout
);
3538 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3540 printf (_("\n Section to Segment mapping:\n"));
3541 printf (_(" Segment Sections...\n"));
3543 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3546 Elf_Internal_Shdr
*section
;
3548 segment
= program_headers
+ i
;
3549 section
= section_headers
;
3551 printf (" %2.2d ", i
);
3553 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3555 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3556 printf ("%s ", SECTION_NAME (section
));
3567 /* Find the file offset corresponding to VMA by using the program headers. */
3570 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3572 Elf_Internal_Phdr
*seg
;
3574 if (! get_program_headers (file
))
3576 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3580 for (seg
= program_headers
;
3581 seg
< program_headers
+ elf_header
.e_phnum
;
3584 if (seg
->p_type
!= PT_LOAD
)
3587 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3588 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3589 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3592 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3599 get_32bit_section_headers (FILE *file
, unsigned int num
)
3601 Elf32_External_Shdr
*shdrs
;
3602 Elf_Internal_Shdr
*internal
;
3605 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3606 elf_header
.e_shentsize
, num
, _("section headers"));
3610 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3612 if (section_headers
== NULL
)
3614 error (_("Out of memory\n"));
3618 for (i
= 0, internal
= section_headers
;
3622 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3623 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3624 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3625 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3626 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3627 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3628 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3629 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3630 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3631 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3640 get_64bit_section_headers (FILE *file
, unsigned int num
)
3642 Elf64_External_Shdr
*shdrs
;
3643 Elf_Internal_Shdr
*internal
;
3646 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3647 elf_header
.e_shentsize
, num
, _("section headers"));
3651 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3653 if (section_headers
== NULL
)
3655 error (_("Out of memory\n"));
3659 for (i
= 0, internal
= section_headers
;
3663 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3664 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3665 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3666 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3667 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3668 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3669 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3670 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3671 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3672 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3680 static Elf_Internal_Sym
*
3681 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3683 unsigned long number
;
3684 Elf32_External_Sym
*esyms
;
3685 Elf_External_Sym_Shndx
*shndx
;
3686 Elf_Internal_Sym
*isyms
;
3687 Elf_Internal_Sym
*psym
;
3690 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3696 if (symtab_shndx_hdr
!= NULL
3697 && (symtab_shndx_hdr
->sh_link
3698 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3700 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3701 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3709 number
= section
->sh_size
/ section
->sh_entsize
;
3710 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3714 error (_("Out of memory\n"));
3721 for (j
= 0, psym
= isyms
;
3725 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3726 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3727 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3728 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3729 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3731 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3732 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3733 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3743 static Elf_Internal_Sym
*
3744 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3746 unsigned long number
;
3747 Elf64_External_Sym
*esyms
;
3748 Elf_External_Sym_Shndx
*shndx
;
3749 Elf_Internal_Sym
*isyms
;
3750 Elf_Internal_Sym
*psym
;
3753 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3759 if (symtab_shndx_hdr
!= NULL
3760 && (symtab_shndx_hdr
->sh_link
3761 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3763 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3764 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3772 number
= section
->sh_size
/ section
->sh_entsize
;
3773 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3777 error (_("Out of memory\n"));
3784 for (j
= 0, psym
= isyms
;
3788 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3789 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3790 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3791 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3792 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3794 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3795 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3796 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3807 get_elf_section_flags (bfd_vma sh_flags
)
3809 static char buff
[1024];
3811 int field_size
= is_32bit_elf
? 8 : 16;
3812 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3813 bfd_vma os_flags
= 0;
3814 bfd_vma proc_flags
= 0;
3815 bfd_vma unknown_flags
= 0;
3829 { "LINK ORDER", 10 },
3830 { "OS NONCONF", 10 },
3835 if (do_section_details
)
3837 sprintf (buff
, "[%*.*lx]: ",
3838 field_size
, field_size
, (unsigned long) sh_flags
);
3839 p
+= field_size
+ 4;
3846 flag
= sh_flags
& - sh_flags
;
3849 if (do_section_details
)
3853 case SHF_WRITE
: index
= 0; break;
3854 case SHF_ALLOC
: index
= 1; break;
3855 case SHF_EXECINSTR
: index
= 2; break;
3856 case SHF_MERGE
: index
= 3; break;
3857 case SHF_STRINGS
: index
= 4; break;
3858 case SHF_INFO_LINK
: index
= 5; break;
3859 case SHF_LINK_ORDER
: index
= 6; break;
3860 case SHF_OS_NONCONFORMING
: index
= 7; break;
3861 case SHF_GROUP
: index
= 8; break;
3862 case SHF_TLS
: index
= 9; break;
3871 if (p
!= buff
+ field_size
+ 4)
3873 if (size
< (10 + 2))
3880 size
-= flags
[index
].len
;
3881 p
= stpcpy (p
, flags
[index
].str
);
3883 else if (flag
& SHF_MASKOS
)
3885 else if (flag
& SHF_MASKPROC
)
3888 unknown_flags
|= flag
;
3894 case SHF_WRITE
: *p
= 'W'; break;
3895 case SHF_ALLOC
: *p
= 'A'; break;
3896 case SHF_EXECINSTR
: *p
= 'X'; break;
3897 case SHF_MERGE
: *p
= 'M'; break;
3898 case SHF_STRINGS
: *p
= 'S'; break;
3899 case SHF_INFO_LINK
: *p
= 'I'; break;
3900 case SHF_LINK_ORDER
: *p
= 'L'; break;
3901 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3902 case SHF_GROUP
: *p
= 'G'; break;
3903 case SHF_TLS
: *p
= 'T'; break;
3906 if (elf_header
.e_machine
== EM_X86_64
3907 && flag
== SHF_X86_64_LARGE
)
3909 else if (flag
& SHF_MASKOS
)
3912 sh_flags
&= ~ SHF_MASKOS
;
3914 else if (flag
& SHF_MASKPROC
)
3917 sh_flags
&= ~ SHF_MASKPROC
;
3927 if (do_section_details
)
3931 size
-= 5 + field_size
;
3932 if (p
!= buff
+ field_size
+ 4)
3940 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3941 (unsigned long) os_flags
);
3942 p
+= 5 + field_size
;
3946 size
-= 7 + field_size
;
3947 if (p
!= buff
+ field_size
+ 4)
3955 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3956 (unsigned long) proc_flags
);
3957 p
+= 7 + field_size
;
3961 size
-= 10 + field_size
;
3962 if (p
!= buff
+ field_size
+ 4)
3970 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3971 (unsigned long) unknown_flags
);
3972 p
+= 10 + field_size
;
3981 process_section_headers (FILE *file
)
3983 Elf_Internal_Shdr
*section
;
3986 section_headers
= NULL
;
3988 if (elf_header
.e_shnum
== 0)
3991 printf (_("\nThere are no sections in this file.\n"));
3996 if (do_sections
&& !do_header
)
3997 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3998 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4002 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4005 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4008 /* Read in the string table, so that we have names to display. */
4009 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4010 && SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
4012 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
4014 if (section
->sh_size
!= 0)
4016 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4017 1, section
->sh_size
, _("string table"));
4019 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4023 /* Scan the sections for the dynamic symbol table
4024 and dynamic string table and debug sections. */
4025 dynamic_symbols
= NULL
;
4026 dynamic_strings
= NULL
;
4027 dynamic_syminfo
= NULL
;
4028 symtab_shndx_hdr
= NULL
;
4030 eh_addr_size
= is_32bit_elf
? 4 : 8;
4031 switch (elf_header
.e_machine
)
4034 case EM_MIPS_RS3_LE
:
4035 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4036 FDE addresses. However, the ABI also has a semi-official ILP32
4037 variant for which the normal FDE address size rules apply.
4039 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4040 section, where XX is the size of longs in bits. Unfortunately,
4041 earlier compilers provided no way of distinguishing ILP32 objects
4042 from LP64 objects, so if there's any doubt, we should assume that
4043 the official LP64 form is being used. */
4044 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4045 && find_section (".gcc_compiled_long32") == NULL
)
4051 switch (elf_header
.e_flags
& EF_H8_MACH
)
4053 case E_H8_MACH_H8300
:
4054 case E_H8_MACH_H8300HN
:
4055 case E_H8_MACH_H8300SN
:
4056 case E_H8_MACH_H8300SXN
:
4059 case E_H8_MACH_H8300H
:
4060 case E_H8_MACH_H8300S
:
4061 case E_H8_MACH_H8300SX
:
4067 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4070 size_t expected_entsize \
4071 = is_32bit_elf ? size32 : size64; \
4072 if (section->sh_entsize != expected_entsize) \
4073 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4074 i, (unsigned long int) section->sh_entsize, \
4075 (unsigned long int) expected_entsize); \
4076 section->sh_entsize = expected_entsize; \
4079 #define CHECK_ENTSIZE(section, i, type) \
4080 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4081 sizeof (Elf64_External_##type))
4083 for (i
= 0, section
= section_headers
;
4084 i
< elf_header
.e_shnum
;
4087 char *name
= SECTION_NAME (section
);
4089 if (section
->sh_type
== SHT_DYNSYM
)
4091 if (dynamic_symbols
!= NULL
)
4093 error (_("File contains multiple dynamic symbol tables\n"));
4097 CHECK_ENTSIZE (section
, i
, Sym
);
4098 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4099 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4101 else if (section
->sh_type
== SHT_STRTAB
4102 && streq (name
, ".dynstr"))
4104 if (dynamic_strings
!= NULL
)
4106 error (_("File contains multiple dynamic string tables\n"));
4110 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4111 1, section
->sh_size
, _("dynamic strings"));
4112 dynamic_strings_length
= section
->sh_size
;
4114 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4116 if (symtab_shndx_hdr
!= NULL
)
4118 error (_("File contains multiple symtab shndx tables\n"));
4121 symtab_shndx_hdr
= section
;
4123 else if (section
->sh_type
== SHT_SYMTAB
)
4124 CHECK_ENTSIZE (section
, i
, Sym
);
4125 else if (section
->sh_type
== SHT_GROUP
)
4126 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4127 else if (section
->sh_type
== SHT_REL
)
4128 CHECK_ENTSIZE (section
, i
, Rel
);
4129 else if (section
->sh_type
== SHT_RELA
)
4130 CHECK_ENTSIZE (section
, i
, Rela
);
4131 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4132 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4133 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4134 || do_debug_loc
|| do_debug_ranges
)
4135 && const_strneq (name
, ".debug_"))
4140 || (do_debug_info
&& streq (name
, "info"))
4141 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4142 || (do_debug_lines
&& streq (name
, "line"))
4143 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4144 || (do_debug_aranges
&& streq (name
, "aranges"))
4145 || (do_debug_ranges
&& streq (name
, "ranges"))
4146 || (do_debug_frames
&& streq (name
, "frame"))
4147 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4148 || (do_debug_str
&& streq (name
, "str"))
4149 || (do_debug_loc
&& streq (name
, "loc"))
4151 request_dump (i
, DEBUG_DUMP
);
4153 /* linkonce section to be combined with .debug_info at link time. */
4154 else if ((do_debugging
|| do_debug_info
)
4155 && const_strneq (name
, ".gnu.linkonce.wi."))
4156 request_dump (i
, DEBUG_DUMP
);
4157 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4158 request_dump (i
, DEBUG_DUMP
);
4164 if (elf_header
.e_shnum
> 1)
4165 printf (_("\nSection Headers:\n"));
4167 printf (_("\nSection Header:\n"));
4171 if (do_section_details
)
4173 printf (_(" [Nr] Name\n"));
4174 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4178 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4182 if (do_section_details
)
4184 printf (_(" [Nr] Name\n"));
4185 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4189 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4193 if (do_section_details
)
4195 printf (_(" [Nr] Name\n"));
4196 printf (_(" Type Address Offset Link\n"));
4197 printf (_(" Size EntSize Info Align\n"));
4201 printf (_(" [Nr] Name Type Address Offset\n"));
4202 printf (_(" Size EntSize Flags Link Info Align\n"));
4206 if (do_section_details
)
4207 printf (_(" Flags\n"));
4209 for (i
= 0, section
= section_headers
;
4210 i
< elf_header
.e_shnum
;
4213 if (do_section_details
)
4215 printf (" [%2u] %s\n",
4216 SECTION_HEADER_NUM (i
),
4217 SECTION_NAME (section
));
4218 if (is_32bit_elf
|| do_wide
)
4219 printf (" %-15.15s ",
4220 get_section_type_name (section
->sh_type
));
4223 printf (" [%2u] %-17.17s %-15.15s ",
4224 SECTION_HEADER_NUM (i
),
4225 SECTION_NAME (section
),
4226 get_section_type_name (section
->sh_type
));
4230 print_vma (section
->sh_addr
, LONG_HEX
);
4232 printf ( " %6.6lx %6.6lx %2.2lx",
4233 (unsigned long) section
->sh_offset
,
4234 (unsigned long) section
->sh_size
,
4235 (unsigned long) section
->sh_entsize
);
4237 if (do_section_details
)
4238 fputs (" ", stdout
);
4240 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4242 printf ("%2ld %3lu %2ld\n",
4243 (unsigned long) section
->sh_link
,
4244 (unsigned long) section
->sh_info
,
4245 (unsigned long) section
->sh_addralign
);
4249 print_vma (section
->sh_addr
, LONG_HEX
);
4251 if ((long) section
->sh_offset
== section
->sh_offset
)
4252 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4256 print_vma (section
->sh_offset
, LONG_HEX
);
4259 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4260 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4264 print_vma (section
->sh_size
, LONG_HEX
);
4267 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4268 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4272 print_vma (section
->sh_entsize
, LONG_HEX
);
4275 if (do_section_details
)
4276 fputs (" ", stdout
);
4278 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4280 printf ("%2ld %3lu ",
4281 (unsigned long) section
->sh_link
,
4282 (unsigned long) section
->sh_info
);
4284 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4285 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4288 print_vma (section
->sh_addralign
, DEC
);
4292 else if (do_section_details
)
4294 printf (" %-15.15s ",
4295 get_section_type_name (section
->sh_type
));
4296 print_vma (section
->sh_addr
, LONG_HEX
);
4297 if ((long) section
->sh_offset
== section
->sh_offset
)
4298 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4302 print_vma (section
->sh_offset
, LONG_HEX
);
4304 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4305 print_vma (section
->sh_size
, LONG_HEX
);
4307 print_vma (section
->sh_entsize
, LONG_HEX
);
4309 printf (" %-16lu %ld\n",
4310 (unsigned long) section
->sh_info
,
4311 (unsigned long) section
->sh_addralign
);
4316 print_vma (section
->sh_addr
, LONG_HEX
);
4317 if ((long) section
->sh_offset
== section
->sh_offset
)
4318 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4322 print_vma (section
->sh_offset
, LONG_HEX
);
4325 print_vma (section
->sh_size
, LONG_HEX
);
4327 print_vma (section
->sh_entsize
, LONG_HEX
);
4329 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4331 printf (" %2ld %3lu %ld\n",
4332 (unsigned long) section
->sh_link
,
4333 (unsigned long) section
->sh_info
,
4334 (unsigned long) section
->sh_addralign
);
4337 if (do_section_details
)
4338 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4341 if (!do_section_details
)
4342 printf (_("Key to Flags:\n\
4343 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4344 I (info), L (link order), G (group), x (unknown)\n\
4345 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4351 get_group_flags (unsigned int flags
)
4353 static char buff
[32];
4360 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4367 process_section_groups (FILE *file
)
4369 Elf_Internal_Shdr
*section
;
4371 struct group
*group
;
4372 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4373 Elf_Internal_Sym
*symtab
;
4377 /* Don't process section groups unless needed. */
4378 if (!do_unwind
&& !do_section_groups
)
4381 if (elf_header
.e_shnum
== 0)
4383 if (do_section_groups
)
4384 printf (_("\nThere are no sections in this file.\n"));
4389 if (section_headers
== NULL
)
4391 error (_("Section headers are not available!\n"));
4395 section_headers_groups
= calloc (elf_header
.e_shnum
,
4396 sizeof (struct group
*));
4398 if (section_headers_groups
== NULL
)
4400 error (_("Out of memory\n"));
4404 /* Scan the sections for the group section. */
4406 for (i
= 0, section
= section_headers
;
4407 i
< elf_header
.e_shnum
;
4409 if (section
->sh_type
== SHT_GROUP
)
4412 if (group_count
== 0)
4414 if (do_section_groups
)
4415 printf (_("\nThere are no section groups in this file.\n"));
4420 section_groups
= calloc (group_count
, sizeof (struct group
));
4422 if (section_groups
== NULL
)
4424 error (_("Out of memory\n"));
4433 for (i
= 0, section
= section_headers
, group
= section_groups
;
4434 i
< elf_header
.e_shnum
;
4437 if (section
->sh_type
== SHT_GROUP
)
4439 char *name
= SECTION_NAME (section
);
4441 unsigned char *start
, *indices
;
4442 unsigned int entry
, j
, size
;
4443 Elf_Internal_Shdr
*sec
;
4444 Elf_Internal_Sym
*sym
;
4446 /* Get the symbol table. */
4447 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4448 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4451 error (_("Bad sh_link in group section `%s'\n"), name
);
4455 if (symtab_sec
!= sec
)
4460 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4463 sym
= symtab
+ section
->sh_info
;
4465 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4467 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4470 error (_("Bad sh_info in group section `%s'\n"), name
);
4474 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4483 /* Get the string table. */
4484 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4485 >= elf_header
.e_shnum
)
4494 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4499 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4500 1, strtab_sec
->sh_size
,
4502 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4504 group_name
= sym
->st_name
< strtab_size
4505 ? strtab
+ sym
->st_name
: "<corrupt>";
4508 start
= get_data (NULL
, file
, section
->sh_offset
,
4509 1, section
->sh_size
, _("section data"));
4512 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4513 entry
= byte_get (indices
, 4);
4516 if (do_section_groups
)
4518 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4519 get_group_flags (entry
), i
, name
, group_name
, size
);
4521 printf (_(" [Index] Name\n"));
4524 group
->group_index
= i
;
4526 for (j
= 0; j
< size
; j
++)
4528 struct group_list
*g
;
4530 entry
= byte_get (indices
, 4);
4533 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4535 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4536 entry
, i
, elf_header
.e_shnum
- 1);
4539 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4541 error (_("invalid section [%5u] in group section [%5u]\n"),
4546 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4551 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4553 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4558 /* Intel C/C++ compiler may put section 0 in a
4559 section group. We just warn it the first time
4560 and ignore it afterwards. */
4561 static int warned
= 0;
4564 error (_("section 0 in group section [%5u]\n"),
4565 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4571 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4574 if (do_section_groups
)
4576 sec
= SECTION_HEADER (entry
);
4577 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4580 g
= xmalloc (sizeof (struct group_list
));
4581 g
->section_index
= entry
;
4582 g
->next
= group
->root
;
4606 } dynamic_relocations
[] =
4608 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4609 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4610 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4613 /* Process the reloc section. */
4616 process_relocs (FILE *file
)
4618 unsigned long rel_size
;
4619 unsigned long rel_offset
;
4625 if (do_using_dynamic
)
4629 int has_dynamic_reloc
;
4632 has_dynamic_reloc
= 0;
4634 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4636 is_rela
= dynamic_relocations
[i
].rela
;
4637 name
= dynamic_relocations
[i
].name
;
4638 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4639 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4641 has_dynamic_reloc
|= rel_size
;
4643 if (is_rela
== UNKNOWN
)
4645 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4646 switch (dynamic_info
[DT_PLTREL
])
4660 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4661 name
, rel_offset
, rel_size
);
4663 dump_relocations (file
,
4664 offset_from_vma (file
, rel_offset
, rel_size
),
4666 dynamic_symbols
, num_dynamic_syms
,
4667 dynamic_strings
, dynamic_strings_length
, is_rela
);
4671 if (! has_dynamic_reloc
)
4672 printf (_("\nThere are no dynamic relocations in this file.\n"));
4676 Elf_Internal_Shdr
*section
;
4680 for (i
= 0, section
= section_headers
;
4681 i
< elf_header
.e_shnum
;
4684 if ( section
->sh_type
!= SHT_RELA
4685 && section
->sh_type
!= SHT_REL
)
4688 rel_offset
= section
->sh_offset
;
4689 rel_size
= section
->sh_size
;
4693 Elf_Internal_Shdr
*strsec
;
4696 printf (_("\nRelocation section "));
4698 if (string_table
== NULL
)
4699 printf ("%d", section
->sh_name
);
4701 printf (_("'%s'"), SECTION_NAME (section
));
4703 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4704 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4706 is_rela
= section
->sh_type
== SHT_RELA
;
4708 if (section
->sh_link
4709 && SECTION_HEADER_INDEX (section
->sh_link
)
4710 < elf_header
.e_shnum
)
4712 Elf_Internal_Shdr
*symsec
;
4713 Elf_Internal_Sym
*symtab
;
4714 unsigned long nsyms
;
4715 unsigned long strtablen
= 0;
4716 char *strtab
= NULL
;
4718 symsec
= SECTION_HEADER (section
->sh_link
);
4719 if (symsec
->sh_type
!= SHT_SYMTAB
4720 && symsec
->sh_type
!= SHT_DYNSYM
)
4723 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4724 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4729 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4730 < elf_header
.e_shnum
)
4732 strsec
= SECTION_HEADER (symsec
->sh_link
);
4734 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4737 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4740 dump_relocations (file
, rel_offset
, rel_size
,
4741 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4747 dump_relocations (file
, rel_offset
, rel_size
,
4748 NULL
, 0, NULL
, 0, is_rela
);
4755 printf (_("\nThere are no relocations in this file.\n"));
4761 /* Process the unwind section. */
4763 #include "unwind-ia64.h"
4765 /* An absolute address consists of a section and an offset. If the
4766 section is NULL, the offset itself is the address, otherwise, the
4767 address equals to LOAD_ADDRESS(section) + offset. */
4771 unsigned short section
;
4775 #define ABSADDR(a) \
4777 ? section_headers [(a).section].sh_addr + (a).offset \
4780 struct ia64_unw_aux_info
4782 struct ia64_unw_table_entry
4784 struct absaddr start
;
4786 struct absaddr info
;
4788 *table
; /* Unwind table. */
4789 unsigned long table_len
; /* Length of unwind table. */
4790 unsigned char *info
; /* Unwind info. */
4791 unsigned long info_size
; /* Size of unwind info. */
4792 bfd_vma info_addr
; /* starting address of unwind info. */
4793 bfd_vma seg_base
; /* Starting address of segment. */
4794 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4795 unsigned long nsyms
; /* Number of symbols. */
4796 char *strtab
; /* The string table. */
4797 unsigned long strtab_size
; /* Size of string table. */
4801 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4802 unsigned long nsyms
,
4804 unsigned long strtab_size
,
4805 struct absaddr addr
,
4806 const char **symname
,
4809 bfd_vma dist
= 0x100000;
4810 Elf_Internal_Sym
*sym
, *best
= NULL
;
4813 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4815 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4816 && sym
->st_name
!= 0
4817 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4818 && addr
.offset
>= sym
->st_value
4819 && addr
.offset
- sym
->st_value
< dist
)
4822 dist
= addr
.offset
- sym
->st_value
;
4829 *symname
= (best
->st_name
>= strtab_size
4830 ? "<corrupt>" : strtab
+ best
->st_name
);
4835 *offset
= addr
.offset
;
4839 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4841 struct ia64_unw_table_entry
*tp
;
4844 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4848 const unsigned char *dp
;
4849 const unsigned char *head
;
4850 const char *procname
;
4852 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4853 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4855 fputs ("\n<", stdout
);
4859 fputs (procname
, stdout
);
4862 printf ("+%lx", (unsigned long) offset
);
4865 fputs (">: [", stdout
);
4866 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4867 fputc ('-', stdout
);
4868 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4869 printf ("], info at +0x%lx\n",
4870 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4872 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4873 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4875 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4876 (unsigned) UNW_VER (stamp
),
4877 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4878 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4879 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4880 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4882 if (UNW_VER (stamp
) != 1)
4884 printf ("\tUnknown version.\n");
4889 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4890 dp
= unw_decode (dp
, in_body
, & in_body
);
4895 slurp_ia64_unwind_table (FILE *file
,
4896 struct ia64_unw_aux_info
*aux
,
4897 Elf_Internal_Shdr
*sec
)
4899 unsigned long size
, nrelas
, i
;
4900 Elf_Internal_Phdr
*seg
;
4901 struct ia64_unw_table_entry
*tep
;
4902 Elf_Internal_Shdr
*relsec
;
4903 Elf_Internal_Rela
*rela
, *rp
;
4904 unsigned char *table
, *tp
;
4905 Elf_Internal_Sym
*sym
;
4906 const char *relname
;
4908 /* First, find the starting address of the segment that includes
4911 if (elf_header
.e_phnum
)
4913 if (! get_program_headers (file
))
4916 for (seg
= program_headers
;
4917 seg
< program_headers
+ elf_header
.e_phnum
;
4920 if (seg
->p_type
!= PT_LOAD
)
4923 if (sec
->sh_addr
>= seg
->p_vaddr
4924 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4926 aux
->seg_base
= seg
->p_vaddr
;
4932 /* Second, build the unwind table from the contents of the unwind section: */
4933 size
= sec
->sh_size
;
4934 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4938 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4940 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4942 tep
->start
.section
= SHN_UNDEF
;
4943 tep
->end
.section
= SHN_UNDEF
;
4944 tep
->info
.section
= SHN_UNDEF
;
4947 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4948 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4949 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4953 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4954 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4955 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4957 tep
->start
.offset
+= aux
->seg_base
;
4958 tep
->end
.offset
+= aux
->seg_base
;
4959 tep
->info
.offset
+= aux
->seg_base
;
4963 /* Third, apply any relocations to the unwind table: */
4965 for (relsec
= section_headers
;
4966 relsec
< section_headers
+ elf_header
.e_shnum
;
4969 if (relsec
->sh_type
!= SHT_RELA
4970 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
4971 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4974 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4978 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4982 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4983 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4987 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4988 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4991 if (! const_strneq (relname
, "R_IA64_SEGREL"))
4993 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4997 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4999 switch (rp
->r_offset
/eh_addr_size
% 3)
5002 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5003 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5006 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5007 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5010 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5011 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5021 aux
->table_len
= size
/ (3 * eh_addr_size
);
5026 ia64_process_unwind (FILE *file
)
5028 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5029 unsigned long i
, unwcount
= 0, unwstart
= 0;
5030 struct ia64_unw_aux_info aux
;
5032 memset (& aux
, 0, sizeof (aux
));
5034 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5036 if (sec
->sh_type
== SHT_SYMTAB
5037 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5039 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5040 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5042 strsec
= SECTION_HEADER (sec
->sh_link
);
5043 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5044 1, strsec
->sh_size
, _("string table"));
5045 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5047 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5052 printf (_("\nThere are no unwind sections in this file.\n"));
5054 while (unwcount
-- > 0)
5059 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5060 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5061 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5068 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5070 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5072 /* We need to find which section group it is in. */
5073 struct group_list
*g
= section_headers_groups
[i
]->root
;
5075 for (; g
!= NULL
; g
= g
->next
)
5077 sec
= SECTION_HEADER (g
->section_index
);
5079 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5084 i
= elf_header
.e_shnum
;
5086 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5088 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5089 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5090 suffix
= SECTION_NAME (unwsec
) + len
;
5091 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5093 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5094 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5099 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5100 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5101 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5102 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5104 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5105 suffix
= SECTION_NAME (unwsec
) + len
;
5106 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5108 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5109 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5113 if (i
== elf_header
.e_shnum
)
5115 printf (_("\nCould not find unwind info section for "));
5117 if (string_table
== NULL
)
5118 printf ("%d", unwsec
->sh_name
);
5120 printf (_("'%s'"), SECTION_NAME (unwsec
));
5124 aux
.info_size
= sec
->sh_size
;
5125 aux
.info_addr
= sec
->sh_addr
;
5126 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5129 printf (_("\nUnwind section "));
5131 if (string_table
== NULL
)
5132 printf ("%d", unwsec
->sh_name
);
5134 printf (_("'%s'"), SECTION_NAME (unwsec
));
5136 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5137 (unsigned long) unwsec
->sh_offset
,
5138 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5140 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5142 if (aux
.table_len
> 0)
5143 dump_ia64_unwind (& aux
);
5146 free ((char *) aux
.table
);
5148 free ((char *) aux
.info
);
5157 free ((char *) aux
.strtab
);
5162 struct hppa_unw_aux_info
5164 struct hppa_unw_table_entry
5166 struct absaddr start
;
5168 unsigned int Cannot_unwind
:1; /* 0 */
5169 unsigned int Millicode
:1; /* 1 */
5170 unsigned int Millicode_save_sr0
:1; /* 2 */
5171 unsigned int Region_description
:2; /* 3..4 */
5172 unsigned int reserved1
:1; /* 5 */
5173 unsigned int Entry_SR
:1; /* 6 */
5174 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5175 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5176 unsigned int Args_stored
:1; /* 16 */
5177 unsigned int Variable_Frame
:1; /* 17 */
5178 unsigned int Separate_Package_Body
:1; /* 18 */
5179 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5180 unsigned int Stack_Overflow_Check
:1; /* 20 */
5181 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5182 unsigned int Ada_Region
:1; /* 22 */
5183 unsigned int cxx_info
:1; /* 23 */
5184 unsigned int cxx_try_catch
:1; /* 24 */
5185 unsigned int sched_entry_seq
:1; /* 25 */
5186 unsigned int reserved2
:1; /* 26 */
5187 unsigned int Save_SP
:1; /* 27 */
5188 unsigned int Save_RP
:1; /* 28 */
5189 unsigned int Save_MRP_in_frame
:1; /* 29 */
5190 unsigned int extn_ptr_defined
:1; /* 30 */
5191 unsigned int Cleanup_defined
:1; /* 31 */
5193 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5194 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5195 unsigned int Large_frame
:1; /* 2 */
5196 unsigned int Pseudo_SP_Set
:1; /* 3 */
5197 unsigned int reserved4
:1; /* 4 */
5198 unsigned int Total_frame_size
:27; /* 5..31 */
5200 *table
; /* Unwind table. */
5201 unsigned long table_len
; /* Length of unwind table. */
5202 bfd_vma seg_base
; /* Starting address of segment. */
5203 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5204 unsigned long nsyms
; /* Number of symbols. */
5205 char *strtab
; /* The string table. */
5206 unsigned long strtab_size
; /* Size of string table. */
5210 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5212 struct hppa_unw_table_entry
*tp
;
5214 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5217 const char *procname
;
5219 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5220 aux
->strtab_size
, tp
->start
, &procname
,
5223 fputs ("\n<", stdout
);
5227 fputs (procname
, stdout
);
5230 printf ("+%lx", (unsigned long) offset
);
5233 fputs (">: [", stdout
);
5234 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5235 fputc ('-', stdout
);
5236 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5239 #define PF(_m) if (tp->_m) printf (#_m " ");
5240 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5243 PF(Millicode_save_sr0
);
5244 /* PV(Region_description); */
5250 PF(Separate_Package_Body
);
5251 PF(Frame_Extension_Millicode
);
5252 PF(Stack_Overflow_Check
);
5253 PF(Two_Instruction_SP_Increment
);
5257 PF(sched_entry_seq
);
5260 PF(Save_MRP_in_frame
);
5261 PF(extn_ptr_defined
);
5262 PF(Cleanup_defined
);
5263 PF(MPE_XL_interrupt_marker
);
5264 PF(HP_UX_interrupt_marker
);
5267 PV(Total_frame_size
);
5276 slurp_hppa_unwind_table (FILE *file
,
5277 struct hppa_unw_aux_info
*aux
,
5278 Elf_Internal_Shdr
*sec
)
5280 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5281 Elf_Internal_Phdr
*seg
;
5282 struct hppa_unw_table_entry
*tep
;
5283 Elf_Internal_Shdr
*relsec
;
5284 Elf_Internal_Rela
*rela
, *rp
;
5285 unsigned char *table
, *tp
;
5286 Elf_Internal_Sym
*sym
;
5287 const char *relname
;
5289 /* First, find the starting address of the segment that includes
5292 if (elf_header
.e_phnum
)
5294 if (! get_program_headers (file
))
5297 for (seg
= program_headers
;
5298 seg
< program_headers
+ elf_header
.e_phnum
;
5301 if (seg
->p_type
!= PT_LOAD
)
5304 if (sec
->sh_addr
>= seg
->p_vaddr
5305 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5307 aux
->seg_base
= seg
->p_vaddr
;
5313 /* Second, build the unwind table from the contents of the unwind
5315 size
= sec
->sh_size
;
5316 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5321 nentries
= size
/ unw_ent_size
;
5322 size
= unw_ent_size
* nentries
;
5324 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5326 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5328 unsigned int tmp1
, tmp2
;
5330 tep
->start
.section
= SHN_UNDEF
;
5331 tep
->end
.section
= SHN_UNDEF
;
5333 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5334 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5335 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5336 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5338 tep
->start
.offset
+= aux
->seg_base
;
5339 tep
->end
.offset
+= aux
->seg_base
;
5341 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5342 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5343 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5344 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5345 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5346 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5347 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5348 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5349 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5350 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5351 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5352 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5353 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5354 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5355 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5356 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5357 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5358 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5359 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5360 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5361 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5362 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5363 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5364 tep
->Cleanup_defined
= tmp1
& 0x1;
5366 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5367 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5368 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5369 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5370 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5371 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5375 /* Third, apply any relocations to the unwind table. */
5377 for (relsec
= section_headers
;
5378 relsec
< section_headers
+ elf_header
.e_shnum
;
5381 if (relsec
->sh_type
!= SHT_RELA
5382 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5383 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5386 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5390 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5394 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5395 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5399 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5400 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5403 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5404 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5406 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5410 i
= rp
->r_offset
/ unw_ent_size
;
5412 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5415 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5416 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5419 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5420 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5430 aux
->table_len
= nentries
;
5436 hppa_process_unwind (FILE *file
)
5438 struct hppa_unw_aux_info aux
;
5439 Elf_Internal_Shdr
*unwsec
= NULL
;
5440 Elf_Internal_Shdr
*strsec
;
5441 Elf_Internal_Shdr
*sec
;
5444 memset (& aux
, 0, sizeof (aux
));
5446 if (string_table
== NULL
)
5449 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5451 if (sec
->sh_type
== SHT_SYMTAB
5452 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5454 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5455 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5457 strsec
= SECTION_HEADER (sec
->sh_link
);
5458 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5459 1, strsec
->sh_size
, _("string table"));
5460 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5462 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5467 printf (_("\nThere are no unwind sections in this file.\n"));
5469 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5471 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5473 printf (_("\nUnwind section "));
5474 printf (_("'%s'"), SECTION_NAME (sec
));
5476 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5477 (unsigned long) sec
->sh_offset
,
5478 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5480 slurp_hppa_unwind_table (file
, &aux
, sec
);
5481 if (aux
.table_len
> 0)
5482 dump_hppa_unwind (&aux
);
5485 free ((char *) aux
.table
);
5493 free ((char *) aux
.strtab
);
5499 process_unwind (FILE *file
)
5501 struct unwind_handler
{
5503 int (*handler
)(FILE *file
);
5505 { EM_IA_64
, ia64_process_unwind
},
5506 { EM_PARISC
, hppa_process_unwind
},
5514 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5515 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5516 return handlers
[i
].handler (file
);
5518 printf (_("\nThere are no unwind sections in this file.\n"));
5523 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5525 switch (entry
->d_tag
)
5528 if (entry
->d_un
.d_val
== 0)
5532 static const char * opts
[] =
5534 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5535 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5536 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5537 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5542 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5543 if (entry
->d_un
.d_val
& (1 << cnt
))
5545 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5552 case DT_MIPS_IVERSION
:
5553 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5554 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5556 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5559 case DT_MIPS_TIME_STAMP
:
5564 time_t time
= entry
->d_un
.d_val
;
5565 tmp
= gmtime (&time
);
5566 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5567 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5568 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5569 printf ("Time Stamp: %s\n", timebuf
);
5573 case DT_MIPS_RLD_VERSION
:
5574 case DT_MIPS_LOCAL_GOTNO
:
5575 case DT_MIPS_CONFLICTNO
:
5576 case DT_MIPS_LIBLISTNO
:
5577 case DT_MIPS_SYMTABNO
:
5578 case DT_MIPS_UNREFEXTNO
:
5579 case DT_MIPS_HIPAGENO
:
5580 case DT_MIPS_DELTA_CLASS_NO
:
5581 case DT_MIPS_DELTA_INSTANCE_NO
:
5582 case DT_MIPS_DELTA_RELOC_NO
:
5583 case DT_MIPS_DELTA_SYM_NO
:
5584 case DT_MIPS_DELTA_CLASSSYM_NO
:
5585 case DT_MIPS_COMPACT_SIZE
:
5586 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5590 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5596 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5598 switch (entry
->d_tag
)
5600 case DT_HP_DLD_FLAGS
:
5609 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5610 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5611 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5612 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5613 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5614 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5615 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5616 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5617 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5618 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5619 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5620 { DT_HP_GST
, "HP_GST" },
5621 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5622 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5623 { DT_HP_NODELETE
, "HP_NODELETE" },
5624 { DT_HP_GROUP
, "HP_GROUP" },
5625 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5629 bfd_vma val
= entry
->d_un
.d_val
;
5631 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5632 if (val
& flags
[cnt
].bit
)
5636 fputs (flags
[cnt
].str
, stdout
);
5638 val
^= flags
[cnt
].bit
;
5641 if (val
!= 0 || first
)
5645 print_vma (val
, HEX
);
5651 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5658 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5660 switch (entry
->d_tag
)
5662 case DT_IA_64_PLT_RESERVE
:
5663 /* First 3 slots reserved. */
5664 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5666 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5670 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5677 get_32bit_dynamic_section (FILE *file
)
5679 Elf32_External_Dyn
*edyn
, *ext
;
5680 Elf_Internal_Dyn
*entry
;
5682 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5683 _("dynamic section"));
5687 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5688 might not have the luxury of section headers. Look for the DT_NULL
5689 terminator to determine the number of entries. */
5690 for (ext
= edyn
, dynamic_nent
= 0;
5691 (char *) ext
< (char *) edyn
+ dynamic_size
;
5695 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5699 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5700 if (dynamic_section
== NULL
)
5702 error (_("Out of memory\n"));
5707 for (ext
= edyn
, entry
= dynamic_section
;
5708 entry
< dynamic_section
+ dynamic_nent
;
5711 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5712 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5721 get_64bit_dynamic_section (FILE *file
)
5723 Elf64_External_Dyn
*edyn
, *ext
;
5724 Elf_Internal_Dyn
*entry
;
5726 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5727 _("dynamic section"));
5731 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5732 might not have the luxury of section headers. Look for the DT_NULL
5733 terminator to determine the number of entries. */
5734 for (ext
= edyn
, dynamic_nent
= 0;
5735 (char *) ext
< (char *) edyn
+ dynamic_size
;
5739 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5743 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5744 if (dynamic_section
== NULL
)
5746 error (_("Out of memory\n"));
5751 for (ext
= edyn
, entry
= dynamic_section
;
5752 entry
< dynamic_section
+ dynamic_nent
;
5755 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5756 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5765 print_dynamic_flags (bfd_vma flags
)
5773 flag
= flags
& - flags
;
5783 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5784 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5785 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5786 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5787 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5788 default: fputs ("unknown", stdout
); break;
5794 /* Parse and display the contents of the dynamic section. */
5797 process_dynamic_section (FILE *file
)
5799 Elf_Internal_Dyn
*entry
;
5801 if (dynamic_size
== 0)
5804 printf (_("\nThere is no dynamic section in this file.\n"));
5811 if (! get_32bit_dynamic_section (file
))
5814 else if (! get_64bit_dynamic_section (file
))
5817 /* Find the appropriate symbol table. */
5818 if (dynamic_symbols
== NULL
)
5820 for (entry
= dynamic_section
;
5821 entry
< dynamic_section
+ dynamic_nent
;
5824 Elf_Internal_Shdr section
;
5826 if (entry
->d_tag
!= DT_SYMTAB
)
5829 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5831 /* Since we do not know how big the symbol table is,
5832 we default to reading in the entire file (!) and
5833 processing that. This is overkill, I know, but it
5835 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5837 if (archive_file_offset
!= 0)
5838 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5841 if (fseek (file
, 0, SEEK_END
))
5842 error (_("Unable to seek to end of file!"));
5844 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5848 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5850 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5852 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5853 if (num_dynamic_syms
< 1)
5855 error (_("Unable to determine the number of symbols to load\n"));
5859 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5863 /* Similarly find a string table. */
5864 if (dynamic_strings
== NULL
)
5866 for (entry
= dynamic_section
;
5867 entry
< dynamic_section
+ dynamic_nent
;
5870 unsigned long offset
;
5873 if (entry
->d_tag
!= DT_STRTAB
)
5876 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5878 /* Since we do not know how big the string table is,
5879 we default to reading in the entire file (!) and
5880 processing that. This is overkill, I know, but it
5883 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5885 if (archive_file_offset
!= 0)
5886 str_tab_len
= archive_file_size
- offset
;
5889 if (fseek (file
, 0, SEEK_END
))
5890 error (_("Unable to seek to end of file\n"));
5891 str_tab_len
= ftell (file
) - offset
;
5894 if (str_tab_len
< 1)
5897 (_("Unable to determine the length of the dynamic string table\n"));
5901 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5902 _("dynamic string table"));
5903 dynamic_strings_length
= str_tab_len
;
5908 /* And find the syminfo section if available. */
5909 if (dynamic_syminfo
== NULL
)
5911 unsigned long syminsz
= 0;
5913 for (entry
= dynamic_section
;
5914 entry
< dynamic_section
+ dynamic_nent
;
5917 if (entry
->d_tag
== DT_SYMINENT
)
5919 /* Note: these braces are necessary to avoid a syntax
5920 error from the SunOS4 C compiler. */
5921 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5923 else if (entry
->d_tag
== DT_SYMINSZ
)
5924 syminsz
= entry
->d_un
.d_val
;
5925 else if (entry
->d_tag
== DT_SYMINFO
)
5926 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5930 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5932 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5933 Elf_Internal_Syminfo
*syminfo
;
5935 /* There is a syminfo section. Read the data. */
5936 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5937 syminsz
, _("symbol information"));
5941 dynamic_syminfo
= malloc (syminsz
);
5942 if (dynamic_syminfo
== NULL
)
5944 error (_("Out of memory\n"));
5948 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5949 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5950 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5951 ++syminfo
, ++extsym
)
5953 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5954 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5961 if (do_dynamic
&& dynamic_addr
)
5962 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5963 dynamic_addr
, dynamic_nent
);
5965 printf (_(" Tag Type Name/Value\n"));
5967 for (entry
= dynamic_section
;
5968 entry
< dynamic_section
+ dynamic_nent
;
5976 print_vma (entry
->d_tag
, FULL_HEX
);
5977 dtype
= get_dynamic_type (entry
->d_tag
);
5978 printf (" (%s)%*s", dtype
,
5979 ((is_32bit_elf
? 27 : 19)
5980 - (int) strlen (dtype
)),
5984 switch (entry
->d_tag
)
5988 print_dynamic_flags (entry
->d_un
.d_val
);
5998 switch (entry
->d_tag
)
6001 printf (_("Auxiliary library"));
6005 printf (_("Filter library"));
6009 printf (_("Configuration file"));
6013 printf (_("Dependency audit library"));
6017 printf (_("Audit library"));
6021 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6022 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6026 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6035 printf (_("Flags:"));
6037 if (entry
->d_un
.d_val
== 0)
6038 printf (_(" None\n"));
6041 unsigned long int val
= entry
->d_un
.d_val
;
6043 if (val
& DTF_1_PARINIT
)
6045 printf (" PARINIT");
6046 val
^= DTF_1_PARINIT
;
6048 if (val
& DTF_1_CONFEXP
)
6050 printf (" CONFEXP");
6051 val
^= DTF_1_CONFEXP
;
6054 printf (" %lx", val
);
6063 printf (_("Flags:"));
6065 if (entry
->d_un
.d_val
== 0)
6066 printf (_(" None\n"));
6069 unsigned long int val
= entry
->d_un
.d_val
;
6071 if (val
& DF_P1_LAZYLOAD
)
6073 printf (" LAZYLOAD");
6074 val
^= DF_P1_LAZYLOAD
;
6076 if (val
& DF_P1_GROUPPERM
)
6078 printf (" GROUPPERM");
6079 val
^= DF_P1_GROUPPERM
;
6082 printf (" %lx", val
);
6091 printf (_("Flags:"));
6092 if (entry
->d_un
.d_val
== 0)
6093 printf (_(" None\n"));
6096 unsigned long int val
= entry
->d_un
.d_val
;
6103 if (val
& DF_1_GLOBAL
)
6108 if (val
& DF_1_GROUP
)
6113 if (val
& DF_1_NODELETE
)
6115 printf (" NODELETE");
6116 val
^= DF_1_NODELETE
;
6118 if (val
& DF_1_LOADFLTR
)
6120 printf (" LOADFLTR");
6121 val
^= DF_1_LOADFLTR
;
6123 if (val
& DF_1_INITFIRST
)
6125 printf (" INITFIRST");
6126 val
^= DF_1_INITFIRST
;
6128 if (val
& DF_1_NOOPEN
)
6133 if (val
& DF_1_ORIGIN
)
6138 if (val
& DF_1_DIRECT
)
6143 if (val
& DF_1_TRANS
)
6148 if (val
& DF_1_INTERPOSE
)
6150 printf (" INTERPOSE");
6151 val
^= DF_1_INTERPOSE
;
6153 if (val
& DF_1_NODEFLIB
)
6155 printf (" NODEFLIB");
6156 val
^= DF_1_NODEFLIB
;
6158 if (val
& DF_1_NODUMP
)
6163 if (val
& DF_1_CONLFAT
)
6165 printf (" CONLFAT");
6166 val
^= DF_1_CONLFAT
;
6169 printf (" %lx", val
);
6176 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6178 puts (get_dynamic_type (entry
->d_un
.d_val
));
6198 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6204 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6205 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6211 switch (entry
->d_tag
)
6214 printf (_("Shared library: [%s]"), name
);
6216 if (streq (name
, program_interpreter
))
6217 printf (_(" program interpreter"));
6221 printf (_("Library soname: [%s]"), name
);
6225 printf (_("Library rpath: [%s]"), name
);
6229 printf (_("Library runpath: [%s]"), name
);
6233 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6238 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6251 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6255 case DT_INIT_ARRAYSZ
:
6256 case DT_FINI_ARRAYSZ
:
6257 case DT_GNU_CONFLICTSZ
:
6258 case DT_GNU_LIBLISTSZ
:
6261 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6262 printf (" (bytes)\n");
6272 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6285 if (entry
->d_tag
== DT_USED
6286 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6288 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6292 printf (_("Not needed object: [%s]\n"), name
);
6297 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6303 /* The value of this entry is ignored. */
6308 case DT_GNU_PRELINKED
:
6312 time_t time
= entry
->d_un
.d_val
;
6314 tmp
= gmtime (&time
);
6315 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6316 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6317 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6323 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6326 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6332 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6333 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6338 switch (elf_header
.e_machine
)
6341 case EM_MIPS_RS3_LE
:
6342 dynamic_section_mips_val (entry
);
6345 dynamic_section_parisc_val (entry
);
6348 dynamic_section_ia64_val (entry
);
6351 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6363 get_ver_flags (unsigned int flags
)
6365 static char buff
[32];
6372 if (flags
& VER_FLG_BASE
)
6373 strcat (buff
, "BASE ");
6375 if (flags
& VER_FLG_WEAK
)
6377 if (flags
& VER_FLG_BASE
)
6378 strcat (buff
, "| ");
6380 strcat (buff
, "WEAK ");
6383 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6384 strcat (buff
, "| <unknown>");
6389 /* Display the contents of the version sections. */
6391 process_version_sections (FILE *file
)
6393 Elf_Internal_Shdr
*section
;
6400 for (i
= 0, section
= section_headers
;
6401 i
< elf_header
.e_shnum
;
6404 switch (section
->sh_type
)
6406 case SHT_GNU_verdef
:
6408 Elf_External_Verdef
*edefs
;
6415 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6416 SECTION_NAME (section
), section
->sh_info
);
6418 printf (_(" Addr: 0x"));
6419 printf_vma (section
->sh_addr
);
6420 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6421 (unsigned long) section
->sh_offset
, section
->sh_link
,
6422 SECTION_HEADER_INDEX (section
->sh_link
)
6423 < elf_header
.e_shnum
6424 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6427 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6429 _("version definition section"));
6433 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6436 Elf_External_Verdef
*edef
;
6437 Elf_Internal_Verdef ent
;
6438 Elf_External_Verdaux
*eaux
;
6439 Elf_Internal_Verdaux aux
;
6443 vstart
= ((char *) edefs
) + idx
;
6445 edef
= (Elf_External_Verdef
*) vstart
;
6447 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6448 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6449 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6450 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6451 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6452 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6453 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6455 printf (_(" %#06x: Rev: %d Flags: %s"),
6456 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6458 printf (_(" Index: %d Cnt: %d "),
6459 ent
.vd_ndx
, ent
.vd_cnt
);
6461 vstart
+= ent
.vd_aux
;
6463 eaux
= (Elf_External_Verdaux
*) vstart
;
6465 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6466 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6468 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6469 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6471 printf (_("Name index: %ld\n"), aux
.vda_name
);
6473 isum
= idx
+ ent
.vd_aux
;
6475 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6477 isum
+= aux
.vda_next
;
6478 vstart
+= aux
.vda_next
;
6480 eaux
= (Elf_External_Verdaux
*) vstart
;
6482 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6483 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6485 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6486 printf (_(" %#06x: Parent %d: %s\n"),
6487 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6489 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6490 isum
, j
, aux
.vda_name
);
6500 case SHT_GNU_verneed
:
6502 Elf_External_Verneed
*eneed
;
6508 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6509 SECTION_NAME (section
), section
->sh_info
);
6511 printf (_(" Addr: 0x"));
6512 printf_vma (section
->sh_addr
);
6513 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6514 (unsigned long) section
->sh_offset
, section
->sh_link
,
6515 SECTION_HEADER_INDEX (section
->sh_link
)
6516 < elf_header
.e_shnum
6517 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6520 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6522 _("version need section"));
6526 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6528 Elf_External_Verneed
*entry
;
6529 Elf_Internal_Verneed ent
;
6534 vstart
= ((char *) eneed
) + idx
;
6536 entry
= (Elf_External_Verneed
*) vstart
;
6538 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6539 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6540 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6541 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6542 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6544 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6546 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6547 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6549 printf (_(" File: %lx"), ent
.vn_file
);
6551 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6553 vstart
+= ent
.vn_aux
;
6555 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6557 Elf_External_Vernaux
*eaux
;
6558 Elf_Internal_Vernaux aux
;
6560 eaux
= (Elf_External_Vernaux
*) vstart
;
6562 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6563 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6564 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6565 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6566 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6568 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6569 printf (_(" %#06x: Name: %s"),
6570 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6572 printf (_(" %#06x: Name index: %lx"),
6573 isum
, aux
.vna_name
);
6575 printf (_(" Flags: %s Version: %d\n"),
6576 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6578 isum
+= aux
.vna_next
;
6579 vstart
+= aux
.vna_next
;
6589 case SHT_GNU_versym
:
6591 Elf_Internal_Shdr
*link_section
;
6594 unsigned char *edata
;
6595 unsigned short *data
;
6597 Elf_Internal_Sym
*symbols
;
6598 Elf_Internal_Shdr
*string_sec
;
6601 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6604 link_section
= SECTION_HEADER (section
->sh_link
);
6605 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6607 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6608 >= elf_header
.e_shnum
)
6613 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6615 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6617 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6618 string_sec
->sh_size
, _("version string table"));
6622 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6623 SECTION_NAME (section
), total
);
6625 printf (_(" Addr: "));
6626 printf_vma (section
->sh_addr
);
6627 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6628 (unsigned long) section
->sh_offset
, section
->sh_link
,
6629 SECTION_NAME (link_section
));
6631 off
= offset_from_vma (file
,
6632 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6633 total
* sizeof (short));
6634 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6635 _("version symbol data"));
6642 data
= cmalloc (total
, sizeof (short));
6644 for (cnt
= total
; cnt
--;)
6645 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6650 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6653 int check_def
, check_need
;
6656 printf (" %03x:", cnt
);
6658 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6659 switch (data
[cnt
+ j
])
6662 fputs (_(" 0 (*local*) "), stdout
);
6666 fputs (_(" 1 (*global*) "), stdout
);
6670 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6671 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6675 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6676 >= elf_header
.e_shnum
6677 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6680 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6687 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6689 Elf_Internal_Verneed ivn
;
6690 unsigned long offset
;
6692 offset
= offset_from_vma
6693 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6694 sizeof (Elf_External_Verneed
));
6698 Elf_Internal_Vernaux ivna
;
6699 Elf_External_Verneed evn
;
6700 Elf_External_Vernaux evna
;
6701 unsigned long a_off
;
6703 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6706 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6707 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6709 a_off
= offset
+ ivn
.vn_aux
;
6713 get_data (&evna
, file
, a_off
, sizeof (evna
),
6714 1, _("version need aux (2)"));
6716 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6717 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6719 a_off
+= ivna
.vna_next
;
6721 while (ivna
.vna_other
!= data
[cnt
+ j
]
6722 && ivna
.vna_next
!= 0);
6724 if (ivna
.vna_other
== data
[cnt
+ j
])
6726 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6728 name
= strtab
+ ivna
.vna_name
;
6729 nn
+= printf ("(%s%-*s",
6731 12 - (int) strlen (name
),
6737 offset
+= ivn
.vn_next
;
6739 while (ivn
.vn_next
);
6742 if (check_def
&& data
[cnt
+ j
] != 0x8001
6743 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6745 Elf_Internal_Verdef ivd
;
6746 Elf_External_Verdef evd
;
6747 unsigned long offset
;
6749 offset
= offset_from_vma
6750 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6755 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6758 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6759 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6761 offset
+= ivd
.vd_next
;
6763 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6764 && ivd
.vd_next
!= 0);
6766 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6768 Elf_External_Verdaux evda
;
6769 Elf_Internal_Verdaux ivda
;
6771 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6773 get_data (&evda
, file
,
6774 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6776 _("version def aux"));
6778 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6780 name
= strtab
+ ivda
.vda_name
;
6781 nn
+= printf ("(%s%-*s",
6783 12 - (int) strlen (name
),
6789 printf ("%*c", 18 - nn
, ' ');
6807 printf (_("\nNo version information found in this file.\n"));
6813 get_symbol_binding (unsigned int binding
)
6815 static char buff
[32];
6819 case STB_LOCAL
: return "LOCAL";
6820 case STB_GLOBAL
: return "GLOBAL";
6821 case STB_WEAK
: return "WEAK";
6823 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6824 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6826 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6827 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6829 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6835 get_symbol_type (unsigned int type
)
6837 static char buff
[32];
6841 case STT_NOTYPE
: return "NOTYPE";
6842 case STT_OBJECT
: return "OBJECT";
6843 case STT_FUNC
: return "FUNC";
6844 case STT_SECTION
: return "SECTION";
6845 case STT_FILE
: return "FILE";
6846 case STT_COMMON
: return "COMMON";
6847 case STT_TLS
: return "TLS";
6849 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6851 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6852 return "THUMB_FUNC";
6854 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6857 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6858 return "PARISC_MILLI";
6860 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6862 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6864 if (elf_header
.e_machine
== EM_PARISC
)
6866 if (type
== STT_HP_OPAQUE
)
6868 if (type
== STT_HP_STUB
)
6872 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6875 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6881 get_symbol_visibility (unsigned int visibility
)
6885 case STV_DEFAULT
: return "DEFAULT";
6886 case STV_INTERNAL
: return "INTERNAL";
6887 case STV_HIDDEN
: return "HIDDEN";
6888 case STV_PROTECTED
: return "PROTECTED";
6894 get_mips_symbol_other (unsigned int other
)
6898 case STO_OPTIONAL
: return "OPTIONAL";
6899 case STO_MIPS16
: return "MIPS16";
6900 default: return NULL
;
6905 get_symbol_other (unsigned int other
)
6907 const char * result
= NULL
;
6908 static char buff
[32];
6913 switch (elf_header
.e_machine
)
6916 result
= get_mips_symbol_other (other
);
6924 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6929 get_symbol_index_type (unsigned int type
)
6931 static char buff
[32];
6935 case SHN_UNDEF
: return "UND";
6936 case SHN_ABS
: return "ABS";
6937 case SHN_COMMON
: return "COM";
6939 if (type
== SHN_IA_64_ANSI_COMMON
6940 && elf_header
.e_machine
== EM_IA_64
6941 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6943 else if (elf_header
.e_machine
== EM_X86_64
6944 && type
== SHN_X86_64_LCOMMON
)
6946 else if (type
== SHN_MIPS_SCOMMON
6947 && elf_header
.e_machine
== EM_MIPS
)
6949 else if (type
== SHN_MIPS_SUNDEFINED
6950 && elf_header
.e_machine
== EM_MIPS
)
6952 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6953 sprintf (buff
, "PRC[0x%04x]", type
);
6954 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6955 sprintf (buff
, "OS [0x%04x]", type
);
6956 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6957 sprintf (buff
, "RSV[0x%04x]", type
);
6959 sprintf (buff
, "%3d", type
);
6967 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6969 unsigned char *e_data
;
6972 e_data
= cmalloc (number
, ent_size
);
6976 error (_("Out of memory\n"));
6980 if (fread (e_data
, ent_size
, number
, file
) != number
)
6982 error (_("Unable to read in dynamic data\n"));
6986 i_data
= cmalloc (number
, sizeof (*i_data
));
6990 error (_("Out of memory\n"));
6996 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7003 /* Dump the symbol table. */
7005 process_symbol_table (FILE *file
)
7007 Elf_Internal_Shdr
*section
;
7008 bfd_vma nbuckets
= 0;
7009 bfd_vma nchains
= 0;
7010 bfd_vma
*buckets
= NULL
;
7011 bfd_vma
*chains
= NULL
;
7012 bfd_vma ngnubuckets
= 0;
7013 bfd_vma
*gnubuckets
= NULL
;
7014 bfd_vma
*gnuchains
= NULL
;
7016 if (! do_syms
&& !do_histogram
)
7019 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
7022 unsigned char nb
[8];
7023 unsigned char nc
[8];
7024 int hash_ent_size
= 4;
7026 if ((elf_header
.e_machine
== EM_ALPHA
7027 || elf_header
.e_machine
== EM_S390
7028 || elf_header
.e_machine
== EM_S390_OLD
)
7029 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7033 (archive_file_offset
7034 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7035 sizeof nb
+ sizeof nc
)),
7038 error (_("Unable to seek to start of dynamic information"));
7042 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7044 error (_("Failed to read in number of buckets\n"));
7048 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7050 error (_("Failed to read in number of chains\n"));
7054 nbuckets
= byte_get (nb
, hash_ent_size
);
7055 nchains
= byte_get (nc
, hash_ent_size
);
7057 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7058 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7060 if (buckets
== NULL
|| chains
== NULL
)
7065 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
7070 printf (_("\nSymbol table for image:\n"));
7072 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7074 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7076 for (hn
= 0; hn
< nbuckets
; hn
++)
7081 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7083 Elf_Internal_Sym
*psym
;
7086 psym
= dynamic_symbols
+ si
;
7088 n
= print_vma (si
, DEC_5
);
7090 fputs (" " + n
, stdout
);
7091 printf (" %3lu: ", hn
);
7092 print_vma (psym
->st_value
, LONG_HEX
);
7094 print_vma (psym
->st_size
, DEC_5
);
7096 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7097 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7098 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7099 /* Check to see if any other bits in the st_other field are set.
7100 Note - displaying this information disrupts the layout of the
7101 table being generated, but for the moment this case is very rare. */
7102 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7103 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7104 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7105 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7106 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7108 printf (" <corrupt: %14ld>", psym
->st_name
);
7113 else if (do_syms
&& !do_using_dynamic
)
7117 for (i
= 0, section
= section_headers
;
7118 i
< elf_header
.e_shnum
;
7122 char *strtab
= NULL
;
7123 unsigned long int strtab_size
= 0;
7124 Elf_Internal_Sym
*symtab
;
7125 Elf_Internal_Sym
*psym
;
7128 if ( section
->sh_type
!= SHT_SYMTAB
7129 && section
->sh_type
!= SHT_DYNSYM
)
7132 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7133 SECTION_NAME (section
),
7134 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7136 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7138 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7140 symtab
= GET_ELF_SYMBOLS (file
, section
);
7144 if (section
->sh_link
== elf_header
.e_shstrndx
)
7146 strtab
= string_table
;
7147 strtab_size
= string_table_length
;
7149 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7151 Elf_Internal_Shdr
*string_sec
;
7153 string_sec
= SECTION_HEADER (section
->sh_link
);
7155 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7156 1, string_sec
->sh_size
, _("string table"));
7157 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7160 for (si
= 0, psym
= symtab
;
7161 si
< section
->sh_size
/ section
->sh_entsize
;
7164 printf ("%6d: ", si
);
7165 print_vma (psym
->st_value
, LONG_HEX
);
7167 print_vma (psym
->st_size
, DEC_5
);
7168 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7169 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7170 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7171 /* Check to see if any other bits in the st_other field are set.
7172 Note - displaying this information disrupts the layout of the
7173 table being generated, but for the moment this case is very rare. */
7174 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7175 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7176 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7177 print_symbol (25, psym
->st_name
< strtab_size
7178 ? strtab
+ psym
->st_name
: "<corrupt>");
7180 if (section
->sh_type
== SHT_DYNSYM
&&
7181 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7183 unsigned char data
[2];
7184 unsigned short vers_data
;
7185 unsigned long offset
;
7189 offset
= offset_from_vma
7190 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7191 sizeof data
+ si
* sizeof (vers_data
));
7193 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7194 sizeof (data
), 1, _("version data"));
7196 vers_data
= byte_get (data
, 2);
7198 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7199 < elf_header
.e_shnum
7200 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7203 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7205 if ((vers_data
& 0x8000) || vers_data
> 1)
7207 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7208 && (is_nobits
|| ! check_def
))
7210 Elf_External_Verneed evn
;
7211 Elf_Internal_Verneed ivn
;
7212 Elf_Internal_Vernaux ivna
;
7214 /* We must test both. */
7215 offset
= offset_from_vma
7216 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7221 unsigned long vna_off
;
7223 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7226 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7227 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7229 vna_off
= offset
+ ivn
.vn_aux
;
7233 Elf_External_Vernaux evna
;
7235 get_data (&evna
, file
, vna_off
,
7237 _("version need aux (3)"));
7239 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7240 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7241 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7243 vna_off
+= ivna
.vna_next
;
7245 while (ivna
.vna_other
!= vers_data
7246 && ivna
.vna_next
!= 0);
7248 if (ivna
.vna_other
== vers_data
)
7251 offset
+= ivn
.vn_next
;
7253 while (ivn
.vn_next
!= 0);
7255 if (ivna
.vna_other
== vers_data
)
7258 ivna
.vna_name
< strtab_size
7259 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7263 else if (! is_nobits
)
7264 error (_("bad dynamic symbol"));
7271 if (vers_data
!= 0x8001
7272 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7274 Elf_Internal_Verdef ivd
;
7275 Elf_Internal_Verdaux ivda
;
7276 Elf_External_Verdaux evda
;
7277 unsigned long offset
;
7279 offset
= offset_from_vma
7281 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7282 sizeof (Elf_External_Verdef
));
7286 Elf_External_Verdef evd
;
7288 get_data (&evd
, file
, offset
, sizeof (evd
),
7289 1, _("version def"));
7291 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7292 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7293 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7295 offset
+= ivd
.vd_next
;
7297 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7298 && ivd
.vd_next
!= 0);
7300 offset
-= ivd
.vd_next
;
7301 offset
+= ivd
.vd_aux
;
7303 get_data (&evda
, file
, offset
, sizeof (evda
),
7304 1, _("version def aux"));
7306 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7308 if (psym
->st_name
!= ivda
.vda_name
)
7309 printf ((vers_data
& 0x8000)
7311 ivda
.vda_name
< strtab_size
7312 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7322 if (strtab
!= string_table
)
7328 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7330 if (do_histogram
&& buckets
!= NULL
)
7332 unsigned long *lengths
;
7333 unsigned long *counts
;
7336 unsigned long maxlength
= 0;
7337 unsigned long nzero_counts
= 0;
7338 unsigned long nsyms
= 0;
7340 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7341 (unsigned long) nbuckets
);
7342 printf (_(" Length Number %% of total Coverage\n"));
7344 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7345 if (lengths
== NULL
)
7347 error (_("Out of memory"));
7350 for (hn
= 0; hn
< nbuckets
; ++hn
)
7352 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7355 if (maxlength
< ++lengths
[hn
])
7360 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7363 error (_("Out of memory"));
7367 for (hn
= 0; hn
< nbuckets
; ++hn
)
7368 ++counts
[lengths
[hn
]];
7373 printf (" 0 %-10lu (%5.1f%%)\n",
7374 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7375 for (i
= 1; i
<= maxlength
; ++i
)
7377 nzero_counts
+= counts
[i
] * i
;
7378 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7379 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7380 (nzero_counts
* 100.0) / nsyms
);
7388 if (buckets
!= NULL
)
7394 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7396 unsigned char nb
[16];
7397 bfd_vma i
, maxchain
= 0xffffffff, symidx
, bitmaskwords
;
7398 unsigned long *lengths
;
7399 unsigned long *counts
;
7401 unsigned long maxlength
= 0;
7402 unsigned long nzero_counts
= 0;
7403 unsigned long nsyms
= 0;
7404 bfd_vma buckets_vma
;
7407 (archive_file_offset
7408 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7412 error (_("Unable to seek to start of dynamic information"));
7416 if (fread (nb
, 16, 1, file
) != 1)
7418 error (_("Failed to read in number of buckets\n"));
7422 ngnubuckets
= byte_get (nb
, 4);
7423 symidx
= byte_get (nb
+ 4, 4);
7424 bitmaskwords
= byte_get (nb
+ 8, 4);
7425 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7427 buckets_vma
+= bitmaskwords
* 4;
7429 buckets_vma
+= bitmaskwords
* 8;
7432 (archive_file_offset
7433 + offset_from_vma (file
, buckets_vma
, 4)),
7436 error (_("Unable to seek to start of dynamic information"));
7440 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7442 if (gnubuckets
== NULL
)
7445 for (i
= 0; i
< ngnubuckets
; i
++)
7446 if (gnubuckets
[i
] != 0)
7448 if (gnubuckets
[i
] < symidx
)
7451 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7452 maxchain
= gnubuckets
[i
];
7455 if (maxchain
== 0xffffffff)
7461 (archive_file_offset
7462 + offset_from_vma (file
, buckets_vma
7463 + 4 * (ngnubuckets
+ maxchain
), 4)),
7466 error (_("Unable to seek to start of dynamic information"));
7472 if (fread (nb
, 4, 1, file
) != 1)
7474 error (_("Failed to determine last chain length\n"));
7478 if (maxchain
+ 1 == 0)
7483 while ((byte_get (nb
, 4) & 1) == 0);
7486 (archive_file_offset
7487 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7490 error (_("Unable to seek to start of dynamic information"));
7494 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7496 if (gnuchains
== NULL
)
7499 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7500 if (lengths
== NULL
)
7502 error (_("Out of memory"));
7506 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7507 (unsigned long) ngnubuckets
);
7508 printf (_(" Length Number %% of total Coverage\n"));
7510 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7511 if (gnubuckets
[hn
] != 0)
7513 bfd_vma off
, length
= 1;
7515 for (off
= gnubuckets
[hn
] - symidx
;
7516 (gnuchains
[off
] & 1) == 0; ++off
)
7518 lengths
[hn
] = length
;
7519 if (length
> maxlength
)
7524 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7527 error (_("Out of memory"));
7531 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7532 ++counts
[lengths
[hn
]];
7534 if (ngnubuckets
> 0)
7537 printf (" 0 %-10lu (%5.1f%%)\n",
7538 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7539 for (j
= 1; j
<= maxlength
; ++j
)
7541 nzero_counts
+= counts
[j
] * j
;
7542 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7543 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7544 (nzero_counts
* 100.0) / nsyms
);
7558 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7562 if (dynamic_syminfo
== NULL
7564 /* No syminfo, this is ok. */
7567 /* There better should be a dynamic symbol section. */
7568 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7572 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7573 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7575 printf (_(" Num: Name BoundTo Flags\n"));
7576 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7578 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7580 printf ("%4d: ", i
);
7581 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7582 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7584 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7587 switch (dynamic_syminfo
[i
].si_boundto
)
7589 case SYMINFO_BT_SELF
:
7590 fputs ("SELF ", stdout
);
7592 case SYMINFO_BT_PARENT
:
7593 fputs ("PARENT ", stdout
);
7596 if (dynamic_syminfo
[i
].si_boundto
> 0
7597 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7598 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7600 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7604 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7608 if (flags
& SYMINFO_FLG_DIRECT
)
7610 if (flags
& SYMINFO_FLG_PASSTHRU
)
7611 printf (" PASSTHRU");
7612 if (flags
& SYMINFO_FLG_COPY
)
7614 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7615 printf (" LAZYLOAD");
7623 #ifdef SUPPORT_DISASSEMBLY
7625 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7627 printf (_("\nAssembly dump of section %s\n"),
7628 SECTION_NAME (section
));
7630 /* XXX -- to be done --- XXX */
7637 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7639 bfd_size_type bytes
;
7641 unsigned char *data
;
7642 unsigned char *start
;
7644 bytes
= section
->sh_size
;
7646 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7648 printf (_("\nSection '%s' has no data to dump.\n"),
7649 SECTION_NAME (section
));
7653 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7655 addr
= section
->sh_addr
;
7657 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7670 lbytes
= (bytes
> 16 ? 16 : bytes
);
7672 printf (" 0x%8.8lx ", (unsigned long) addr
);
7674 switch (elf_header
.e_ident
[EI_DATA
])
7678 for (j
= 15; j
>= 0; j
--)
7681 printf ("%2.2x", data
[j
]);
7691 for (j
= 0; j
< 16; j
++)
7694 printf ("%2.2x", data
[j
]);
7704 for (j
= 0; j
< lbytes
; j
++)
7707 if (k
>= ' ' && k
< 0x7f)
7725 /* Apply addends of RELA relocations. */
7728 debug_apply_rela_addends (void *file
,
7729 Elf_Internal_Shdr
*section
,
7730 unsigned char *start
)
7732 Elf_Internal_Shdr
*relsec
;
7733 unsigned char *end
= start
+ section
->sh_size
;
7734 /* FIXME: The relocation field size is relocation type dependent. */
7735 unsigned int reloc_size
= 4;
7737 if (!is_relocatable
)
7740 if (section
->sh_size
< reloc_size
)
7743 for (relsec
= section_headers
;
7744 relsec
< section_headers
+ elf_header
.e_shnum
;
7747 unsigned long nrelas
;
7748 Elf_Internal_Rela
*rela
, *rp
;
7749 Elf_Internal_Shdr
*symsec
;
7750 Elf_Internal_Sym
*symtab
;
7751 Elf_Internal_Sym
*sym
;
7753 if (relsec
->sh_type
!= SHT_RELA
7754 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7755 || SECTION_HEADER (relsec
->sh_info
) != section
7756 || relsec
->sh_size
== 0
7757 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7760 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7764 symsec
= SECTION_HEADER (relsec
->sh_link
);
7765 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7767 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7771 loc
= start
+ rp
->r_offset
;
7772 if ((loc
+ reloc_size
) > end
)
7774 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7775 (unsigned long) rp
->r_offset
,
7776 SECTION_NAME (section
));
7782 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7784 if (ELF32_R_SYM (rp
->r_info
) != 0
7785 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7786 /* Relocations against symbols without type can happen.
7787 Gcc -feliminate-dwarf2-dups may generate symbols
7788 without type for debug info. */
7789 && ELF32_ST_TYPE (sym
->st_info
) != STT_NOTYPE
7790 /* Relocations against object symbols can happen,
7791 eg when referencing a global array. For an
7792 example of this see the _clz.o binary in libgcc.a. */
7793 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7795 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7796 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7797 SECTION_NAME (section
));
7803 /* In MIPS little-endian objects, r_info isn't really a
7804 64-bit little-endian value: it has a 32-bit little-endian
7805 symbol index followed by four individual byte fields.
7806 Reorder INFO accordingly. */
7807 if (elf_header
.e_machine
== EM_MIPS
7808 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7809 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7810 | ((rp
->r_info
>> 56) & 0xff)
7811 | ((rp
->r_info
>> 40) & 0xff00)
7812 | ((rp
->r_info
>> 24) & 0xff0000)
7813 | ((rp
->r_info
>> 8) & 0xff000000));
7815 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7817 if (ELF64_R_SYM (rp
->r_info
) != 0
7818 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7819 && ELF64_ST_TYPE (sym
->st_info
) != STT_NOTYPE
7820 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7822 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7823 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7824 SECTION_NAME (section
));
7829 byte_put (loc
, rp
->r_addend
, reloc_size
);
7840 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
7842 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7843 Elf_Internal_Shdr
*sec
;
7846 /* If it is already loaded, do nothing. */
7847 if (section
->start
!= NULL
)
7850 /* Locate the debug section. */
7851 sec
= find_section (section
->name
);
7855 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
7856 section
->address
= sec
->sh_addr
;
7857 section
->size
= sec
->sh_size
;
7858 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
7861 if (debug_displays
[debug
].relocate
)
7862 debug_apply_rela_addends (file
, sec
, section
->start
);
7864 return section
->start
!= NULL
;
7868 free_debug_section (enum dwarf_section_display_enum debug
)
7870 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
7872 if (section
->start
== NULL
)
7875 free ((char *) section
->start
);
7876 section
->start
= NULL
;
7877 section
->address
= 0;
7882 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
7884 char *name
= SECTION_NAME (section
);
7885 bfd_size_type length
;
7887 enum dwarf_section_display_enum i
;
7889 length
= section
->sh_size
;
7892 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7896 if (const_strneq (name
, ".gnu.linkonce.wi."))
7897 name
= ".debug_info";
7899 /* See if we know how to display the contents of this section. */
7900 for (i
= 0; i
< max
; i
++)
7901 if (streq (debug_displays
[i
].section
.name
, name
))
7903 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
7905 if (load_debug_section (i
, file
))
7907 result
&= debug_displays
[i
].display (sec
, file
);
7909 if (i
!= info
&& i
!= abbrev
)
7910 free_debug_section (i
);
7918 printf (_("Unrecognized debug section: %s\n"), name
);
7925 /* Set DUMP_SECTS for all sections where dumps were requested
7926 based on section name. */
7929 initialise_dumps_byname (void)
7931 struct dump_list_entry
*cur
;
7933 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
7938 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
7939 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
7941 request_dump (i
, cur
->type
);
7946 warn (_("Section '%s' was not dumped because it does not exist!\n"),
7952 process_section_contents (FILE *file
)
7954 Elf_Internal_Shdr
*section
;
7960 initialise_dumps_byname ();
7962 for (i
= 0, section
= section_headers
;
7963 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7966 #ifdef SUPPORT_DISASSEMBLY
7967 if (dump_sects
[i
] & DISASS_DUMP
)
7968 disassemble_section (section
, file
);
7970 if (dump_sects
[i
] & HEX_DUMP
)
7971 dump_section (section
, file
);
7973 if (dump_sects
[i
] & DEBUG_DUMP
)
7974 display_debug_section (section
, file
);
7977 /* Check to see if the user requested a
7978 dump of a section that does not exist. */
7979 while (i
++ < num_dump_sects
)
7981 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
7985 process_mips_fpe_exception (int mask
)
7990 if (mask
& OEX_FPU_INEX
)
7991 fputs ("INEX", stdout
), first
= 0;
7992 if (mask
& OEX_FPU_UFLO
)
7993 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7994 if (mask
& OEX_FPU_OFLO
)
7995 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7996 if (mask
& OEX_FPU_DIV0
)
7997 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7998 if (mask
& OEX_FPU_INVAL
)
7999 printf ("%sINVAL", first
? "" : "|");
8002 fputs ("0", stdout
);
8005 /* ARM EABI attributes section. */
8010 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8013 } arm_attr_public_tag
;
8015 static const char *arm_attr_tag_CPU_arch
[] =
8016 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8018 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8019 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8020 {"No", "Thumb-1", "Thumb-2"};
8021 /* FIXME: VFPv3 encoding was extrapolated! */
8022 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8023 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8024 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8025 static const char *arm_attr_tag_ABI_PCS_config
[] =
8026 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8027 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8028 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8029 {"V6", "SB", "TLS", "Unused"};
8030 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8031 {"Absolute", "PC-relative", "SB-relative", "None"};
8032 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8033 {"Absolute", "PC-relative", "None"};
8034 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8035 {"None", "direct", "GOT-indirect"};
8036 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8037 {"None", "??? 1", "2", "??? 3", "4"};
8038 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8039 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8040 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8041 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8042 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8043 {"Unused", "Finite", "RTABI", "IEEE 754"};
8044 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8045 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8046 {"No", "Yes, except leaf SP", "Yes"};
8047 static const char *arm_attr_tag_ABI_enum_size
[] =
8048 {"Unused", "small", "int", "forced to int"};
8049 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8050 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8051 static const char *arm_attr_tag_ABI_VFP_args
[] =
8052 {"AAPCS", "VFP registers", "custom"};
8053 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8054 {"AAPCS", "WMMX registers", "custom"};
8055 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8056 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8057 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8058 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8059 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8060 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8062 #define LOOKUP(id, name) \
8063 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8064 static arm_attr_public_tag arm_attr_public_tags
[] =
8066 {4, "CPU_raw_name", 1, NULL
},
8067 {5, "CPU_name", 1, NULL
},
8068 LOOKUP(6, CPU_arch
),
8069 {7, "CPU_arch_profile", 0, NULL
},
8070 LOOKUP(8, ARM_ISA_use
),
8071 LOOKUP(9, THUMB_ISA_use
),
8072 LOOKUP(10, VFP_arch
),
8073 LOOKUP(11, WMMX_arch
),
8074 LOOKUP(12, NEON_arch
),
8075 LOOKUP(13, ABI_PCS_config
),
8076 LOOKUP(14, ABI_PCS_R9_use
),
8077 LOOKUP(15, ABI_PCS_RW_data
),
8078 LOOKUP(16, ABI_PCS_RO_DATA
),
8079 LOOKUP(17, ABI_PCS_GOT_use
),
8080 LOOKUP(18, ABI_PCS_wchar_t
),
8081 LOOKUP(19, ABI_FP_rounding
),
8082 LOOKUP(20, ABI_FP_denormal
),
8083 LOOKUP(21, ABI_FP_exceptions
),
8084 LOOKUP(22, ABI_FP_user_exceptions
),
8085 LOOKUP(23, ABI_FP_number_model
),
8086 LOOKUP(24, ABI_align8_needed
),
8087 LOOKUP(25, ABI_align8_preserved
),
8088 LOOKUP(26, ABI_enum_size
),
8089 LOOKUP(27, ABI_HardFP_use
),
8090 LOOKUP(28, ABI_VFP_args
),
8091 LOOKUP(29, ABI_WMMX_args
),
8092 LOOKUP(30, ABI_optimization_goals
),
8093 LOOKUP(31, ABI_FP_optimization_goals
),
8094 {32, "compatibility", 0, NULL
}
8098 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8101 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8115 val
|= ((unsigned int)c
& 0x7f) << shift
;
8124 static unsigned char *
8125 display_arm_attribute (unsigned char *p
)
8130 arm_attr_public_tag
*attr
;
8134 tag
= read_uleb128 (p
, &len
);
8137 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8139 if (arm_attr_public_tags
[i
].tag
== tag
)
8141 attr
= &arm_attr_public_tags
[i
];
8148 printf (" Tag_%s: ", attr
->name
);
8154 case 7: /* Tag_CPU_arch_profile. */
8155 val
= read_uleb128 (p
, &len
);
8159 case 0: printf ("None\n"); break;
8160 case 'A': printf ("Application\n"); break;
8161 case 'R': printf ("Realtime\n"); break;
8162 case 'M': printf ("Microcontroller\n"); break;
8163 default: printf ("??? (%d)\n", val
); break;
8167 case 32: /* Tag_compatibility. */
8168 val
= read_uleb128 (p
, &len
);
8170 printf ("flag = %d, vendor = %s\n", val
, p
);
8171 p
+= strlen((char *)p
) + 1;
8185 assert (attr
->type
& 0x80);
8186 val
= read_uleb128 (p
, &len
);
8188 type
= attr
->type
& 0x7f;
8190 printf ("??? (%d)\n", val
);
8192 printf ("%s\n", attr
->table
[val
]);
8199 type
= 1; /* String. */
8201 type
= 2; /* uleb128. */
8202 printf (" Tag_unknown_%d: ", tag
);
8207 printf ("\"%s\"\n", p
);
8208 p
+= strlen((char *)p
) + 1;
8212 val
= read_uleb128 (p
, &len
);
8214 printf ("%d (0x%x)\n", val
, val
);
8221 process_arm_specific (FILE *file
)
8223 Elf_Internal_Shdr
*sect
;
8224 unsigned char *contents
;
8227 bfd_vma section_len
;
8231 /* Find the section header so that we get the size. */
8232 for (i
= 0, sect
= section_headers
;
8233 i
< elf_header
.e_shnum
;
8236 if (sect
->sh_type
!= SHT_ARM_ATTRIBUTES
)
8239 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
8247 len
= sect
->sh_size
- 1;
8252 bfd_boolean public_section
;
8254 section_len
= byte_get (p
, 4);
8256 if (section_len
> len
)
8258 printf (_("ERROR: Bad section length (%d > %d)\n"),
8259 (int)section_len
, (int)len
);
8263 printf ("Attribute Section: %s\n", p
);
8264 if (strcmp ((char *)p
, "aeabi") == 0)
8265 public_section
= TRUE
;
8267 public_section
= FALSE
;
8268 namelen
= strlen ((char *)p
) + 1;
8270 section_len
-= namelen
+ 4;
8271 while (section_len
> 0)
8276 size
= byte_get (p
, 4);
8277 if (size
> section_len
)
8279 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8280 (int)size
, (int)section_len
);
8283 section_len
-= size
;
8289 printf ("File Attributes\n");
8292 printf ("Section Attributes:");
8295 printf ("Symbol Attributes:");
8300 val
= read_uleb128 (p
, &i
);
8304 printf (" %d", val
);
8309 printf ("Unknown tag: %d\n", tag
);
8310 public_section
= FALSE
;
8316 p
= display_arm_attribute(p
);
8320 /* ??? Do something sensible, like dump hex. */
8321 printf (" Unknown section contexts\n");
8329 printf (_("Unknown format '%c'\n"), *p
);
8338 process_mips_specific (FILE *file
)
8340 Elf_Internal_Dyn
*entry
;
8341 size_t liblist_offset
= 0;
8342 size_t liblistno
= 0;
8343 size_t conflictsno
= 0;
8344 size_t options_offset
= 0;
8345 size_t conflicts_offset
= 0;
8347 /* We have a lot of special sections. Thanks SGI! */
8348 if (dynamic_section
== NULL
)
8349 /* No information available. */
8352 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
8353 switch (entry
->d_tag
)
8355 case DT_MIPS_LIBLIST
:
8357 = offset_from_vma (file
, entry
->d_un
.d_val
,
8358 liblistno
* sizeof (Elf32_External_Lib
));
8360 case DT_MIPS_LIBLISTNO
:
8361 liblistno
= entry
->d_un
.d_val
;
8363 case DT_MIPS_OPTIONS
:
8364 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8366 case DT_MIPS_CONFLICT
:
8368 = offset_from_vma (file
, entry
->d_un
.d_val
,
8369 conflictsno
* sizeof (Elf32_External_Conflict
));
8371 case DT_MIPS_CONFLICTNO
:
8372 conflictsno
= entry
->d_un
.d_val
;
8378 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8380 Elf32_External_Lib
*elib
;
8383 elib
= get_data (NULL
, file
, liblist_offset
,
8384 liblistno
, sizeof (Elf32_External_Lib
),
8388 printf ("\nSection '.liblist' contains %lu entries:\n",
8389 (unsigned long) liblistno
);
8390 fputs (" Library Time Stamp Checksum Version Flags\n",
8393 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8400 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8401 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8402 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8403 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8404 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8406 tmp
= gmtime (&time
);
8407 snprintf (timebuf
, sizeof (timebuf
),
8408 "%04u-%02u-%02uT%02u:%02u:%02u",
8409 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8410 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8412 printf ("%3lu: ", (unsigned long) cnt
);
8413 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
8414 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
8416 printf ("<corrupt: %9ld>", liblist
.l_name
);
8417 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8420 if (liblist
.l_flags
== 0)
8431 { " EXACT_MATCH", LL_EXACT_MATCH
},
8432 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8433 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8434 { " EXPORTS", LL_EXPORTS
},
8435 { " DELAY_LOAD", LL_DELAY_LOAD
},
8436 { " DELTA", LL_DELTA
}
8438 int flags
= liblist
.l_flags
;
8442 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
8444 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8446 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8447 flags
^= l_flags_vals
[fcnt
].bit
;
8450 printf (" %#x", (unsigned int) flags
);
8460 if (options_offset
!= 0)
8462 Elf_External_Options
*eopt
;
8463 Elf_Internal_Shdr
*sect
= section_headers
;
8464 Elf_Internal_Options
*iopt
;
8465 Elf_Internal_Options
*option
;
8469 /* Find the section header so that we get the size. */
8470 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8473 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
8477 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
8480 error (_("Out of memory"));
8487 while (offset
< sect
->sh_size
)
8489 Elf_External_Options
*eoption
;
8491 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8493 option
->kind
= BYTE_GET (eoption
->kind
);
8494 option
->size
= BYTE_GET (eoption
->size
);
8495 option
->section
= BYTE_GET (eoption
->section
);
8496 option
->info
= BYTE_GET (eoption
->info
);
8498 offset
+= option
->size
;
8504 printf (_("\nSection '%s' contains %d entries:\n"),
8505 SECTION_NAME (sect
), cnt
);
8513 switch (option
->kind
)
8516 /* This shouldn't happen. */
8517 printf (" NULL %d %lx", option
->section
, option
->info
);
8520 printf (" REGINFO ");
8521 if (elf_header
.e_machine
== EM_MIPS
)
8524 Elf32_External_RegInfo
*ereg
;
8525 Elf32_RegInfo reginfo
;
8527 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8528 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8529 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8530 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8531 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8532 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8533 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8535 printf ("GPR %08lx GP 0x%lx\n",
8537 (unsigned long) reginfo
.ri_gp_value
);
8538 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8539 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8540 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8545 Elf64_External_RegInfo
*ereg
;
8546 Elf64_Internal_RegInfo reginfo
;
8548 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8549 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8550 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8551 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8552 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8553 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8554 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8556 printf ("GPR %08lx GP 0x",
8557 reginfo
.ri_gprmask
);
8558 printf_vma (reginfo
.ri_gp_value
);
8561 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8562 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8563 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8567 case ODK_EXCEPTIONS
:
8568 fputs (" EXCEPTIONS fpe_min(", stdout
);
8569 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8570 fputs (") fpe_max(", stdout
);
8571 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8572 fputs (")", stdout
);
8574 if (option
->info
& OEX_PAGE0
)
8575 fputs (" PAGE0", stdout
);
8576 if (option
->info
& OEX_SMM
)
8577 fputs (" SMM", stdout
);
8578 if (option
->info
& OEX_FPDBUG
)
8579 fputs (" FPDBUG", stdout
);
8580 if (option
->info
& OEX_DISMISS
)
8581 fputs (" DISMISS", stdout
);
8584 fputs (" PAD ", stdout
);
8585 if (option
->info
& OPAD_PREFIX
)
8586 fputs (" PREFIX", stdout
);
8587 if (option
->info
& OPAD_POSTFIX
)
8588 fputs (" POSTFIX", stdout
);
8589 if (option
->info
& OPAD_SYMBOL
)
8590 fputs (" SYMBOL", stdout
);
8593 fputs (" HWPATCH ", stdout
);
8594 if (option
->info
& OHW_R4KEOP
)
8595 fputs (" R4KEOP", stdout
);
8596 if (option
->info
& OHW_R8KPFETCH
)
8597 fputs (" R8KPFETCH", stdout
);
8598 if (option
->info
& OHW_R5KEOP
)
8599 fputs (" R5KEOP", stdout
);
8600 if (option
->info
& OHW_R5KCVTL
)
8601 fputs (" R5KCVTL", stdout
);
8604 fputs (" FILL ", stdout
);
8605 /* XXX Print content of info word? */
8608 fputs (" TAGS ", stdout
);
8609 /* XXX Print content of info word? */
8612 fputs (" HWAND ", stdout
);
8613 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8614 fputs (" R4KEOP_CHECKED", stdout
);
8615 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8616 fputs (" R4KEOP_CLEAN", stdout
);
8619 fputs (" HWOR ", stdout
);
8620 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8621 fputs (" R4KEOP_CHECKED", stdout
);
8622 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8623 fputs (" R4KEOP_CLEAN", stdout
);
8626 printf (" GP_GROUP %#06lx self-contained %#06lx",
8627 option
->info
& OGP_GROUP
,
8628 (option
->info
& OGP_SELF
) >> 16);
8631 printf (" IDENT %#06lx self-contained %#06lx",
8632 option
->info
& OGP_GROUP
,
8633 (option
->info
& OGP_SELF
) >> 16);
8636 /* This shouldn't happen. */
8637 printf (" %3d ??? %d %lx",
8638 option
->kind
, option
->section
, option
->info
);
8642 len
= sizeof (*eopt
);
8643 while (len
< option
->size
)
8644 if (((char *) option
)[len
] >= ' '
8645 && ((char *) option
)[len
] < 0x7f)
8646 printf ("%c", ((char *) option
)[len
++]);
8648 printf ("\\%03o", ((char *) option
)[len
++]);
8650 fputs ("\n", stdout
);
8658 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8660 Elf32_Conflict
*iconf
;
8663 if (dynamic_symbols
== NULL
)
8665 error (_("conflict list found without a dynamic symbol table"));
8669 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
8672 error (_("Out of memory"));
8678 Elf32_External_Conflict
*econf32
;
8680 econf32
= get_data (NULL
, file
, conflicts_offset
,
8681 conflictsno
, sizeof (*econf32
), _("conflict"));
8685 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8686 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8692 Elf64_External_Conflict
*econf64
;
8694 econf64
= get_data (NULL
, file
, conflicts_offset
,
8695 conflictsno
, sizeof (*econf64
), _("conflict"));
8699 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8700 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8705 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8706 (unsigned long) conflictsno
);
8707 puts (_(" Num: Index Value Name"));
8709 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8711 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
8713 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8714 print_vma (psym
->st_value
, FULL_HEX
);
8716 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8717 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8719 printf ("<corrupt: %14ld>", psym
->st_name
);
8730 process_gnu_liblist (FILE *file
)
8732 Elf_Internal_Shdr
*section
, *string_sec
;
8733 Elf32_External_Lib
*elib
;
8742 for (i
= 0, section
= section_headers
;
8743 i
< elf_header
.e_shnum
;
8746 switch (section
->sh_type
)
8748 case SHT_GNU_LIBLIST
:
8749 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
8752 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
8757 string_sec
= SECTION_HEADER (section
->sh_link
);
8759 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8760 string_sec
->sh_size
, _("liblist string table"));
8761 strtab_size
= string_sec
->sh_size
;
8764 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
8770 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8771 SECTION_NAME (section
),
8772 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
8774 puts (" Library Time Stamp Checksum Version Flags");
8776 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
8784 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8785 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8786 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8787 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8788 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8790 tmp
= gmtime (&time
);
8791 snprintf (timebuf
, sizeof (timebuf
),
8792 "%04u-%02u-%02uT%02u:%02u:%02u",
8793 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8794 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8796 printf ("%3lu: ", (unsigned long) cnt
);
8798 printf ("%-20s", liblist
.l_name
< strtab_size
8799 ? strtab
+ liblist
.l_name
: "<corrupt>");
8801 printf ("%-20.20s", liblist
.l_name
< strtab_size
8802 ? strtab
+ liblist
.l_name
: "<corrupt>");
8803 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
8804 liblist
.l_version
, liblist
.l_flags
);
8815 get_note_type (unsigned e_type
)
8817 static char buff
[64];
8819 if (elf_header
.e_type
== ET_CORE
)
8823 return _("NT_AUXV (auxiliary vector)");
8825 return _("NT_PRSTATUS (prstatus structure)");
8827 return _("NT_FPREGSET (floating point registers)");
8829 return _("NT_PRPSINFO (prpsinfo structure)");
8831 return _("NT_TASKSTRUCT (task structure)");
8833 return _("NT_PRXFPREG (user_xfpregs structure)");
8835 return _("NT_PSTATUS (pstatus structure)");
8837 return _("NT_FPREGS (floating point registers)");
8839 return _("NT_PSINFO (psinfo structure)");
8841 return _("NT_LWPSTATUS (lwpstatus_t structure)");
8843 return _("NT_LWPSINFO (lwpsinfo_t structure)");
8844 case NT_WIN32PSTATUS
:
8845 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8853 return _("NT_VERSION (version)");
8855 return _("NT_ARCH (architecture)");
8860 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8865 get_netbsd_elfcore_note_type (unsigned e_type
)
8867 static char buff
[64];
8869 if (e_type
== NT_NETBSDCORE_PROCINFO
)
8871 /* NetBSD core "procinfo" structure. */
8872 return _("NetBSD procinfo structure");
8875 /* As of Jan 2002 there are no other machine-independent notes
8876 defined for NetBSD core files. If the note type is less
8877 than the start of the machine-dependent note types, we don't
8880 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
8882 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
8886 switch (elf_header
.e_machine
)
8888 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8889 and PT_GETFPREGS == mach+2. */
8894 case EM_SPARC32PLUS
:
8898 case NT_NETBSDCORE_FIRSTMACH
+0:
8899 return _("PT_GETREGS (reg structure)");
8900 case NT_NETBSDCORE_FIRSTMACH
+2:
8901 return _("PT_GETFPREGS (fpreg structure)");
8907 /* On all other arch's, PT_GETREGS == mach+1 and
8908 PT_GETFPREGS == mach+3. */
8912 case NT_NETBSDCORE_FIRSTMACH
+1:
8913 return _("PT_GETREGS (reg structure)");
8914 case NT_NETBSDCORE_FIRSTMACH
+3:
8915 return _("PT_GETFPREGS (fpreg structure)");
8921 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
8922 e_type
- NT_NETBSDCORE_FIRSTMACH
);
8926 /* Note that by the ELF standard, the name field is already null byte
8927 terminated, and namesz includes the terminating null byte.
8928 I.E. the value of namesz for the name "FSF" is 4.
8930 If the value of namesz is zero, there is no name present. */
8932 process_note (Elf_Internal_Note
*pnote
)
8936 if (pnote
->namesz
== 0)
8937 /* If there is no note name, then use the default set of
8938 note type strings. */
8939 nt
= get_note_type (pnote
->type
);
8941 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
8942 /* NetBSD-specific core file notes. */
8943 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
8946 /* Don't recognize this note name; just use the default set of
8947 note type strings. */
8948 nt
= get_note_type (pnote
->type
);
8950 printf (" %s\t\t0x%08lx\t%s\n",
8951 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8958 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
8960 Elf_External_Note
*pnotes
;
8961 Elf_External_Note
*external
;
8967 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
8973 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8974 (unsigned long) offset
, (unsigned long) length
);
8975 printf (_(" Owner\t\tData size\tDescription\n"));
8977 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8979 Elf_External_Note
*next
;
8980 Elf_Internal_Note inote
;
8983 inote
.type
= BYTE_GET (external
->type
);
8984 inote
.namesz
= BYTE_GET (external
->namesz
);
8985 inote
.namedata
= external
->name
;
8986 inote
.descsz
= BYTE_GET (external
->descsz
);
8987 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8988 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8990 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8992 if (((char *) next
) > (((char *) pnotes
) + length
))
8994 warn (_("corrupt note found at offset %lx into core notes\n"),
8995 (long)((char *)external
- (char *)pnotes
));
8996 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8997 inote
.type
, inote
.namesz
, inote
.descsz
);
9003 /* Verify that name is null terminated. It appears that at least
9004 one version of Linux (RedHat 6.0) generates corefiles that don't
9005 comply with the ELF spec by failing to include the null byte in
9007 if (inote
.namedata
[inote
.namesz
] != '\0')
9009 temp
= malloc (inote
.namesz
+ 1);
9013 error (_("Out of memory\n"));
9018 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9019 temp
[inote
.namesz
] = 0;
9021 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9022 inote
.namedata
= temp
;
9025 res
&= process_note (& inote
);
9040 process_corefile_note_segments (FILE *file
)
9042 Elf_Internal_Phdr
*segment
;
9046 if (! get_program_headers (file
))
9049 for (i
= 0, segment
= program_headers
;
9050 i
< elf_header
.e_phnum
;
9053 if (segment
->p_type
== PT_NOTE
)
9054 res
&= process_corefile_note_segment (file
,
9055 (bfd_vma
) segment
->p_offset
,
9056 (bfd_vma
) segment
->p_filesz
);
9063 process_note_sections (FILE *file
)
9065 Elf_Internal_Shdr
*section
;
9069 for (i
= 0, section
= section_headers
;
9070 i
< elf_header
.e_shnum
;
9072 if (section
->sh_type
== SHT_NOTE
)
9073 res
&= process_corefile_note_segment (file
,
9074 (bfd_vma
) section
->sh_offset
,
9075 (bfd_vma
) section
->sh_size
);
9081 process_notes (FILE *file
)
9083 /* If we have not been asked to display the notes then do nothing. */
9087 if (elf_header
.e_type
!= ET_CORE
)
9088 return process_note_sections (file
);
9090 /* No program headers means no NOTE segment. */
9091 if (elf_header
.e_phnum
> 0)
9092 return process_corefile_note_segments (file
);
9094 printf (_("No note segments present in the core file.\n"));
9099 process_arch_specific (FILE *file
)
9104 switch (elf_header
.e_machine
)
9107 return process_arm_specific (file
);
9109 case EM_MIPS_RS3_LE
:
9110 return process_mips_specific (file
);
9119 get_file_header (FILE *file
)
9121 /* Read in the identity array. */
9122 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9125 /* Determine how to read the rest of the header. */
9126 switch (elf_header
.e_ident
[EI_DATA
])
9128 default: /* fall through */
9129 case ELFDATANONE
: /* fall through */
9131 byte_get
= byte_get_little_endian
;
9132 byte_put
= byte_put_little_endian
;
9135 byte_get
= byte_get_big_endian
;
9136 byte_put
= byte_put_big_endian
;
9140 /* For now we only support 32 bit and 64 bit ELF files. */
9141 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9143 /* Read in the rest of the header. */
9146 Elf32_External_Ehdr ehdr32
;
9148 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9151 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9152 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9153 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9154 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9155 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9156 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9157 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9158 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9159 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9160 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9161 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9162 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9163 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9167 Elf64_External_Ehdr ehdr64
;
9169 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9170 we will not be able to cope with the 64bit data found in
9171 64 ELF files. Detect this now and abort before we start
9172 overwriting things. */
9173 if (sizeof (bfd_vma
) < 8)
9175 error (_("This instance of readelf has been built without support for a\n\
9176 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9180 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9183 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9184 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9185 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9186 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
9187 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
9188 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
9189 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9190 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9191 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9192 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9193 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9194 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9195 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9198 if (elf_header
.e_shoff
)
9200 /* There may be some extensions in the first section header. Don't
9201 bomb if we can't read it. */
9203 get_32bit_section_headers (file
, 1);
9205 get_64bit_section_headers (file
, 1);
9208 is_relocatable
= elf_header
.e_type
== ET_REL
;
9213 /* Process one ELF object file according to the command line options.
9214 This file may actually be stored in an archive. The file is
9215 positioned at the start of the ELF object. */
9218 process_object (char *file_name
, FILE *file
)
9222 if (! get_file_header (file
))
9224 error (_("%s: Failed to read file header\n"), file_name
);
9228 /* Initialise per file variables. */
9229 for (i
= NUM_ELEM (version_info
); i
--;)
9230 version_info
[i
] = 0;
9232 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9233 dynamic_info
[i
] = 0;
9235 /* Process the file. */
9237 printf (_("\nFile: %s\n"), file_name
);
9239 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9240 Note we do this even if cmdline_dump_sects is empty because we
9241 must make sure that the dump_sets array is zeroed out before each
9242 object file is processed. */
9243 if (num_dump_sects
> num_cmdline_dump_sects
)
9244 memset (dump_sects
, 0, num_dump_sects
);
9246 if (num_cmdline_dump_sects
> 0)
9248 if (num_dump_sects
== 0)
9249 /* A sneaky way of allocating the dump_sects array. */
9250 request_dump (num_cmdline_dump_sects
, 0);
9252 assert (num_dump_sects
>= num_cmdline_dump_sects
);
9253 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
9256 if (! process_file_header ())
9259 if (! process_section_headers (file
))
9261 /* Without loaded section headers we cannot process lots of
9263 do_unwind
= do_version
= do_dump
= do_arch
= 0;
9265 if (! do_using_dynamic
)
9266 do_syms
= do_reloc
= 0;
9269 if (! process_section_groups (file
))
9271 /* Without loaded section groups we cannot process unwind. */
9275 if (process_program_headers (file
))
9276 process_dynamic_section (file
);
9278 process_relocs (file
);
9280 process_unwind (file
);
9282 process_symbol_table (file
);
9284 process_syminfo (file
);
9286 process_version_sections (file
);
9288 process_section_contents (file
);
9290 process_notes (file
);
9292 process_gnu_liblist (file
);
9294 process_arch_specific (file
);
9296 if (program_headers
)
9298 free (program_headers
);
9299 program_headers
= NULL
;
9302 if (section_headers
)
9304 free (section_headers
);
9305 section_headers
= NULL
;
9310 free (string_table
);
9311 string_table
= NULL
;
9312 string_table_length
= 0;
9315 if (dynamic_strings
)
9317 free (dynamic_strings
);
9318 dynamic_strings
= NULL
;
9319 dynamic_strings_length
= 0;
9322 if (dynamic_symbols
)
9324 free (dynamic_symbols
);
9325 dynamic_symbols
= NULL
;
9326 num_dynamic_syms
= 0;
9329 if (dynamic_syminfo
)
9331 free (dynamic_syminfo
);
9332 dynamic_syminfo
= NULL
;
9335 if (section_headers_groups
)
9337 free (section_headers_groups
);
9338 section_headers_groups
= NULL
;
9343 struct group_list
*g
, *next
;
9345 for (i
= 0; i
< group_count
; i
++)
9347 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
9354 free (section_groups
);
9355 section_groups
= NULL
;
9358 free_debug_memory ();
9363 /* Process an ELF archive. The file is positioned just after the
9367 process_archive (char *file_name
, FILE *file
)
9369 struct ar_hdr arhdr
;
9372 char *longnames
= NULL
;
9373 unsigned long longnames_size
= 0;
9374 size_t file_name_size
;
9379 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9380 if (got
!= sizeof arhdr
)
9385 error (_("%s: failed to read archive header\n"), file_name
);
9389 if (const_strneq (arhdr
.ar_name
, "/ "))
9391 /* This is the archive symbol table. Skip it.
9392 FIXME: We should have an option to dump it. */
9393 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9394 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
9396 error (_("%s: failed to skip archive symbol table\n"), file_name
);
9400 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9401 if (got
!= sizeof arhdr
)
9406 error (_("%s: failed to read archive header\n"), file_name
);
9411 if (const_strneq (arhdr
.ar_name
, "// "))
9413 /* This is the archive string table holding long member
9416 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9418 longnames
= malloc (longnames_size
);
9419 if (longnames
== NULL
)
9421 error (_("Out of memory\n"));
9425 if (fread (longnames
, longnames_size
, 1, file
) != 1)
9428 error (_("%s: failed to read string table\n"), file_name
);
9432 if ((longnames_size
& 1) != 0)
9435 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9436 if (got
!= sizeof arhdr
)
9443 error (_("%s: failed to read archive header\n"), file_name
);
9448 file_name_size
= strlen (file_name
);
9457 if (arhdr
.ar_name
[0] == '/')
9461 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
9462 if (off
>= longnames_size
)
9464 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
9469 name
= longnames
+ off
;
9470 nameend
= memchr (name
, '/', longnames_size
- off
);
9474 name
= arhdr
.ar_name
;
9475 nameend
= memchr (name
, '/', 16);
9478 if (nameend
== NULL
)
9480 error (_("%s: bad archive file name\n"), file_name
);
9485 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
9486 if (namealc
== NULL
)
9488 error (_("Out of memory\n"));
9493 memcpy (namealc
, file_name
, file_name_size
);
9494 namealc
[file_name_size
] = '(';
9495 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
9496 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
9497 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
9499 archive_file_offset
= ftell (file
);
9500 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
9502 ret
|= process_object (namealc
, file
);
9507 (archive_file_offset
9509 + (archive_file_size
& 1)),
9512 error (_("%s: failed to seek to next archive header\n"), file_name
);
9517 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
9518 if (got
!= sizeof arhdr
)
9523 error (_("%s: failed to read archive header\n"), file_name
);
9536 process_file (char *file_name
)
9539 struct stat statbuf
;
9543 if (stat (file_name
, &statbuf
) < 0)
9545 if (errno
== ENOENT
)
9546 error (_("'%s': No such file\n"), file_name
);
9548 error (_("Could not locate '%s'. System error message: %s\n"),
9549 file_name
, strerror (errno
));
9553 if (! S_ISREG (statbuf
.st_mode
))
9555 error (_("'%s' is not an ordinary file\n"), file_name
);
9559 file
= fopen (file_name
, "rb");
9562 error (_("Input file '%s' is not readable.\n"), file_name
);
9566 if (fread (armag
, SARMAG
, 1, file
) != 1)
9568 error (_("%s: Failed to read file header\n"), file_name
);
9573 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
9574 ret
= process_archive (file_name
, file
);
9578 archive_file_size
= archive_file_offset
= 0;
9579 ret
= process_object (file_name
, file
);
9587 #ifdef SUPPORT_DISASSEMBLY
9588 /* Needed by the i386 disassembler. For extra credit, someone could
9589 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9593 print_address (unsigned int addr
, FILE *outfile
)
9595 fprintf (outfile
,"0x%8.8x", addr
);
9598 /* Needed by the i386 disassembler. */
9600 db_task_printsym (unsigned int addr
)
9602 print_address (addr
, stderr
);
9607 main (int argc
, char **argv
)
9611 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9612 setlocale (LC_MESSAGES
, "");
9614 #if defined (HAVE_SETLOCALE)
9615 setlocale (LC_CTYPE
, "");
9617 bindtextdomain (PACKAGE
, LOCALEDIR
);
9618 textdomain (PACKAGE
);
9620 expandargv (&argc
, &argv
);
9622 parse_args (argc
, argv
);
9624 if (num_dump_sects
> 0)
9626 /* Make a copy of the dump_sects array. */
9627 cmdline_dump_sects
= malloc (num_dump_sects
);
9628 if (cmdline_dump_sects
== NULL
)
9629 error (_("Out of memory allocating dump request table."));
9632 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
9633 num_cmdline_dump_sects
= num_dump_sects
;
9637 if (optind
< (argc
- 1))
9641 while (optind
< argc
)
9642 err
|= process_file (argv
[optind
++]);
9644 if (dump_sects
!= NULL
)
9646 if (cmdline_dump_sects
!= NULL
)
9647 free (cmdline_dump_sects
);