1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008 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 3 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. */
56 # ifdef HAVE_SYS_PARAM_H
57 # include <sys/param.h>
61 # define PATH_MAX MAXPATHLEN
63 # define PATH_MAX 1024
69 /* Define BFD64 here, even if our default architecture is 32 bit ELF
70 as this will allow us to read in and parse 64bit and 32bit ELF files.
71 Only do this if we believe that the compiler can support a 64 bit
72 data type. For now we only rely on GCC being able to do this. */
80 #include "elf/common.h"
81 #include "elf/external.h"
82 #include "elf/internal.h"
85 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
86 we can obtain the H8 reloc numbers. We need these for the
87 get_reloc_size() function. We include h8.h again after defining
88 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
93 /* Undo the effects of #including reloc-macros.h. */
95 #undef START_RELOC_NUMBERS
99 #undef END_RELOC_NUMBERS
100 #undef _RELOC_MACROS_H
102 /* The following headers use the elf/reloc-macros.h file to
103 automatically generate relocation recognition functions
104 such as elf_mips_reloc_type() */
106 #define RELOC_MACROS_GEN_FUNC
108 #include "elf/alpha.h"
112 #include "elf/bfin.h"
113 #include "elf/cr16.h"
114 #include "elf/cris.h"
116 #include "elf/d10v.h"
117 #include "elf/d30v.h"
119 #include "elf/fr30.h"
122 #include "elf/hppa.h"
123 #include "elf/i386.h"
124 #include "elf/i370.h"
125 #include "elf/i860.h"
126 #include "elf/i960.h"
127 #include "elf/ia64.h"
128 #include "elf/ip2k.h"
129 #include "elf/iq2000.h"
130 #include "elf/m32c.h"
131 #include "elf/m32r.h"
132 #include "elf/m68k.h"
133 #include "elf/m68hc11.h"
134 #include "elf/mcore.h"
136 #include "elf/mips.h"
137 #include "elf/mmix.h"
138 #include "elf/mn10200.h"
139 #include "elf/mn10300.h"
141 #include "elf/msp430.h"
142 #include "elf/or32.h"
145 #include "elf/ppc64.h"
146 #include "elf/s390.h"
147 #include "elf/score.h"
149 #include "elf/sparc.h"
151 #include "elf/v850.h"
153 #include "elf/x86-64.h"
154 #include "elf/xstormy16.h"
155 #include "elf/xtensa.h"
160 #include "libiberty.h"
161 #include "safe-ctype.h"
163 char *program_name
= "readelf";
165 static long archive_file_offset
;
166 static unsigned long archive_file_size
;
167 static unsigned long dynamic_addr
;
168 static bfd_size_type dynamic_size
;
169 static unsigned int dynamic_nent
;
170 static char *dynamic_strings
;
171 static unsigned long dynamic_strings_length
;
172 static char *string_table
;
173 static unsigned long string_table_length
;
174 static unsigned long num_dynamic_syms
;
175 static Elf_Internal_Sym
*dynamic_symbols
;
176 static Elf_Internal_Syminfo
*dynamic_syminfo
;
177 static unsigned long dynamic_syminfo_offset
;
178 static unsigned int dynamic_syminfo_nent
;
179 static char program_interpreter
[PATH_MAX
];
180 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
181 static bfd_vma dynamic_info_DT_GNU_HASH
;
182 static bfd_vma version_info
[16];
183 static Elf_Internal_Ehdr elf_header
;
184 static Elf_Internal_Shdr
*section_headers
;
185 static Elf_Internal_Phdr
*program_headers
;
186 static Elf_Internal_Dyn
*dynamic_section
;
187 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
188 static int show_name
;
189 static int do_dynamic
;
192 static int do_sections
;
193 static int do_section_groups
;
194 static int do_section_details
;
195 static int do_segments
;
196 static int do_unwind
;
197 static int do_using_dynamic
;
198 static int do_header
;
200 static int do_version
;
201 static int do_histogram
;
202 static int do_debugging
;
205 static int do_archive_index
;
206 static int is_32bit_elf
;
210 struct group_list
*next
;
211 unsigned int section_index
;
216 struct group_list
*root
;
217 unsigned int group_index
;
220 static size_t group_count
;
221 static struct group
*section_groups
;
222 static struct group
**section_headers_groups
;
225 /* Flag bits indicating particular types of dump. */
226 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
227 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
228 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
229 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
231 typedef unsigned char dump_type
;
233 /* A linked list of the section names for which dumps were requested. */
234 struct dump_list_entry
238 struct dump_list_entry
*next
;
240 static struct dump_list_entry
*dump_sects_byname
;
242 /* A dynamic array of flags indicating for which sections a dump
243 has been requested via command line switches. */
244 static dump_type
* cmdline_dump_sects
= NULL
;
245 static unsigned int num_cmdline_dump_sects
= 0;
247 /* A dynamic array of flags indicating for which sections a dump of
248 some kind has been requested. It is reset on a per-object file
249 basis and then initialised from the cmdline_dump_sects array,
250 the results of interpreting the -w switch, and the
251 dump_sects_byname list. */
252 static dump_type
* dump_sects
= NULL
;
253 static unsigned int num_dump_sects
= 0;
256 /* How to print a vma value. */
257 typedef enum print_mode
269 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
273 #define SECTION_NAME(X) \
274 ((X) == NULL ? "<none>" \
275 : string_table == NULL ? "<no-name>" \
276 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
277 : string_table + (X)->sh_name))
279 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
281 #define BYTE_GET(field) byte_get (field, sizeof (field))
283 #define GET_ELF_SYMBOLS(file, section) \
284 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
285 : get_64bit_elf_symbols (file, section))
287 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
288 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
289 already been called and verified that the string exists. */
290 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
292 /* This is just a bit of syntatic sugar. */
293 #define streq(a,b) (strcmp ((a), (b)) == 0)
294 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
295 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
298 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
303 if (size
== 0 || nmemb
== 0)
306 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
308 error (_("Unable to seek to 0x%lx for %s\n"),
309 archive_file_offset
+ offset
, reason
);
316 /* Check for overflow. */
317 if (nmemb
< (~(size_t) 0 - 1) / size
)
318 /* + 1 so that we can '\0' terminate invalid string table sections. */
319 mvar
= malloc (size
* nmemb
+ 1);
323 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
324 (unsigned long)(size
* nmemb
), reason
);
328 ((char *) mvar
)[size
* nmemb
] = '\0';
331 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
333 error (_("Unable to read in 0x%lx bytes of %s\n"),
334 (unsigned long)(size
* nmemb
), reason
);
344 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
349 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
350 field
[6] = ((value
>> 24) >> 24) & 0xff;
351 field
[5] = ((value
>> 24) >> 16) & 0xff;
352 field
[4] = ((value
>> 24) >> 8) & 0xff;
355 field
[3] = (value
>> 24) & 0xff;
356 field
[2] = (value
>> 16) & 0xff;
359 field
[1] = (value
>> 8) & 0xff;
362 field
[0] = value
& 0xff;
366 error (_("Unhandled data length: %d\n"), size
);
371 #if defined BFD64 && !BFD_HOST_64BIT_LONG && !BFD_HOST_64BIT_LONG_LONG
373 print_dec_vma (bfd_vma vma
, int is_signed
)
379 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
388 *bufp
++ = '0' + vma
% 10;
400 print_hex_vma (bfd_vma vma
)
408 char digit
= '0' + (vma
& 0x0f);
410 digit
+= 'a' - '0' - 10;
423 /* Print a VMA value. */
425 print_vma (bfd_vma vma
, print_mode mode
)
434 return printf ("0x%8.8lx", (unsigned long) vma
);
437 return printf ("%8.8lx", (unsigned long) vma
);
441 return printf ("%5ld", (long) vma
);
445 return printf ("0x%lx", (unsigned long) vma
);
448 return printf ("%lx", (unsigned long) vma
);
451 return printf ("%ld", (unsigned long) vma
);
454 return printf ("%lu", (unsigned long) vma
);
477 #if BFD_HOST_64BIT_LONG
478 return nc
+ printf ("%lx", vma
);
479 #elif BFD_HOST_64BIT_LONG_LONG
481 return nc
+ printf ("%llx", vma
);
483 return nc
+ printf ("%I64x", vma
);
486 return nc
+ print_hex_vma (vma
);
490 #if BFD_HOST_64BIT_LONG
491 return printf ("%ld", vma
);
492 #elif BFD_HOST_64BIT_LONG_LONG
494 return printf ("%lld", vma
);
496 return printf ("%I64d", vma
);
499 return print_dec_vma (vma
, 1);
503 #if BFD_HOST_64BIT_LONG
505 return printf ("%5ld", vma
);
507 return printf ("%#lx", vma
);
508 #elif BFD_HOST_64BIT_LONG_LONG
511 return printf ("%5lld", vma
);
513 return printf ("%#llx", vma
);
516 return printf ("%5I64d", vma
);
518 return printf ("%#I64x", vma
);
522 return printf ("%5ld", _bfd_int64_low (vma
));
524 return print_hex_vma (vma
);
528 #if BFD_HOST_64BIT_LONG
529 return printf ("%lu", vma
);
530 #elif BFD_HOST_64BIT_LONG_LONG
532 return printf ("%llu", vma
);
534 return printf ("%I64u", vma
);
537 return print_dec_vma (vma
, 0);
545 /* Display a symbol on stdout. Handles the display of
546 non-printing characters.
547 If DO_WIDE is not true then format the symbol to be
548 at most WIDTH characters, truncating as necessary.
549 If WIDTH is negative then format the string to be
550 exactly - WIDTH characters, truncating or padding
554 print_symbol (int width
, const char *symbol
)
556 const char * format_string
;
561 format_string
= "%.*s";
562 /* Set the width to a very large value. This simplifies the code below. */
567 format_string
= "%-*.*2s";
568 /* Keep the width positive. This also helps. */
573 format_string
= "%-.*s";
582 /* Look for non-printing symbols inside the symbol's name.
583 This test is triggered in particular by the names generated
584 by the assembler for local labels. */
585 while (ISPRINT (* c
))
595 printf (format_string
, len
, symbol
);
600 if (* c
== 0 || width
== 0)
603 /* Now display the non-printing character, if
604 there is room left in which to dipslay it. */
610 printf ("^%c", *c
+ 0x40);
619 printf ("<0x%.2x>", *c
);
629 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
634 field
[7] = value
& 0xff;
635 field
[6] = (value
>> 8) & 0xff;
636 field
[5] = (value
>> 16) & 0xff;
637 field
[4] = (value
>> 24) & 0xff;
642 field
[3] = value
& 0xff;
643 field
[2] = (value
>> 8) & 0xff;
647 field
[1] = value
& 0xff;
651 field
[0] = value
& 0xff;
655 error (_("Unhandled data length: %d\n"), size
);
660 /* Return a pointer to section NAME, or NULL if no such section exists. */
662 static Elf_Internal_Shdr
*
663 find_section (const char *name
)
667 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
668 if (streq (SECTION_NAME (section_headers
+ i
), name
))
669 return section_headers
+ i
;
674 /* Guess the relocation size commonly used by the specific machines. */
677 guess_is_rela (unsigned int e_machine
)
681 /* Targets that use REL relocations. */
697 /* Targets that use RELA relocations. */
701 case EM_ALTERA_NIOS2
:
728 case EM_CYGNUS_MN10200
:
730 case EM_CYGNUS_MN10300
:
771 warn (_("Don't know about relocations on this machine architecture\n"));
777 slurp_rela_relocs (FILE *file
,
778 unsigned long rel_offset
,
779 unsigned long rel_size
,
780 Elf_Internal_Rela
**relasp
,
781 unsigned long *nrelasp
)
783 Elf_Internal_Rela
*relas
;
784 unsigned long nrelas
;
789 Elf32_External_Rela
*erelas
;
791 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
795 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
797 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
802 error (_("out of memory parsing relocs\n"));
806 for (i
= 0; i
< nrelas
; i
++)
808 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
809 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
810 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
817 Elf64_External_Rela
*erelas
;
819 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
823 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
825 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
830 error (_("out of memory parsing relocs\n"));
834 for (i
= 0; i
< nrelas
; i
++)
836 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
837 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
838 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
849 slurp_rel_relocs (FILE *file
,
850 unsigned long rel_offset
,
851 unsigned long rel_size
,
852 Elf_Internal_Rela
**relsp
,
853 unsigned long *nrelsp
)
855 Elf_Internal_Rela
*rels
;
861 Elf32_External_Rel
*erels
;
863 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
867 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
869 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
874 error (_("out of memory parsing relocs\n"));
878 for (i
= 0; i
< nrels
; i
++)
880 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
881 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
882 rels
[i
].r_addend
= 0;
889 Elf64_External_Rel
*erels
;
891 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
895 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
897 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
902 error (_("out of memory parsing relocs\n"));
906 for (i
= 0; i
< nrels
; i
++)
908 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
909 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
910 rels
[i
].r_addend
= 0;
920 /* Returns the reloc type extracted from the reloc info field. */
923 get_reloc_type (bfd_vma reloc_info
)
926 return ELF32_R_TYPE (reloc_info
);
928 switch (elf_header
.e_machine
)
931 /* Note: We assume that reloc_info has already been adjusted for us. */
932 return ELF64_MIPS_R_TYPE (reloc_info
);
935 return ELF64_R_TYPE_ID (reloc_info
);
938 return ELF64_R_TYPE (reloc_info
);
942 /* Return the symbol index extracted from the reloc info field. */
945 get_reloc_symindex (bfd_vma reloc_info
)
947 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
950 /* Display the contents of the relocation data found at the specified
954 dump_relocations (FILE *file
,
955 unsigned long rel_offset
,
956 unsigned long rel_size
,
957 Elf_Internal_Sym
*symtab
,
960 unsigned long strtablen
,
964 Elf_Internal_Rela
*rels
;
967 if (is_rela
== UNKNOWN
)
968 is_rela
= guess_is_rela (elf_header
.e_machine
);
972 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
977 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
986 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
988 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
993 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
995 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1003 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1005 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1010 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1012 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1016 for (i
= 0; i
< rel_size
; i
++)
1021 bfd_vma symtab_index
;
1024 offset
= rels
[i
].r_offset
;
1025 info
= rels
[i
].r_info
;
1027 /* The #ifdef BFD64 below is to prevent a compile time warning.
1028 We know that if we do not have a 64 bit data type that we
1029 will never execute this code anyway. */
1032 && elf_header
.e_machine
== EM_MIPS
1033 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1035 /* In little-endian objects, r_info isn't really a 64-bit
1036 little-endian value: it has a 32-bit little-endian
1037 symbol index followed by four individual byte fields.
1038 Reorder INFO accordingly. */
1039 info
= (((info
& 0xffffffff) << 32)
1040 | ((info
>> 56) & 0xff)
1041 | ((info
>> 40) & 0xff00)
1042 | ((info
>> 24) & 0xff0000)
1043 | ((info
>> 8) & 0xff000000));
1047 type
= get_reloc_type (info
);
1048 symtab_index
= get_reloc_symindex (info
);
1052 printf ("%8.8lx %8.8lx ",
1053 (unsigned long) offset
& 0xffffffff,
1054 (unsigned long) info
& 0xffffffff);
1058 #if BFD_HOST_64BIT_LONG
1060 ? "%16.16lx %16.16lx "
1061 : "%12.12lx %12.12lx ",
1063 #elif BFD_HOST_64BIT_LONG_LONG
1066 ? "%16.16llx %16.16llx "
1067 : "%12.12llx %12.12llx ",
1071 ? "%16.16I64x %16.16I64x "
1072 : "%12.12I64x %12.12I64x ",
1077 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1078 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1079 _bfd_int64_high (offset
),
1080 _bfd_int64_low (offset
),
1081 _bfd_int64_high (info
),
1082 _bfd_int64_low (info
));
1086 switch (elf_header
.e_machine
)
1093 case EM_CYGNUS_M32R
:
1094 rtype
= elf_m32r_reloc_type (type
);
1099 rtype
= elf_i386_reloc_type (type
);
1104 rtype
= elf_m68hc11_reloc_type (type
);
1108 rtype
= elf_m68k_reloc_type (type
);
1112 rtype
= elf_i960_reloc_type (type
);
1117 rtype
= elf_avr_reloc_type (type
);
1120 case EM_OLD_SPARCV9
:
1121 case EM_SPARC32PLUS
:
1124 rtype
= elf_sparc_reloc_type (type
);
1128 rtype
= elf_spu_reloc_type (type
);
1132 case EM_CYGNUS_V850
:
1133 rtype
= v850_reloc_type (type
);
1137 case EM_CYGNUS_D10V
:
1138 rtype
= elf_d10v_reloc_type (type
);
1142 case EM_CYGNUS_D30V
:
1143 rtype
= elf_d30v_reloc_type (type
);
1147 rtype
= elf_dlx_reloc_type (type
);
1151 rtype
= elf_sh_reloc_type (type
);
1155 case EM_CYGNUS_MN10300
:
1156 rtype
= elf_mn10300_reloc_type (type
);
1160 case EM_CYGNUS_MN10200
:
1161 rtype
= elf_mn10200_reloc_type (type
);
1165 case EM_CYGNUS_FR30
:
1166 rtype
= elf_fr30_reloc_type (type
);
1170 rtype
= elf_frv_reloc_type (type
);
1174 rtype
= elf_mcore_reloc_type (type
);
1178 rtype
= elf_mmix_reloc_type (type
);
1183 rtype
= elf_msp430_reloc_type (type
);
1187 rtype
= elf_ppc_reloc_type (type
);
1191 rtype
= elf_ppc64_reloc_type (type
);
1195 case EM_MIPS_RS3_LE
:
1196 rtype
= elf_mips_reloc_type (type
);
1200 rtype
= elf_alpha_reloc_type (type
);
1204 rtype
= elf_arm_reloc_type (type
);
1208 rtype
= elf_arc_reloc_type (type
);
1212 rtype
= elf_hppa_reloc_type (type
);
1218 rtype
= elf_h8_reloc_type (type
);
1223 rtype
= elf_or32_reloc_type (type
);
1228 rtype
= elf_pj_reloc_type (type
);
1231 rtype
= elf_ia64_reloc_type (type
);
1235 rtype
= elf_cris_reloc_type (type
);
1239 rtype
= elf_i860_reloc_type (type
);
1243 rtype
= elf_x86_64_reloc_type (type
);
1247 rtype
= i370_reloc_type (type
);
1252 rtype
= elf_s390_reloc_type (type
);
1256 rtype
= elf_score_reloc_type (type
);
1260 rtype
= elf_xstormy16_reloc_type (type
);
1264 rtype
= elf_crx_reloc_type (type
);
1268 rtype
= elf_vax_reloc_type (type
);
1273 rtype
= elf_ip2k_reloc_type (type
);
1277 rtype
= elf_iq2000_reloc_type (type
);
1282 rtype
= elf_xtensa_reloc_type (type
);
1287 rtype
= elf_m32c_reloc_type (type
);
1291 rtype
= elf_mt_reloc_type (type
);
1295 rtype
= elf_bfin_reloc_type (type
);
1299 rtype
= elf_mep_reloc_type (type
);
1304 rtype
= elf_cr16_reloc_type (type
);
1309 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1311 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1313 if (elf_header
.e_machine
== EM_ALPHA
1315 && streq (rtype
, "R_ALPHA_LITUSE")
1318 switch (rels
[i
].r_addend
)
1320 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1321 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1322 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1323 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1324 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1325 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1326 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1327 default: rtype
= NULL
;
1330 printf (" (%s)", rtype
);
1334 printf (_("<unknown addend: %lx>"),
1335 (unsigned long) rels
[i
].r_addend
);
1338 else if (symtab_index
)
1340 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1341 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1344 Elf_Internal_Sym
*psym
;
1346 psym
= symtab
+ symtab_index
;
1349 print_vma (psym
->st_value
, LONG_HEX
);
1350 printf (is_32bit_elf
? " " : " ");
1352 if (psym
->st_name
== 0)
1354 const char *sec_name
= "<null>";
1357 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1359 if (psym
->st_shndx
< elf_header
.e_shnum
)
1361 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1362 else if (psym
->st_shndx
== SHN_ABS
)
1364 else if (psym
->st_shndx
== SHN_COMMON
)
1365 sec_name
= "COMMON";
1366 else if (elf_header
.e_machine
== EM_MIPS
1367 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1368 sec_name
= "SCOMMON";
1369 else if (elf_header
.e_machine
== EM_MIPS
1370 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1371 sec_name
= "SUNDEF";
1372 else if (elf_header
.e_machine
== EM_X86_64
1373 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1374 sec_name
= "LARGE_COMMON";
1375 else if (elf_header
.e_machine
== EM_IA_64
1376 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1377 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1378 sec_name
= "ANSI_COM";
1379 else if (elf_header
.e_machine
== EM_IA_64
1380 && (elf_header
.e_ident
[EI_OSABI
]
1381 == ELFOSABI_OPENVMS
)
1382 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1383 sec_name
= "VMS_SYMVEC";
1386 sprintf (name_buf
, "<section 0x%x>",
1387 (unsigned int) psym
->st_shndx
);
1388 sec_name
= name_buf
;
1391 print_symbol (22, sec_name
);
1393 else if (strtab
== NULL
)
1394 printf (_("<string table index: %3ld>"), psym
->st_name
);
1395 else if (psym
->st_name
>= strtablen
)
1396 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1398 print_symbol (22, strtab
+ psym
->st_name
);
1401 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1406 printf ("%*c", is_32bit_elf
?
1407 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1408 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1411 if (elf_header
.e_machine
== EM_SPARCV9
1413 && streq (rtype
, "R_SPARC_OLO10"))
1414 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1419 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1421 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1422 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1423 const char *rtype2
= elf_mips_reloc_type (type2
);
1424 const char *rtype3
= elf_mips_reloc_type (type3
);
1426 printf (" Type2: ");
1429 printf (_("unrecognized: %-7lx"),
1430 (unsigned long) type2
& 0xffffffff);
1432 printf ("%-17.17s", rtype2
);
1434 printf ("\n Type3: ");
1437 printf (_("unrecognized: %-7lx"),
1438 (unsigned long) type3
& 0xffffffff);
1440 printf ("%-17.17s", rtype3
);
1451 get_mips_dynamic_type (unsigned long type
)
1455 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1456 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1457 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1458 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1459 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1460 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1461 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1462 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1463 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1464 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1465 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1466 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1467 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1468 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1469 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1470 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1471 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1472 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1473 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1474 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1475 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1476 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1477 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1478 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1479 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1480 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1481 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1482 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1483 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1484 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1485 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1486 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1487 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1488 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1489 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1490 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1491 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1492 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1493 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1494 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1495 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1496 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1497 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1504 get_sparc64_dynamic_type (unsigned long type
)
1508 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1515 get_ppc_dynamic_type (unsigned long type
)
1519 case DT_PPC_GOT
: return "PPC_GOT";
1526 get_ppc64_dynamic_type (unsigned long type
)
1530 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1531 case DT_PPC64_OPD
: return "PPC64_OPD";
1532 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1539 get_parisc_dynamic_type (unsigned long type
)
1543 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1544 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1545 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1546 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1547 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1548 case DT_HP_PREINIT
: return "HP_PREINIT";
1549 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1550 case DT_HP_NEEDED
: return "HP_NEEDED";
1551 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1552 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1553 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1554 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1555 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1556 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1557 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1558 case DT_HP_FILTERED
: return "HP_FILTERED";
1559 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1560 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1561 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1562 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1563 case DT_PLT
: return "PLT";
1564 case DT_PLT_SIZE
: return "PLT_SIZE";
1565 case DT_DLT
: return "DLT";
1566 case DT_DLT_SIZE
: return "DLT_SIZE";
1573 get_ia64_dynamic_type (unsigned long type
)
1577 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1578 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1579 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1580 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1581 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1582 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1583 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1584 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1585 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1586 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1587 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1588 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1589 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1590 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1591 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1592 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1593 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1594 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1595 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1596 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1597 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1598 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1599 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1600 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1601 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1602 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1603 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1604 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1605 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1606 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1607 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1614 get_alpha_dynamic_type (unsigned long type
)
1618 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1625 get_score_dynamic_type (unsigned long type
)
1629 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1630 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1631 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1632 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1633 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1634 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1642 get_dynamic_type (unsigned long type
)
1644 static char buff
[64];
1648 case DT_NULL
: return "NULL";
1649 case DT_NEEDED
: return "NEEDED";
1650 case DT_PLTRELSZ
: return "PLTRELSZ";
1651 case DT_PLTGOT
: return "PLTGOT";
1652 case DT_HASH
: return "HASH";
1653 case DT_STRTAB
: return "STRTAB";
1654 case DT_SYMTAB
: return "SYMTAB";
1655 case DT_RELA
: return "RELA";
1656 case DT_RELASZ
: return "RELASZ";
1657 case DT_RELAENT
: return "RELAENT";
1658 case DT_STRSZ
: return "STRSZ";
1659 case DT_SYMENT
: return "SYMENT";
1660 case DT_INIT
: return "INIT";
1661 case DT_FINI
: return "FINI";
1662 case DT_SONAME
: return "SONAME";
1663 case DT_RPATH
: return "RPATH";
1664 case DT_SYMBOLIC
: return "SYMBOLIC";
1665 case DT_REL
: return "REL";
1666 case DT_RELSZ
: return "RELSZ";
1667 case DT_RELENT
: return "RELENT";
1668 case DT_PLTREL
: return "PLTREL";
1669 case DT_DEBUG
: return "DEBUG";
1670 case DT_TEXTREL
: return "TEXTREL";
1671 case DT_JMPREL
: return "JMPREL";
1672 case DT_BIND_NOW
: return "BIND_NOW";
1673 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1674 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1675 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1676 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1677 case DT_RUNPATH
: return "RUNPATH";
1678 case DT_FLAGS
: return "FLAGS";
1680 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1681 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1683 case DT_CHECKSUM
: return "CHECKSUM";
1684 case DT_PLTPADSZ
: return "PLTPADSZ";
1685 case DT_MOVEENT
: return "MOVEENT";
1686 case DT_MOVESZ
: return "MOVESZ";
1687 case DT_FEATURE
: return "FEATURE";
1688 case DT_POSFLAG_1
: return "POSFLAG_1";
1689 case DT_SYMINSZ
: return "SYMINSZ";
1690 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1692 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1693 case DT_CONFIG
: return "CONFIG";
1694 case DT_DEPAUDIT
: return "DEPAUDIT";
1695 case DT_AUDIT
: return "AUDIT";
1696 case DT_PLTPAD
: return "PLTPAD";
1697 case DT_MOVETAB
: return "MOVETAB";
1698 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1700 case DT_VERSYM
: return "VERSYM";
1702 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1703 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1704 case DT_RELACOUNT
: return "RELACOUNT";
1705 case DT_RELCOUNT
: return "RELCOUNT";
1706 case DT_FLAGS_1
: return "FLAGS_1";
1707 case DT_VERDEF
: return "VERDEF";
1708 case DT_VERDEFNUM
: return "VERDEFNUM";
1709 case DT_VERNEED
: return "VERNEED";
1710 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1712 case DT_AUXILIARY
: return "AUXILIARY";
1713 case DT_USED
: return "USED";
1714 case DT_FILTER
: return "FILTER";
1716 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1717 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1718 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1719 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1720 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1721 case DT_GNU_HASH
: return "GNU_HASH";
1724 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1728 switch (elf_header
.e_machine
)
1731 case EM_MIPS_RS3_LE
:
1732 result
= get_mips_dynamic_type (type
);
1735 result
= get_sparc64_dynamic_type (type
);
1738 result
= get_ppc_dynamic_type (type
);
1741 result
= get_ppc64_dynamic_type (type
);
1744 result
= get_ia64_dynamic_type (type
);
1747 result
= get_alpha_dynamic_type (type
);
1750 result
= get_score_dynamic_type (type
);
1760 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1762 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1763 || (elf_header
.e_machine
== EM_PARISC
1764 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1768 switch (elf_header
.e_machine
)
1771 result
= get_parisc_dynamic_type (type
);
1774 result
= get_ia64_dynamic_type (type
);
1784 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1788 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1795 get_file_type (unsigned e_type
)
1797 static char buff
[32];
1801 case ET_NONE
: return _("NONE (None)");
1802 case ET_REL
: return _("REL (Relocatable file)");
1803 case ET_EXEC
: return _("EXEC (Executable file)");
1804 case ET_DYN
: return _("DYN (Shared object file)");
1805 case ET_CORE
: return _("CORE (Core file)");
1808 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1809 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1810 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1811 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1813 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1819 get_machine_name (unsigned e_machine
)
1821 static char buff
[64]; /* XXX */
1825 case EM_NONE
: return _("None");
1826 case EM_M32
: return "WE32100";
1827 case EM_SPARC
: return "Sparc";
1828 case EM_SPU
: return "SPU";
1829 case EM_386
: return "Intel 80386";
1830 case EM_68K
: return "MC68000";
1831 case EM_88K
: return "MC88000";
1832 case EM_486
: return "Intel 80486";
1833 case EM_860
: return "Intel 80860";
1834 case EM_MIPS
: return "MIPS R3000";
1835 case EM_S370
: return "IBM System/370";
1836 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1837 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1838 case EM_PARISC
: return "HPPA";
1839 case EM_PPC_OLD
: return "Power PC (old)";
1840 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1841 case EM_960
: return "Intel 90860";
1842 case EM_PPC
: return "PowerPC";
1843 case EM_PPC64
: return "PowerPC64";
1844 case EM_V800
: return "NEC V800";
1845 case EM_FR20
: return "Fujitsu FR20";
1846 case EM_RH32
: return "TRW RH32";
1847 case EM_MCORE
: return "MCORE";
1848 case EM_ARM
: return "ARM";
1849 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1850 case EM_SH
: return "Renesas / SuperH SH";
1851 case EM_SPARCV9
: return "Sparc v9";
1852 case EM_TRICORE
: return "Siemens Tricore";
1853 case EM_ARC
: return "ARC";
1854 case EM_H8_300
: return "Renesas H8/300";
1855 case EM_H8_300H
: return "Renesas H8/300H";
1856 case EM_H8S
: return "Renesas H8S";
1857 case EM_H8_500
: return "Renesas H8/500";
1858 case EM_IA_64
: return "Intel IA-64";
1859 case EM_MIPS_X
: return "Stanford MIPS-X";
1860 case EM_COLDFIRE
: return "Motorola Coldfire";
1861 case EM_68HC12
: return "Motorola M68HC12";
1862 case EM_ALPHA
: return "Alpha";
1863 case EM_CYGNUS_D10V
:
1864 case EM_D10V
: return "d10v";
1865 case EM_CYGNUS_D30V
:
1866 case EM_D30V
: return "d30v";
1867 case EM_CYGNUS_M32R
:
1868 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1869 case EM_CYGNUS_V850
:
1870 case EM_V850
: return "NEC v850";
1871 case EM_CYGNUS_MN10300
:
1872 case EM_MN10300
: return "mn10300";
1873 case EM_CYGNUS_MN10200
:
1874 case EM_MN10200
: return "mn10200";
1875 case EM_CYGNUS_FR30
:
1876 case EM_FR30
: return "Fujitsu FR30";
1877 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1879 case EM_PJ
: return "picoJava";
1880 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1881 case EM_PCP
: return "Siemens PCP";
1882 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1883 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1884 case EM_STARCORE
: return "Motorola Star*Core processor";
1885 case EM_ME16
: return "Toyota ME16 processor";
1886 case EM_ST100
: return "STMicroelectronics ST100 processor";
1887 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1888 case EM_FX66
: return "Siemens FX66 microcontroller";
1889 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1890 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1891 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1892 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1893 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1894 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1895 case EM_SVX
: return "Silicon Graphics SVx";
1896 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1897 case EM_VAX
: return "Digital VAX";
1899 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1900 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1901 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1902 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1903 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1904 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1905 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1906 case EM_PRISM
: return "Vitesse Prism";
1907 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1909 case EM_S390
: return "IBM S/390";
1910 case EM_SCORE
: return "SUNPLUS S+Core";
1911 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1913 case EM_OR32
: return "OpenRISC";
1914 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1915 case EM_DLX
: return "OpenDLX";
1917 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1918 case EM_IQ2000
: return "Vitesse IQ2000";
1920 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1922 case EM_M32C
: return "Renesas M32c";
1923 case EM_MT
: return "Morpho Techologies MT processor";
1924 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1925 case EM_NIOS32
: return "Altera Nios";
1926 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1927 case EM_XC16X
: return "Infineon Technologies xc16x";
1928 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1930 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1932 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1938 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1943 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1944 e_flags
&= ~ EF_ARM_EABIMASK
;
1946 /* Handle "generic" ARM flags. */
1947 if (e_flags
& EF_ARM_RELEXEC
)
1949 strcat (buf
, ", relocatable executable");
1950 e_flags
&= ~ EF_ARM_RELEXEC
;
1953 if (e_flags
& EF_ARM_HASENTRY
)
1955 strcat (buf
, ", has entry point");
1956 e_flags
&= ~ EF_ARM_HASENTRY
;
1959 /* Now handle EABI specific flags. */
1963 strcat (buf
, ", <unrecognized EABI>");
1968 case EF_ARM_EABI_VER1
:
1969 strcat (buf
, ", Version1 EABI");
1974 /* Process flags one bit at a time. */
1975 flag
= e_flags
& - e_flags
;
1980 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1981 strcat (buf
, ", sorted symbol tables");
1991 case EF_ARM_EABI_VER2
:
1992 strcat (buf
, ", Version2 EABI");
1997 /* Process flags one bit at a time. */
1998 flag
= e_flags
& - e_flags
;
2003 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2004 strcat (buf
, ", sorted symbol tables");
2007 case EF_ARM_DYNSYMSUSESEGIDX
:
2008 strcat (buf
, ", dynamic symbols use segment index");
2011 case EF_ARM_MAPSYMSFIRST
:
2012 strcat (buf
, ", mapping symbols precede others");
2022 case EF_ARM_EABI_VER3
:
2023 strcat (buf
, ", Version3 EABI");
2026 case EF_ARM_EABI_VER4
:
2027 strcat (buf
, ", Version4 EABI");
2030 case EF_ARM_EABI_VER5
:
2031 strcat (buf
, ", Version5 EABI");
2037 /* Process flags one bit at a time. */
2038 flag
= e_flags
& - e_flags
;
2044 strcat (buf
, ", BE8");
2048 strcat (buf
, ", LE8");
2058 case EF_ARM_EABI_UNKNOWN
:
2059 strcat (buf
, ", GNU EABI");
2064 /* Process flags one bit at a time. */
2065 flag
= e_flags
& - e_flags
;
2070 case EF_ARM_INTERWORK
:
2071 strcat (buf
, ", interworking enabled");
2074 case EF_ARM_APCS_26
:
2075 strcat (buf
, ", uses APCS/26");
2078 case EF_ARM_APCS_FLOAT
:
2079 strcat (buf
, ", uses APCS/float");
2083 strcat (buf
, ", position independent");
2087 strcat (buf
, ", 8 bit structure alignment");
2090 case EF_ARM_NEW_ABI
:
2091 strcat (buf
, ", uses new ABI");
2094 case EF_ARM_OLD_ABI
:
2095 strcat (buf
, ", uses old ABI");
2098 case EF_ARM_SOFT_FLOAT
:
2099 strcat (buf
, ", software FP");
2102 case EF_ARM_VFP_FLOAT
:
2103 strcat (buf
, ", VFP");
2106 case EF_ARM_MAVERICK_FLOAT
:
2107 strcat (buf
, ", Maverick FP");
2118 strcat (buf
,", <unknown>");
2122 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2124 static char buf
[1024];
2136 decode_ARM_machine_flags (e_flags
, buf
);
2140 switch (e_flags
& EF_FRV_CPU_MASK
)
2142 case EF_FRV_CPU_GENERIC
:
2146 strcat (buf
, ", fr???");
2149 case EF_FRV_CPU_FR300
:
2150 strcat (buf
, ", fr300");
2153 case EF_FRV_CPU_FR400
:
2154 strcat (buf
, ", fr400");
2156 case EF_FRV_CPU_FR405
:
2157 strcat (buf
, ", fr405");
2160 case EF_FRV_CPU_FR450
:
2161 strcat (buf
, ", fr450");
2164 case EF_FRV_CPU_FR500
:
2165 strcat (buf
, ", fr500");
2167 case EF_FRV_CPU_FR550
:
2168 strcat (buf
, ", fr550");
2171 case EF_FRV_CPU_SIMPLE
:
2172 strcat (buf
, ", simple");
2174 case EF_FRV_CPU_TOMCAT
:
2175 strcat (buf
, ", tomcat");
2181 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2182 strcat (buf
, ", m68000");
2183 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2184 strcat (buf
, ", cpu32");
2185 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2186 strcat (buf
, ", fido_a");
2189 char const *isa
= _("unknown");
2190 char const *mac
= _("unknown mac");
2191 char const *additional
= NULL
;
2193 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2195 case EF_M68K_CF_ISA_A_NODIV
:
2197 additional
= ", nodiv";
2199 case EF_M68K_CF_ISA_A
:
2202 case EF_M68K_CF_ISA_A_PLUS
:
2205 case EF_M68K_CF_ISA_B_NOUSP
:
2207 additional
= ", nousp";
2209 case EF_M68K_CF_ISA_B
:
2213 strcat (buf
, ", cf, isa ");
2216 strcat (buf
, additional
);
2217 if (e_flags
& EF_M68K_CF_FLOAT
)
2218 strcat (buf
, ", float");
2219 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2224 case EF_M68K_CF_MAC
:
2227 case EF_M68K_CF_EMAC
:
2240 if (e_flags
& EF_PPC_EMB
)
2241 strcat (buf
, ", emb");
2243 if (e_flags
& EF_PPC_RELOCATABLE
)
2244 strcat (buf
, ", relocatable");
2246 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2247 strcat (buf
, ", relocatable-lib");
2251 case EM_CYGNUS_V850
:
2252 switch (e_flags
& EF_V850_ARCH
)
2255 strcat (buf
, ", v850e1");
2258 strcat (buf
, ", v850e");
2261 strcat (buf
, ", v850");
2264 strcat (buf
, ", unknown v850 architecture variant");
2270 case EM_CYGNUS_M32R
:
2271 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2272 strcat (buf
, ", m32r");
2276 case EM_MIPS_RS3_LE
:
2277 if (e_flags
& EF_MIPS_NOREORDER
)
2278 strcat (buf
, ", noreorder");
2280 if (e_flags
& EF_MIPS_PIC
)
2281 strcat (buf
, ", pic");
2283 if (e_flags
& EF_MIPS_CPIC
)
2284 strcat (buf
, ", cpic");
2286 if (e_flags
& EF_MIPS_UCODE
)
2287 strcat (buf
, ", ugen_reserved");
2289 if (e_flags
& EF_MIPS_ABI2
)
2290 strcat (buf
, ", abi2");
2292 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2293 strcat (buf
, ", odk first");
2295 if (e_flags
& EF_MIPS_32BITMODE
)
2296 strcat (buf
, ", 32bitmode");
2298 switch ((e_flags
& EF_MIPS_MACH
))
2300 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2301 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2302 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2303 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2304 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2305 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2306 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2307 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2308 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2309 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2310 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2311 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2312 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2314 /* We simply ignore the field in this case to avoid confusion:
2315 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2318 default: strcat (buf
, ", unknown CPU"); break;
2321 switch ((e_flags
& EF_MIPS_ABI
))
2323 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2324 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2325 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2326 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2328 /* We simply ignore the field in this case to avoid confusion:
2329 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2330 This means it is likely to be an o32 file, but not for
2333 default: strcat (buf
, ", unknown ABI"); break;
2336 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2337 strcat (buf
, ", mdmx");
2339 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2340 strcat (buf
, ", mips16");
2342 switch ((e_flags
& EF_MIPS_ARCH
))
2344 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2345 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2346 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2347 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2348 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2349 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2350 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2351 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2352 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2353 default: strcat (buf
, ", unknown ISA"); break;
2359 switch ((e_flags
& EF_SH_MACH_MASK
))
2361 case EF_SH1
: strcat (buf
, ", sh1"); break;
2362 case EF_SH2
: strcat (buf
, ", sh2"); break;
2363 case EF_SH3
: strcat (buf
, ", sh3"); break;
2364 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2365 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2366 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2367 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2368 case EF_SH4
: strcat (buf
, ", sh4"); break;
2369 case EF_SH5
: strcat (buf
, ", sh5"); break;
2370 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2371 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2372 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2373 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2374 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2375 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2376 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2377 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2378 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2379 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2380 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2381 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2382 default: strcat (buf
, ", unknown ISA"); break;
2388 if (e_flags
& EF_SPARC_32PLUS
)
2389 strcat (buf
, ", v8+");
2391 if (e_flags
& EF_SPARC_SUN_US1
)
2392 strcat (buf
, ", ultrasparcI");
2394 if (e_flags
& EF_SPARC_SUN_US3
)
2395 strcat (buf
, ", ultrasparcIII");
2397 if (e_flags
& EF_SPARC_HAL_R1
)
2398 strcat (buf
, ", halr1");
2400 if (e_flags
& EF_SPARC_LEDATA
)
2401 strcat (buf
, ", ledata");
2403 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2404 strcat (buf
, ", tso");
2406 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2407 strcat (buf
, ", pso");
2409 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2410 strcat (buf
, ", rmo");
2414 switch (e_flags
& EF_PARISC_ARCH
)
2416 case EFA_PARISC_1_0
:
2417 strcpy (buf
, ", PA-RISC 1.0");
2419 case EFA_PARISC_1_1
:
2420 strcpy (buf
, ", PA-RISC 1.1");
2422 case EFA_PARISC_2_0
:
2423 strcpy (buf
, ", PA-RISC 2.0");
2428 if (e_flags
& EF_PARISC_TRAPNIL
)
2429 strcat (buf
, ", trapnil");
2430 if (e_flags
& EF_PARISC_EXT
)
2431 strcat (buf
, ", ext");
2432 if (e_flags
& EF_PARISC_LSB
)
2433 strcat (buf
, ", lsb");
2434 if (e_flags
& EF_PARISC_WIDE
)
2435 strcat (buf
, ", wide");
2436 if (e_flags
& EF_PARISC_NO_KABP
)
2437 strcat (buf
, ", no kabp");
2438 if (e_flags
& EF_PARISC_LAZYSWAP
)
2439 strcat (buf
, ", lazyswap");
2444 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2445 strcat (buf
, ", new calling convention");
2447 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2448 strcat (buf
, ", gnu calling convention");
2452 if ((e_flags
& EF_IA_64_ABI64
))
2453 strcat (buf
, ", 64-bit");
2455 strcat (buf
, ", 32-bit");
2456 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2457 strcat (buf
, ", reduced fp model");
2458 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2459 strcat (buf
, ", no function descriptors, constant gp");
2460 else if ((e_flags
& EF_IA_64_CONS_GP
))
2461 strcat (buf
, ", constant gp");
2462 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2463 strcat (buf
, ", absolute");
2467 if ((e_flags
& EF_VAX_NONPIC
))
2468 strcat (buf
, ", non-PIC");
2469 if ((e_flags
& EF_VAX_DFLOAT
))
2470 strcat (buf
, ", D-Float");
2471 if ((e_flags
& EF_VAX_GFLOAT
))
2472 strcat (buf
, ", G-Float");
2481 get_osabi_name (unsigned int osabi
)
2483 static char buff
[32];
2487 case ELFOSABI_NONE
: return "UNIX - System V";
2488 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2489 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2490 case ELFOSABI_LINUX
: return "UNIX - Linux";
2491 case ELFOSABI_HURD
: return "GNU/Hurd";
2492 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2493 case ELFOSABI_AIX
: return "UNIX - AIX";
2494 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2495 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2496 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2497 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2498 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2499 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2500 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2501 case ELFOSABI_AROS
: return "Amiga Research OS";
2502 case ELFOSABI_STANDALONE
: return _("Standalone App");
2503 case ELFOSABI_ARM
: return "ARM";
2505 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2511 get_arm_segment_type (unsigned long type
)
2525 get_mips_segment_type (unsigned long type
)
2529 case PT_MIPS_REGINFO
:
2531 case PT_MIPS_RTPROC
:
2533 case PT_MIPS_OPTIONS
:
2543 get_parisc_segment_type (unsigned long type
)
2547 case PT_HP_TLS
: return "HP_TLS";
2548 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2549 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2550 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2551 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2552 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2553 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2554 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2555 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2556 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2557 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2558 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2559 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2560 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2561 case PT_HP_STACK
: return "HP_STACK";
2562 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2563 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2564 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2565 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2574 get_ia64_segment_type (unsigned long type
)
2578 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2579 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2580 case PT_HP_TLS
: return "HP_TLS";
2581 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2582 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2583 case PT_IA_64_HP_STACK
: return "HP_STACK";
2592 get_segment_type (unsigned long p_type
)
2594 static char buff
[32];
2598 case PT_NULL
: return "NULL";
2599 case PT_LOAD
: return "LOAD";
2600 case PT_DYNAMIC
: return "DYNAMIC";
2601 case PT_INTERP
: return "INTERP";
2602 case PT_NOTE
: return "NOTE";
2603 case PT_SHLIB
: return "SHLIB";
2604 case PT_PHDR
: return "PHDR";
2605 case PT_TLS
: return "TLS";
2607 case PT_GNU_EH_FRAME
:
2608 return "GNU_EH_FRAME";
2609 case PT_GNU_STACK
: return "GNU_STACK";
2610 case PT_GNU_RELRO
: return "GNU_RELRO";
2613 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2617 switch (elf_header
.e_machine
)
2620 result
= get_arm_segment_type (p_type
);
2623 case EM_MIPS_RS3_LE
:
2624 result
= get_mips_segment_type (p_type
);
2627 result
= get_parisc_segment_type (p_type
);
2630 result
= get_ia64_segment_type (p_type
);
2640 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2642 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2646 switch (elf_header
.e_machine
)
2649 result
= get_parisc_segment_type (p_type
);
2652 result
= get_ia64_segment_type (p_type
);
2662 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2665 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2672 get_mips_section_type_name (unsigned int sh_type
)
2676 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2677 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2678 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2679 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2680 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2681 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2682 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2683 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2684 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2685 case SHT_MIPS_RELD
: return "MIPS_RELD";
2686 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2687 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2688 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2689 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2690 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2691 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2692 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2693 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2694 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2695 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2696 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2697 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2698 case SHT_MIPS_LINE
: return "MIPS_LINE";
2699 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2700 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2701 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2702 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2703 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2704 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2705 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2706 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2707 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2708 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2709 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2710 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2711 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2712 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2713 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2714 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2722 get_parisc_section_type_name (unsigned int sh_type
)
2726 case SHT_PARISC_EXT
: return "PARISC_EXT";
2727 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2728 case SHT_PARISC_DOC
: return "PARISC_DOC";
2729 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2730 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2731 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2732 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2740 get_ia64_section_type_name (unsigned int sh_type
)
2742 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2743 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2744 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2748 case SHT_IA_64_EXT
: return "IA_64_EXT";
2749 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2750 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2751 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2752 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2753 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2754 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2755 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2756 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2757 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2765 get_x86_64_section_type_name (unsigned int sh_type
)
2769 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2777 get_arm_section_type_name (unsigned int sh_type
)
2783 case SHT_ARM_PREEMPTMAP
:
2784 return "ARM_PREEMPTMAP";
2785 case SHT_ARM_ATTRIBUTES
:
2786 return "ARM_ATTRIBUTES";
2794 get_section_type_name (unsigned int sh_type
)
2796 static char buff
[32];
2800 case SHT_NULL
: return "NULL";
2801 case SHT_PROGBITS
: return "PROGBITS";
2802 case SHT_SYMTAB
: return "SYMTAB";
2803 case SHT_STRTAB
: return "STRTAB";
2804 case SHT_RELA
: return "RELA";
2805 case SHT_HASH
: return "HASH";
2806 case SHT_DYNAMIC
: return "DYNAMIC";
2807 case SHT_NOTE
: return "NOTE";
2808 case SHT_NOBITS
: return "NOBITS";
2809 case SHT_REL
: return "REL";
2810 case SHT_SHLIB
: return "SHLIB";
2811 case SHT_DYNSYM
: return "DYNSYM";
2812 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2813 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2814 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2815 case SHT_GNU_HASH
: return "GNU_HASH";
2816 case SHT_GROUP
: return "GROUP";
2817 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2818 case SHT_GNU_verdef
: return "VERDEF";
2819 case SHT_GNU_verneed
: return "VERNEED";
2820 case SHT_GNU_versym
: return "VERSYM";
2821 case 0x6ffffff0: return "VERSYM";
2822 case 0x6ffffffc: return "VERDEF";
2823 case 0x7ffffffd: return "AUXILIARY";
2824 case 0x7fffffff: return "FILTER";
2825 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2828 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2832 switch (elf_header
.e_machine
)
2835 case EM_MIPS_RS3_LE
:
2836 result
= get_mips_section_type_name (sh_type
);
2839 result
= get_parisc_section_type_name (sh_type
);
2842 result
= get_ia64_section_type_name (sh_type
);
2845 result
= get_x86_64_section_type_name (sh_type
);
2848 result
= get_arm_section_type_name (sh_type
);
2858 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2860 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2864 switch (elf_header
.e_machine
)
2867 result
= get_ia64_section_type_name (sh_type
);
2877 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2879 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2880 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2882 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2888 #define OPTION_DEBUG_DUMP 512
2890 static struct option options
[] =
2892 {"all", no_argument
, 0, 'a'},
2893 {"file-header", no_argument
, 0, 'h'},
2894 {"program-headers", no_argument
, 0, 'l'},
2895 {"headers", no_argument
, 0, 'e'},
2896 {"histogram", no_argument
, 0, 'I'},
2897 {"segments", no_argument
, 0, 'l'},
2898 {"sections", no_argument
, 0, 'S'},
2899 {"section-headers", no_argument
, 0, 'S'},
2900 {"section-groups", no_argument
, 0, 'g'},
2901 {"section-details", no_argument
, 0, 't'},
2902 {"full-section-name",no_argument
, 0, 'N'},
2903 {"symbols", no_argument
, 0, 's'},
2904 {"syms", no_argument
, 0, 's'},
2905 {"relocs", no_argument
, 0, 'r'},
2906 {"notes", no_argument
, 0, 'n'},
2907 {"dynamic", no_argument
, 0, 'd'},
2908 {"arch-specific", no_argument
, 0, 'A'},
2909 {"version-info", no_argument
, 0, 'V'},
2910 {"use-dynamic", no_argument
, 0, 'D'},
2911 {"unwind", no_argument
, 0, 'u'},
2912 {"archive-index", no_argument
, 0, 'c'},
2913 {"hex-dump", required_argument
, 0, 'x'},
2914 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2915 {"string-dump", required_argument
, 0, 'p'},
2916 #ifdef SUPPORT_DISASSEMBLY
2917 {"instruction-dump", required_argument
, 0, 'i'},
2920 {"version", no_argument
, 0, 'v'},
2921 {"wide", no_argument
, 0, 'W'},
2922 {"help", no_argument
, 0, 'H'},
2923 {0, no_argument
, 0, 0}
2927 usage (FILE *stream
)
2929 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2930 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2931 fprintf (stream
, _(" Options are:\n\
2932 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2933 -h --file-header Display the ELF file header\n\
2934 -l --program-headers Display the program headers\n\
2935 --segments An alias for --program-headers\n\
2936 -S --section-headers Display the sections' header\n\
2937 --sections An alias for --section-headers\n\
2938 -g --section-groups Display the section groups\n\
2939 -t --section-details Display the section details\n\
2940 -e --headers Equivalent to: -h -l -S\n\
2941 -s --syms Display the symbol table\n\
2942 --symbols An alias for --syms\n\
2943 -n --notes Display the core notes (if present)\n\
2944 -r --relocs Display the relocations (if present)\n\
2945 -u --unwind Display the unwind info (if present)\n\
2946 -d --dynamic Display the dynamic section (if present)\n\
2947 -V --version-info Display the version sections (if present)\n\
2948 -A --arch-specific Display architecture specific information (if any).\n\
2949 -c --archive-index Display the symbol/file index in an archive\n\
2950 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2951 -x --hex-dump=<number|name>\n\
2952 Dump the contents of section <number|name> as bytes\n\
2953 -p --string-dump=<number|name>\n\
2954 Dump the contents of section <number|name> as strings\n\
2955 -w[lLiaprmfFsoR] or\n\
2956 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2957 Display the contents of DWARF2 debug sections\n"));
2958 #ifdef SUPPORT_DISASSEMBLY
2959 fprintf (stream
, _("\
2960 -i --instruction-dump=<number|name>\n\
2961 Disassemble the contents of section <number|name>\n"));
2963 fprintf (stream
, _("\
2964 -I --histogram Display histogram of bucket list lengths\n\
2965 -W --wide Allow output width to exceed 80 characters\n\
2966 @<file> Read options from <file>\n\
2967 -H --help Display this information\n\
2968 -v --version Display the version number of readelf\n"));
2970 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2971 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2973 exit (stream
== stdout
? 0 : 1);
2976 /* Record the fact that the user wants the contents of section number
2977 SECTION to be displayed using the method(s) encoded as flags bits
2978 in TYPE. Note, TYPE can be zero if we are creating the array for
2982 request_dump_bynumber (unsigned int section
, dump_type type
)
2984 if (section
>= num_dump_sects
)
2986 dump_type
*new_dump_sects
;
2988 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2990 if (new_dump_sects
== NULL
)
2991 error (_("Out of memory allocating dump request table.\n"));
2994 /* Copy current flag settings. */
2995 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2999 dump_sects
= new_dump_sects
;
3000 num_dump_sects
= section
+ 1;
3005 dump_sects
[section
] |= type
;
3010 /* Request a dump by section name. */
3013 request_dump_byname (const char *section
, dump_type type
)
3015 struct dump_list_entry
*new_request
;
3017 new_request
= malloc (sizeof (struct dump_list_entry
));
3019 error (_("Out of memory allocating dump request table.\n"));
3021 new_request
->name
= strdup (section
);
3022 if (!new_request
->name
)
3023 error (_("Out of memory allocating dump request table.\n"));
3025 new_request
->type
= type
;
3027 new_request
->next
= dump_sects_byname
;
3028 dump_sects_byname
= new_request
;
3032 parse_args (int argc
, char **argv
)
3039 while ((c
= getopt_long
3040 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3061 do_section_groups
++;
3069 do_section_groups
++;
3074 do_section_details
++;
3119 section
= strtoul (optarg
, & cp
, 0);
3120 if (! *cp
&& section
>= 0)
3121 request_dump_bynumber (section
, HEX_DUMP
);
3123 request_dump_byname (optarg
, HEX_DUMP
);
3127 section
= strtoul (optarg
, & cp
, 0);
3128 if (! *cp
&& section
>= 0)
3129 request_dump_bynumber (section
, STRING_DUMP
);
3131 request_dump_byname (optarg
, STRING_DUMP
);
3139 unsigned int index
= 0;
3143 while (optarg
[index
])
3144 switch (optarg
[index
++])
3151 do_debug_abbrevs
= 1;
3159 do_debug_lines_decoded
= 1;
3163 do_debug_pubnames
= 1;
3167 do_debug_aranges
= 1;
3171 do_debug_ranges
= 1;
3175 do_debug_frames_interp
= 1;
3177 do_debug_frames
= 1;
3181 do_debug_macinfo
= 1;
3193 warn (_("Unrecognized debug option '%s'\n"), optarg
);
3198 case OPTION_DEBUG_DUMP
:
3206 const char * option
;
3209 debug_dump_long_opts
;
3211 debug_dump_long_opts opts_table
[] =
3213 /* Please keep this table alpha- sorted. */
3214 { "Ranges", & do_debug_ranges
},
3215 { "abbrev", & do_debug_abbrevs
},
3216 { "aranges", & do_debug_aranges
},
3217 { "frames", & do_debug_frames
},
3218 { "frames-interp", & do_debug_frames_interp
},
3219 { "info", & do_debug_info
},
3220 { "line", & do_debug_lines
}, /* For backwards compatibility. */
3221 { "rawline", & do_debug_lines
},
3222 { "decodedline", & do_debug_lines_decoded
},
3223 { "loc", & do_debug_loc
},
3224 { "macro", & do_debug_macinfo
},
3225 { "pubnames", & do_debug_pubnames
},
3226 /* This entry is for compatability
3227 with earlier versions of readelf. */
3228 { "ranges", & do_debug_aranges
},
3229 { "str", & do_debug_str
},
3240 debug_dump_long_opts
* entry
;
3242 for (entry
= opts_table
; entry
->option
; entry
++)
3244 size_t len
= strlen (entry
->option
);
3246 if (strneq (p
, entry
->option
, len
)
3247 && (p
[len
] == ',' || p
[len
] == '\0'))
3249 * entry
->variable
= 1;
3251 /* The --debug-dump=frames-interp option also
3252 enables the --debug-dump=frames option. */
3253 if (do_debug_frames_interp
)
3254 do_debug_frames
= 1;
3261 if (entry
->option
== NULL
)
3263 warn (_("Unrecognized debug option '%s'\n"), p
);
3264 p
= strchr (p
, ',');
3274 #ifdef SUPPORT_DISASSEMBLY
3277 section
= strtoul (optarg
, & cp
, 0);
3278 if (! *cp
&& section
>= 0)
3279 request_dump_bynumber (section
, DISASS_DUMP
);
3281 request_dump_byname (optarg
, DISASS_DUMP
);
3284 print_version (program_name
);
3293 /* xgettext:c-format */
3294 error (_("Invalid option '-%c'\n"), c
);
3301 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3302 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3303 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3304 && !do_section_groups
&& !do_archive_index
)
3308 warn (_("Nothing to do.\n"));
3314 get_elf_class (unsigned int elf_class
)
3316 static char buff
[32];
3320 case ELFCLASSNONE
: return _("none");
3321 case ELFCLASS32
: return "ELF32";
3322 case ELFCLASS64
: return "ELF64";
3324 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3330 get_data_encoding (unsigned int encoding
)
3332 static char buff
[32];
3336 case ELFDATANONE
: return _("none");
3337 case ELFDATA2LSB
: return _("2's complement, little endian");
3338 case ELFDATA2MSB
: return _("2's complement, big endian");
3340 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3345 /* Decode the data held in 'elf_header'. */
3348 process_file_header (void)
3350 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3351 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3352 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3353 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3356 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3360 init_dwarf_regnames (elf_header
.e_machine
);
3366 printf (_("ELF Header:\n"));
3367 printf (_(" Magic: "));
3368 for (i
= 0; i
< EI_NIDENT
; i
++)
3369 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3371 printf (_(" Class: %s\n"),
3372 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3373 printf (_(" Data: %s\n"),
3374 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3375 printf (_(" Version: %d %s\n"),
3376 elf_header
.e_ident
[EI_VERSION
],
3377 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3379 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3382 printf (_(" OS/ABI: %s\n"),
3383 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3384 printf (_(" ABI Version: %d\n"),
3385 elf_header
.e_ident
[EI_ABIVERSION
]);
3386 printf (_(" Type: %s\n"),
3387 get_file_type (elf_header
.e_type
));
3388 printf (_(" Machine: %s\n"),
3389 get_machine_name (elf_header
.e_machine
));
3390 printf (_(" Version: 0x%lx\n"),
3391 (unsigned long) elf_header
.e_version
);
3393 printf (_(" Entry point address: "));
3394 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3395 printf (_("\n Start of program headers: "));
3396 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3397 printf (_(" (bytes into file)\n Start of section headers: "));
3398 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3399 printf (_(" (bytes into file)\n"));
3401 printf (_(" Flags: 0x%lx%s\n"),
3402 (unsigned long) elf_header
.e_flags
,
3403 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3404 printf (_(" Size of this header: %ld (bytes)\n"),
3405 (long) elf_header
.e_ehsize
);
3406 printf (_(" Size of program headers: %ld (bytes)\n"),
3407 (long) elf_header
.e_phentsize
);
3408 printf (_(" Number of program headers: %ld\n"),
3409 (long) elf_header
.e_phnum
);
3410 printf (_(" Size of section headers: %ld (bytes)\n"),
3411 (long) elf_header
.e_shentsize
);
3412 printf (_(" Number of section headers: %ld"),
3413 (long) elf_header
.e_shnum
);
3414 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3415 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3416 putc ('\n', stdout
);
3417 printf (_(" Section header string table index: %ld"),
3418 (long) elf_header
.e_shstrndx
);
3419 if (section_headers
!= NULL
3420 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3421 printf (" (%u)", section_headers
[0].sh_link
);
3422 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3423 printf (" <corrupt: out of range>");
3424 putc ('\n', stdout
);
3427 if (section_headers
!= NULL
)
3429 if (elf_header
.e_shnum
== SHN_UNDEF
)
3430 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3431 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3432 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3433 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3434 elf_header
.e_shstrndx
= SHN_UNDEF
;
3435 free (section_headers
);
3436 section_headers
= NULL
;
3444 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3446 Elf32_External_Phdr
*phdrs
;
3447 Elf32_External_Phdr
*external
;
3448 Elf_Internal_Phdr
*internal
;
3451 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3452 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3453 _("program headers"));
3457 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3458 i
< elf_header
.e_phnum
;
3459 i
++, internal
++, external
++)
3461 internal
->p_type
= BYTE_GET (external
->p_type
);
3462 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3463 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3464 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3465 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3466 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3467 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3468 internal
->p_align
= BYTE_GET (external
->p_align
);
3477 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3479 Elf64_External_Phdr
*phdrs
;
3480 Elf64_External_Phdr
*external
;
3481 Elf_Internal_Phdr
*internal
;
3484 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3485 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3486 _("program headers"));
3490 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3491 i
< elf_header
.e_phnum
;
3492 i
++, internal
++, external
++)
3494 internal
->p_type
= BYTE_GET (external
->p_type
);
3495 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3496 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3497 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3498 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3499 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3500 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3501 internal
->p_align
= BYTE_GET (external
->p_align
);
3509 /* Returns 1 if the program headers were read into `program_headers'. */
3512 get_program_headers (FILE *file
)
3514 Elf_Internal_Phdr
*phdrs
;
3516 /* Check cache of prior read. */
3517 if (program_headers
!= NULL
)
3520 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3524 error (_("Out of memory\n"));
3529 ? get_32bit_program_headers (file
, phdrs
)
3530 : get_64bit_program_headers (file
, phdrs
))
3532 program_headers
= phdrs
;
3540 /* Returns 1 if the program headers were loaded. */
3543 process_program_headers (FILE *file
)
3545 Elf_Internal_Phdr
*segment
;
3548 if (elf_header
.e_phnum
== 0)
3551 printf (_("\nThere are no program headers in this file.\n"));
3555 if (do_segments
&& !do_header
)
3557 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3558 printf (_("Entry point "));
3559 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3560 printf (_("\nThere are %d program headers, starting at offset "),
3561 elf_header
.e_phnum
);
3562 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3566 if (! get_program_headers (file
))
3571 if (elf_header
.e_phnum
> 1)
3572 printf (_("\nProgram Headers:\n"));
3574 printf (_("\nProgram Headers:\n"));
3578 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3581 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3585 (_(" Type Offset VirtAddr PhysAddr\n"));
3587 (_(" FileSiz MemSiz Flags Align\n"));
3594 for (i
= 0, segment
= program_headers
;
3595 i
< elf_header
.e_phnum
;
3600 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3604 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3605 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3606 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3607 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3608 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3610 (segment
->p_flags
& PF_R
? 'R' : ' '),
3611 (segment
->p_flags
& PF_W
? 'W' : ' '),
3612 (segment
->p_flags
& PF_X
? 'E' : ' '));
3613 printf ("%#lx", (unsigned long) segment
->p_align
);
3617 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3618 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3621 print_vma (segment
->p_offset
, FULL_HEX
);
3625 print_vma (segment
->p_vaddr
, FULL_HEX
);
3627 print_vma (segment
->p_paddr
, FULL_HEX
);
3630 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3631 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3634 print_vma (segment
->p_filesz
, FULL_HEX
);
3638 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3639 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3642 print_vma (segment
->p_offset
, FULL_HEX
);
3646 (segment
->p_flags
& PF_R
? 'R' : ' '),
3647 (segment
->p_flags
& PF_W
? 'W' : ' '),
3648 (segment
->p_flags
& PF_X
? 'E' : ' '));
3650 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3651 printf ("%#lx", (unsigned long) segment
->p_align
);
3654 print_vma (segment
->p_align
, PREFIX_HEX
);
3659 print_vma (segment
->p_offset
, FULL_HEX
);
3661 print_vma (segment
->p_vaddr
, FULL_HEX
);
3663 print_vma (segment
->p_paddr
, FULL_HEX
);
3665 print_vma (segment
->p_filesz
, FULL_HEX
);
3667 print_vma (segment
->p_memsz
, FULL_HEX
);
3669 (segment
->p_flags
& PF_R
? 'R' : ' '),
3670 (segment
->p_flags
& PF_W
? 'W' : ' '),
3671 (segment
->p_flags
& PF_X
? 'E' : ' '));
3672 print_vma (segment
->p_align
, HEX
);
3676 switch (segment
->p_type
)
3680 error (_("more than one dynamic segment\n"));
3682 /* By default, assume that the .dynamic section is the first
3683 section in the DYNAMIC segment. */
3684 dynamic_addr
= segment
->p_offset
;
3685 dynamic_size
= segment
->p_filesz
;
3687 /* Try to locate the .dynamic section. If there is
3688 a section header table, we can easily locate it. */
3689 if (section_headers
!= NULL
)
3691 Elf_Internal_Shdr
*sec
;
3693 sec
= find_section (".dynamic");
3694 if (sec
== NULL
|| sec
->sh_size
== 0)
3696 error (_("no .dynamic section in the dynamic segment\n"));
3700 if (sec
->sh_type
== SHT_NOBITS
)
3706 dynamic_addr
= sec
->sh_offset
;
3707 dynamic_size
= sec
->sh_size
;
3709 if (dynamic_addr
< segment
->p_offset
3710 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3711 warn (_("the .dynamic section is not contained"
3712 " within the dynamic segment\n"));
3713 else if (dynamic_addr
> segment
->p_offset
)
3714 warn (_("the .dynamic section is not the first section"
3715 " in the dynamic segment.\n"));
3720 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3722 error (_("Unable to find program interpreter name\n"));
3726 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3728 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3729 error (_("Internal error: failed to create format string to display program interpreter\n"));
3731 program_interpreter
[0] = 0;
3732 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3733 error (_("Unable to read program interpreter name\n"));
3736 printf (_("\n [Requesting program interpreter: %s]"),
3737 program_interpreter
);
3743 putc ('\n', stdout
);
3746 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3748 printf (_("\n Section to Segment mapping:\n"));
3749 printf (_(" Segment Sections...\n"));
3751 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3754 Elf_Internal_Shdr
*section
;
3756 segment
= program_headers
+ i
;
3757 section
= section_headers
+ 1;
3759 printf (" %2.2d ", i
);
3761 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3763 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3764 printf ("%s ", SECTION_NAME (section
));
3775 /* Find the file offset corresponding to VMA by using the program headers. */
3778 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3780 Elf_Internal_Phdr
*seg
;
3782 if (! get_program_headers (file
))
3784 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3788 for (seg
= program_headers
;
3789 seg
< program_headers
+ elf_header
.e_phnum
;
3792 if (seg
->p_type
!= PT_LOAD
)
3795 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3796 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3797 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3800 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3807 get_32bit_section_headers (FILE *file
, unsigned int num
)
3809 Elf32_External_Shdr
*shdrs
;
3810 Elf_Internal_Shdr
*internal
;
3813 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3814 elf_header
.e_shentsize
, num
, _("section headers"));
3818 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3820 if (section_headers
== NULL
)
3822 error (_("Out of memory\n"));
3826 for (i
= 0, internal
= section_headers
;
3830 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3831 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3832 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3833 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3834 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3835 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3836 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3837 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3838 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3839 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3848 get_64bit_section_headers (FILE *file
, unsigned int num
)
3850 Elf64_External_Shdr
*shdrs
;
3851 Elf_Internal_Shdr
*internal
;
3854 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3855 elf_header
.e_shentsize
, num
, _("section headers"));
3859 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3861 if (section_headers
== NULL
)
3863 error (_("Out of memory\n"));
3867 for (i
= 0, internal
= section_headers
;
3871 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3872 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3873 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3874 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3875 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3876 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3877 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3878 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3879 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3880 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3888 static Elf_Internal_Sym
*
3889 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3891 unsigned long number
;
3892 Elf32_External_Sym
*esyms
;
3893 Elf_External_Sym_Shndx
*shndx
;
3894 Elf_Internal_Sym
*isyms
;
3895 Elf_Internal_Sym
*psym
;
3898 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3904 if (symtab_shndx_hdr
!= NULL
3905 && (symtab_shndx_hdr
->sh_link
3906 == (unsigned long) (section
- section_headers
)))
3908 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3909 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3917 number
= section
->sh_size
/ section
->sh_entsize
;
3918 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3922 error (_("Out of memory\n"));
3929 for (j
= 0, psym
= isyms
;
3933 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3934 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3935 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3936 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3937 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3939 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3940 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3941 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3942 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3943 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3953 static Elf_Internal_Sym
*
3954 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3956 unsigned long number
;
3957 Elf64_External_Sym
*esyms
;
3958 Elf_External_Sym_Shndx
*shndx
;
3959 Elf_Internal_Sym
*isyms
;
3960 Elf_Internal_Sym
*psym
;
3963 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3969 if (symtab_shndx_hdr
!= NULL
3970 && (symtab_shndx_hdr
->sh_link
3971 == (unsigned long) (section
- section_headers
)))
3973 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3974 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3982 number
= section
->sh_size
/ section
->sh_entsize
;
3983 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3987 error (_("Out of memory\n"));
3994 for (j
= 0, psym
= isyms
;
3998 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3999 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4000 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4001 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4002 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4004 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4005 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4006 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4007 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4008 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4019 get_elf_section_flags (bfd_vma sh_flags
)
4021 static char buff
[1024];
4023 int field_size
= is_32bit_elf
? 8 : 16;
4024 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
4025 bfd_vma os_flags
= 0;
4026 bfd_vma proc_flags
= 0;
4027 bfd_vma unknown_flags
= 0;
4041 { "LINK ORDER", 10 },
4042 { "OS NONCONF", 10 },
4045 /* IA-64 specific. */
4048 /* IA-64 OpenVMS specific. */
4049 { "VMS_GLOBAL", 10 },
4050 { "VMS_OVERLAID", 12 },
4051 { "VMS_SHARED", 10 },
4052 { "VMS_VECTOR", 10 },
4053 { "VMS_ALLOC_64BIT", 15 },
4054 { "VMS_PROTECTED", 13}
4057 if (do_section_details
)
4059 sprintf (buff
, "[%*.*lx]: ",
4060 field_size
, field_size
, (unsigned long) sh_flags
);
4061 p
+= field_size
+ 4;
4068 flag
= sh_flags
& - sh_flags
;
4071 if (do_section_details
)
4075 case SHF_WRITE
: index
= 0; break;
4076 case SHF_ALLOC
: index
= 1; break;
4077 case SHF_EXECINSTR
: index
= 2; break;
4078 case SHF_MERGE
: index
= 3; break;
4079 case SHF_STRINGS
: index
= 4; break;
4080 case SHF_INFO_LINK
: index
= 5; break;
4081 case SHF_LINK_ORDER
: index
= 6; break;
4082 case SHF_OS_NONCONFORMING
: index
= 7; break;
4083 case SHF_GROUP
: index
= 8; break;
4084 case SHF_TLS
: index
= 9; break;
4088 if (elf_header
.e_machine
== EM_IA_64
)
4090 if (flag
== SHF_IA_64_SHORT
)
4092 else if (flag
== SHF_IA_64_NORECOV
)
4095 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4098 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
4099 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
4100 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
4101 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
4102 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
4103 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
4113 if (p
!= buff
+ field_size
+ 4)
4115 if (size
< (10 + 2))
4122 size
-= flags
[index
].len
;
4123 p
= stpcpy (p
, flags
[index
].str
);
4125 else if (flag
& SHF_MASKOS
)
4127 else if (flag
& SHF_MASKPROC
)
4130 unknown_flags
|= flag
;
4136 case SHF_WRITE
: *p
= 'W'; break;
4137 case SHF_ALLOC
: *p
= 'A'; break;
4138 case SHF_EXECINSTR
: *p
= 'X'; break;
4139 case SHF_MERGE
: *p
= 'M'; break;
4140 case SHF_STRINGS
: *p
= 'S'; break;
4141 case SHF_INFO_LINK
: *p
= 'I'; break;
4142 case SHF_LINK_ORDER
: *p
= 'L'; break;
4143 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4144 case SHF_GROUP
: *p
= 'G'; break;
4145 case SHF_TLS
: *p
= 'T'; break;
4148 if (elf_header
.e_machine
== EM_X86_64
4149 && flag
== SHF_X86_64_LARGE
)
4151 else if (flag
& SHF_MASKOS
)
4154 sh_flags
&= ~ SHF_MASKOS
;
4156 else if (flag
& SHF_MASKPROC
)
4159 sh_flags
&= ~ SHF_MASKPROC
;
4169 if (do_section_details
)
4173 size
-= 5 + field_size
;
4174 if (p
!= buff
+ field_size
+ 4)
4182 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4183 (unsigned long) os_flags
);
4184 p
+= 5 + field_size
;
4188 size
-= 7 + field_size
;
4189 if (p
!= buff
+ field_size
+ 4)
4197 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4198 (unsigned long) proc_flags
);
4199 p
+= 7 + field_size
;
4203 size
-= 10 + field_size
;
4204 if (p
!= buff
+ field_size
+ 4)
4212 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4213 (unsigned long) unknown_flags
);
4214 p
+= 10 + field_size
;
4223 process_section_headers (FILE *file
)
4225 Elf_Internal_Shdr
*section
;
4228 section_headers
= NULL
;
4230 if (elf_header
.e_shnum
== 0)
4233 printf (_("\nThere are no sections in this file.\n"));
4238 if (do_sections
&& !do_header
)
4239 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4240 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4244 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4247 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4250 /* Read in the string table, so that we have names to display. */
4251 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4252 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4254 section
= section_headers
+ elf_header
.e_shstrndx
;
4256 if (section
->sh_size
!= 0)
4258 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4259 1, section
->sh_size
, _("string table"));
4261 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4265 /* Scan the sections for the dynamic symbol table
4266 and dynamic string table and debug sections. */
4267 dynamic_symbols
= NULL
;
4268 dynamic_strings
= NULL
;
4269 dynamic_syminfo
= NULL
;
4270 symtab_shndx_hdr
= NULL
;
4272 eh_addr_size
= is_32bit_elf
? 4 : 8;
4273 switch (elf_header
.e_machine
)
4276 case EM_MIPS_RS3_LE
:
4277 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4278 FDE addresses. However, the ABI also has a semi-official ILP32
4279 variant for which the normal FDE address size rules apply.
4281 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4282 section, where XX is the size of longs in bits. Unfortunately,
4283 earlier compilers provided no way of distinguishing ILP32 objects
4284 from LP64 objects, so if there's any doubt, we should assume that
4285 the official LP64 form is being used. */
4286 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4287 && find_section (".gcc_compiled_long32") == NULL
)
4293 switch (elf_header
.e_flags
& EF_H8_MACH
)
4295 case E_H8_MACH_H8300
:
4296 case E_H8_MACH_H8300HN
:
4297 case E_H8_MACH_H8300SN
:
4298 case E_H8_MACH_H8300SXN
:
4301 case E_H8_MACH_H8300H
:
4302 case E_H8_MACH_H8300S
:
4303 case E_H8_MACH_H8300SX
:
4311 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4313 case EF_M32C_CPU_M16C
:
4320 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4323 size_t expected_entsize \
4324 = is_32bit_elf ? size32 : size64; \
4325 if (section->sh_entsize != expected_entsize) \
4326 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4327 i, (unsigned long int) section->sh_entsize, \
4328 (unsigned long int) expected_entsize); \
4329 section->sh_entsize = expected_entsize; \
4332 #define CHECK_ENTSIZE(section, i, type) \
4333 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4334 sizeof (Elf64_External_##type))
4336 for (i
= 0, section
= section_headers
;
4337 i
< elf_header
.e_shnum
;
4340 char *name
= SECTION_NAME (section
);
4342 if (section
->sh_type
== SHT_DYNSYM
)
4344 if (dynamic_symbols
!= NULL
)
4346 error (_("File contains multiple dynamic symbol tables\n"));
4350 CHECK_ENTSIZE (section
, i
, Sym
);
4351 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4352 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4354 else if (section
->sh_type
== SHT_STRTAB
4355 && streq (name
, ".dynstr"))
4357 if (dynamic_strings
!= NULL
)
4359 error (_("File contains multiple dynamic string tables\n"));
4363 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4364 1, section
->sh_size
, _("dynamic strings"));
4365 dynamic_strings_length
= section
->sh_size
;
4367 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4369 if (symtab_shndx_hdr
!= NULL
)
4371 error (_("File contains multiple symtab shndx tables\n"));
4374 symtab_shndx_hdr
= section
;
4376 else if (section
->sh_type
== SHT_SYMTAB
)
4377 CHECK_ENTSIZE (section
, i
, Sym
);
4378 else if (section
->sh_type
== SHT_GROUP
)
4379 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4380 else if (section
->sh_type
== SHT_REL
)
4381 CHECK_ENTSIZE (section
, i
, Rel
);
4382 else if (section
->sh_type
== SHT_RELA
)
4383 CHECK_ENTSIZE (section
, i
, Rela
);
4384 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4385 || do_debug_lines
|| do_debug_lines_decoded
|| do_debug_pubnames
4386 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4387 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4388 && const_strneq (name
, ".debug_"))
4393 || (do_debug_info
&& streq (name
, "info"))
4394 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4395 || ((do_debug_lines
|| do_debug_lines_decoded
)
4396 && streq (name
, "line"))
4397 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4398 || (do_debug_aranges
&& streq (name
, "aranges"))
4399 || (do_debug_ranges
&& streq (name
, "ranges"))
4400 || (do_debug_frames
&& streq (name
, "frame"))
4401 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4402 || (do_debug_str
&& streq (name
, "str"))
4403 || (do_debug_loc
&& streq (name
, "loc"))
4405 request_dump_bynumber (i
, DEBUG_DUMP
);
4407 /* Linkonce section to be combined with .debug_info at link time. */
4408 else if ((do_debugging
|| do_debug_info
)
4409 && const_strneq (name
, ".gnu.linkonce.wi."))
4410 request_dump_bynumber (i
, DEBUG_DUMP
);
4411 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4412 request_dump_bynumber (i
, DEBUG_DUMP
);
4418 if (elf_header
.e_shnum
> 1)
4419 printf (_("\nSection Headers:\n"));
4421 printf (_("\nSection Header:\n"));
4425 if (do_section_details
)
4427 printf (_(" [Nr] Name\n"));
4428 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4432 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4436 if (do_section_details
)
4438 printf (_(" [Nr] Name\n"));
4439 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4443 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4447 if (do_section_details
)
4449 printf (_(" [Nr] Name\n"));
4450 printf (_(" Type Address Offset Link\n"));
4451 printf (_(" Size EntSize Info Align\n"));
4455 printf (_(" [Nr] Name Type Address Offset\n"));
4456 printf (_(" Size EntSize Flags Link Info Align\n"));
4460 if (do_section_details
)
4461 printf (_(" Flags\n"));
4463 for (i
= 0, section
= section_headers
;
4464 i
< elf_header
.e_shnum
;
4467 if (do_section_details
)
4469 printf (" [%2u] %s\n",
4471 SECTION_NAME (section
));
4472 if (is_32bit_elf
|| do_wide
)
4473 printf (" %-15.15s ",
4474 get_section_type_name (section
->sh_type
));
4477 printf (" [%2u] %-17.17s %-15.15s ",
4479 SECTION_NAME (section
),
4480 get_section_type_name (section
->sh_type
));
4484 print_vma (section
->sh_addr
, LONG_HEX
);
4486 printf ( " %6.6lx %6.6lx %2.2lx",
4487 (unsigned long) section
->sh_offset
,
4488 (unsigned long) section
->sh_size
,
4489 (unsigned long) section
->sh_entsize
);
4491 if (do_section_details
)
4492 fputs (" ", stdout
);
4494 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4496 printf ("%2u %3u %2lu\n",
4499 (unsigned long) section
->sh_addralign
);
4503 print_vma (section
->sh_addr
, LONG_HEX
);
4505 if ((long) section
->sh_offset
== section
->sh_offset
)
4506 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4510 print_vma (section
->sh_offset
, LONG_HEX
);
4513 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4514 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4518 print_vma (section
->sh_size
, LONG_HEX
);
4521 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4522 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4526 print_vma (section
->sh_entsize
, LONG_HEX
);
4529 if (do_section_details
)
4530 fputs (" ", stdout
);
4532 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4534 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4536 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4537 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4540 print_vma (section
->sh_addralign
, DEC
);
4544 else if (do_section_details
)
4546 printf (" %-15.15s ",
4547 get_section_type_name (section
->sh_type
));
4548 print_vma (section
->sh_addr
, LONG_HEX
);
4549 if ((long) section
->sh_offset
== section
->sh_offset
)
4550 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4554 print_vma (section
->sh_offset
, LONG_HEX
);
4556 printf (" %u\n ", section
->sh_link
);
4557 print_vma (section
->sh_size
, LONG_HEX
);
4559 print_vma (section
->sh_entsize
, LONG_HEX
);
4561 printf (" %-16u %lu\n",
4563 (unsigned long) section
->sh_addralign
);
4568 print_vma (section
->sh_addr
, LONG_HEX
);
4569 if ((long) section
->sh_offset
== section
->sh_offset
)
4570 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4574 print_vma (section
->sh_offset
, LONG_HEX
);
4577 print_vma (section
->sh_size
, LONG_HEX
);
4579 print_vma (section
->sh_entsize
, LONG_HEX
);
4581 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4583 printf (" %2u %3u %lu\n",
4586 (unsigned long) section
->sh_addralign
);
4589 if (do_section_details
)
4590 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4593 if (!do_section_details
)
4594 printf (_("Key to Flags:\n\
4595 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4596 I (info), L (link order), G (group), x (unknown)\n\
4597 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4603 get_group_flags (unsigned int flags
)
4605 static char buff
[32];
4612 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4619 process_section_groups (FILE *file
)
4621 Elf_Internal_Shdr
*section
;
4623 struct group
*group
;
4624 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4625 Elf_Internal_Sym
*symtab
;
4629 /* Don't process section groups unless needed. */
4630 if (!do_unwind
&& !do_section_groups
)
4633 if (elf_header
.e_shnum
== 0)
4635 if (do_section_groups
)
4636 printf (_("\nThere are no sections in this file.\n"));
4641 if (section_headers
== NULL
)
4643 error (_("Section headers are not available!\n"));
4647 section_headers_groups
= calloc (elf_header
.e_shnum
,
4648 sizeof (struct group
*));
4650 if (section_headers_groups
== NULL
)
4652 error (_("Out of memory\n"));
4656 /* Scan the sections for the group section. */
4658 for (i
= 0, section
= section_headers
;
4659 i
< elf_header
.e_shnum
;
4661 if (section
->sh_type
== SHT_GROUP
)
4664 if (group_count
== 0)
4666 if (do_section_groups
)
4667 printf (_("\nThere are no section groups in this file.\n"));
4672 section_groups
= calloc (group_count
, sizeof (struct group
));
4674 if (section_groups
== NULL
)
4676 error (_("Out of memory\n"));
4685 for (i
= 0, section
= section_headers
, group
= section_groups
;
4686 i
< elf_header
.e_shnum
;
4689 if (section
->sh_type
== SHT_GROUP
)
4691 char *name
= SECTION_NAME (section
);
4693 unsigned char *start
, *indices
;
4694 unsigned int entry
, j
, size
;
4695 Elf_Internal_Shdr
*sec
;
4696 Elf_Internal_Sym
*sym
;
4698 /* Get the symbol table. */
4699 if (section
->sh_link
>= elf_header
.e_shnum
4700 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4703 error (_("Bad sh_link in group section `%s'\n"), name
);
4707 if (symtab_sec
!= sec
)
4712 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4715 sym
= symtab
+ section
->sh_info
;
4717 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4719 if (sym
->st_shndx
== 0
4720 || sym
->st_shndx
>= elf_header
.e_shnum
)
4722 error (_("Bad sh_info in group section `%s'\n"), name
);
4726 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4735 /* Get the string table. */
4736 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4745 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4750 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4751 1, strtab_sec
->sh_size
,
4753 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4755 group_name
= sym
->st_name
< strtab_size
4756 ? strtab
+ sym
->st_name
: "<corrupt>";
4759 start
= get_data (NULL
, file
, section
->sh_offset
,
4760 1, section
->sh_size
, _("section data"));
4763 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4764 entry
= byte_get (indices
, 4);
4767 if (do_section_groups
)
4769 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4770 get_group_flags (entry
), i
, name
, group_name
, size
);
4772 printf (_(" [Index] Name\n"));
4775 group
->group_index
= i
;
4777 for (j
= 0; j
< size
; j
++)
4779 struct group_list
*g
;
4781 entry
= byte_get (indices
, 4);
4784 if (entry
>= elf_header
.e_shnum
)
4786 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4787 entry
, i
, elf_header
.e_shnum
- 1);
4791 if (section_headers_groups
[entry
] != NULL
)
4795 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4797 section_headers_groups
[entry
]->group_index
);
4802 /* Intel C/C++ compiler may put section 0 in a
4803 section group. We just warn it the first time
4804 and ignore it afterwards. */
4805 static int warned
= 0;
4808 error (_("section 0 in group section [%5u]\n"),
4809 section_headers_groups
[entry
]->group_index
);
4815 section_headers_groups
[entry
] = group
;
4817 if (do_section_groups
)
4819 sec
= section_headers
+ entry
;
4820 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4823 g
= xmalloc (sizeof (struct group_list
));
4824 g
->section_index
= entry
;
4825 g
->next
= group
->root
;
4849 } dynamic_relocations
[] =
4851 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4852 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4853 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4856 /* Process the reloc section. */
4859 process_relocs (FILE *file
)
4861 unsigned long rel_size
;
4862 unsigned long rel_offset
;
4868 if (do_using_dynamic
)
4872 int has_dynamic_reloc
;
4875 has_dynamic_reloc
= 0;
4877 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4879 is_rela
= dynamic_relocations
[i
].rela
;
4880 name
= dynamic_relocations
[i
].name
;
4881 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4882 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4884 has_dynamic_reloc
|= rel_size
;
4886 if (is_rela
== UNKNOWN
)
4888 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4889 switch (dynamic_info
[DT_PLTREL
])
4903 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4904 name
, rel_offset
, rel_size
);
4906 dump_relocations (file
,
4907 offset_from_vma (file
, rel_offset
, rel_size
),
4909 dynamic_symbols
, num_dynamic_syms
,
4910 dynamic_strings
, dynamic_strings_length
, is_rela
);
4914 if (! has_dynamic_reloc
)
4915 printf (_("\nThere are no dynamic relocations in this file.\n"));
4919 Elf_Internal_Shdr
*section
;
4923 for (i
= 0, section
= section_headers
;
4924 i
< elf_header
.e_shnum
;
4927 if ( section
->sh_type
!= SHT_RELA
4928 && section
->sh_type
!= SHT_REL
)
4931 rel_offset
= section
->sh_offset
;
4932 rel_size
= section
->sh_size
;
4936 Elf_Internal_Shdr
*strsec
;
4939 printf (_("\nRelocation section "));
4941 if (string_table
== NULL
)
4942 printf ("%d", section
->sh_name
);
4944 printf (_("'%s'"), SECTION_NAME (section
));
4946 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4947 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4949 is_rela
= section
->sh_type
== SHT_RELA
;
4951 if (section
->sh_link
!= 0
4952 && section
->sh_link
< elf_header
.e_shnum
)
4954 Elf_Internal_Shdr
*symsec
;
4955 Elf_Internal_Sym
*symtab
;
4956 unsigned long nsyms
;
4957 unsigned long strtablen
= 0;
4958 char *strtab
= NULL
;
4960 symsec
= section_headers
+ section
->sh_link
;
4961 if (symsec
->sh_type
!= SHT_SYMTAB
4962 && symsec
->sh_type
!= SHT_DYNSYM
)
4965 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4966 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4971 if (symsec
->sh_link
!= 0
4972 && symsec
->sh_link
< elf_header
.e_shnum
)
4974 strsec
= section_headers
+ symsec
->sh_link
;
4976 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4979 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4982 dump_relocations (file
, rel_offset
, rel_size
,
4983 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4989 dump_relocations (file
, rel_offset
, rel_size
,
4990 NULL
, 0, NULL
, 0, is_rela
);
4997 printf (_("\nThere are no relocations in this file.\n"));
5003 /* Process the unwind section. */
5005 #include "unwind-ia64.h"
5007 /* An absolute address consists of a section and an offset. If the
5008 section is NULL, the offset itself is the address, otherwise, the
5009 address equals to LOAD_ADDRESS(section) + offset. */
5013 unsigned short section
;
5017 #define ABSADDR(a) \
5019 ? section_headers [(a).section].sh_addr + (a).offset \
5022 struct ia64_unw_aux_info
5024 struct ia64_unw_table_entry
5026 struct absaddr start
;
5028 struct absaddr info
;
5030 *table
; /* Unwind table. */
5031 unsigned long table_len
; /* Length of unwind table. */
5032 unsigned char *info
; /* Unwind info. */
5033 unsigned long info_size
; /* Size of unwind info. */
5034 bfd_vma info_addr
; /* starting address of unwind info. */
5035 bfd_vma seg_base
; /* Starting address of segment. */
5036 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5037 unsigned long nsyms
; /* Number of symbols. */
5038 char *strtab
; /* The string table. */
5039 unsigned long strtab_size
; /* Size of string table. */
5043 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
5044 unsigned long nsyms
,
5046 unsigned long strtab_size
,
5047 struct absaddr addr
,
5048 const char **symname
,
5051 bfd_vma dist
= 0x100000;
5052 Elf_Internal_Sym
*sym
, *best
= NULL
;
5055 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5057 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5058 && sym
->st_name
!= 0
5059 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5060 && addr
.offset
>= sym
->st_value
5061 && addr
.offset
- sym
->st_value
< dist
)
5064 dist
= addr
.offset
- sym
->st_value
;
5071 *symname
= (best
->st_name
>= strtab_size
5072 ? "<corrupt>" : strtab
+ best
->st_name
);
5077 *offset
= addr
.offset
;
5081 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
5083 struct ia64_unw_table_entry
*tp
;
5086 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5090 const unsigned char *dp
;
5091 const unsigned char *head
;
5092 const char *procname
;
5094 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5095 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5097 fputs ("\n<", stdout
);
5101 fputs (procname
, stdout
);
5104 printf ("+%lx", (unsigned long) offset
);
5107 fputs (">: [", stdout
);
5108 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5109 fputc ('-', stdout
);
5110 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5111 printf ("], info at +0x%lx\n",
5112 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5114 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5115 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5117 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5118 (unsigned) UNW_VER (stamp
),
5119 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5120 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5121 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5122 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5124 if (UNW_VER (stamp
) != 1)
5126 printf ("\tUnknown version.\n");
5131 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5132 dp
= unw_decode (dp
, in_body
, & in_body
);
5137 slurp_ia64_unwind_table (FILE *file
,
5138 struct ia64_unw_aux_info
*aux
,
5139 Elf_Internal_Shdr
*sec
)
5141 unsigned long size
, nrelas
, i
;
5142 Elf_Internal_Phdr
*seg
;
5143 struct ia64_unw_table_entry
*tep
;
5144 Elf_Internal_Shdr
*relsec
;
5145 Elf_Internal_Rela
*rela
, *rp
;
5146 unsigned char *table
, *tp
;
5147 Elf_Internal_Sym
*sym
;
5148 const char *relname
;
5150 /* First, find the starting address of the segment that includes
5153 if (elf_header
.e_phnum
)
5155 if (! get_program_headers (file
))
5158 for (seg
= program_headers
;
5159 seg
< program_headers
+ elf_header
.e_phnum
;
5162 if (seg
->p_type
!= PT_LOAD
)
5165 if (sec
->sh_addr
>= seg
->p_vaddr
5166 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5168 aux
->seg_base
= seg
->p_vaddr
;
5174 /* Second, build the unwind table from the contents of the unwind section: */
5175 size
= sec
->sh_size
;
5176 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5180 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5182 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
5184 tep
->start
.section
= SHN_UNDEF
;
5185 tep
->end
.section
= SHN_UNDEF
;
5186 tep
->info
.section
= SHN_UNDEF
;
5189 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5190 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5191 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5195 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5196 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5197 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5199 tep
->start
.offset
+= aux
->seg_base
;
5200 tep
->end
.offset
+= aux
->seg_base
;
5201 tep
->info
.offset
+= aux
->seg_base
;
5205 /* Third, apply any relocations to the unwind table: */
5206 for (relsec
= section_headers
;
5207 relsec
< section_headers
+ elf_header
.e_shnum
;
5210 if (relsec
->sh_type
!= SHT_RELA
5211 || relsec
->sh_info
>= elf_header
.e_shnum
5212 || section_headers
+ relsec
->sh_info
!= sec
)
5215 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5219 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5221 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5222 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5224 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5226 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5230 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5232 switch (rp
->r_offset
/eh_addr_size
% 3)
5235 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5236 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5239 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5240 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5243 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5244 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5254 aux
->table_len
= size
/ (3 * eh_addr_size
);
5259 ia64_process_unwind (FILE *file
)
5261 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5262 unsigned long i
, unwcount
= 0, unwstart
= 0;
5263 struct ia64_unw_aux_info aux
;
5265 memset (& aux
, 0, sizeof (aux
));
5267 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5269 if (sec
->sh_type
== SHT_SYMTAB
5270 && sec
->sh_link
< elf_header
.e_shnum
)
5272 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5273 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5275 strsec
= section_headers
+ sec
->sh_link
;
5276 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5277 1, strsec
->sh_size
, _("string table"));
5278 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5280 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5285 printf (_("\nThere are no unwind sections in this file.\n"));
5287 while (unwcount
-- > 0)
5292 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5293 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5294 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5301 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5303 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5305 /* We need to find which section group it is in. */
5306 struct group_list
*g
= section_headers_groups
[i
]->root
;
5308 for (; g
!= NULL
; g
= g
->next
)
5310 sec
= section_headers
+ g
->section_index
;
5312 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5317 i
= elf_header
.e_shnum
;
5319 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5321 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5322 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5323 suffix
= SECTION_NAME (unwsec
) + len
;
5324 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5326 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5327 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5332 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5333 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5334 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5335 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5337 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5338 suffix
= SECTION_NAME (unwsec
) + len
;
5339 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5341 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5342 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5346 if (i
== elf_header
.e_shnum
)
5348 printf (_("\nCould not find unwind info section for "));
5350 if (string_table
== NULL
)
5351 printf ("%d", unwsec
->sh_name
);
5353 printf (_("'%s'"), SECTION_NAME (unwsec
));
5357 aux
.info_size
= sec
->sh_size
;
5358 aux
.info_addr
= sec
->sh_addr
;
5359 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5362 printf (_("\nUnwind section "));
5364 if (string_table
== NULL
)
5365 printf ("%d", unwsec
->sh_name
);
5367 printf (_("'%s'"), SECTION_NAME (unwsec
));
5369 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5370 (unsigned long) unwsec
->sh_offset
,
5371 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5373 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5375 if (aux
.table_len
> 0)
5376 dump_ia64_unwind (& aux
);
5379 free ((char *) aux
.table
);
5381 free ((char *) aux
.info
);
5390 free ((char *) aux
.strtab
);
5395 struct hppa_unw_aux_info
5397 struct hppa_unw_table_entry
5399 struct absaddr start
;
5401 unsigned int Cannot_unwind
:1; /* 0 */
5402 unsigned int Millicode
:1; /* 1 */
5403 unsigned int Millicode_save_sr0
:1; /* 2 */
5404 unsigned int Region_description
:2; /* 3..4 */
5405 unsigned int reserved1
:1; /* 5 */
5406 unsigned int Entry_SR
:1; /* 6 */
5407 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5408 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5409 unsigned int Args_stored
:1; /* 16 */
5410 unsigned int Variable_Frame
:1; /* 17 */
5411 unsigned int Separate_Package_Body
:1; /* 18 */
5412 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5413 unsigned int Stack_Overflow_Check
:1; /* 20 */
5414 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5415 unsigned int Ada_Region
:1; /* 22 */
5416 unsigned int cxx_info
:1; /* 23 */
5417 unsigned int cxx_try_catch
:1; /* 24 */
5418 unsigned int sched_entry_seq
:1; /* 25 */
5419 unsigned int reserved2
:1; /* 26 */
5420 unsigned int Save_SP
:1; /* 27 */
5421 unsigned int Save_RP
:1; /* 28 */
5422 unsigned int Save_MRP_in_frame
:1; /* 29 */
5423 unsigned int extn_ptr_defined
:1; /* 30 */
5424 unsigned int Cleanup_defined
:1; /* 31 */
5426 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5427 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5428 unsigned int Large_frame
:1; /* 2 */
5429 unsigned int Pseudo_SP_Set
:1; /* 3 */
5430 unsigned int reserved4
:1; /* 4 */
5431 unsigned int Total_frame_size
:27; /* 5..31 */
5433 *table
; /* Unwind table. */
5434 unsigned long table_len
; /* Length of unwind table. */
5435 bfd_vma seg_base
; /* Starting address of segment. */
5436 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5437 unsigned long nsyms
; /* Number of symbols. */
5438 char *strtab
; /* The string table. */
5439 unsigned long strtab_size
; /* Size of string table. */
5443 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5445 struct hppa_unw_table_entry
*tp
;
5447 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5450 const char *procname
;
5452 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5453 aux
->strtab_size
, tp
->start
, &procname
,
5456 fputs ("\n<", stdout
);
5460 fputs (procname
, stdout
);
5463 printf ("+%lx", (unsigned long) offset
);
5466 fputs (">: [", stdout
);
5467 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5468 fputc ('-', stdout
);
5469 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5472 #define PF(_m) if (tp->_m) printf (#_m " ");
5473 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5476 PF(Millicode_save_sr0
);
5477 /* PV(Region_description); */
5483 PF(Separate_Package_Body
);
5484 PF(Frame_Extension_Millicode
);
5485 PF(Stack_Overflow_Check
);
5486 PF(Two_Instruction_SP_Increment
);
5490 PF(sched_entry_seq
);
5493 PF(Save_MRP_in_frame
);
5494 PF(extn_ptr_defined
);
5495 PF(Cleanup_defined
);
5496 PF(MPE_XL_interrupt_marker
);
5497 PF(HP_UX_interrupt_marker
);
5500 PV(Total_frame_size
);
5509 slurp_hppa_unwind_table (FILE *file
,
5510 struct hppa_unw_aux_info
*aux
,
5511 Elf_Internal_Shdr
*sec
)
5513 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5514 Elf_Internal_Phdr
*seg
;
5515 struct hppa_unw_table_entry
*tep
;
5516 Elf_Internal_Shdr
*relsec
;
5517 Elf_Internal_Rela
*rela
, *rp
;
5518 unsigned char *table
, *tp
;
5519 Elf_Internal_Sym
*sym
;
5520 const char *relname
;
5522 /* First, find the starting address of the segment that includes
5525 if (elf_header
.e_phnum
)
5527 if (! get_program_headers (file
))
5530 for (seg
= program_headers
;
5531 seg
< program_headers
+ elf_header
.e_phnum
;
5534 if (seg
->p_type
!= PT_LOAD
)
5537 if (sec
->sh_addr
>= seg
->p_vaddr
5538 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5540 aux
->seg_base
= seg
->p_vaddr
;
5546 /* Second, build the unwind table from the contents of the unwind
5548 size
= sec
->sh_size
;
5549 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5554 nentries
= size
/ unw_ent_size
;
5555 size
= unw_ent_size
* nentries
;
5557 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5559 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5561 unsigned int tmp1
, tmp2
;
5563 tep
->start
.section
= SHN_UNDEF
;
5564 tep
->end
.section
= SHN_UNDEF
;
5566 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5567 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5568 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5569 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5571 tep
->start
.offset
+= aux
->seg_base
;
5572 tep
->end
.offset
+= aux
->seg_base
;
5574 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5575 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5576 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5577 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5578 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5579 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5580 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5581 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5582 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5583 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5584 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5585 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5586 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5587 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5588 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5589 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5590 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5591 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5592 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5593 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5594 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5595 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5596 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5597 tep
->Cleanup_defined
= tmp1
& 0x1;
5599 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5600 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5601 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5602 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5603 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5604 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5608 /* Third, apply any relocations to the unwind table. */
5609 for (relsec
= section_headers
;
5610 relsec
< section_headers
+ elf_header
.e_shnum
;
5613 if (relsec
->sh_type
!= SHT_RELA
5614 || relsec
->sh_info
>= elf_header
.e_shnum
5615 || section_headers
+ relsec
->sh_info
!= sec
)
5618 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5622 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5624 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5625 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5627 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5628 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5630 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5634 i
= rp
->r_offset
/ unw_ent_size
;
5636 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5639 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5640 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5643 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5644 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5654 aux
->table_len
= nentries
;
5660 hppa_process_unwind (FILE *file
)
5662 struct hppa_unw_aux_info aux
;
5663 Elf_Internal_Shdr
*unwsec
= NULL
;
5664 Elf_Internal_Shdr
*strsec
;
5665 Elf_Internal_Shdr
*sec
;
5668 memset (& aux
, 0, sizeof (aux
));
5670 if (string_table
== NULL
)
5673 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5675 if (sec
->sh_type
== SHT_SYMTAB
5676 && sec
->sh_link
< elf_header
.e_shnum
)
5678 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5679 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5681 strsec
= section_headers
+ sec
->sh_link
;
5682 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5683 1, strsec
->sh_size
, _("string table"));
5684 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5686 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5691 printf (_("\nThere are no unwind sections in this file.\n"));
5693 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5695 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5697 printf (_("\nUnwind section "));
5698 printf (_("'%s'"), SECTION_NAME (sec
));
5700 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5701 (unsigned long) sec
->sh_offset
,
5702 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5704 slurp_hppa_unwind_table (file
, &aux
, sec
);
5705 if (aux
.table_len
> 0)
5706 dump_hppa_unwind (&aux
);
5709 free ((char *) aux
.table
);
5717 free ((char *) aux
.strtab
);
5723 process_unwind (FILE *file
)
5725 struct unwind_handler
{
5727 int (*handler
)(FILE *file
);
5729 { EM_IA_64
, ia64_process_unwind
},
5730 { EM_PARISC
, hppa_process_unwind
},
5738 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5739 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5740 return handlers
[i
].handler (file
);
5742 printf (_("\nThere are no unwind sections in this file.\n"));
5747 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5749 switch (entry
->d_tag
)
5752 if (entry
->d_un
.d_val
== 0)
5756 static const char * opts
[] =
5758 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5759 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5760 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5761 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5766 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5767 if (entry
->d_un
.d_val
& (1 << cnt
))
5769 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5776 case DT_MIPS_IVERSION
:
5777 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5778 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5780 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5783 case DT_MIPS_TIME_STAMP
:
5788 time_t time
= entry
->d_un
.d_val
;
5789 tmp
= gmtime (&time
);
5790 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5791 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5792 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5793 printf ("Time Stamp: %s\n", timebuf
);
5797 case DT_MIPS_RLD_VERSION
:
5798 case DT_MIPS_LOCAL_GOTNO
:
5799 case DT_MIPS_CONFLICTNO
:
5800 case DT_MIPS_LIBLISTNO
:
5801 case DT_MIPS_SYMTABNO
:
5802 case DT_MIPS_UNREFEXTNO
:
5803 case DT_MIPS_HIPAGENO
:
5804 case DT_MIPS_DELTA_CLASS_NO
:
5805 case DT_MIPS_DELTA_INSTANCE_NO
:
5806 case DT_MIPS_DELTA_RELOC_NO
:
5807 case DT_MIPS_DELTA_SYM_NO
:
5808 case DT_MIPS_DELTA_CLASSSYM_NO
:
5809 case DT_MIPS_COMPACT_SIZE
:
5810 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5814 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5820 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5822 switch (entry
->d_tag
)
5824 case DT_HP_DLD_FLAGS
:
5833 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5834 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5835 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5836 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5837 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5838 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5839 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5840 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5841 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5842 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5843 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5844 { DT_HP_GST
, "HP_GST" },
5845 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5846 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5847 { DT_HP_NODELETE
, "HP_NODELETE" },
5848 { DT_HP_GROUP
, "HP_GROUP" },
5849 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5853 bfd_vma val
= entry
->d_un
.d_val
;
5855 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5856 if (val
& flags
[cnt
].bit
)
5860 fputs (flags
[cnt
].str
, stdout
);
5862 val
^= flags
[cnt
].bit
;
5865 if (val
!= 0 || first
)
5869 print_vma (val
, HEX
);
5875 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5882 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5884 switch (entry
->d_tag
)
5886 case DT_IA_64_PLT_RESERVE
:
5887 /* First 3 slots reserved. */
5888 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5890 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5894 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5901 get_32bit_dynamic_section (FILE *file
)
5903 Elf32_External_Dyn
*edyn
, *ext
;
5904 Elf_Internal_Dyn
*entry
;
5906 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5907 _("dynamic section"));
5911 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5912 might not have the luxury of section headers. Look for the DT_NULL
5913 terminator to determine the number of entries. */
5914 for (ext
= edyn
, dynamic_nent
= 0;
5915 (char *) ext
< (char *) edyn
+ dynamic_size
;
5919 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5923 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5924 if (dynamic_section
== NULL
)
5926 error (_("Out of memory\n"));
5931 for (ext
= edyn
, entry
= dynamic_section
;
5932 entry
< dynamic_section
+ dynamic_nent
;
5935 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5936 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5945 get_64bit_dynamic_section (FILE *file
)
5947 Elf64_External_Dyn
*edyn
, *ext
;
5948 Elf_Internal_Dyn
*entry
;
5950 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5951 _("dynamic section"));
5955 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5956 might not have the luxury of section headers. Look for the DT_NULL
5957 terminator to determine the number of entries. */
5958 for (ext
= edyn
, dynamic_nent
= 0;
5959 (char *) ext
< (char *) edyn
+ dynamic_size
;
5963 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5967 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5968 if (dynamic_section
== NULL
)
5970 error (_("Out of memory\n"));
5975 for (ext
= edyn
, entry
= dynamic_section
;
5976 entry
< dynamic_section
+ dynamic_nent
;
5979 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5980 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5989 print_dynamic_flags (bfd_vma flags
)
5997 flag
= flags
& - flags
;
6007 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6008 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6009 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6010 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6011 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6012 default: fputs ("unknown", stdout
); break;
6018 /* Parse and display the contents of the dynamic section. */
6021 process_dynamic_section (FILE *file
)
6023 Elf_Internal_Dyn
*entry
;
6025 if (dynamic_size
== 0)
6028 printf (_("\nThere is no dynamic section in this file.\n"));
6035 if (! get_32bit_dynamic_section (file
))
6038 else if (! get_64bit_dynamic_section (file
))
6041 /* Find the appropriate symbol table. */
6042 if (dynamic_symbols
== NULL
)
6044 for (entry
= dynamic_section
;
6045 entry
< dynamic_section
+ dynamic_nent
;
6048 Elf_Internal_Shdr section
;
6050 if (entry
->d_tag
!= DT_SYMTAB
)
6053 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6055 /* Since we do not know how big the symbol table is,
6056 we default to reading in the entire file (!) and
6057 processing that. This is overkill, I know, but it
6059 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6061 if (archive_file_offset
!= 0)
6062 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6065 if (fseek (file
, 0, SEEK_END
))
6066 error (_("Unable to seek to end of file!\n"));
6068 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6072 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6074 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6076 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6077 if (num_dynamic_syms
< 1)
6079 error (_("Unable to determine the number of symbols to load\n"));
6083 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6087 /* Similarly find a string table. */
6088 if (dynamic_strings
== NULL
)
6090 for (entry
= dynamic_section
;
6091 entry
< dynamic_section
+ dynamic_nent
;
6094 unsigned long offset
;
6097 if (entry
->d_tag
!= DT_STRTAB
)
6100 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6102 /* Since we do not know how big the string table is,
6103 we default to reading in the entire file (!) and
6104 processing that. This is overkill, I know, but it
6107 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6109 if (archive_file_offset
!= 0)
6110 str_tab_len
= archive_file_size
- offset
;
6113 if (fseek (file
, 0, SEEK_END
))
6114 error (_("Unable to seek to end of file\n"));
6115 str_tab_len
= ftell (file
) - offset
;
6118 if (str_tab_len
< 1)
6121 (_("Unable to determine the length of the dynamic string table\n"));
6125 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
6126 _("dynamic string table"));
6127 dynamic_strings_length
= str_tab_len
;
6132 /* And find the syminfo section if available. */
6133 if (dynamic_syminfo
== NULL
)
6135 unsigned long syminsz
= 0;
6137 for (entry
= dynamic_section
;
6138 entry
< dynamic_section
+ dynamic_nent
;
6141 if (entry
->d_tag
== DT_SYMINENT
)
6143 /* Note: these braces are necessary to avoid a syntax
6144 error from the SunOS4 C compiler. */
6145 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6147 else if (entry
->d_tag
== DT_SYMINSZ
)
6148 syminsz
= entry
->d_un
.d_val
;
6149 else if (entry
->d_tag
== DT_SYMINFO
)
6150 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6154 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6156 Elf_External_Syminfo
*extsyminfo
, *extsym
;
6157 Elf_Internal_Syminfo
*syminfo
;
6159 /* There is a syminfo section. Read the data. */
6160 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
6161 syminsz
, _("symbol information"));
6165 dynamic_syminfo
= malloc (syminsz
);
6166 if (dynamic_syminfo
== NULL
)
6168 error (_("Out of memory\n"));
6172 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6173 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6174 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6175 ++syminfo
, ++extsym
)
6177 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6178 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6185 if (do_dynamic
&& dynamic_addr
)
6186 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6187 dynamic_addr
, dynamic_nent
);
6189 printf (_(" Tag Type Name/Value\n"));
6191 for (entry
= dynamic_section
;
6192 entry
< dynamic_section
+ dynamic_nent
;
6200 print_vma (entry
->d_tag
, FULL_HEX
);
6201 dtype
= get_dynamic_type (entry
->d_tag
);
6202 printf (" (%s)%*s", dtype
,
6203 ((is_32bit_elf
? 27 : 19)
6204 - (int) strlen (dtype
)),
6208 switch (entry
->d_tag
)
6212 print_dynamic_flags (entry
->d_un
.d_val
);
6222 switch (entry
->d_tag
)
6225 printf (_("Auxiliary library"));
6229 printf (_("Filter library"));
6233 printf (_("Configuration file"));
6237 printf (_("Dependency audit library"));
6241 printf (_("Audit library"));
6245 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6246 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6250 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6259 printf (_("Flags:"));
6261 if (entry
->d_un
.d_val
== 0)
6262 printf (_(" None\n"));
6265 unsigned long int val
= entry
->d_un
.d_val
;
6267 if (val
& DTF_1_PARINIT
)
6269 printf (" PARINIT");
6270 val
^= DTF_1_PARINIT
;
6272 if (val
& DTF_1_CONFEXP
)
6274 printf (" CONFEXP");
6275 val
^= DTF_1_CONFEXP
;
6278 printf (" %lx", val
);
6287 printf (_("Flags:"));
6289 if (entry
->d_un
.d_val
== 0)
6290 printf (_(" None\n"));
6293 unsigned long int val
= entry
->d_un
.d_val
;
6295 if (val
& DF_P1_LAZYLOAD
)
6297 printf (" LAZYLOAD");
6298 val
^= DF_P1_LAZYLOAD
;
6300 if (val
& DF_P1_GROUPPERM
)
6302 printf (" GROUPPERM");
6303 val
^= DF_P1_GROUPPERM
;
6306 printf (" %lx", val
);
6315 printf (_("Flags:"));
6316 if (entry
->d_un
.d_val
== 0)
6317 printf (_(" None\n"));
6320 unsigned long int val
= entry
->d_un
.d_val
;
6327 if (val
& DF_1_GLOBAL
)
6332 if (val
& DF_1_GROUP
)
6337 if (val
& DF_1_NODELETE
)
6339 printf (" NODELETE");
6340 val
^= DF_1_NODELETE
;
6342 if (val
& DF_1_LOADFLTR
)
6344 printf (" LOADFLTR");
6345 val
^= DF_1_LOADFLTR
;
6347 if (val
& DF_1_INITFIRST
)
6349 printf (" INITFIRST");
6350 val
^= DF_1_INITFIRST
;
6352 if (val
& DF_1_NOOPEN
)
6357 if (val
& DF_1_ORIGIN
)
6362 if (val
& DF_1_DIRECT
)
6367 if (val
& DF_1_TRANS
)
6372 if (val
& DF_1_INTERPOSE
)
6374 printf (" INTERPOSE");
6375 val
^= DF_1_INTERPOSE
;
6377 if (val
& DF_1_NODEFLIB
)
6379 printf (" NODEFLIB");
6380 val
^= DF_1_NODEFLIB
;
6382 if (val
& DF_1_NODUMP
)
6387 if (val
& DF_1_CONLFAT
)
6389 printf (" CONLFAT");
6390 val
^= DF_1_CONLFAT
;
6393 printf (" %lx", val
);
6400 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6402 puts (get_dynamic_type (entry
->d_un
.d_val
));
6422 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6428 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6429 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6435 switch (entry
->d_tag
)
6438 printf (_("Shared library: [%s]"), name
);
6440 if (streq (name
, program_interpreter
))
6441 printf (_(" program interpreter"));
6445 printf (_("Library soname: [%s]"), name
);
6449 printf (_("Library rpath: [%s]"), name
);
6453 printf (_("Library runpath: [%s]"), name
);
6457 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6462 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6475 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6479 case DT_INIT_ARRAYSZ
:
6480 case DT_FINI_ARRAYSZ
:
6481 case DT_GNU_CONFLICTSZ
:
6482 case DT_GNU_LIBLISTSZ
:
6485 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6486 printf (" (bytes)\n");
6496 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6509 if (entry
->d_tag
== DT_USED
6510 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6512 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6516 printf (_("Not needed object: [%s]\n"), name
);
6521 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6527 /* The value of this entry is ignored. */
6532 case DT_GNU_PRELINKED
:
6536 time_t time
= entry
->d_un
.d_val
;
6538 tmp
= gmtime (&time
);
6539 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6540 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6541 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6547 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6550 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6556 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6557 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6562 switch (elf_header
.e_machine
)
6565 case EM_MIPS_RS3_LE
:
6566 dynamic_section_mips_val (entry
);
6569 dynamic_section_parisc_val (entry
);
6572 dynamic_section_ia64_val (entry
);
6575 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6587 get_ver_flags (unsigned int flags
)
6589 static char buff
[32];
6596 if (flags
& VER_FLG_BASE
)
6597 strcat (buff
, "BASE ");
6599 if (flags
& VER_FLG_WEAK
)
6601 if (flags
& VER_FLG_BASE
)
6602 strcat (buff
, "| ");
6604 strcat (buff
, "WEAK ");
6607 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6608 strcat (buff
, "| <unknown>");
6613 /* Display the contents of the version sections. */
6615 process_version_sections (FILE *file
)
6617 Elf_Internal_Shdr
*section
;
6624 for (i
= 0, section
= section_headers
;
6625 i
< elf_header
.e_shnum
;
6628 switch (section
->sh_type
)
6630 case SHT_GNU_verdef
:
6632 Elf_External_Verdef
*edefs
;
6640 (_("\nVersion definition section '%s' contains %u entries:\n"),
6641 SECTION_NAME (section
), section
->sh_info
);
6643 printf (_(" Addr: 0x"));
6644 printf_vma (section
->sh_addr
);
6645 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6646 (unsigned long) section
->sh_offset
, section
->sh_link
,
6647 section
->sh_link
< elf_header
.e_shnum
6648 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6651 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6653 _("version definition section"));
6654 endbuf
= (char *) edefs
+ section
->sh_size
;
6658 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6661 Elf_External_Verdef
*edef
;
6662 Elf_Internal_Verdef ent
;
6663 Elf_External_Verdaux
*eaux
;
6664 Elf_Internal_Verdaux aux
;
6668 vstart
= ((char *) edefs
) + idx
;
6669 if (vstart
+ sizeof (*edef
) > endbuf
)
6672 edef
= (Elf_External_Verdef
*) vstart
;
6674 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6675 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6676 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6677 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6678 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6679 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6680 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6682 printf (_(" %#06x: Rev: %d Flags: %s"),
6683 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6685 printf (_(" Index: %d Cnt: %d "),
6686 ent
.vd_ndx
, ent
.vd_cnt
);
6688 vstart
+= ent
.vd_aux
;
6690 eaux
= (Elf_External_Verdaux
*) vstart
;
6692 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6693 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6695 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6696 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6698 printf (_("Name index: %ld\n"), aux
.vda_name
);
6700 isum
= idx
+ ent
.vd_aux
;
6702 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6704 isum
+= aux
.vda_next
;
6705 vstart
+= aux
.vda_next
;
6707 eaux
= (Elf_External_Verdaux
*) vstart
;
6708 if (vstart
+ sizeof (*eaux
) > endbuf
)
6711 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6712 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6714 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6715 printf (_(" %#06x: Parent %d: %s\n"),
6716 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6718 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6719 isum
, j
, aux
.vda_name
);
6722 printf (_(" Version def aux past end of section\n"));
6726 if (cnt
< section
->sh_info
)
6727 printf (_(" Version definition past end of section\n"));
6733 case SHT_GNU_verneed
:
6735 Elf_External_Verneed
*eneed
;
6742 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6743 SECTION_NAME (section
), section
->sh_info
);
6745 printf (_(" Addr: 0x"));
6746 printf_vma (section
->sh_addr
);
6747 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6748 (unsigned long) section
->sh_offset
, section
->sh_link
,
6749 section
->sh_link
< elf_header
.e_shnum
6750 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6753 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6755 _("version need section"));
6756 endbuf
= (char *) eneed
+ section
->sh_size
;
6760 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6762 Elf_External_Verneed
*entry
;
6763 Elf_Internal_Verneed ent
;
6768 vstart
= ((char *) eneed
) + idx
;
6769 if (vstart
+ sizeof (*entry
) > endbuf
)
6772 entry
= (Elf_External_Verneed
*) vstart
;
6774 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6775 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6776 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6777 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6778 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6780 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6782 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6783 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6785 printf (_(" File: %lx"), ent
.vn_file
);
6787 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6789 vstart
+= ent
.vn_aux
;
6791 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6793 Elf_External_Vernaux
*eaux
;
6794 Elf_Internal_Vernaux aux
;
6796 if (vstart
+ sizeof (*eaux
) > endbuf
)
6798 eaux
= (Elf_External_Vernaux
*) vstart
;
6800 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6801 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6802 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6803 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6804 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6806 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6807 printf (_(" %#06x: Name: %s"),
6808 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6810 printf (_(" %#06x: Name index: %lx"),
6811 isum
, aux
.vna_name
);
6813 printf (_(" Flags: %s Version: %d\n"),
6814 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6816 isum
+= aux
.vna_next
;
6817 vstart
+= aux
.vna_next
;
6820 printf (_(" Version need aux past end of section\n"));
6824 if (cnt
< section
->sh_info
)
6825 printf (_(" Version need past end of section\n"));
6831 case SHT_GNU_versym
:
6833 Elf_Internal_Shdr
*link_section
;
6836 unsigned char *edata
;
6837 unsigned short *data
;
6839 Elf_Internal_Sym
*symbols
;
6840 Elf_Internal_Shdr
*string_sec
;
6843 if (section
->sh_link
>= elf_header
.e_shnum
)
6846 link_section
= section_headers
+ section
->sh_link
;
6847 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6849 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6854 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6856 string_sec
= section_headers
+ link_section
->sh_link
;
6858 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6859 string_sec
->sh_size
, _("version string table"));
6863 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6864 SECTION_NAME (section
), total
);
6866 printf (_(" Addr: "));
6867 printf_vma (section
->sh_addr
);
6868 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6869 (unsigned long) section
->sh_offset
, section
->sh_link
,
6870 SECTION_NAME (link_section
));
6872 off
= offset_from_vma (file
,
6873 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6874 total
* sizeof (short));
6875 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6876 _("version symbol data"));
6883 data
= cmalloc (total
, sizeof (short));
6885 for (cnt
= total
; cnt
--;)
6886 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6891 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6894 int check_def
, check_need
;
6897 printf (" %03x:", cnt
);
6899 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6900 switch (data
[cnt
+ j
])
6903 fputs (_(" 0 (*local*) "), stdout
);
6907 fputs (_(" 1 (*global*) "), stdout
);
6911 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6912 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6916 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6917 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6920 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6927 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6929 Elf_Internal_Verneed ivn
;
6930 unsigned long offset
;
6932 offset
= offset_from_vma
6933 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6934 sizeof (Elf_External_Verneed
));
6938 Elf_Internal_Vernaux ivna
;
6939 Elf_External_Verneed evn
;
6940 Elf_External_Vernaux evna
;
6941 unsigned long a_off
;
6943 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6946 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6947 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6949 a_off
= offset
+ ivn
.vn_aux
;
6953 get_data (&evna
, file
, a_off
, sizeof (evna
),
6954 1, _("version need aux (2)"));
6956 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6957 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6959 a_off
+= ivna
.vna_next
;
6961 while (ivna
.vna_other
!= data
[cnt
+ j
]
6962 && ivna
.vna_next
!= 0);
6964 if (ivna
.vna_other
== data
[cnt
+ j
])
6966 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6968 if (ivna
.vna_name
>= string_sec
->sh_size
)
6969 name
= _("*invalid*");
6971 name
= strtab
+ ivna
.vna_name
;
6972 nn
+= printf ("(%s%-*s",
6974 12 - (int) strlen (name
),
6980 offset
+= ivn
.vn_next
;
6982 while (ivn
.vn_next
);
6985 if (check_def
&& data
[cnt
+ j
] != 0x8001
6986 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6988 Elf_Internal_Verdef ivd
;
6989 Elf_External_Verdef evd
;
6990 unsigned long offset
;
6992 offset
= offset_from_vma
6993 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6998 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
7001 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7002 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7004 offset
+= ivd
.vd_next
;
7006 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
7007 && ivd
.vd_next
!= 0);
7009 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
7011 Elf_External_Verdaux evda
;
7012 Elf_Internal_Verdaux ivda
;
7014 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7016 get_data (&evda
, file
,
7017 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7019 _("version def aux"));
7021 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7023 if (ivda
.vda_name
>= string_sec
->sh_size
)
7024 name
= _("*invalid*");
7026 name
= strtab
+ ivda
.vda_name
;
7027 nn
+= printf ("(%s%-*s",
7029 12 - (int) strlen (name
),
7035 printf ("%*c", 18 - nn
, ' ');
7053 printf (_("\nNo version information found in this file.\n"));
7059 get_symbol_binding (unsigned int binding
)
7061 static char buff
[32];
7065 case STB_LOCAL
: return "LOCAL";
7066 case STB_GLOBAL
: return "GLOBAL";
7067 case STB_WEAK
: return "WEAK";
7069 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7070 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7072 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7073 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7075 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7081 get_symbol_type (unsigned int type
)
7083 static char buff
[32];
7087 case STT_NOTYPE
: return "NOTYPE";
7088 case STT_OBJECT
: return "OBJECT";
7089 case STT_FUNC
: return "FUNC";
7090 case STT_SECTION
: return "SECTION";
7091 case STT_FILE
: return "FILE";
7092 case STT_COMMON
: return "COMMON";
7093 case STT_TLS
: return "TLS";
7094 case STT_RELC
: return "RELC";
7095 case STT_SRELC
: return "SRELC";
7097 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7099 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7100 return "THUMB_FUNC";
7102 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7105 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7106 return "PARISC_MILLI";
7108 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7110 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7112 if (elf_header
.e_machine
== EM_PARISC
)
7114 if (type
== STT_HP_OPAQUE
)
7116 if (type
== STT_HP_STUB
)
7120 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7123 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7129 get_symbol_visibility (unsigned int visibility
)
7133 case STV_DEFAULT
: return "DEFAULT";
7134 case STV_INTERNAL
: return "INTERNAL";
7135 case STV_HIDDEN
: return "HIDDEN";
7136 case STV_PROTECTED
: return "PROTECTED";
7142 get_mips_symbol_other (unsigned int other
)
7146 case STO_OPTIONAL
: return "OPTIONAL";
7147 case STO_MIPS16
: return "MIPS16";
7148 default: return NULL
;
7153 get_symbol_other (unsigned int other
)
7155 const char * result
= NULL
;
7156 static char buff
[32];
7161 switch (elf_header
.e_machine
)
7164 result
= get_mips_symbol_other (other
);
7172 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7177 get_symbol_index_type (unsigned int type
)
7179 static char buff
[32];
7183 case SHN_UNDEF
: return "UND";
7184 case SHN_ABS
: return "ABS";
7185 case SHN_COMMON
: return "COM";
7187 if (type
== SHN_IA_64_ANSI_COMMON
7188 && elf_header
.e_machine
== EM_IA_64
7189 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7191 else if (elf_header
.e_machine
== EM_X86_64
7192 && type
== SHN_X86_64_LCOMMON
)
7194 else if (type
== SHN_MIPS_SCOMMON
7195 && elf_header
.e_machine
== EM_MIPS
)
7197 else if (type
== SHN_MIPS_SUNDEFINED
7198 && elf_header
.e_machine
== EM_MIPS
)
7200 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7201 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7202 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7203 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7204 else if (type
>= SHN_LORESERVE
)
7205 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7207 sprintf (buff
, "%3d", type
);
7215 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7217 unsigned char *e_data
;
7220 e_data
= cmalloc (number
, ent_size
);
7224 error (_("Out of memory\n"));
7228 if (fread (e_data
, ent_size
, number
, file
) != number
)
7230 error (_("Unable to read in dynamic data\n"));
7234 i_data
= cmalloc (number
, sizeof (*i_data
));
7238 error (_("Out of memory\n"));
7244 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7252 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7254 Elf_Internal_Sym
*psym
;
7257 psym
= dynamic_symbols
+ si
;
7259 n
= print_vma (si
, DEC_5
);
7261 fputs (" " + n
, stdout
);
7262 printf (" %3lu: ", hn
);
7263 print_vma (psym
->st_value
, LONG_HEX
);
7265 print_vma (psym
->st_size
, DEC_5
);
7267 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7268 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7269 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7270 /* Check to see if any other bits in the st_other field are set.
7271 Note - displaying this information disrupts the layout of the
7272 table being generated, but for the moment this case is very
7274 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7275 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7276 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7277 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7278 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7280 printf (" <corrupt: %14ld>", psym
->st_name
);
7284 /* Dump the symbol table. */
7286 process_symbol_table (FILE *file
)
7288 Elf_Internal_Shdr
*section
;
7289 bfd_vma nbuckets
= 0;
7290 bfd_vma nchains
= 0;
7291 bfd_vma
*buckets
= NULL
;
7292 bfd_vma
*chains
= NULL
;
7293 bfd_vma ngnubuckets
= 0;
7294 bfd_vma
*gnubuckets
= NULL
;
7295 bfd_vma
*gnuchains
= NULL
;
7296 bfd_vma gnusymidx
= 0;
7298 if (! do_syms
&& !do_histogram
)
7301 if (dynamic_info
[DT_HASH
]
7303 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7305 unsigned char nb
[8];
7306 unsigned char nc
[8];
7307 int hash_ent_size
= 4;
7309 if ((elf_header
.e_machine
== EM_ALPHA
7310 || elf_header
.e_machine
== EM_S390
7311 || elf_header
.e_machine
== EM_S390_OLD
)
7312 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7316 (archive_file_offset
7317 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7318 sizeof nb
+ sizeof nc
)),
7321 error (_("Unable to seek to start of dynamic information\n"));
7325 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7327 error (_("Failed to read in number of buckets\n"));
7331 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7333 error (_("Failed to read in number of chains\n"));
7337 nbuckets
= byte_get (nb
, hash_ent_size
);
7338 nchains
= byte_get (nc
, hash_ent_size
);
7340 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7341 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7343 if (buckets
== NULL
|| chains
== NULL
)
7347 if (dynamic_info_DT_GNU_HASH
7349 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7351 unsigned char nb
[16];
7352 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7353 bfd_vma buckets_vma
;
7356 (archive_file_offset
7357 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7361 error (_("Unable to seek to start of dynamic information\n"));
7365 if (fread (nb
, 16, 1, file
) != 1)
7367 error (_("Failed to read in number of buckets\n"));
7371 ngnubuckets
= byte_get (nb
, 4);
7372 gnusymidx
= byte_get (nb
+ 4, 4);
7373 bitmaskwords
= byte_get (nb
+ 8, 4);
7374 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7376 buckets_vma
+= bitmaskwords
* 4;
7378 buckets_vma
+= bitmaskwords
* 8;
7381 (archive_file_offset
7382 + offset_from_vma (file
, buckets_vma
, 4)),
7385 error (_("Unable to seek to start of dynamic information\n"));
7389 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7391 if (gnubuckets
== NULL
)
7394 for (i
= 0; i
< ngnubuckets
; i
++)
7395 if (gnubuckets
[i
] != 0)
7397 if (gnubuckets
[i
] < gnusymidx
)
7400 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7401 maxchain
= gnubuckets
[i
];
7404 if (maxchain
== 0xffffffff)
7407 maxchain
-= gnusymidx
;
7410 (archive_file_offset
7411 + offset_from_vma (file
, buckets_vma
7412 + 4 * (ngnubuckets
+ maxchain
), 4)),
7415 error (_("Unable to seek to start of dynamic information\n"));
7421 if (fread (nb
, 4, 1, file
) != 1)
7423 error (_("Failed to determine last chain length\n"));
7427 if (maxchain
+ 1 == 0)
7432 while ((byte_get (nb
, 4) & 1) == 0);
7435 (archive_file_offset
7436 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7439 error (_("Unable to seek to start of dynamic information\n"));
7443 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7445 if (gnuchains
== NULL
)
7449 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7452 && dynamic_strings
!= NULL
)
7456 if (dynamic_info
[DT_HASH
])
7460 printf (_("\nSymbol table for image:\n"));
7462 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7464 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7466 for (hn
= 0; hn
< nbuckets
; hn
++)
7471 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7472 print_dynamic_symbol (si
, hn
);
7476 if (dynamic_info_DT_GNU_HASH
)
7478 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7480 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7482 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7484 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7485 if (gnubuckets
[hn
] != 0)
7487 bfd_vma si
= gnubuckets
[hn
];
7488 bfd_vma off
= si
- gnusymidx
;
7492 print_dynamic_symbol (si
, hn
);
7495 while ((gnuchains
[off
++] & 1) == 0);
7499 else if (do_syms
&& !do_using_dynamic
)
7503 for (i
= 0, section
= section_headers
;
7504 i
< elf_header
.e_shnum
;
7508 char *strtab
= NULL
;
7509 unsigned long int strtab_size
= 0;
7510 Elf_Internal_Sym
*symtab
;
7511 Elf_Internal_Sym
*psym
;
7514 if ( section
->sh_type
!= SHT_SYMTAB
7515 && section
->sh_type
!= SHT_DYNSYM
)
7518 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7519 SECTION_NAME (section
),
7520 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7522 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7524 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7526 symtab
= GET_ELF_SYMBOLS (file
, section
);
7530 if (section
->sh_link
== elf_header
.e_shstrndx
)
7532 strtab
= string_table
;
7533 strtab_size
= string_table_length
;
7535 else if (section
->sh_link
< elf_header
.e_shnum
)
7537 Elf_Internal_Shdr
*string_sec
;
7539 string_sec
= section_headers
+ section
->sh_link
;
7541 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7542 1, string_sec
->sh_size
, _("string table"));
7543 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7546 for (si
= 0, psym
= symtab
;
7547 si
< section
->sh_size
/ section
->sh_entsize
;
7550 printf ("%6d: ", si
);
7551 print_vma (psym
->st_value
, LONG_HEX
);
7553 print_vma (psym
->st_size
, DEC_5
);
7554 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7555 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7556 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7557 /* Check to see if any other bits in the st_other field are set.
7558 Note - displaying this information disrupts the layout of the
7559 table being generated, but for the moment this case is very rare. */
7560 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7561 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7562 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7563 print_symbol (25, psym
->st_name
< strtab_size
7564 ? strtab
+ psym
->st_name
: "<corrupt>");
7566 if (section
->sh_type
== SHT_DYNSYM
&&
7567 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7569 unsigned char data
[2];
7570 unsigned short vers_data
;
7571 unsigned long offset
;
7575 offset
= offset_from_vma
7576 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7577 sizeof data
+ si
* sizeof (vers_data
));
7579 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7580 sizeof (data
), 1, _("version data"));
7582 vers_data
= byte_get (data
, 2);
7584 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7585 && section_headers
[psym
->st_shndx
].sh_type
7588 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7590 if ((vers_data
& 0x8000) || vers_data
> 1)
7592 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7593 && (is_nobits
|| ! check_def
))
7595 Elf_External_Verneed evn
;
7596 Elf_Internal_Verneed ivn
;
7597 Elf_Internal_Vernaux ivna
;
7599 /* We must test both. */
7600 offset
= offset_from_vma
7601 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7606 unsigned long vna_off
;
7608 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7611 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7612 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7614 vna_off
= offset
+ ivn
.vn_aux
;
7618 Elf_External_Vernaux evna
;
7620 get_data (&evna
, file
, vna_off
,
7622 _("version need aux (3)"));
7624 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7625 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7626 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7628 vna_off
+= ivna
.vna_next
;
7630 while (ivna
.vna_other
!= vers_data
7631 && ivna
.vna_next
!= 0);
7633 if (ivna
.vna_other
== vers_data
)
7636 offset
+= ivn
.vn_next
;
7638 while (ivn
.vn_next
!= 0);
7640 if (ivna
.vna_other
== vers_data
)
7643 ivna
.vna_name
< strtab_size
7644 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7648 else if (! is_nobits
)
7649 error (_("bad dynamic symbol\n"));
7656 if (vers_data
!= 0x8001
7657 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7659 Elf_Internal_Verdef ivd
;
7660 Elf_Internal_Verdaux ivda
;
7661 Elf_External_Verdaux evda
;
7662 unsigned long offset
;
7664 offset
= offset_from_vma
7666 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7667 sizeof (Elf_External_Verdef
));
7671 Elf_External_Verdef evd
;
7673 get_data (&evd
, file
, offset
, sizeof (evd
),
7674 1, _("version def"));
7676 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7677 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7678 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7680 offset
+= ivd
.vd_next
;
7682 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7683 && ivd
.vd_next
!= 0);
7685 offset
-= ivd
.vd_next
;
7686 offset
+= ivd
.vd_aux
;
7688 get_data (&evda
, file
, offset
, sizeof (evda
),
7689 1, _("version def aux"));
7691 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7693 if (psym
->st_name
!= ivda
.vda_name
)
7694 printf ((vers_data
& 0x8000)
7696 ivda
.vda_name
< strtab_size
7697 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7707 if (strtab
!= string_table
)
7713 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7715 if (do_histogram
&& buckets
!= NULL
)
7717 unsigned long *lengths
;
7718 unsigned long *counts
;
7721 unsigned long maxlength
= 0;
7722 unsigned long nzero_counts
= 0;
7723 unsigned long nsyms
= 0;
7725 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7726 (unsigned long) nbuckets
);
7727 printf (_(" Length Number %% of total Coverage\n"));
7729 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7730 if (lengths
== NULL
)
7732 error (_("Out of memory\n"));
7735 for (hn
= 0; hn
< nbuckets
; ++hn
)
7737 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7740 if (maxlength
< ++lengths
[hn
])
7745 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7748 error (_("Out of memory\n"));
7752 for (hn
= 0; hn
< nbuckets
; ++hn
)
7753 ++counts
[lengths
[hn
]];
7758 printf (" 0 %-10lu (%5.1f%%)\n",
7759 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7760 for (i
= 1; i
<= maxlength
; ++i
)
7762 nzero_counts
+= counts
[i
] * i
;
7763 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7764 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7765 (nzero_counts
* 100.0) / nsyms
);
7773 if (buckets
!= NULL
)
7779 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7781 unsigned long *lengths
;
7782 unsigned long *counts
;
7784 unsigned long maxlength
= 0;
7785 unsigned long nzero_counts
= 0;
7786 unsigned long nsyms
= 0;
7788 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7789 if (lengths
== NULL
)
7791 error (_("Out of memory\n"));
7795 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7796 (unsigned long) ngnubuckets
);
7797 printf (_(" Length Number %% of total Coverage\n"));
7799 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7800 if (gnubuckets
[hn
] != 0)
7802 bfd_vma off
, length
= 1;
7804 for (off
= gnubuckets
[hn
] - gnusymidx
;
7805 (gnuchains
[off
] & 1) == 0; ++off
)
7807 lengths
[hn
] = length
;
7808 if (length
> maxlength
)
7813 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7816 error (_("Out of memory\n"));
7820 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7821 ++counts
[lengths
[hn
]];
7823 if (ngnubuckets
> 0)
7826 printf (" 0 %-10lu (%5.1f%%)\n",
7827 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7828 for (j
= 1; j
<= maxlength
; ++j
)
7830 nzero_counts
+= counts
[j
] * j
;
7831 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7832 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7833 (nzero_counts
* 100.0) / nsyms
);
7847 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7851 if (dynamic_syminfo
== NULL
7853 /* No syminfo, this is ok. */
7856 /* There better should be a dynamic symbol section. */
7857 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7861 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7862 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7864 printf (_(" Num: Name BoundTo Flags\n"));
7865 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7867 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7869 printf ("%4d: ", i
);
7870 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7871 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7873 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7876 switch (dynamic_syminfo
[i
].si_boundto
)
7878 case SYMINFO_BT_SELF
:
7879 fputs ("SELF ", stdout
);
7881 case SYMINFO_BT_PARENT
:
7882 fputs ("PARENT ", stdout
);
7885 if (dynamic_syminfo
[i
].si_boundto
> 0
7886 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7887 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7889 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7893 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7897 if (flags
& SYMINFO_FLG_DIRECT
)
7899 if (flags
& SYMINFO_FLG_PASSTHRU
)
7900 printf (" PASSTHRU");
7901 if (flags
& SYMINFO_FLG_COPY
)
7903 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7904 printf (" LAZYLOAD");
7912 #ifdef SUPPORT_DISASSEMBLY
7914 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7916 printf (_("\nAssembly dump of section %s\n"),
7917 SECTION_NAME (section
));
7919 /* XXX -- to be done --- XXX */
7926 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7928 Elf_Internal_Shdr
*relsec
;
7929 bfd_size_type num_bytes
;
7934 char *name
= SECTION_NAME (section
);
7935 bfd_boolean some_strings_shown
;
7937 num_bytes
= section
->sh_size
;
7939 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7941 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7945 addr
= section
->sh_addr
;
7947 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7952 printf (_("\nString dump of section '%s':\n"), name
);
7954 /* If the section being dumped has relocations against it the user might
7955 be expecting these relocations to have been applied. Check for this
7956 case and issue a warning message in order to avoid confusion.
7957 FIXME: Maybe we ought to have an option that dumps a section with
7959 for (relsec
= section_headers
;
7960 relsec
< section_headers
+ elf_header
.e_shnum
;
7963 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7964 || relsec
->sh_info
>= elf_header
.e_shnum
7965 || section_headers
+ relsec
->sh_info
!= section
7966 || relsec
->sh_size
== 0
7967 || relsec
->sh_link
>= elf_header
.e_shnum
)
7970 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7975 end
= start
+ num_bytes
;
7976 some_strings_shown
= FALSE
;
7980 while (!ISPRINT (* data
))
7987 printf (" [%6tx] %s\n", data
- start
, data
);
7989 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7991 data
+= strlen (data
);
7992 some_strings_shown
= TRUE
;
7996 if (! some_strings_shown
)
7997 printf (_(" No strings found in this section."));
8007 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
8009 Elf_Internal_Shdr
*relsec
;
8010 bfd_size_type bytes
;
8012 unsigned char *data
;
8013 unsigned char *start
;
8015 bytes
= section
->sh_size
;
8017 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8019 printf (_("\nSection '%s' has no data to dump.\n"),
8020 SECTION_NAME (section
));
8024 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8026 addr
= section
->sh_addr
;
8028 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
8033 /* If the section being dumped has relocations against it the user might
8034 be expecting these relocations to have been applied. Check for this
8035 case and issue a warning message in order to avoid confusion.
8036 FIXME: Maybe we ought to have an option that dumps a section with
8038 for (relsec
= section_headers
;
8039 relsec
< section_headers
+ elf_header
.e_shnum
;
8042 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8043 || relsec
->sh_info
>= elf_header
.e_shnum
8044 || section_headers
+ relsec
->sh_info
!= section
8045 || relsec
->sh_size
== 0
8046 || relsec
->sh_link
>= elf_header
.e_shnum
)
8049 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8061 lbytes
= (bytes
> 16 ? 16 : bytes
);
8063 printf (" 0x%8.8lx ", (unsigned long) addr
);
8065 for (j
= 0; j
< 16; j
++)
8068 printf ("%2.2x", data
[j
]);
8076 for (j
= 0; j
< lbytes
; j
++)
8079 if (k
>= ' ' && k
< 0x7f)
8098 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8099 DWARF debug sections. This is a target specific test. Note - we do not
8100 go through the whole including-target-headers-multiple-times route, (as
8101 we have already done with <elf/h8.h>) because this would become very
8102 messy and even then this function would have to contain target specific
8103 information (the names of the relocs instead of their numeric values).
8104 FIXME: This is not the correct way to solve this problem. The proper way
8105 is to have target specific reloc sizing and typing functions created by
8106 the reloc-macros.h header, in the same way that it already creates the
8107 reloc naming functions. */
8110 is_32bit_abs_reloc (unsigned int reloc_type
)
8112 switch (elf_header
.e_machine
)
8116 return reloc_type
== 1; /* R_386_32. */
8118 return reloc_type
== 1; /* R_68K_32. */
8120 return reloc_type
== 1; /* R_860_32. */
8122 return reloc_type
== 1; /* XXX Is this right ? */
8124 return reloc_type
== 1; /* R_ARC_32. */
8126 return reloc_type
== 2; /* R_ARM_ABS32 */
8129 return reloc_type
== 1;
8131 return reloc_type
== 0x12; /* R_byte4_data. */
8133 return reloc_type
== 3; /* R_CRIS_32. */
8136 return reloc_type
== 3; /* R_CR16_NUM32. */
8138 return reloc_type
== 15; /* R_CRX_NUM32. */
8140 return reloc_type
== 1;
8141 case EM_CYGNUS_D10V
:
8143 return reloc_type
== 6; /* R_D10V_32. */
8144 case EM_CYGNUS_D30V
:
8146 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8148 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8149 case EM_CYGNUS_FR30
:
8151 return reloc_type
== 3; /* R_FR30_32. */
8155 return reloc_type
== 1; /* R_H8_DIR32. */
8157 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8160 return reloc_type
== 2; /* R_IP2K_32. */
8162 return reloc_type
== 2; /* R_IQ2000_32. */
8165 return reloc_type
== 3; /* R_M32C_32. */
8167 return reloc_type
== 34; /* R_M32R_32_RELA. */
8169 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8171 return reloc_type
== 4; /* R_MEP_32. */
8173 return reloc_type
== 2; /* R_MIPS_32. */
8175 return reloc_type
== 4; /* R_MMIX_32. */
8176 case EM_CYGNUS_MN10200
:
8178 return reloc_type
== 1; /* R_MN10200_32. */
8179 case EM_CYGNUS_MN10300
:
8181 return reloc_type
== 1; /* R_MN10300_32. */
8184 return reloc_type
== 1; /* R_MSP43_32. */
8186 return reloc_type
== 2; /* R_MT_32. */
8187 case EM_ALTERA_NIOS2
:
8189 return reloc_type
== 1; /* R_NIOS_32. */
8192 return reloc_type
== 1; /* R_OR32_32. */
8194 return reloc_type
== 1; /* R_PARISC_DIR32. */
8197 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8199 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8201 return reloc_type
== 1; /* R_PPC_ADDR32. */
8203 return reloc_type
== 1; /* R_I370_ADDR31. */
8206 return reloc_type
== 4; /* R_S390_32. */
8208 return reloc_type
== 8; /* R_SCORE_ABS32. */
8210 return reloc_type
== 1; /* R_SH_DIR32. */
8211 case EM_SPARC32PLUS
:
8214 return reloc_type
== 3 /* R_SPARC_32. */
8215 || reloc_type
== 23; /* R_SPARC_UA32. */
8217 return reloc_type
== 6; /* R_SPU_ADDR32 */
8218 case EM_CYGNUS_V850
:
8220 return reloc_type
== 6; /* R_V850_ABS32. */
8222 return reloc_type
== 1; /* R_VAX_32. */
8224 return reloc_type
== 10; /* R_X86_64_32. */
8226 return reloc_type
== 1; /* R_XSTROMY16_32. */
8229 return reloc_type
== 1; /* R_XTENSA_32. */
8232 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8233 elf_header
.e_machine
);
8238 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8239 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8242 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8244 switch (elf_header
.e_machine
)
8248 return reloc_type
== 2; /* R_386_PC32. */
8250 return reloc_type
== 4; /* R_68K_PC32. */
8252 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8254 return reloc_type
== 3; /* R_ARM_REL32 */
8256 return reloc_type
== 0; /* R_PARISC_NONE. *//* FIXME: This reloc is generated, but it may be a bug. */
8258 return reloc_type
== 26; /* R_PPC_REL32. */
8260 return reloc_type
== 26; /* R_PPC64_REL32. */
8263 return reloc_type
== 5; /* R_390_PC32. */
8265 return reloc_type
== 2; /* R_SH_REL32. */
8266 case EM_SPARC32PLUS
:
8269 return reloc_type
== 6; /* R_SPARC_DISP32. */
8271 return reloc_type
== 13; /* R_SPU_REL32. */
8273 return reloc_type
== 2; /* R_X86_64_PC32. */
8276 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8278 /* Do not abort or issue an error message here. Not all targets use
8279 pc-relative 32-bit relocs in their DWARF debug information and we
8280 have already tested for target coverage in is_32bit_abs_reloc. A
8281 more helpful warning message will be generated by
8282 debug_apply_relocations anyway, so just return. */
8287 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8288 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8291 is_64bit_abs_reloc (unsigned int reloc_type
)
8293 switch (elf_header
.e_machine
)
8296 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8298 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8300 return reloc_type
== 80; /* R_PARISC_DIR64. */
8302 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8303 case EM_SPARC32PLUS
:
8306 return reloc_type
== 54; /* R_SPARC_UA64. */
8308 return reloc_type
== 1; /* R_X86_64_64. */
8311 return reloc_type
== 22; /* R_S390_64 */
8317 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8318 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8321 is_16bit_abs_reloc (unsigned int reloc_type
)
8323 switch (elf_header
.e_machine
)
8327 return reloc_type
== 4; /* R_AVR_16. */
8328 case EM_CYGNUS_D10V
:
8330 return reloc_type
== 3; /* R_D10V_16. */
8334 return reloc_type
== R_H8_DIR16
;
8337 return reloc_type
== 1; /* R_IP2K_16. */
8340 return reloc_type
== 1; /* R_M32C_16 */
8343 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8344 case EM_ALTERA_NIOS2
:
8346 return reloc_type
== 9; /* R_NIOS_16. */
8352 /* Apply relocations to a debug section. */
8355 debug_apply_relocations (void *file
,
8356 Elf_Internal_Shdr
*section
,
8357 unsigned char *start
)
8359 Elf_Internal_Shdr
*relsec
;
8360 unsigned char *end
= start
+ section
->sh_size
;
8362 if (elf_header
.e_type
!= ET_REL
)
8365 /* Find the reloc section associated with the debug section. */
8366 for (relsec
= section_headers
;
8367 relsec
< section_headers
+ elf_header
.e_shnum
;
8370 bfd_boolean is_rela
;
8371 unsigned long num_relocs
;
8372 Elf_Internal_Rela
*relocs
, *rp
;
8373 Elf_Internal_Shdr
*symsec
;
8374 Elf_Internal_Sym
*symtab
;
8375 Elf_Internal_Sym
*sym
;
8377 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8378 || relsec
->sh_info
>= elf_header
.e_shnum
8379 || section_headers
+ relsec
->sh_info
!= section
8380 || relsec
->sh_size
== 0
8381 || relsec
->sh_link
>= elf_header
.e_shnum
)
8384 is_rela
= relsec
->sh_type
== SHT_RELA
;
8388 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8389 & relocs
, & num_relocs
))
8394 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8395 & relocs
, & num_relocs
))
8399 /* SH uses RELA but uses in place value instead of the addend field. */
8400 if (elf_header
.e_machine
== EM_SH
)
8403 symsec
= section_headers
+ relsec
->sh_link
;
8404 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8406 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8409 unsigned int reloc_type
;
8410 unsigned int reloc_size
;
8411 unsigned char * loc
;
8413 /* In MIPS little-endian objects, r_info isn't really a
8414 64-bit little-endian value: it has a 32-bit little-endian
8415 symbol index followed by four individual byte fields.
8416 Reorder INFO accordingly. */
8418 && elf_header
.e_machine
== EM_MIPS
8419 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
8420 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
8421 | ((rp
->r_info
>> 56) & 0xff)
8422 | ((rp
->r_info
>> 40) & 0xff00)
8423 | ((rp
->r_info
>> 24) & 0xff0000)
8424 | ((rp
->r_info
>> 8) & 0xff000000));
8426 reloc_type
= get_reloc_type (rp
->r_info
);
8428 if (is_32bit_abs_reloc (reloc_type
)
8429 || is_32bit_pcrel_reloc (reloc_type
))
8431 else if (is_64bit_abs_reloc (reloc_type
))
8433 else if (is_16bit_abs_reloc (reloc_type
))
8437 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8438 reloc_type
, SECTION_NAME (section
));
8442 loc
= start
+ rp
->r_offset
;
8443 if ((loc
+ reloc_size
) > end
)
8445 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8446 (unsigned long) rp
->r_offset
,
8447 SECTION_NAME (section
));
8451 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8453 /* If the reloc has a symbol associated with it,
8454 make sure that it is of an appropriate type. */
8456 && ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
8457 /* Relocations against symbols without type can happen.
8458 Gcc -feliminate-dwarf2-dups may generate symbols
8459 without type for debug info. */
8460 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8461 /* Relocations against object symbols can happen,
8462 eg when referencing a global array. For an
8463 example of this see the _clz.o binary in libgcc.a. */
8464 && ELF_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8466 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8467 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8468 (long int)(rp
- relocs
),
8469 SECTION_NAME (relsec
));
8473 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8475 if (is_32bit_pcrel_reloc (reloc_type
))
8476 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8479 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8489 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8491 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8492 Elf_Internal_Shdr
*sec
;
8495 /* If it is already loaded, do nothing. */
8496 if (section
->start
!= NULL
)
8499 /* Locate the debug section. */
8500 sec
= find_section (section
->name
);
8504 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8505 section
->address
= sec
->sh_addr
;
8506 section
->size
= sec
->sh_size
;
8507 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8510 if (debug_displays
[debug
].relocate
)
8511 debug_apply_relocations (file
, sec
, section
->start
);
8513 return section
->start
!= NULL
;
8517 free_debug_section (enum dwarf_section_display_enum debug
)
8519 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8521 if (section
->start
== NULL
)
8524 free ((char *) section
->start
);
8525 section
->start
= NULL
;
8526 section
->address
= 0;
8531 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8533 char *name
= SECTION_NAME (section
);
8534 bfd_size_type length
;
8536 enum dwarf_section_display_enum i
;
8538 length
= section
->sh_size
;
8541 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8545 if (const_strneq (name
, ".gnu.linkonce.wi."))
8546 name
= ".debug_info";
8548 /* See if we know how to display the contents of this section. */
8549 for (i
= 0; i
< max
; i
++)
8550 if (streq (debug_displays
[i
].section
.name
, name
))
8552 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8554 if (load_debug_section (i
, file
))
8556 result
&= debug_displays
[i
].display (sec
, file
);
8558 if (i
!= info
&& i
!= abbrev
)
8559 free_debug_section (i
);
8567 printf (_("Unrecognized debug section: %s\n"), name
);
8574 /* Set DUMP_SECTS for all sections where dumps were requested
8575 based on section name. */
8578 initialise_dumps_byname (void)
8580 struct dump_list_entry
*cur
;
8582 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8587 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8588 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8590 request_dump_bynumber (i
, cur
->type
);
8595 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8601 process_section_contents (FILE *file
)
8603 Elf_Internal_Shdr
*section
;
8609 initialise_dumps_byname ();
8611 for (i
= 0, section
= section_headers
;
8612 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8615 #ifdef SUPPORT_DISASSEMBLY
8616 if (dump_sects
[i
] & DISASS_DUMP
)
8617 disassemble_section (section
, file
);
8619 if (dump_sects
[i
] & HEX_DUMP
)
8620 dump_section_as_bytes (section
, file
);
8622 if (dump_sects
[i
] & DEBUG_DUMP
)
8623 display_debug_section (section
, file
);
8625 if (dump_sects
[i
] & STRING_DUMP
)
8626 dump_section_as_strings (section
, file
);
8629 /* Check to see if the user requested a
8630 dump of a section that does not exist. */
8631 while (i
++ < num_dump_sects
)
8633 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8637 process_mips_fpe_exception (int mask
)
8642 if (mask
& OEX_FPU_INEX
)
8643 fputs ("INEX", stdout
), first
= 0;
8644 if (mask
& OEX_FPU_UFLO
)
8645 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8646 if (mask
& OEX_FPU_OFLO
)
8647 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8648 if (mask
& OEX_FPU_DIV0
)
8649 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8650 if (mask
& OEX_FPU_INVAL
)
8651 printf ("%sINVAL", first
? "" : "|");
8654 fputs ("0", stdout
);
8657 /* ARM EABI attributes section. */
8662 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8665 } arm_attr_public_tag
;
8667 static const char *arm_attr_tag_CPU_arch
[] =
8668 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8670 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8671 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8672 {"No", "Thumb-1", "Thumb-2"};
8673 static const char *arm_attr_tag_VFP_arch
[] =
8674 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8675 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8676 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8677 static const char *arm_attr_tag_ABI_PCS_config
[] =
8678 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8679 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8680 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8681 {"V6", "SB", "TLS", "Unused"};
8682 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8683 {"Absolute", "PC-relative", "SB-relative", "None"};
8684 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8685 {"Absolute", "PC-relative", "None"};
8686 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8687 {"None", "direct", "GOT-indirect"};
8688 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8689 {"None", "??? 1", "2", "??? 3", "4"};
8690 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8691 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8692 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8693 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8694 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8695 {"Unused", "Finite", "RTABI", "IEEE 754"};
8696 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8697 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8698 {"No", "Yes, except leaf SP", "Yes"};
8699 static const char *arm_attr_tag_ABI_enum_size
[] =
8700 {"Unused", "small", "int", "forced to int"};
8701 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8702 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8703 static const char *arm_attr_tag_ABI_VFP_args
[] =
8704 {"AAPCS", "VFP registers", "custom"};
8705 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8706 {"AAPCS", "WMMX registers", "custom"};
8707 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8708 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8709 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8710 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8711 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8712 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8714 #define LOOKUP(id, name) \
8715 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8716 static arm_attr_public_tag arm_attr_public_tags
[] =
8718 {4, "CPU_raw_name", 1, NULL
},
8719 {5, "CPU_name", 1, NULL
},
8720 LOOKUP(6, CPU_arch
),
8721 {7, "CPU_arch_profile", 0, NULL
},
8722 LOOKUP(8, ARM_ISA_use
),
8723 LOOKUP(9, THUMB_ISA_use
),
8724 LOOKUP(10, VFP_arch
),
8725 LOOKUP(11, WMMX_arch
),
8726 LOOKUP(12, NEON_arch
),
8727 LOOKUP(13, ABI_PCS_config
),
8728 LOOKUP(14, ABI_PCS_R9_use
),
8729 LOOKUP(15, ABI_PCS_RW_data
),
8730 LOOKUP(16, ABI_PCS_RO_DATA
),
8731 LOOKUP(17, ABI_PCS_GOT_use
),
8732 LOOKUP(18, ABI_PCS_wchar_t
),
8733 LOOKUP(19, ABI_FP_rounding
),
8734 LOOKUP(20, ABI_FP_denormal
),
8735 LOOKUP(21, ABI_FP_exceptions
),
8736 LOOKUP(22, ABI_FP_user_exceptions
),
8737 LOOKUP(23, ABI_FP_number_model
),
8738 LOOKUP(24, ABI_align8_needed
),
8739 LOOKUP(25, ABI_align8_preserved
),
8740 LOOKUP(26, ABI_enum_size
),
8741 LOOKUP(27, ABI_HardFP_use
),
8742 LOOKUP(28, ABI_VFP_args
),
8743 LOOKUP(29, ABI_WMMX_args
),
8744 LOOKUP(30, ABI_optimization_goals
),
8745 LOOKUP(31, ABI_FP_optimization_goals
),
8746 {32, "compatibility", 0, NULL
}
8750 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8753 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8767 val
|= ((unsigned int)c
& 0x7f) << shift
;
8776 static unsigned char *
8777 display_arm_attribute (unsigned char *p
)
8782 arm_attr_public_tag
*attr
;
8786 tag
= read_uleb128 (p
, &len
);
8789 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8791 if (arm_attr_public_tags
[i
].tag
== tag
)
8793 attr
= &arm_attr_public_tags
[i
];
8800 printf (" Tag_%s: ", attr
->name
);
8806 case 7: /* Tag_CPU_arch_profile. */
8807 val
= read_uleb128 (p
, &len
);
8811 case 0: printf ("None\n"); break;
8812 case 'A': printf ("Application\n"); break;
8813 case 'R': printf ("Realtime\n"); break;
8814 case 'M': printf ("Microcontroller\n"); break;
8815 default: printf ("??? (%d)\n", val
); break;
8819 case 32: /* Tag_compatibility. */
8820 val
= read_uleb128 (p
, &len
);
8822 printf ("flag = %d, vendor = %s\n", val
, p
);
8823 p
+= strlen((char *)p
) + 1;
8837 assert (attr
->type
& 0x80);
8838 val
= read_uleb128 (p
, &len
);
8840 type
= attr
->type
& 0x7f;
8842 printf ("??? (%d)\n", val
);
8844 printf ("%s\n", attr
->table
[val
]);
8851 type
= 1; /* String. */
8853 type
= 2; /* uleb128. */
8854 printf (" Tag_unknown_%d: ", tag
);
8859 printf ("\"%s\"\n", p
);
8860 p
+= strlen((char *)p
) + 1;
8864 val
= read_uleb128 (p
, &len
);
8866 printf ("%d (0x%x)\n", val
, val
);
8872 static unsigned char *
8873 display_gnu_attribute (unsigned char * p
,
8874 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8881 tag
= read_uleb128 (p
, &len
);
8884 /* Tag_compatibility is the only generic GNU attribute defined at
8888 val
= read_uleb128 (p
, &len
);
8890 printf ("flag = %d, vendor = %s\n", val
, p
);
8891 p
+= strlen ((char *) p
) + 1;
8895 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8896 return display_proc_gnu_attribute (p
, tag
);
8899 type
= 1; /* String. */
8901 type
= 2; /* uleb128. */
8902 printf (" Tag_unknown_%d: ", tag
);
8906 printf ("\"%s\"\n", p
);
8907 p
+= strlen ((char *) p
) + 1;
8911 val
= read_uleb128 (p
, &len
);
8913 printf ("%d (0x%x)\n", val
, val
);
8919 static unsigned char *
8920 display_power_gnu_attribute (unsigned char *p
, int tag
)
8926 if (tag
== Tag_GNU_Power_ABI_FP
)
8928 val
= read_uleb128 (p
, &len
);
8930 printf (" Tag_GNU_Power_ABI_FP: ");
8935 printf ("Hard or soft float\n");
8938 printf ("Hard float\n");
8941 printf ("Soft float\n");
8944 printf ("??? (%d)\n", val
);
8950 if (tag
== Tag_GNU_Power_ABI_Vector
)
8952 val
= read_uleb128 (p
, &len
);
8954 printf (" Tag_GNU_Power_ABI_Vector: ");
8961 printf ("Generic\n");
8964 printf ("AltiVec\n");
8970 printf ("??? (%d)\n", val
);
8977 type
= 1; /* String. */
8979 type
= 2; /* uleb128. */
8980 printf (" Tag_unknown_%d: ", tag
);
8984 printf ("\"%s\"\n", p
);
8985 p
+= strlen ((char *) p
) + 1;
8989 val
= read_uleb128 (p
, &len
);
8991 printf ("%d (0x%x)\n", val
, val
);
8997 static unsigned char *
8998 display_mips_gnu_attribute (unsigned char *p
, int tag
)
9004 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9006 val
= read_uleb128 (p
, &len
);
9008 printf (" Tag_GNU_MIPS_ABI_FP: ");
9013 printf ("Hard or soft float\n");
9016 printf ("Hard float (-mdouble-float)\n");
9019 printf ("Hard float (-msingle-float)\n");
9022 printf ("Soft float\n");
9025 printf ("64-bit float (-mips32r2 -mfp64)\n");
9028 printf ("??? (%d)\n", val
);
9035 type
= 1; /* String. */
9037 type
= 2; /* uleb128. */
9038 printf (" Tag_unknown_%d: ", tag
);
9042 printf ("\"%s\"\n", p
);
9043 p
+= strlen ((char *) p
) + 1;
9047 val
= read_uleb128 (p
, &len
);
9049 printf ("%d (0x%x)\n", val
, val
);
9056 process_attributes (FILE * file
,
9057 const char * public_name
,
9058 unsigned int proc_type
,
9059 unsigned char * (* display_pub_attribute
) (unsigned char *),
9060 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9062 Elf_Internal_Shdr
*sect
;
9063 unsigned char *contents
;
9066 bfd_vma section_len
;
9070 /* Find the section header so that we get the size. */
9071 for (i
= 0, sect
= section_headers
;
9072 i
< elf_header
.e_shnum
;
9075 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9078 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9080 if (contents
== NULL
)
9086 len
= sect
->sh_size
- 1;
9092 bfd_boolean public_section
;
9093 bfd_boolean gnu_section
;
9095 section_len
= byte_get (p
, 4);
9098 if (section_len
> len
)
9100 printf (_("ERROR: Bad section length (%d > %d)\n"),
9101 (int) section_len
, (int) len
);
9106 printf ("Attribute Section: %s\n", p
);
9108 if (public_name
&& streq ((char *) p
, public_name
))
9109 public_section
= TRUE
;
9111 public_section
= FALSE
;
9113 if (streq ((char *) p
, "gnu"))
9116 gnu_section
= FALSE
;
9118 namelen
= strlen ((char *) p
) + 1;
9120 section_len
-= namelen
+ 4;
9122 while (section_len
> 0)
9128 size
= byte_get (p
, 4);
9129 if (size
> section_len
)
9131 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9132 (int) size
, (int) section_len
);
9136 section_len
-= size
;
9143 printf ("File Attributes\n");
9146 printf ("Section Attributes:");
9149 printf ("Symbol Attributes:");
9155 val
= read_uleb128 (p
, &i
);
9159 printf (" %d", val
);
9164 printf ("Unknown tag: %d\n", tag
);
9165 public_section
= FALSE
;
9172 p
= display_pub_attribute (p
);
9174 else if (gnu_section
)
9177 p
= display_gnu_attribute (p
,
9178 display_proc_gnu_attribute
);
9182 /* ??? Do something sensible, like dump hex. */
9183 printf (" Unknown section contexts\n");
9190 printf (_("Unknown format '%c'\n"), *p
);
9198 process_arm_specific (FILE *file
)
9200 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9201 display_arm_attribute
, NULL
);
9205 process_power_specific (FILE *file
)
9207 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9208 display_power_gnu_attribute
);
9211 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9212 Print the Address, Access and Initial fields of an entry at VMA ADDR
9213 and return the VMA of the next entry. */
9216 print_mips_got_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9219 print_vma (addr
, LONG_HEX
);
9221 if (addr
< pltgot
+ 0xfff0)
9222 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9224 printf ("%10s", "");
9227 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9232 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9233 print_vma (entry
, LONG_HEX
);
9235 return addr
+ (is_32bit_elf
? 4 : 8);
9239 process_mips_specific (FILE *file
)
9241 Elf_Internal_Dyn
*entry
;
9242 size_t liblist_offset
= 0;
9243 size_t liblistno
= 0;
9244 size_t conflictsno
= 0;
9245 size_t options_offset
= 0;
9246 size_t conflicts_offset
= 0;
9248 bfd_vma local_gotno
= 0;
9250 bfd_vma symtabno
= 0;
9252 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9253 display_mips_gnu_attribute
);
9255 /* We have a lot of special sections. Thanks SGI! */
9256 if (dynamic_section
== NULL
)
9257 /* No information available. */
9260 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9261 switch (entry
->d_tag
)
9263 case DT_MIPS_LIBLIST
:
9265 = offset_from_vma (file
, entry
->d_un
.d_val
,
9266 liblistno
* sizeof (Elf32_External_Lib
));
9268 case DT_MIPS_LIBLISTNO
:
9269 liblistno
= entry
->d_un
.d_val
;
9271 case DT_MIPS_OPTIONS
:
9272 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9274 case DT_MIPS_CONFLICT
:
9276 = offset_from_vma (file
, entry
->d_un
.d_val
,
9277 conflictsno
* sizeof (Elf32_External_Conflict
));
9279 case DT_MIPS_CONFLICTNO
:
9280 conflictsno
= entry
->d_un
.d_val
;
9283 pltgot
= entry
->d_un
.d_val
;
9284 case DT_MIPS_LOCAL_GOTNO
:
9285 local_gotno
= entry
->d_un
.d_val
;
9287 case DT_MIPS_GOTSYM
:
9288 gotsym
= entry
->d_un
.d_val
;
9290 case DT_MIPS_SYMTABNO
:
9291 symtabno
= entry
->d_un
.d_val
;
9297 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9299 Elf32_External_Lib
*elib
;
9302 elib
= get_data (NULL
, file
, liblist_offset
,
9303 liblistno
, sizeof (Elf32_External_Lib
),
9307 printf ("\nSection '.liblist' contains %lu entries:\n",
9308 (unsigned long) liblistno
);
9309 fputs (" Library Time Stamp Checksum Version Flags\n",
9312 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9319 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9320 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9321 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9322 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9323 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9325 tmp
= gmtime (&time
);
9326 snprintf (timebuf
, sizeof (timebuf
),
9327 "%04u-%02u-%02uT%02u:%02u:%02u",
9328 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9329 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9331 printf ("%3lu: ", (unsigned long) cnt
);
9332 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9333 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9335 printf ("<corrupt: %9ld>", liblist
.l_name
);
9336 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9339 if (liblist
.l_flags
== 0)
9350 { " EXACT_MATCH", LL_EXACT_MATCH
},
9351 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9352 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9353 { " EXPORTS", LL_EXPORTS
},
9354 { " DELAY_LOAD", LL_DELAY_LOAD
},
9355 { " DELTA", LL_DELTA
}
9357 int flags
= liblist
.l_flags
;
9360 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9361 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9363 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9364 flags
^= l_flags_vals
[fcnt
].bit
;
9367 printf (" %#x", (unsigned int) flags
);
9377 if (options_offset
!= 0)
9379 Elf_External_Options
*eopt
;
9380 Elf_Internal_Shdr
*sect
= section_headers
;
9381 Elf_Internal_Options
*iopt
;
9382 Elf_Internal_Options
*option
;
9386 /* Find the section header so that we get the size. */
9387 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9390 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9394 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
9397 error (_("Out of memory\n"));
9404 while (offset
< sect
->sh_size
)
9406 Elf_External_Options
*eoption
;
9408 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9410 option
->kind
= BYTE_GET (eoption
->kind
);
9411 option
->size
= BYTE_GET (eoption
->size
);
9412 option
->section
= BYTE_GET (eoption
->section
);
9413 option
->info
= BYTE_GET (eoption
->info
);
9415 offset
+= option
->size
;
9421 printf (_("\nSection '%s' contains %d entries:\n"),
9422 SECTION_NAME (sect
), cnt
);
9430 switch (option
->kind
)
9433 /* This shouldn't happen. */
9434 printf (" NULL %d %lx", option
->section
, option
->info
);
9437 printf (" REGINFO ");
9438 if (elf_header
.e_machine
== EM_MIPS
)
9441 Elf32_External_RegInfo
*ereg
;
9442 Elf32_RegInfo reginfo
;
9444 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9445 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9446 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9447 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9448 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9449 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9450 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9452 printf ("GPR %08lx GP 0x%lx\n",
9454 (unsigned long) reginfo
.ri_gp_value
);
9455 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9456 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9457 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9462 Elf64_External_RegInfo
*ereg
;
9463 Elf64_Internal_RegInfo reginfo
;
9465 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9466 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9467 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9468 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9469 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9470 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9471 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9473 printf ("GPR %08lx GP 0x",
9474 reginfo
.ri_gprmask
);
9475 printf_vma (reginfo
.ri_gp_value
);
9478 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9479 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9480 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9484 case ODK_EXCEPTIONS
:
9485 fputs (" EXCEPTIONS fpe_min(", stdout
);
9486 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9487 fputs (") fpe_max(", stdout
);
9488 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9489 fputs (")", stdout
);
9491 if (option
->info
& OEX_PAGE0
)
9492 fputs (" PAGE0", stdout
);
9493 if (option
->info
& OEX_SMM
)
9494 fputs (" SMM", stdout
);
9495 if (option
->info
& OEX_FPDBUG
)
9496 fputs (" FPDBUG", stdout
);
9497 if (option
->info
& OEX_DISMISS
)
9498 fputs (" DISMISS", stdout
);
9501 fputs (" PAD ", stdout
);
9502 if (option
->info
& OPAD_PREFIX
)
9503 fputs (" PREFIX", stdout
);
9504 if (option
->info
& OPAD_POSTFIX
)
9505 fputs (" POSTFIX", stdout
);
9506 if (option
->info
& OPAD_SYMBOL
)
9507 fputs (" SYMBOL", stdout
);
9510 fputs (" HWPATCH ", stdout
);
9511 if (option
->info
& OHW_R4KEOP
)
9512 fputs (" R4KEOP", stdout
);
9513 if (option
->info
& OHW_R8KPFETCH
)
9514 fputs (" R8KPFETCH", stdout
);
9515 if (option
->info
& OHW_R5KEOP
)
9516 fputs (" R5KEOP", stdout
);
9517 if (option
->info
& OHW_R5KCVTL
)
9518 fputs (" R5KCVTL", stdout
);
9521 fputs (" FILL ", stdout
);
9522 /* XXX Print content of info word? */
9525 fputs (" TAGS ", stdout
);
9526 /* XXX Print content of info word? */
9529 fputs (" HWAND ", stdout
);
9530 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9531 fputs (" R4KEOP_CHECKED", stdout
);
9532 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9533 fputs (" R4KEOP_CLEAN", stdout
);
9536 fputs (" HWOR ", stdout
);
9537 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9538 fputs (" R4KEOP_CHECKED", stdout
);
9539 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9540 fputs (" R4KEOP_CLEAN", stdout
);
9543 printf (" GP_GROUP %#06lx self-contained %#06lx",
9544 option
->info
& OGP_GROUP
,
9545 (option
->info
& OGP_SELF
) >> 16);
9548 printf (" IDENT %#06lx self-contained %#06lx",
9549 option
->info
& OGP_GROUP
,
9550 (option
->info
& OGP_SELF
) >> 16);
9553 /* This shouldn't happen. */
9554 printf (" %3d ??? %d %lx",
9555 option
->kind
, option
->section
, option
->info
);
9559 len
= sizeof (*eopt
);
9560 while (len
< option
->size
)
9561 if (((char *) option
)[len
] >= ' '
9562 && ((char *) option
)[len
] < 0x7f)
9563 printf ("%c", ((char *) option
)[len
++]);
9565 printf ("\\%03o", ((char *) option
)[len
++]);
9567 fputs ("\n", stdout
);
9575 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9577 Elf32_Conflict
*iconf
;
9580 if (dynamic_symbols
== NULL
)
9582 error (_("conflict list found without a dynamic symbol table\n"));
9586 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9589 error (_("Out of memory\n"));
9595 Elf32_External_Conflict
*econf32
;
9597 econf32
= get_data (NULL
, file
, conflicts_offset
,
9598 conflictsno
, sizeof (*econf32
), _("conflict"));
9602 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9603 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9609 Elf64_External_Conflict
*econf64
;
9611 econf64
= get_data (NULL
, file
, conflicts_offset
,
9612 conflictsno
, sizeof (*econf64
), _("conflict"));
9616 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9617 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9622 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9623 (unsigned long) conflictsno
);
9624 puts (_(" Num: Index Value Name"));
9626 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9628 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9630 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9631 print_vma (psym
->st_value
, FULL_HEX
);
9633 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9634 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9636 printf ("<corrupt: %14ld>", psym
->st_name
);
9643 if (pltgot
!= 0 && local_gotno
!= 0)
9645 bfd_vma entry
, local_end
, global_end
;
9647 unsigned char *data
;
9651 addr_size
= (is_32bit_elf
? 4 : 8);
9652 local_end
= pltgot
+ local_gotno
* addr_size
;
9653 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9655 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9656 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9657 printf (_("\nPrimary GOT:\n"));
9658 printf (_(" Canonical gp value: "));
9659 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9662 printf (_(" Reserved entries:\n"));
9663 printf (_(" %*s %10s %*s Purpose\n"),
9664 addr_size
* 2, "Address", "Access",
9665 addr_size
* 2, "Initial");
9666 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9667 printf (" Lazy resolver\n");
9669 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9670 >> (addr_size
* 8 - 1)) != 0)
9672 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9673 printf (" Module pointer (GNU extension)\n");
9677 if (entry
< local_end
)
9679 printf (_(" Local entries:\n"));
9680 printf (_(" %*s %10s %*s\n"),
9681 addr_size
* 2, "Address", "Access",
9682 addr_size
* 2, "Initial");
9683 while (entry
< local_end
)
9685 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9691 if (gotsym
< symtabno
)
9695 printf (_(" Global entries:\n"));
9696 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9697 addr_size
* 2, "Address", "Access",
9698 addr_size
* 2, "Initial",
9699 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9700 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9701 for (i
= gotsym
; i
< symtabno
; i
++)
9703 Elf_Internal_Sym
*psym
;
9705 psym
= dynamic_symbols
+ i
;
9706 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9708 print_vma (psym
->st_value
, LONG_HEX
);
9709 printf (" %-7s %3s ",
9710 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9711 get_symbol_index_type (psym
->st_shndx
));
9712 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9713 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9715 printf ("<corrupt: %14ld>", psym
->st_name
);
9729 process_gnu_liblist (FILE *file
)
9731 Elf_Internal_Shdr
*section
, *string_sec
;
9732 Elf32_External_Lib
*elib
;
9741 for (i
= 0, section
= section_headers
;
9742 i
< elf_header
.e_shnum
;
9745 switch (section
->sh_type
)
9747 case SHT_GNU_LIBLIST
:
9748 if (section
->sh_link
>= elf_header
.e_shnum
)
9751 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9756 string_sec
= section_headers
+ section
->sh_link
;
9758 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9759 string_sec
->sh_size
, _("liblist string table"));
9760 strtab_size
= string_sec
->sh_size
;
9763 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9769 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9770 SECTION_NAME (section
),
9771 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9773 puts (" Library Time Stamp Checksum Version Flags");
9775 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9783 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9784 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9785 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9786 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9787 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9789 tmp
= gmtime (&time
);
9790 snprintf (timebuf
, sizeof (timebuf
),
9791 "%04u-%02u-%02uT%02u:%02u:%02u",
9792 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9793 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9795 printf ("%3lu: ", (unsigned long) cnt
);
9797 printf ("%-20s", liblist
.l_name
< strtab_size
9798 ? strtab
+ liblist
.l_name
: "<corrupt>");
9800 printf ("%-20.20s", liblist
.l_name
< strtab_size
9801 ? strtab
+ liblist
.l_name
: "<corrupt>");
9802 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9803 liblist
.l_version
, liblist
.l_flags
);
9814 get_note_type (unsigned e_type
)
9816 static char buff
[64];
9818 if (elf_header
.e_type
== ET_CORE
)
9822 return _("NT_AUXV (auxiliary vector)");
9824 return _("NT_PRSTATUS (prstatus structure)");
9826 return _("NT_FPREGSET (floating point registers)");
9828 return _("NT_PRPSINFO (prpsinfo structure)");
9830 return _("NT_TASKSTRUCT (task structure)");
9832 return _("NT_PRXFPREG (user_xfpregs structure)");
9834 return _("NT_PPC_VMX (ppc Altivec registers)");
9836 return _("NT_PSTATUS (pstatus structure)");
9838 return _("NT_FPREGS (floating point registers)");
9840 return _("NT_PSINFO (psinfo structure)");
9842 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9844 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9845 case NT_WIN32PSTATUS
:
9846 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9854 return _("NT_VERSION (version)");
9856 return _("NT_ARCH (architecture)");
9861 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9866 get_gnu_elf_note_type (unsigned e_type
)
9868 static char buff
[64];
9872 case NT_GNU_ABI_TAG
:
9873 return _("NT_GNU_ABI_TAG (ABI version tag)");
9875 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9876 case NT_GNU_BUILD_ID
:
9877 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9878 case NT_GNU_GOLD_VERSION
:
9879 return _("NT_GNU_GOLD_VERSION (gold version)");
9884 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9889 get_netbsd_elfcore_note_type (unsigned e_type
)
9891 static char buff
[64];
9893 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9895 /* NetBSD core "procinfo" structure. */
9896 return _("NetBSD procinfo structure");
9899 /* As of Jan 2002 there are no other machine-independent notes
9900 defined for NetBSD core files. If the note type is less
9901 than the start of the machine-dependent note types, we don't
9904 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9906 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9910 switch (elf_header
.e_machine
)
9912 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9913 and PT_GETFPREGS == mach+2. */
9918 case EM_SPARC32PLUS
:
9922 case NT_NETBSDCORE_FIRSTMACH
+0:
9923 return _("PT_GETREGS (reg structure)");
9924 case NT_NETBSDCORE_FIRSTMACH
+2:
9925 return _("PT_GETFPREGS (fpreg structure)");
9931 /* On all other arch's, PT_GETREGS == mach+1 and
9932 PT_GETFPREGS == mach+3. */
9936 case NT_NETBSDCORE_FIRSTMACH
+1:
9937 return _("PT_GETREGS (reg structure)");
9938 case NT_NETBSDCORE_FIRSTMACH
+3:
9939 return _("PT_GETFPREGS (fpreg structure)");
9945 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
9946 e_type
- NT_NETBSDCORE_FIRSTMACH
);
9950 /* Note that by the ELF standard, the name field is already null byte
9951 terminated, and namesz includes the terminating null byte.
9952 I.E. the value of namesz for the name "FSF" is 4.
9954 If the value of namesz is zero, there is no name present. */
9956 process_note (Elf_Internal_Note
*pnote
)
9958 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
9961 if (pnote
->namesz
== 0)
9962 /* If there is no note name, then use the default set of
9963 note type strings. */
9964 nt
= get_note_type (pnote
->type
);
9966 else if (const_strneq (pnote
->namedata
, "GNU"))
9967 /* GNU-specific object file notes. */
9968 nt
= get_gnu_elf_note_type (pnote
->type
);
9970 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
9971 /* NetBSD-specific core file notes. */
9972 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9974 else if (strneq (pnote
->namedata
, "SPU/", 4))
9976 /* SPU-specific core file notes. */
9977 nt
= pnote
->namedata
+ 4;
9982 /* Don't recognize this note name; just use the default set of
9983 note type strings. */
9984 nt
= get_note_type (pnote
->type
);
9986 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
9992 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
9994 Elf_External_Note
*pnotes
;
9995 Elf_External_Note
*external
;
10001 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10007 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10008 (unsigned long) offset
, (unsigned long) length
);
10009 printf (_(" Owner\t\tData size\tDescription\n"));
10011 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10013 Elf_External_Note
*next
;
10014 Elf_Internal_Note inote
;
10017 inote
.type
= BYTE_GET (external
->type
);
10018 inote
.namesz
= BYTE_GET (external
->namesz
);
10019 inote
.namedata
= external
->name
;
10020 inote
.descsz
= BYTE_GET (external
->descsz
);
10021 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10022 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10024 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10026 if (((char *) next
) > (((char *) pnotes
) + length
))
10028 warn (_("corrupt note found at offset %lx into core notes\n"),
10029 (long)((char *)external
- (char *)pnotes
));
10030 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10031 inote
.type
, inote
.namesz
, inote
.descsz
);
10037 /* Verify that name is null terminated. It appears that at least
10038 one version of Linux (RedHat 6.0) generates corefiles that don't
10039 comply with the ELF spec by failing to include the null byte in
10041 if (inote
.namedata
[inote
.namesz
] != '\0')
10043 temp
= malloc (inote
.namesz
+ 1);
10047 error (_("Out of memory\n"));
10052 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10053 temp
[inote
.namesz
] = 0;
10055 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10056 inote
.namedata
= temp
;
10059 res
&= process_note (& inote
);
10074 process_corefile_note_segments (FILE *file
)
10076 Elf_Internal_Phdr
*segment
;
10080 if (! get_program_headers (file
))
10083 for (i
= 0, segment
= program_headers
;
10084 i
< elf_header
.e_phnum
;
10087 if (segment
->p_type
== PT_NOTE
)
10088 res
&= process_corefile_note_segment (file
,
10089 (bfd_vma
) segment
->p_offset
,
10090 (bfd_vma
) segment
->p_filesz
);
10097 process_note_sections (FILE *file
)
10099 Elf_Internal_Shdr
*section
;
10103 for (i
= 0, section
= section_headers
;
10104 i
< elf_header
.e_shnum
;
10106 if (section
->sh_type
== SHT_NOTE
)
10107 res
&= process_corefile_note_segment (file
,
10108 (bfd_vma
) section
->sh_offset
,
10109 (bfd_vma
) section
->sh_size
);
10115 process_notes (FILE *file
)
10117 /* If we have not been asked to display the notes then do nothing. */
10121 if (elf_header
.e_type
!= ET_CORE
)
10122 return process_note_sections (file
);
10124 /* No program headers means no NOTE segment. */
10125 if (elf_header
.e_phnum
> 0)
10126 return process_corefile_note_segments (file
);
10128 printf (_("No note segments present in the core file.\n"));
10133 process_arch_specific (FILE *file
)
10138 switch (elf_header
.e_machine
)
10141 return process_arm_specific (file
);
10143 case EM_MIPS_RS3_LE
:
10144 return process_mips_specific (file
);
10147 return process_power_specific (file
);
10156 get_file_header (FILE *file
)
10158 /* Read in the identity array. */
10159 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10162 /* Determine how to read the rest of the header. */
10163 switch (elf_header
.e_ident
[EI_DATA
])
10165 default: /* fall through */
10166 case ELFDATANONE
: /* fall through */
10168 byte_get
= byte_get_little_endian
;
10169 byte_put
= byte_put_little_endian
;
10172 byte_get
= byte_get_big_endian
;
10173 byte_put
= byte_put_big_endian
;
10177 /* For now we only support 32 bit and 64 bit ELF files. */
10178 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10180 /* Read in the rest of the header. */
10183 Elf32_External_Ehdr ehdr32
;
10185 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10188 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10189 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10190 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10191 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10192 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10193 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10194 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10195 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10196 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10197 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10198 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10199 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10200 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10204 Elf64_External_Ehdr ehdr64
;
10206 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10207 we will not be able to cope with the 64bit data found in
10208 64 ELF files. Detect this now and abort before we start
10209 overwriting things. */
10210 if (sizeof (bfd_vma
) < 8)
10212 error (_("This instance of readelf has been built without support for a\n\
10213 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10217 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10220 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10221 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10222 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10223 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10224 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10225 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10226 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10227 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10228 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10229 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10230 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10231 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10232 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10235 if (elf_header
.e_shoff
)
10237 /* There may be some extensions in the first section header. Don't
10238 bomb if we can't read it. */
10240 get_32bit_section_headers (file
, 1);
10242 get_64bit_section_headers (file
, 1);
10248 /* Process one ELF object file according to the command line options.
10249 This file may actually be stored in an archive. The file is
10250 positioned at the start of the ELF object. */
10253 process_object (char *file_name
, FILE *file
)
10257 if (! get_file_header (file
))
10259 error (_("%s: Failed to read file header\n"), file_name
);
10263 /* Initialise per file variables. */
10264 for (i
= ARRAY_SIZE (version_info
); i
--;)
10265 version_info
[i
] = 0;
10267 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10268 dynamic_info
[i
] = 0;
10270 /* Process the file. */
10272 printf (_("\nFile: %s\n"), file_name
);
10274 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10275 Note we do this even if cmdline_dump_sects is empty because we
10276 must make sure that the dump_sets array is zeroed out before each
10277 object file is processed. */
10278 if (num_dump_sects
> num_cmdline_dump_sects
)
10279 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10281 if (num_cmdline_dump_sects
> 0)
10283 if (num_dump_sects
== 0)
10284 /* A sneaky way of allocating the dump_sects array. */
10285 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10287 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10288 memcpy (dump_sects
, cmdline_dump_sects
,
10289 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10292 if (! process_file_header ())
10295 if (! process_section_headers (file
))
10297 /* Without loaded section headers we cannot process lots of
10299 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10301 if (! do_using_dynamic
)
10302 do_syms
= do_reloc
= 0;
10305 if (! process_section_groups (file
))
10307 /* Without loaded section groups we cannot process unwind. */
10311 if (process_program_headers (file
))
10312 process_dynamic_section (file
);
10314 process_relocs (file
);
10316 process_unwind (file
);
10318 process_symbol_table (file
);
10320 process_syminfo (file
);
10322 process_version_sections (file
);
10324 process_section_contents (file
);
10326 process_notes (file
);
10328 process_gnu_liblist (file
);
10330 process_arch_specific (file
);
10332 if (program_headers
)
10334 free (program_headers
);
10335 program_headers
= NULL
;
10338 if (section_headers
)
10340 free (section_headers
);
10341 section_headers
= NULL
;
10346 free (string_table
);
10347 string_table
= NULL
;
10348 string_table_length
= 0;
10351 if (dynamic_strings
)
10353 free (dynamic_strings
);
10354 dynamic_strings
= NULL
;
10355 dynamic_strings_length
= 0;
10358 if (dynamic_symbols
)
10360 free (dynamic_symbols
);
10361 dynamic_symbols
= NULL
;
10362 num_dynamic_syms
= 0;
10365 if (dynamic_syminfo
)
10367 free (dynamic_syminfo
);
10368 dynamic_syminfo
= NULL
;
10371 if (section_headers_groups
)
10373 free (section_headers_groups
);
10374 section_headers_groups
= NULL
;
10377 if (section_groups
)
10379 struct group_list
*g
, *next
;
10381 for (i
= 0; i
< group_count
; i
++)
10383 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10390 free (section_groups
);
10391 section_groups
= NULL
;
10394 free_debug_memory ();
10399 /* Process an ELF archive.
10400 On entry the file is positioned just after the ARMAG string. */
10403 process_archive (char *file_name
, FILE *file
)
10405 struct ar_hdr arhdr
;
10407 unsigned long size
;
10408 unsigned long index_num
= 0;
10409 unsigned long *index_array
= NULL
;
10410 char *sym_table
= NULL
;
10411 unsigned long sym_size
= 0;
10412 char *longnames
= NULL
;
10413 unsigned long longnames_size
= 0;
10414 size_t file_name_size
;
10419 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10420 if (got
!= sizeof arhdr
)
10425 error (_("%s: failed to read archive header\n"), file_name
);
10429 /* See if this is the archive symbol table. */
10430 if (const_strneq (arhdr
.ar_name
, "/ ")
10431 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
10433 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10434 size
= size
+ (size
& 1);
10436 if (do_archive_index
)
10439 /* A buffer used to hold numbers read in from an archive index.
10440 These are always 4 bytes long and stored in big-endian format. */
10441 #define SIZEOF_AR_INDEX_NUMBERS 4
10442 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10443 unsigned char * index_buffer
;
10445 /* Check the size of the archive index. */
10446 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10448 error (_("%s: the archive index is empty\n"), file_name
);
10452 /* Read the numer of entries in the archive index. */
10453 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10454 if (got
!= sizeof (integer_buffer
))
10456 error (_("%s: failed to read archive index\n"), file_name
);
10459 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10460 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10462 /* Read in the archive index. */
10463 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10465 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10466 file_name
, index_num
);
10469 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10470 if (index_buffer
== NULL
)
10472 error (_("Out of memory whilst trying to read archive symbol index\n"));
10475 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
10476 if (got
!= index_num
)
10478 free (index_buffer
);
10479 error (_("%s: failed to read archive index\n"), file_name
);
10483 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10485 /* Convert the index numbers into the host's numeric format. */
10486 index_array
= malloc (index_num
* sizeof (* index_array
));
10487 if (index_array
== NULL
)
10489 free (index_buffer
);
10490 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10494 for (i
= 0; i
< index_num
; i
++)
10495 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10496 SIZEOF_AR_INDEX_NUMBERS
);
10497 free (index_buffer
);
10499 /* The remaining space in the header is taken up by the symbol table. */
10502 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10506 sym_table
= malloc (size
);
10508 if (sym_table
== NULL
)
10510 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10514 got
= fread (sym_table
, 1, size
, file
);
10517 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10524 if (fseek (file
, size
, SEEK_CUR
) != 0)
10526 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10531 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10532 if (got
!= sizeof arhdr
)
10540 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10545 else if (do_archive_index
)
10546 printf (_("%s has no archive index\n"), file_name
);
10548 if (const_strneq (arhdr
.ar_name
, "// "))
10550 /* This is the archive string table holding long member
10553 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10554 longnames
= malloc (longnames_size
);
10555 if (longnames
== NULL
)
10557 error (_("Out of memory reading long symbol names in archive\n"));
10562 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10565 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10570 if ((longnames_size
& 1) != 0)
10573 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10574 if (got
!= sizeof arhdr
)
10580 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10587 if (do_archive_index
)
10589 if (sym_table
== NULL
)
10590 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10593 unsigned int i
, j
, k
, l
;
10595 unsigned long current_pos
;
10597 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10598 file_name
, index_num
, sym_size
);
10599 current_pos
= ftell (file
);
10601 for (i
= l
= 0; i
< index_num
; i
++)
10603 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10605 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10607 error (_("%s: failed to seek to next file name\n"), file_name
);
10611 got
= fread (elf_name
, 1, 16, file
);
10614 error (_("%s: failed to read file name\n"), file_name
);
10619 if (elf_name
[0] == '/')
10621 /* We have a long name. */
10622 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10623 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10625 longnames
[j
] = '\0';
10626 printf (_("Binary %s contains:\n"), longnames
+ k
);
10627 longnames
[j
] = '/';
10632 while ((elf_name
[j
] != '/') && (j
< 16))
10634 elf_name
[j
] = '\0';
10635 printf(_("Binary %s contains:\n"), elf_name
);
10640 error (_("%s: end of the symbol table reached before the end of the index\n"),
10644 printf ("\t%s\n", sym_table
+ l
);
10645 l
+= strlen (sym_table
+ l
) + 1;
10649 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10652 free (index_array
);
10653 index_array
= NULL
;
10656 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10658 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10663 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10664 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10665 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10666 && !do_section_groups
)
10667 return 0; /* Archive index only. */
10670 file_name_size
= strlen (file_name
);
10679 if (arhdr
.ar_name
[0] == '/')
10683 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10684 if (off
>= longnames_size
)
10686 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10691 name
= longnames
+ off
;
10692 nameend
= memchr (name
, '/', longnames_size
- off
);
10696 name
= arhdr
.ar_name
;
10697 nameend
= memchr (name
, '/', 16);
10700 if (nameend
== NULL
)
10702 error (_("%s: bad archive file name\n"), file_name
);
10707 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10708 if (namealc
== NULL
)
10710 error (_("Out of memory\n"));
10715 memcpy (namealc
, file_name
, file_name_size
);
10716 namealc
[file_name_size
] = '(';
10717 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10718 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10719 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10721 archive_file_offset
= ftell (file
);
10722 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10724 ret
|= process_object (namealc
, file
);
10729 (archive_file_offset
10730 + archive_file_size
10731 + (archive_file_size
& 1)),
10734 error (_("%s: failed to seek to next archive header\n"), file_name
);
10739 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10740 if (got
!= sizeof arhdr
)
10745 error (_("%s: failed to read archive header\n"), file_name
);
10752 if (index_array
!= NULL
)
10753 free (index_array
);
10754 if (sym_table
!= NULL
)
10756 if (longnames
!= NULL
)
10763 process_file (char *file_name
)
10766 struct stat statbuf
;
10767 char armag
[SARMAG
];
10770 if (stat (file_name
, &statbuf
) < 0)
10772 if (errno
== ENOENT
)
10773 error (_("'%s': No such file\n"), file_name
);
10775 error (_("Could not locate '%s'. System error message: %s\n"),
10776 file_name
, strerror (errno
));
10780 if (! S_ISREG (statbuf
.st_mode
))
10782 error (_("'%s' is not an ordinary file\n"), file_name
);
10786 file
= fopen (file_name
, "rb");
10789 error (_("Input file '%s' is not readable.\n"), file_name
);
10793 if (fread (armag
, SARMAG
, 1, file
) != 1)
10795 error (_("%s: Failed to read file's magic number\n"), file_name
);
10800 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10801 ret
= process_archive (file_name
, file
);
10804 if (do_archive_index
)
10805 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10809 archive_file_size
= archive_file_offset
= 0;
10810 ret
= process_object (file_name
, file
);
10818 #ifdef SUPPORT_DISASSEMBLY
10819 /* Needed by the i386 disassembler. For extra credit, someone could
10820 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10824 print_address (unsigned int addr
, FILE *outfile
)
10826 fprintf (outfile
,"0x%8.8x", addr
);
10829 /* Needed by the i386 disassembler. */
10831 db_task_printsym (unsigned int addr
)
10833 print_address (addr
, stderr
);
10838 main (int argc
, char **argv
)
10842 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10843 setlocale (LC_MESSAGES
, "");
10845 #if defined (HAVE_SETLOCALE)
10846 setlocale (LC_CTYPE
, "");
10848 bindtextdomain (PACKAGE
, LOCALEDIR
);
10849 textdomain (PACKAGE
);
10851 expandargv (&argc
, &argv
);
10853 parse_args (argc
, argv
);
10855 if (num_dump_sects
> 0)
10857 /* Make a copy of the dump_sects array. */
10858 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10859 if (cmdline_dump_sects
== NULL
)
10860 error (_("Out of memory allocating dump request table.\n"));
10863 memcpy (cmdline_dump_sects
, dump_sects
,
10864 num_dump_sects
* sizeof (* dump_sects
));
10865 num_cmdline_dump_sects
= num_dump_sects
;
10869 if (optind
< (argc
- 1))
10873 while (optind
< argc
)
10874 err
|= process_file (argv
[optind
++]);
10876 if (dump_sects
!= NULL
)
10878 if (cmdline_dump_sects
!= NULL
)
10879 free (cmdline_dump_sects
);