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
:
727 case EM_CYGNUS_MN10200
:
729 case EM_CYGNUS_MN10300
:
770 warn (_("Don't know about relocations on this machine architecture\n"));
776 slurp_rela_relocs (FILE *file
,
777 unsigned long rel_offset
,
778 unsigned long rel_size
,
779 Elf_Internal_Rela
**relasp
,
780 unsigned long *nrelasp
)
782 Elf_Internal_Rela
*relas
;
783 unsigned long nrelas
;
788 Elf32_External_Rela
*erelas
;
790 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
794 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
796 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
801 error (_("out of memory parsing relocs\n"));
805 for (i
= 0; i
< nrelas
; i
++)
807 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
808 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
809 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
816 Elf64_External_Rela
*erelas
;
818 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
822 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
824 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
829 error (_("out of memory parsing relocs\n"));
833 for (i
= 0; i
< nrelas
; i
++)
835 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
836 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
837 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
848 slurp_rel_relocs (FILE *file
,
849 unsigned long rel_offset
,
850 unsigned long rel_size
,
851 Elf_Internal_Rela
**relsp
,
852 unsigned long *nrelsp
)
854 Elf_Internal_Rela
*rels
;
860 Elf32_External_Rel
*erels
;
862 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
866 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
868 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
873 error (_("out of memory parsing relocs\n"));
877 for (i
= 0; i
< nrels
; i
++)
879 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
880 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
881 rels
[i
].r_addend
= 0;
888 Elf64_External_Rel
*erels
;
890 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
894 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
896 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
901 error (_("out of memory parsing relocs\n"));
905 for (i
= 0; i
< nrels
; i
++)
907 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
908 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
909 rels
[i
].r_addend
= 0;
919 /* Returns the reloc type extracted from the reloc info field. */
922 get_reloc_type (bfd_vma reloc_info
)
925 return ELF32_R_TYPE (reloc_info
);
927 switch (elf_header
.e_machine
)
930 /* Note: We assume that reloc_info has already been adjusted for us. */
931 return ELF64_MIPS_R_TYPE (reloc_info
);
934 return ELF64_R_TYPE_ID (reloc_info
);
937 return ELF64_R_TYPE (reloc_info
);
941 /* Return the symbol index extracted from the reloc info field. */
944 get_reloc_symindex (bfd_vma reloc_info
)
946 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
949 /* Display the contents of the relocation data found at the specified
953 dump_relocations (FILE *file
,
954 unsigned long rel_offset
,
955 unsigned long rel_size
,
956 Elf_Internal_Sym
*symtab
,
959 unsigned long strtablen
,
963 Elf_Internal_Rela
*rels
;
966 if (is_rela
== UNKNOWN
)
967 is_rela
= guess_is_rela (elf_header
.e_machine
);
971 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
976 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
985 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
987 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
992 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
994 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1002 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1004 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1009 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1011 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1015 for (i
= 0; i
< rel_size
; i
++)
1020 bfd_vma symtab_index
;
1023 offset
= rels
[i
].r_offset
;
1024 info
= rels
[i
].r_info
;
1026 /* The #ifdef BFD64 below is to prevent a compile time warning.
1027 We know that if we do not have a 64 bit data type that we
1028 will never execute this code anyway. */
1031 && elf_header
.e_machine
== EM_MIPS
1032 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1034 /* In little-endian objects, r_info isn't really a 64-bit
1035 little-endian value: it has a 32-bit little-endian
1036 symbol index followed by four individual byte fields.
1037 Reorder INFO accordingly. */
1038 info
= (((info
& 0xffffffff) << 32)
1039 | ((info
>> 56) & 0xff)
1040 | ((info
>> 40) & 0xff00)
1041 | ((info
>> 24) & 0xff0000)
1042 | ((info
>> 8) & 0xff000000));
1046 type
= get_reloc_type (info
);
1047 symtab_index
= get_reloc_symindex (info
);
1051 printf ("%8.8lx %8.8lx ",
1052 (unsigned long) offset
& 0xffffffff,
1053 (unsigned long) info
& 0xffffffff);
1057 #if BFD_HOST_64BIT_LONG
1059 ? "%16.16lx %16.16lx "
1060 : "%12.12lx %12.12lx ",
1062 #elif BFD_HOST_64BIT_LONG_LONG
1065 ? "%16.16llx %16.16llx "
1066 : "%12.12llx %12.12llx ",
1070 ? "%16.16I64x %16.16I64x "
1071 : "%12.12I64x %12.12I64x ",
1076 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1077 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1078 _bfd_int64_high (offset
),
1079 _bfd_int64_low (offset
),
1080 _bfd_int64_high (info
),
1081 _bfd_int64_low (info
));
1085 switch (elf_header
.e_machine
)
1092 case EM_CYGNUS_M32R
:
1093 rtype
= elf_m32r_reloc_type (type
);
1098 rtype
= elf_i386_reloc_type (type
);
1103 rtype
= elf_m68hc11_reloc_type (type
);
1107 rtype
= elf_m68k_reloc_type (type
);
1111 rtype
= elf_i960_reloc_type (type
);
1116 rtype
= elf_avr_reloc_type (type
);
1119 case EM_OLD_SPARCV9
:
1120 case EM_SPARC32PLUS
:
1123 rtype
= elf_sparc_reloc_type (type
);
1127 rtype
= elf_spu_reloc_type (type
);
1131 case EM_CYGNUS_V850
:
1132 rtype
= v850_reloc_type (type
);
1136 case EM_CYGNUS_D10V
:
1137 rtype
= elf_d10v_reloc_type (type
);
1141 case EM_CYGNUS_D30V
:
1142 rtype
= elf_d30v_reloc_type (type
);
1146 rtype
= elf_dlx_reloc_type (type
);
1150 rtype
= elf_sh_reloc_type (type
);
1154 case EM_CYGNUS_MN10300
:
1155 rtype
= elf_mn10300_reloc_type (type
);
1159 case EM_CYGNUS_MN10200
:
1160 rtype
= elf_mn10200_reloc_type (type
);
1164 case EM_CYGNUS_FR30
:
1165 rtype
= elf_fr30_reloc_type (type
);
1169 rtype
= elf_frv_reloc_type (type
);
1173 rtype
= elf_mcore_reloc_type (type
);
1177 rtype
= elf_mmix_reloc_type (type
);
1182 rtype
= elf_msp430_reloc_type (type
);
1186 rtype
= elf_ppc_reloc_type (type
);
1190 rtype
= elf_ppc64_reloc_type (type
);
1194 case EM_MIPS_RS3_LE
:
1195 rtype
= elf_mips_reloc_type (type
);
1199 rtype
= elf_alpha_reloc_type (type
);
1203 rtype
= elf_arm_reloc_type (type
);
1207 rtype
= elf_arc_reloc_type (type
);
1211 rtype
= elf_hppa_reloc_type (type
);
1217 rtype
= elf_h8_reloc_type (type
);
1222 rtype
= elf_or32_reloc_type (type
);
1227 rtype
= elf_pj_reloc_type (type
);
1230 rtype
= elf_ia64_reloc_type (type
);
1234 rtype
= elf_cris_reloc_type (type
);
1238 rtype
= elf_i860_reloc_type (type
);
1242 rtype
= elf_x86_64_reloc_type (type
);
1246 rtype
= i370_reloc_type (type
);
1251 rtype
= elf_s390_reloc_type (type
);
1255 rtype
= elf_score_reloc_type (type
);
1259 rtype
= elf_xstormy16_reloc_type (type
);
1263 rtype
= elf_crx_reloc_type (type
);
1267 rtype
= elf_vax_reloc_type (type
);
1272 rtype
= elf_ip2k_reloc_type (type
);
1276 rtype
= elf_iq2000_reloc_type (type
);
1281 rtype
= elf_xtensa_reloc_type (type
);
1286 rtype
= elf_m32c_reloc_type (type
);
1290 rtype
= elf_mt_reloc_type (type
);
1294 rtype
= elf_bfin_reloc_type (type
);
1298 rtype
= elf_mep_reloc_type (type
);
1302 rtype
= elf_cr16_reloc_type (type
);
1307 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1309 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1311 if (elf_header
.e_machine
== EM_ALPHA
1313 && streq (rtype
, "R_ALPHA_LITUSE")
1316 switch (rels
[i
].r_addend
)
1318 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1319 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1320 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1321 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1322 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1323 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1324 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1325 default: rtype
= NULL
;
1328 printf (" (%s)", rtype
);
1332 printf (_("<unknown addend: %lx>"),
1333 (unsigned long) rels
[i
].r_addend
);
1336 else if (symtab_index
)
1338 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1339 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1342 Elf_Internal_Sym
*psym
;
1344 psym
= symtab
+ symtab_index
;
1347 print_vma (psym
->st_value
, LONG_HEX
);
1348 printf (is_32bit_elf
? " " : " ");
1350 if (psym
->st_name
== 0)
1352 const char *sec_name
= "<null>";
1355 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1357 if (psym
->st_shndx
< elf_header
.e_shnum
)
1359 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1360 else if (psym
->st_shndx
== SHN_ABS
)
1362 else if (psym
->st_shndx
== SHN_COMMON
)
1363 sec_name
= "COMMON";
1364 else if (elf_header
.e_machine
== EM_MIPS
1365 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1366 sec_name
= "SCOMMON";
1367 else if (elf_header
.e_machine
== EM_MIPS
1368 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1369 sec_name
= "SUNDEF";
1370 else if (elf_header
.e_machine
== EM_X86_64
1371 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1372 sec_name
= "LARGE_COMMON";
1373 else if (elf_header
.e_machine
== EM_IA_64
1374 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1375 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1376 sec_name
= "ANSI_COM";
1377 else if (elf_header
.e_machine
== EM_IA_64
1378 && (elf_header
.e_ident
[EI_OSABI
]
1379 == ELFOSABI_OPENVMS
)
1380 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1381 sec_name
= "VMS_SYMVEC";
1384 sprintf (name_buf
, "<section 0x%x>",
1385 (unsigned int) psym
->st_shndx
);
1386 sec_name
= name_buf
;
1389 print_symbol (22, sec_name
);
1391 else if (strtab
== NULL
)
1392 printf (_("<string table index: %3ld>"), psym
->st_name
);
1393 else if (psym
->st_name
>= strtablen
)
1394 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1396 print_symbol (22, strtab
+ psym
->st_name
);
1399 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1404 printf ("%*c", is_32bit_elf
?
1405 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1406 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1409 if (elf_header
.e_machine
== EM_SPARCV9
1411 && streq (rtype
, "R_SPARC_OLO10"))
1412 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1417 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1419 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1420 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1421 const char *rtype2
= elf_mips_reloc_type (type2
);
1422 const char *rtype3
= elf_mips_reloc_type (type3
);
1424 printf (" Type2: ");
1427 printf (_("unrecognized: %-7lx"),
1428 (unsigned long) type2
& 0xffffffff);
1430 printf ("%-17.17s", rtype2
);
1432 printf ("\n Type3: ");
1435 printf (_("unrecognized: %-7lx"),
1436 (unsigned long) type3
& 0xffffffff);
1438 printf ("%-17.17s", rtype3
);
1449 get_mips_dynamic_type (unsigned long type
)
1453 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1454 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1455 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1456 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1457 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1458 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1459 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1460 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1461 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1462 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1463 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1464 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1465 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1466 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1467 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1468 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1469 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1470 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1471 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1472 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1473 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1474 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1475 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1476 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1477 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1478 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1479 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1480 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1481 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1482 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1483 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1484 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1485 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1486 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1487 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1488 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1489 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1490 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1491 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1492 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1493 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1494 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1495 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1502 get_sparc64_dynamic_type (unsigned long type
)
1506 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1513 get_ppc_dynamic_type (unsigned long type
)
1517 case DT_PPC_GOT
: return "PPC_GOT";
1524 get_ppc64_dynamic_type (unsigned long type
)
1528 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1529 case DT_PPC64_OPD
: return "PPC64_OPD";
1530 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1537 get_parisc_dynamic_type (unsigned long type
)
1541 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1542 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1543 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1544 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1545 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1546 case DT_HP_PREINIT
: return "HP_PREINIT";
1547 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1548 case DT_HP_NEEDED
: return "HP_NEEDED";
1549 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1550 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1551 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1552 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1553 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1554 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1555 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1556 case DT_HP_FILTERED
: return "HP_FILTERED";
1557 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1558 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1559 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1560 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1561 case DT_PLT
: return "PLT";
1562 case DT_PLT_SIZE
: return "PLT_SIZE";
1563 case DT_DLT
: return "DLT";
1564 case DT_DLT_SIZE
: return "DLT_SIZE";
1571 get_ia64_dynamic_type (unsigned long type
)
1575 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1576 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1577 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1578 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1579 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1580 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1581 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1582 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1583 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1584 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1585 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1586 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1587 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1588 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1589 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1590 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1591 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1592 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1593 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1594 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1595 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1596 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1597 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1598 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1599 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1600 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1601 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1602 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1603 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1604 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1605 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1612 get_alpha_dynamic_type (unsigned long type
)
1616 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1623 get_score_dynamic_type (unsigned long type
)
1627 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1628 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1629 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1630 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1631 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1632 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1640 get_dynamic_type (unsigned long type
)
1642 static char buff
[64];
1646 case DT_NULL
: return "NULL";
1647 case DT_NEEDED
: return "NEEDED";
1648 case DT_PLTRELSZ
: return "PLTRELSZ";
1649 case DT_PLTGOT
: return "PLTGOT";
1650 case DT_HASH
: return "HASH";
1651 case DT_STRTAB
: return "STRTAB";
1652 case DT_SYMTAB
: return "SYMTAB";
1653 case DT_RELA
: return "RELA";
1654 case DT_RELASZ
: return "RELASZ";
1655 case DT_RELAENT
: return "RELAENT";
1656 case DT_STRSZ
: return "STRSZ";
1657 case DT_SYMENT
: return "SYMENT";
1658 case DT_INIT
: return "INIT";
1659 case DT_FINI
: return "FINI";
1660 case DT_SONAME
: return "SONAME";
1661 case DT_RPATH
: return "RPATH";
1662 case DT_SYMBOLIC
: return "SYMBOLIC";
1663 case DT_REL
: return "REL";
1664 case DT_RELSZ
: return "RELSZ";
1665 case DT_RELENT
: return "RELENT";
1666 case DT_PLTREL
: return "PLTREL";
1667 case DT_DEBUG
: return "DEBUG";
1668 case DT_TEXTREL
: return "TEXTREL";
1669 case DT_JMPREL
: return "JMPREL";
1670 case DT_BIND_NOW
: return "BIND_NOW";
1671 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1672 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1673 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1674 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1675 case DT_RUNPATH
: return "RUNPATH";
1676 case DT_FLAGS
: return "FLAGS";
1678 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1679 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1681 case DT_CHECKSUM
: return "CHECKSUM";
1682 case DT_PLTPADSZ
: return "PLTPADSZ";
1683 case DT_MOVEENT
: return "MOVEENT";
1684 case DT_MOVESZ
: return "MOVESZ";
1685 case DT_FEATURE
: return "FEATURE";
1686 case DT_POSFLAG_1
: return "POSFLAG_1";
1687 case DT_SYMINSZ
: return "SYMINSZ";
1688 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1690 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1691 case DT_CONFIG
: return "CONFIG";
1692 case DT_DEPAUDIT
: return "DEPAUDIT";
1693 case DT_AUDIT
: return "AUDIT";
1694 case DT_PLTPAD
: return "PLTPAD";
1695 case DT_MOVETAB
: return "MOVETAB";
1696 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1698 case DT_VERSYM
: return "VERSYM";
1700 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1701 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1702 case DT_RELACOUNT
: return "RELACOUNT";
1703 case DT_RELCOUNT
: return "RELCOUNT";
1704 case DT_FLAGS_1
: return "FLAGS_1";
1705 case DT_VERDEF
: return "VERDEF";
1706 case DT_VERDEFNUM
: return "VERDEFNUM";
1707 case DT_VERNEED
: return "VERNEED";
1708 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1710 case DT_AUXILIARY
: return "AUXILIARY";
1711 case DT_USED
: return "USED";
1712 case DT_FILTER
: return "FILTER";
1714 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1715 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1716 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1717 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1718 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1719 case DT_GNU_HASH
: return "GNU_HASH";
1722 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1726 switch (elf_header
.e_machine
)
1729 case EM_MIPS_RS3_LE
:
1730 result
= get_mips_dynamic_type (type
);
1733 result
= get_sparc64_dynamic_type (type
);
1736 result
= get_ppc_dynamic_type (type
);
1739 result
= get_ppc64_dynamic_type (type
);
1742 result
= get_ia64_dynamic_type (type
);
1745 result
= get_alpha_dynamic_type (type
);
1748 result
= get_score_dynamic_type (type
);
1758 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1760 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1761 || (elf_header
.e_machine
== EM_PARISC
1762 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1766 switch (elf_header
.e_machine
)
1769 result
= get_parisc_dynamic_type (type
);
1772 result
= get_ia64_dynamic_type (type
);
1782 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1786 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1793 get_file_type (unsigned e_type
)
1795 static char buff
[32];
1799 case ET_NONE
: return _("NONE (None)");
1800 case ET_REL
: return _("REL (Relocatable file)");
1801 case ET_EXEC
: return _("EXEC (Executable file)");
1802 case ET_DYN
: return _("DYN (Shared object file)");
1803 case ET_CORE
: return _("CORE (Core file)");
1806 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1807 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1808 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1809 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1811 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1817 get_machine_name (unsigned e_machine
)
1819 static char buff
[64]; /* XXX */
1823 case EM_NONE
: return _("None");
1824 case EM_M32
: return "WE32100";
1825 case EM_SPARC
: return "Sparc";
1826 case EM_SPU
: return "SPU";
1827 case EM_386
: return "Intel 80386";
1828 case EM_68K
: return "MC68000";
1829 case EM_88K
: return "MC88000";
1830 case EM_486
: return "Intel 80486";
1831 case EM_860
: return "Intel 80860";
1832 case EM_MIPS
: return "MIPS R3000";
1833 case EM_S370
: return "IBM System/370";
1834 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1835 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1836 case EM_PARISC
: return "HPPA";
1837 case EM_PPC_OLD
: return "Power PC (old)";
1838 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1839 case EM_960
: return "Intel 90860";
1840 case EM_PPC
: return "PowerPC";
1841 case EM_PPC64
: return "PowerPC64";
1842 case EM_V800
: return "NEC V800";
1843 case EM_FR20
: return "Fujitsu FR20";
1844 case EM_RH32
: return "TRW RH32";
1845 case EM_MCORE
: return "MCORE";
1846 case EM_ARM
: return "ARM";
1847 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1848 case EM_SH
: return "Renesas / SuperH SH";
1849 case EM_SPARCV9
: return "Sparc v9";
1850 case EM_TRICORE
: return "Siemens Tricore";
1851 case EM_ARC
: return "ARC";
1852 case EM_H8_300
: return "Renesas H8/300";
1853 case EM_H8_300H
: return "Renesas H8/300H";
1854 case EM_H8S
: return "Renesas H8S";
1855 case EM_H8_500
: return "Renesas H8/500";
1856 case EM_IA_64
: return "Intel IA-64";
1857 case EM_MIPS_X
: return "Stanford MIPS-X";
1858 case EM_COLDFIRE
: return "Motorola Coldfire";
1859 case EM_68HC12
: return "Motorola M68HC12";
1860 case EM_ALPHA
: return "Alpha";
1861 case EM_CYGNUS_D10V
:
1862 case EM_D10V
: return "d10v";
1863 case EM_CYGNUS_D30V
:
1864 case EM_D30V
: return "d30v";
1865 case EM_CYGNUS_M32R
:
1866 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1867 case EM_CYGNUS_V850
:
1868 case EM_V850
: return "NEC v850";
1869 case EM_CYGNUS_MN10300
:
1870 case EM_MN10300
: return "mn10300";
1871 case EM_CYGNUS_MN10200
:
1872 case EM_MN10200
: return "mn10200";
1873 case EM_CYGNUS_FR30
:
1874 case EM_FR30
: return "Fujitsu FR30";
1875 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1877 case EM_PJ
: return "picoJava";
1878 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1879 case EM_PCP
: return "Siemens PCP";
1880 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1881 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1882 case EM_STARCORE
: return "Motorola Star*Core processor";
1883 case EM_ME16
: return "Toyota ME16 processor";
1884 case EM_ST100
: return "STMicroelectronics ST100 processor";
1885 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1886 case EM_FX66
: return "Siemens FX66 microcontroller";
1887 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1888 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1889 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1890 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1891 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1892 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1893 case EM_SVX
: return "Silicon Graphics SVx";
1894 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1895 case EM_VAX
: return "Digital VAX";
1897 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1898 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1899 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1900 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1901 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1902 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1903 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1904 case EM_PRISM
: return "Vitesse Prism";
1905 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1907 case EM_S390
: return "IBM S/390";
1908 case EM_SCORE
: return "SUNPLUS S+Core";
1909 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1911 case EM_OR32
: return "OpenRISC";
1912 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1913 case EM_DLX
: return "OpenDLX";
1915 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1916 case EM_IQ2000
: return "Vitesse IQ2000";
1918 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1920 case EM_M32C
: return "Renesas M32c";
1921 case EM_MT
: return "Morpho Techologies MT processor";
1922 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1923 case EM_NIOS32
: return "Altera Nios";
1924 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1925 case EM_XC16X
: return "Infineon Technologies xc16x";
1926 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1927 case EM_CR16
: return "National Semiconductor's CR16";
1929 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1935 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1940 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1941 e_flags
&= ~ EF_ARM_EABIMASK
;
1943 /* Handle "generic" ARM flags. */
1944 if (e_flags
& EF_ARM_RELEXEC
)
1946 strcat (buf
, ", relocatable executable");
1947 e_flags
&= ~ EF_ARM_RELEXEC
;
1950 if (e_flags
& EF_ARM_HASENTRY
)
1952 strcat (buf
, ", has entry point");
1953 e_flags
&= ~ EF_ARM_HASENTRY
;
1956 /* Now handle EABI specific flags. */
1960 strcat (buf
, ", <unrecognized EABI>");
1965 case EF_ARM_EABI_VER1
:
1966 strcat (buf
, ", Version1 EABI");
1971 /* Process flags one bit at a time. */
1972 flag
= e_flags
& - e_flags
;
1977 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1978 strcat (buf
, ", sorted symbol tables");
1988 case EF_ARM_EABI_VER2
:
1989 strcat (buf
, ", Version2 EABI");
1994 /* Process flags one bit at a time. */
1995 flag
= e_flags
& - e_flags
;
2000 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2001 strcat (buf
, ", sorted symbol tables");
2004 case EF_ARM_DYNSYMSUSESEGIDX
:
2005 strcat (buf
, ", dynamic symbols use segment index");
2008 case EF_ARM_MAPSYMSFIRST
:
2009 strcat (buf
, ", mapping symbols precede others");
2019 case EF_ARM_EABI_VER3
:
2020 strcat (buf
, ", Version3 EABI");
2023 case EF_ARM_EABI_VER4
:
2024 strcat (buf
, ", Version4 EABI");
2027 case EF_ARM_EABI_VER5
:
2028 strcat (buf
, ", Version5 EABI");
2034 /* Process flags one bit at a time. */
2035 flag
= e_flags
& - e_flags
;
2041 strcat (buf
, ", BE8");
2045 strcat (buf
, ", LE8");
2055 case EF_ARM_EABI_UNKNOWN
:
2056 strcat (buf
, ", GNU EABI");
2061 /* Process flags one bit at a time. */
2062 flag
= e_flags
& - e_flags
;
2067 case EF_ARM_INTERWORK
:
2068 strcat (buf
, ", interworking enabled");
2071 case EF_ARM_APCS_26
:
2072 strcat (buf
, ", uses APCS/26");
2075 case EF_ARM_APCS_FLOAT
:
2076 strcat (buf
, ", uses APCS/float");
2080 strcat (buf
, ", position independent");
2084 strcat (buf
, ", 8 bit structure alignment");
2087 case EF_ARM_NEW_ABI
:
2088 strcat (buf
, ", uses new ABI");
2091 case EF_ARM_OLD_ABI
:
2092 strcat (buf
, ", uses old ABI");
2095 case EF_ARM_SOFT_FLOAT
:
2096 strcat (buf
, ", software FP");
2099 case EF_ARM_VFP_FLOAT
:
2100 strcat (buf
, ", VFP");
2103 case EF_ARM_MAVERICK_FLOAT
:
2104 strcat (buf
, ", Maverick FP");
2115 strcat (buf
,", <unknown>");
2119 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2121 static char buf
[1024];
2133 decode_ARM_machine_flags (e_flags
, buf
);
2137 switch (e_flags
& EF_FRV_CPU_MASK
)
2139 case EF_FRV_CPU_GENERIC
:
2143 strcat (buf
, ", fr???");
2146 case EF_FRV_CPU_FR300
:
2147 strcat (buf
, ", fr300");
2150 case EF_FRV_CPU_FR400
:
2151 strcat (buf
, ", fr400");
2153 case EF_FRV_CPU_FR405
:
2154 strcat (buf
, ", fr405");
2157 case EF_FRV_CPU_FR450
:
2158 strcat (buf
, ", fr450");
2161 case EF_FRV_CPU_FR500
:
2162 strcat (buf
, ", fr500");
2164 case EF_FRV_CPU_FR550
:
2165 strcat (buf
, ", fr550");
2168 case EF_FRV_CPU_SIMPLE
:
2169 strcat (buf
, ", simple");
2171 case EF_FRV_CPU_TOMCAT
:
2172 strcat (buf
, ", tomcat");
2178 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2179 strcat (buf
, ", m68000");
2180 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2181 strcat (buf
, ", cpu32");
2182 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2183 strcat (buf
, ", fido_a");
2186 char const *isa
= _("unknown");
2187 char const *mac
= _("unknown mac");
2188 char const *additional
= NULL
;
2190 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2192 case EF_M68K_CF_ISA_A_NODIV
:
2194 additional
= ", nodiv";
2196 case EF_M68K_CF_ISA_A
:
2199 case EF_M68K_CF_ISA_A_PLUS
:
2202 case EF_M68K_CF_ISA_B_NOUSP
:
2204 additional
= ", nousp";
2206 case EF_M68K_CF_ISA_B
:
2210 strcat (buf
, ", cf, isa ");
2213 strcat (buf
, additional
);
2214 if (e_flags
& EF_M68K_CF_FLOAT
)
2215 strcat (buf
, ", float");
2216 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2221 case EF_M68K_CF_MAC
:
2224 case EF_M68K_CF_EMAC
:
2237 if (e_flags
& EF_PPC_EMB
)
2238 strcat (buf
, ", emb");
2240 if (e_flags
& EF_PPC_RELOCATABLE
)
2241 strcat (buf
, ", relocatable");
2243 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2244 strcat (buf
, ", relocatable-lib");
2248 case EM_CYGNUS_V850
:
2249 switch (e_flags
& EF_V850_ARCH
)
2252 strcat (buf
, ", v850e1");
2255 strcat (buf
, ", v850e");
2258 strcat (buf
, ", v850");
2261 strcat (buf
, ", unknown v850 architecture variant");
2267 case EM_CYGNUS_M32R
:
2268 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2269 strcat (buf
, ", m32r");
2273 case EM_MIPS_RS3_LE
:
2274 if (e_flags
& EF_MIPS_NOREORDER
)
2275 strcat (buf
, ", noreorder");
2277 if (e_flags
& EF_MIPS_PIC
)
2278 strcat (buf
, ", pic");
2280 if (e_flags
& EF_MIPS_CPIC
)
2281 strcat (buf
, ", cpic");
2283 if (e_flags
& EF_MIPS_UCODE
)
2284 strcat (buf
, ", ugen_reserved");
2286 if (e_flags
& EF_MIPS_ABI2
)
2287 strcat (buf
, ", abi2");
2289 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2290 strcat (buf
, ", odk first");
2292 if (e_flags
& EF_MIPS_32BITMODE
)
2293 strcat (buf
, ", 32bitmode");
2295 switch ((e_flags
& EF_MIPS_MACH
))
2297 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2298 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2299 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2300 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2301 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2302 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2303 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2304 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2305 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2306 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2307 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2308 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2309 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2311 /* We simply ignore the field in this case to avoid confusion:
2312 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2315 default: strcat (buf
, ", unknown CPU"); break;
2318 switch ((e_flags
& EF_MIPS_ABI
))
2320 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2321 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2322 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2323 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2325 /* We simply ignore the field in this case to avoid confusion:
2326 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2327 This means it is likely to be an o32 file, but not for
2330 default: strcat (buf
, ", unknown ABI"); break;
2333 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2334 strcat (buf
, ", mdmx");
2336 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2337 strcat (buf
, ", mips16");
2339 switch ((e_flags
& EF_MIPS_ARCH
))
2341 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2342 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2343 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2344 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2345 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2346 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2347 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2348 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2349 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2350 default: strcat (buf
, ", unknown ISA"); break;
2356 switch ((e_flags
& EF_SH_MACH_MASK
))
2358 case EF_SH1
: strcat (buf
, ", sh1"); break;
2359 case EF_SH2
: strcat (buf
, ", sh2"); break;
2360 case EF_SH3
: strcat (buf
, ", sh3"); break;
2361 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2362 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2363 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2364 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2365 case EF_SH4
: strcat (buf
, ", sh4"); break;
2366 case EF_SH5
: strcat (buf
, ", sh5"); break;
2367 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2368 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2369 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2370 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2371 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2372 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2373 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2374 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2375 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2376 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2377 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2378 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2379 default: strcat (buf
, ", unknown ISA"); break;
2385 if (e_flags
& EF_SPARC_32PLUS
)
2386 strcat (buf
, ", v8+");
2388 if (e_flags
& EF_SPARC_SUN_US1
)
2389 strcat (buf
, ", ultrasparcI");
2391 if (e_flags
& EF_SPARC_SUN_US3
)
2392 strcat (buf
, ", ultrasparcIII");
2394 if (e_flags
& EF_SPARC_HAL_R1
)
2395 strcat (buf
, ", halr1");
2397 if (e_flags
& EF_SPARC_LEDATA
)
2398 strcat (buf
, ", ledata");
2400 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2401 strcat (buf
, ", tso");
2403 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2404 strcat (buf
, ", pso");
2406 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2407 strcat (buf
, ", rmo");
2411 switch (e_flags
& EF_PARISC_ARCH
)
2413 case EFA_PARISC_1_0
:
2414 strcpy (buf
, ", PA-RISC 1.0");
2416 case EFA_PARISC_1_1
:
2417 strcpy (buf
, ", PA-RISC 1.1");
2419 case EFA_PARISC_2_0
:
2420 strcpy (buf
, ", PA-RISC 2.0");
2425 if (e_flags
& EF_PARISC_TRAPNIL
)
2426 strcat (buf
, ", trapnil");
2427 if (e_flags
& EF_PARISC_EXT
)
2428 strcat (buf
, ", ext");
2429 if (e_flags
& EF_PARISC_LSB
)
2430 strcat (buf
, ", lsb");
2431 if (e_flags
& EF_PARISC_WIDE
)
2432 strcat (buf
, ", wide");
2433 if (e_flags
& EF_PARISC_NO_KABP
)
2434 strcat (buf
, ", no kabp");
2435 if (e_flags
& EF_PARISC_LAZYSWAP
)
2436 strcat (buf
, ", lazyswap");
2441 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2442 strcat (buf
, ", new calling convention");
2444 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2445 strcat (buf
, ", gnu calling convention");
2449 if ((e_flags
& EF_IA_64_ABI64
))
2450 strcat (buf
, ", 64-bit");
2452 strcat (buf
, ", 32-bit");
2453 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2454 strcat (buf
, ", reduced fp model");
2455 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2456 strcat (buf
, ", no function descriptors, constant gp");
2457 else if ((e_flags
& EF_IA_64_CONS_GP
))
2458 strcat (buf
, ", constant gp");
2459 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2460 strcat (buf
, ", absolute");
2464 if ((e_flags
& EF_VAX_NONPIC
))
2465 strcat (buf
, ", non-PIC");
2466 if ((e_flags
& EF_VAX_DFLOAT
))
2467 strcat (buf
, ", D-Float");
2468 if ((e_flags
& EF_VAX_GFLOAT
))
2469 strcat (buf
, ", G-Float");
2478 get_osabi_name (unsigned int osabi
)
2480 static char buff
[32];
2484 case ELFOSABI_NONE
: return "UNIX - System V";
2485 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2486 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2487 case ELFOSABI_LINUX
: return "UNIX - Linux";
2488 case ELFOSABI_HURD
: return "GNU/Hurd";
2489 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2490 case ELFOSABI_AIX
: return "UNIX - AIX";
2491 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2492 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2493 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2494 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2495 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2496 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2497 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2498 case ELFOSABI_AROS
: return "Amiga Research OS";
2499 case ELFOSABI_STANDALONE
: return _("Standalone App");
2500 case ELFOSABI_ARM
: return "ARM";
2502 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2508 get_arm_segment_type (unsigned long type
)
2522 get_mips_segment_type (unsigned long type
)
2526 case PT_MIPS_REGINFO
:
2528 case PT_MIPS_RTPROC
:
2530 case PT_MIPS_OPTIONS
:
2540 get_parisc_segment_type (unsigned long type
)
2544 case PT_HP_TLS
: return "HP_TLS";
2545 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2546 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2547 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2548 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2549 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2550 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2551 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2552 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2553 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2554 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2555 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2556 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2557 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2558 case PT_HP_STACK
: return "HP_STACK";
2559 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2560 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2561 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2562 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2571 get_ia64_segment_type (unsigned long type
)
2575 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2576 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2577 case PT_HP_TLS
: return "HP_TLS";
2578 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2579 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2580 case PT_IA_64_HP_STACK
: return "HP_STACK";
2589 get_segment_type (unsigned long p_type
)
2591 static char buff
[32];
2595 case PT_NULL
: return "NULL";
2596 case PT_LOAD
: return "LOAD";
2597 case PT_DYNAMIC
: return "DYNAMIC";
2598 case PT_INTERP
: return "INTERP";
2599 case PT_NOTE
: return "NOTE";
2600 case PT_SHLIB
: return "SHLIB";
2601 case PT_PHDR
: return "PHDR";
2602 case PT_TLS
: return "TLS";
2604 case PT_GNU_EH_FRAME
:
2605 return "GNU_EH_FRAME";
2606 case PT_GNU_STACK
: return "GNU_STACK";
2607 case PT_GNU_RELRO
: return "GNU_RELRO";
2610 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2614 switch (elf_header
.e_machine
)
2617 result
= get_arm_segment_type (p_type
);
2620 case EM_MIPS_RS3_LE
:
2621 result
= get_mips_segment_type (p_type
);
2624 result
= get_parisc_segment_type (p_type
);
2627 result
= get_ia64_segment_type (p_type
);
2637 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2639 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2643 switch (elf_header
.e_machine
)
2646 result
= get_parisc_segment_type (p_type
);
2649 result
= get_ia64_segment_type (p_type
);
2659 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2662 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2669 get_mips_section_type_name (unsigned int sh_type
)
2673 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2674 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2675 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2676 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2677 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2678 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2679 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2680 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2681 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2682 case SHT_MIPS_RELD
: return "MIPS_RELD";
2683 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2684 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2685 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2686 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2687 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2688 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2689 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2690 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2691 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2692 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2693 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2694 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2695 case SHT_MIPS_LINE
: return "MIPS_LINE";
2696 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2697 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2698 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2699 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2700 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2701 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2702 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2703 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2704 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2705 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2706 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2707 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2708 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2709 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2710 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2711 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2719 get_parisc_section_type_name (unsigned int sh_type
)
2723 case SHT_PARISC_EXT
: return "PARISC_EXT";
2724 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2725 case SHT_PARISC_DOC
: return "PARISC_DOC";
2726 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2727 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2728 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2729 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2737 get_ia64_section_type_name (unsigned int sh_type
)
2739 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2740 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2741 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2745 case SHT_IA_64_EXT
: return "IA_64_EXT";
2746 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2747 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2748 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2749 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2750 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2751 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2752 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2753 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2754 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2762 get_x86_64_section_type_name (unsigned int sh_type
)
2766 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2774 get_arm_section_type_name (unsigned int sh_type
)
2780 case SHT_ARM_PREEMPTMAP
:
2781 return "ARM_PREEMPTMAP";
2782 case SHT_ARM_ATTRIBUTES
:
2783 return "ARM_ATTRIBUTES";
2791 get_section_type_name (unsigned int sh_type
)
2793 static char buff
[32];
2797 case SHT_NULL
: return "NULL";
2798 case SHT_PROGBITS
: return "PROGBITS";
2799 case SHT_SYMTAB
: return "SYMTAB";
2800 case SHT_STRTAB
: return "STRTAB";
2801 case SHT_RELA
: return "RELA";
2802 case SHT_HASH
: return "HASH";
2803 case SHT_DYNAMIC
: return "DYNAMIC";
2804 case SHT_NOTE
: return "NOTE";
2805 case SHT_NOBITS
: return "NOBITS";
2806 case SHT_REL
: return "REL";
2807 case SHT_SHLIB
: return "SHLIB";
2808 case SHT_DYNSYM
: return "DYNSYM";
2809 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2810 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2811 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2812 case SHT_GNU_HASH
: return "GNU_HASH";
2813 case SHT_GROUP
: return "GROUP";
2814 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2815 case SHT_GNU_verdef
: return "VERDEF";
2816 case SHT_GNU_verneed
: return "VERNEED";
2817 case SHT_GNU_versym
: return "VERSYM";
2818 case 0x6ffffff0: return "VERSYM";
2819 case 0x6ffffffc: return "VERDEF";
2820 case 0x7ffffffd: return "AUXILIARY";
2821 case 0x7fffffff: return "FILTER";
2822 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2825 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2829 switch (elf_header
.e_machine
)
2832 case EM_MIPS_RS3_LE
:
2833 result
= get_mips_section_type_name (sh_type
);
2836 result
= get_parisc_section_type_name (sh_type
);
2839 result
= get_ia64_section_type_name (sh_type
);
2842 result
= get_x86_64_section_type_name (sh_type
);
2845 result
= get_arm_section_type_name (sh_type
);
2855 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2857 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2861 switch (elf_header
.e_machine
)
2864 result
= get_ia64_section_type_name (sh_type
);
2874 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2876 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2877 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2879 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2885 #define OPTION_DEBUG_DUMP 512
2887 static struct option options
[] =
2889 {"all", no_argument
, 0, 'a'},
2890 {"file-header", no_argument
, 0, 'h'},
2891 {"program-headers", no_argument
, 0, 'l'},
2892 {"headers", no_argument
, 0, 'e'},
2893 {"histogram", no_argument
, 0, 'I'},
2894 {"segments", no_argument
, 0, 'l'},
2895 {"sections", no_argument
, 0, 'S'},
2896 {"section-headers", no_argument
, 0, 'S'},
2897 {"section-groups", no_argument
, 0, 'g'},
2898 {"section-details", no_argument
, 0, 't'},
2899 {"full-section-name",no_argument
, 0, 'N'},
2900 {"symbols", no_argument
, 0, 's'},
2901 {"syms", no_argument
, 0, 's'},
2902 {"relocs", no_argument
, 0, 'r'},
2903 {"notes", no_argument
, 0, 'n'},
2904 {"dynamic", no_argument
, 0, 'd'},
2905 {"arch-specific", no_argument
, 0, 'A'},
2906 {"version-info", no_argument
, 0, 'V'},
2907 {"use-dynamic", no_argument
, 0, 'D'},
2908 {"unwind", no_argument
, 0, 'u'},
2909 {"archive-index", no_argument
, 0, 'c'},
2910 {"hex-dump", required_argument
, 0, 'x'},
2911 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2912 {"string-dump", required_argument
, 0, 'p'},
2913 #ifdef SUPPORT_DISASSEMBLY
2914 {"instruction-dump", required_argument
, 0, 'i'},
2917 {"version", no_argument
, 0, 'v'},
2918 {"wide", no_argument
, 0, 'W'},
2919 {"help", no_argument
, 0, 'H'},
2920 {0, no_argument
, 0, 0}
2924 usage (FILE *stream
)
2926 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2927 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2928 fprintf (stream
, _(" Options are:\n\
2929 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2930 -h --file-header Display the ELF file header\n\
2931 -l --program-headers Display the program headers\n\
2932 --segments An alias for --program-headers\n\
2933 -S --section-headers Display the sections' header\n\
2934 --sections An alias for --section-headers\n\
2935 -g --section-groups Display the section groups\n\
2936 -t --section-details Display the section details\n\
2937 -e --headers Equivalent to: -h -l -S\n\
2938 -s --syms Display the symbol table\n\
2939 --symbols An alias for --syms\n\
2940 -n --notes Display the core notes (if present)\n\
2941 -r --relocs Display the relocations (if present)\n\
2942 -u --unwind Display the unwind info (if present)\n\
2943 -d --dynamic Display the dynamic section (if present)\n\
2944 -V --version-info Display the version sections (if present)\n\
2945 -A --arch-specific Display architecture specific information (if any).\n\
2946 -c --archive-index Display the symbol/file index in an archive\n\
2947 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2948 -x --hex-dump=<number|name>\n\
2949 Dump the contents of section <number|name> as bytes\n\
2950 -p --string-dump=<number|name>\n\
2951 Dump the contents of section <number|name> as strings\n\
2952 -w[lLiaprmfFsoR] or\n\
2953 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2954 Display the contents of DWARF2 debug sections\n"));
2955 #ifdef SUPPORT_DISASSEMBLY
2956 fprintf (stream
, _("\
2957 -i --instruction-dump=<number|name>\n\
2958 Disassemble the contents of section <number|name>\n"));
2960 fprintf (stream
, _("\
2961 -I --histogram Display histogram of bucket list lengths\n\
2962 -W --wide Allow output width to exceed 80 characters\n\
2963 @<file> Read options from <file>\n\
2964 -H --help Display this information\n\
2965 -v --version Display the version number of readelf\n"));
2967 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2968 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2970 exit (stream
== stdout
? 0 : 1);
2973 /* Record the fact that the user wants the contents of section number
2974 SECTION to be displayed using the method(s) encoded as flags bits
2975 in TYPE. Note, TYPE can be zero if we are creating the array for
2979 request_dump_bynumber (unsigned int section
, dump_type type
)
2981 if (section
>= num_dump_sects
)
2983 dump_type
*new_dump_sects
;
2985 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2987 if (new_dump_sects
== NULL
)
2988 error (_("Out of memory allocating dump request table.\n"));
2991 /* Copy current flag settings. */
2992 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2996 dump_sects
= new_dump_sects
;
2997 num_dump_sects
= section
+ 1;
3002 dump_sects
[section
] |= type
;
3007 /* Request a dump by section name. */
3010 request_dump_byname (const char *section
, dump_type type
)
3012 struct dump_list_entry
*new_request
;
3014 new_request
= malloc (sizeof (struct dump_list_entry
));
3016 error (_("Out of memory allocating dump request table.\n"));
3018 new_request
->name
= strdup (section
);
3019 if (!new_request
->name
)
3020 error (_("Out of memory allocating dump request table.\n"));
3022 new_request
->type
= type
;
3024 new_request
->next
= dump_sects_byname
;
3025 dump_sects_byname
= new_request
;
3029 parse_args (int argc
, char **argv
)
3036 while ((c
= getopt_long
3037 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3058 do_section_groups
++;
3066 do_section_groups
++;
3071 do_section_details
++;
3116 section
= strtoul (optarg
, & cp
, 0);
3117 if (! *cp
&& section
>= 0)
3118 request_dump_bynumber (section
, HEX_DUMP
);
3120 request_dump_byname (optarg
, HEX_DUMP
);
3124 section
= strtoul (optarg
, & cp
, 0);
3125 if (! *cp
&& section
>= 0)
3126 request_dump_bynumber (section
, STRING_DUMP
);
3128 request_dump_byname (optarg
, STRING_DUMP
);
3136 unsigned int index
= 0;
3140 while (optarg
[index
])
3141 switch (optarg
[index
++])
3148 do_debug_abbrevs
= 1;
3156 do_debug_lines_decoded
= 1;
3160 do_debug_pubnames
= 1;
3164 do_debug_aranges
= 1;
3168 do_debug_ranges
= 1;
3172 do_debug_frames_interp
= 1;
3174 do_debug_frames
= 1;
3178 do_debug_macinfo
= 1;
3190 warn (_("Unrecognized debug option '%s'\n"), optarg
);
3195 case OPTION_DEBUG_DUMP
:
3203 const char * option
;
3206 debug_dump_long_opts
;
3208 debug_dump_long_opts opts_table
[] =
3210 /* Please keep this table alpha- sorted. */
3211 { "Ranges", & do_debug_ranges
},
3212 { "abbrev", & do_debug_abbrevs
},
3213 { "aranges", & do_debug_aranges
},
3214 { "frames", & do_debug_frames
},
3215 { "frames-interp", & do_debug_frames_interp
},
3216 { "info", & do_debug_info
},
3217 { "line", & do_debug_lines
}, /* For backwards compatibility. */
3218 { "rawline", & do_debug_lines
},
3219 { "decodedline", & do_debug_lines_decoded
},
3220 { "loc", & do_debug_loc
},
3221 { "macro", & do_debug_macinfo
},
3222 { "pubnames", & do_debug_pubnames
},
3223 /* This entry is for compatability
3224 with earlier versions of readelf. */
3225 { "ranges", & do_debug_aranges
},
3226 { "str", & do_debug_str
},
3237 debug_dump_long_opts
* entry
;
3239 for (entry
= opts_table
; entry
->option
; entry
++)
3241 size_t len
= strlen (entry
->option
);
3243 if (strneq (p
, entry
->option
, len
)
3244 && (p
[len
] == ',' || p
[len
] == '\0'))
3246 * entry
->variable
= 1;
3248 /* The --debug-dump=frames-interp option also
3249 enables the --debug-dump=frames option. */
3250 if (do_debug_frames_interp
)
3251 do_debug_frames
= 1;
3258 if (entry
->option
== NULL
)
3260 warn (_("Unrecognized debug option '%s'\n"), p
);
3261 p
= strchr (p
, ',');
3271 #ifdef SUPPORT_DISASSEMBLY
3274 section
= strtoul (optarg
, & cp
, 0);
3275 if (! *cp
&& section
>= 0)
3276 request_dump_bynumber (section
, DISASS_DUMP
);
3278 request_dump_byname (optarg
, DISASS_DUMP
);
3281 print_version (program_name
);
3290 /* xgettext:c-format */
3291 error (_("Invalid option '-%c'\n"), c
);
3298 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3299 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3300 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3301 && !do_section_groups
&& !do_archive_index
)
3305 warn (_("Nothing to do.\n"));
3311 get_elf_class (unsigned int elf_class
)
3313 static char buff
[32];
3317 case ELFCLASSNONE
: return _("none");
3318 case ELFCLASS32
: return "ELF32";
3319 case ELFCLASS64
: return "ELF64";
3321 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3327 get_data_encoding (unsigned int encoding
)
3329 static char buff
[32];
3333 case ELFDATANONE
: return _("none");
3334 case ELFDATA2LSB
: return _("2's complement, little endian");
3335 case ELFDATA2MSB
: return _("2's complement, big endian");
3337 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3342 /* Decode the data held in 'elf_header'. */
3345 process_file_header (void)
3347 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3348 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3349 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3350 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3353 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3357 init_dwarf_regnames (elf_header
.e_machine
);
3363 printf (_("ELF Header:\n"));
3364 printf (_(" Magic: "));
3365 for (i
= 0; i
< EI_NIDENT
; i
++)
3366 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3368 printf (_(" Class: %s\n"),
3369 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3370 printf (_(" Data: %s\n"),
3371 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3372 printf (_(" Version: %d %s\n"),
3373 elf_header
.e_ident
[EI_VERSION
],
3374 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3376 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3379 printf (_(" OS/ABI: %s\n"),
3380 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3381 printf (_(" ABI Version: %d\n"),
3382 elf_header
.e_ident
[EI_ABIVERSION
]);
3383 printf (_(" Type: %s\n"),
3384 get_file_type (elf_header
.e_type
));
3385 printf (_(" Machine: %s\n"),
3386 get_machine_name (elf_header
.e_machine
));
3387 printf (_(" Version: 0x%lx\n"),
3388 (unsigned long) elf_header
.e_version
);
3390 printf (_(" Entry point address: "));
3391 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3392 printf (_("\n Start of program headers: "));
3393 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3394 printf (_(" (bytes into file)\n Start of section headers: "));
3395 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3396 printf (_(" (bytes into file)\n"));
3398 printf (_(" Flags: 0x%lx%s\n"),
3399 (unsigned long) elf_header
.e_flags
,
3400 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3401 printf (_(" Size of this header: %ld (bytes)\n"),
3402 (long) elf_header
.e_ehsize
);
3403 printf (_(" Size of program headers: %ld (bytes)\n"),
3404 (long) elf_header
.e_phentsize
);
3405 printf (_(" Number of program headers: %ld\n"),
3406 (long) elf_header
.e_phnum
);
3407 printf (_(" Size of section headers: %ld (bytes)\n"),
3408 (long) elf_header
.e_shentsize
);
3409 printf (_(" Number of section headers: %ld"),
3410 (long) elf_header
.e_shnum
);
3411 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3412 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3413 putc ('\n', stdout
);
3414 printf (_(" Section header string table index: %ld"),
3415 (long) elf_header
.e_shstrndx
);
3416 if (section_headers
!= NULL
3417 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3418 printf (" (%u)", section_headers
[0].sh_link
);
3419 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3420 printf (" <corrupt: out of range>");
3421 putc ('\n', stdout
);
3424 if (section_headers
!= NULL
)
3426 if (elf_header
.e_shnum
== SHN_UNDEF
)
3427 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3428 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3429 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3430 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3431 elf_header
.e_shstrndx
= SHN_UNDEF
;
3432 free (section_headers
);
3433 section_headers
= NULL
;
3441 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3443 Elf32_External_Phdr
*phdrs
;
3444 Elf32_External_Phdr
*external
;
3445 Elf_Internal_Phdr
*internal
;
3448 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3449 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3450 _("program headers"));
3454 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3455 i
< elf_header
.e_phnum
;
3456 i
++, internal
++, external
++)
3458 internal
->p_type
= BYTE_GET (external
->p_type
);
3459 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3460 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3461 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3462 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3463 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3464 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3465 internal
->p_align
= BYTE_GET (external
->p_align
);
3474 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3476 Elf64_External_Phdr
*phdrs
;
3477 Elf64_External_Phdr
*external
;
3478 Elf_Internal_Phdr
*internal
;
3481 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3482 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3483 _("program headers"));
3487 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3488 i
< elf_header
.e_phnum
;
3489 i
++, internal
++, external
++)
3491 internal
->p_type
= BYTE_GET (external
->p_type
);
3492 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3493 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3494 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3495 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3496 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3497 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3498 internal
->p_align
= BYTE_GET (external
->p_align
);
3506 /* Returns 1 if the program headers were read into `program_headers'. */
3509 get_program_headers (FILE *file
)
3511 Elf_Internal_Phdr
*phdrs
;
3513 /* Check cache of prior read. */
3514 if (program_headers
!= NULL
)
3517 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3521 error (_("Out of memory\n"));
3526 ? get_32bit_program_headers (file
, phdrs
)
3527 : get_64bit_program_headers (file
, phdrs
))
3529 program_headers
= phdrs
;
3537 /* Returns 1 if the program headers were loaded. */
3540 process_program_headers (FILE *file
)
3542 Elf_Internal_Phdr
*segment
;
3545 if (elf_header
.e_phnum
== 0)
3548 printf (_("\nThere are no program headers in this file.\n"));
3552 if (do_segments
&& !do_header
)
3554 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3555 printf (_("Entry point "));
3556 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3557 printf (_("\nThere are %d program headers, starting at offset "),
3558 elf_header
.e_phnum
);
3559 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3563 if (! get_program_headers (file
))
3568 if (elf_header
.e_phnum
> 1)
3569 printf (_("\nProgram Headers:\n"));
3571 printf (_("\nProgram Headers:\n"));
3575 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3578 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3582 (_(" Type Offset VirtAddr PhysAddr\n"));
3584 (_(" FileSiz MemSiz Flags Align\n"));
3591 for (i
= 0, segment
= program_headers
;
3592 i
< elf_header
.e_phnum
;
3597 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3601 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3602 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3603 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3604 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3605 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3607 (segment
->p_flags
& PF_R
? 'R' : ' '),
3608 (segment
->p_flags
& PF_W
? 'W' : ' '),
3609 (segment
->p_flags
& PF_X
? 'E' : ' '));
3610 printf ("%#lx", (unsigned long) segment
->p_align
);
3614 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3615 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3618 print_vma (segment
->p_offset
, FULL_HEX
);
3622 print_vma (segment
->p_vaddr
, FULL_HEX
);
3624 print_vma (segment
->p_paddr
, FULL_HEX
);
3627 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3628 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3631 print_vma (segment
->p_filesz
, FULL_HEX
);
3635 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3636 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3639 print_vma (segment
->p_offset
, FULL_HEX
);
3643 (segment
->p_flags
& PF_R
? 'R' : ' '),
3644 (segment
->p_flags
& PF_W
? 'W' : ' '),
3645 (segment
->p_flags
& PF_X
? 'E' : ' '));
3647 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3648 printf ("%#lx", (unsigned long) segment
->p_align
);
3651 print_vma (segment
->p_align
, PREFIX_HEX
);
3656 print_vma (segment
->p_offset
, FULL_HEX
);
3658 print_vma (segment
->p_vaddr
, FULL_HEX
);
3660 print_vma (segment
->p_paddr
, FULL_HEX
);
3662 print_vma (segment
->p_filesz
, FULL_HEX
);
3664 print_vma (segment
->p_memsz
, FULL_HEX
);
3666 (segment
->p_flags
& PF_R
? 'R' : ' '),
3667 (segment
->p_flags
& PF_W
? 'W' : ' '),
3668 (segment
->p_flags
& PF_X
? 'E' : ' '));
3669 print_vma (segment
->p_align
, HEX
);
3673 switch (segment
->p_type
)
3677 error (_("more than one dynamic segment\n"));
3679 /* By default, assume that the .dynamic section is the first
3680 section in the DYNAMIC segment. */
3681 dynamic_addr
= segment
->p_offset
;
3682 dynamic_size
= segment
->p_filesz
;
3684 /* Try to locate the .dynamic section. If there is
3685 a section header table, we can easily locate it. */
3686 if (section_headers
!= NULL
)
3688 Elf_Internal_Shdr
*sec
;
3690 sec
= find_section (".dynamic");
3691 if (sec
== NULL
|| sec
->sh_size
== 0)
3693 error (_("no .dynamic section in the dynamic segment\n"));
3697 if (sec
->sh_type
== SHT_NOBITS
)
3703 dynamic_addr
= sec
->sh_offset
;
3704 dynamic_size
= sec
->sh_size
;
3706 if (dynamic_addr
< segment
->p_offset
3707 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3708 warn (_("the .dynamic section is not contained"
3709 " within the dynamic segment\n"));
3710 else if (dynamic_addr
> segment
->p_offset
)
3711 warn (_("the .dynamic section is not the first section"
3712 " in the dynamic segment.\n"));
3717 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3719 error (_("Unable to find program interpreter name\n"));
3723 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3725 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3726 error (_("Internal error: failed to create format string to display program interpreter\n"));
3728 program_interpreter
[0] = 0;
3729 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3730 error (_("Unable to read program interpreter name\n"));
3733 printf (_("\n [Requesting program interpreter: %s]"),
3734 program_interpreter
);
3740 putc ('\n', stdout
);
3743 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3745 printf (_("\n Section to Segment mapping:\n"));
3746 printf (_(" Segment Sections...\n"));
3748 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3751 Elf_Internal_Shdr
*section
;
3753 segment
= program_headers
+ i
;
3754 section
= section_headers
+ 1;
3756 printf (" %2.2d ", i
);
3758 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3760 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3761 printf ("%s ", SECTION_NAME (section
));
3772 /* Find the file offset corresponding to VMA by using the program headers. */
3775 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3777 Elf_Internal_Phdr
*seg
;
3779 if (! get_program_headers (file
))
3781 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3785 for (seg
= program_headers
;
3786 seg
< program_headers
+ elf_header
.e_phnum
;
3789 if (seg
->p_type
!= PT_LOAD
)
3792 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3793 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3794 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3797 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3804 get_32bit_section_headers (FILE *file
, unsigned int num
)
3806 Elf32_External_Shdr
*shdrs
;
3807 Elf_Internal_Shdr
*internal
;
3810 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3811 elf_header
.e_shentsize
, num
, _("section headers"));
3815 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3817 if (section_headers
== NULL
)
3819 error (_("Out of memory\n"));
3823 for (i
= 0, internal
= section_headers
;
3827 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3828 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3829 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3830 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3831 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3832 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3833 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3834 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3835 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3836 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3845 get_64bit_section_headers (FILE *file
, unsigned int num
)
3847 Elf64_External_Shdr
*shdrs
;
3848 Elf_Internal_Shdr
*internal
;
3851 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3852 elf_header
.e_shentsize
, num
, _("section headers"));
3856 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3858 if (section_headers
== NULL
)
3860 error (_("Out of memory\n"));
3864 for (i
= 0, internal
= section_headers
;
3868 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3869 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3870 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3871 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3872 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3873 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3874 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3875 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3876 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3877 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3885 static Elf_Internal_Sym
*
3886 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3888 unsigned long number
;
3889 Elf32_External_Sym
*esyms
;
3890 Elf_External_Sym_Shndx
*shndx
;
3891 Elf_Internal_Sym
*isyms
;
3892 Elf_Internal_Sym
*psym
;
3895 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3901 if (symtab_shndx_hdr
!= NULL
3902 && (symtab_shndx_hdr
->sh_link
3903 == (unsigned long) (section
- section_headers
)))
3905 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3906 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3914 number
= section
->sh_size
/ section
->sh_entsize
;
3915 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3919 error (_("Out of memory\n"));
3926 for (j
= 0, psym
= isyms
;
3930 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3931 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3932 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3933 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3934 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3936 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3937 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3938 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3939 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3940 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3950 static Elf_Internal_Sym
*
3951 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3953 unsigned long number
;
3954 Elf64_External_Sym
*esyms
;
3955 Elf_External_Sym_Shndx
*shndx
;
3956 Elf_Internal_Sym
*isyms
;
3957 Elf_Internal_Sym
*psym
;
3960 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3966 if (symtab_shndx_hdr
!= NULL
3967 && (symtab_shndx_hdr
->sh_link
3968 == (unsigned long) (section
- section_headers
)))
3970 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3971 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3979 number
= section
->sh_size
/ section
->sh_entsize
;
3980 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3984 error (_("Out of memory\n"));
3991 for (j
= 0, psym
= isyms
;
3995 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3996 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3997 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3998 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3999 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4001 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4002 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4003 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4004 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4005 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4016 get_elf_section_flags (bfd_vma sh_flags
)
4018 static char buff
[1024];
4020 int field_size
= is_32bit_elf
? 8 : 16;
4021 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
4022 bfd_vma os_flags
= 0;
4023 bfd_vma proc_flags
= 0;
4024 bfd_vma unknown_flags
= 0;
4038 { "LINK ORDER", 10 },
4039 { "OS NONCONF", 10 },
4042 /* IA-64 specific. */
4045 /* IA-64 OpenVMS specific. */
4046 { "VMS_GLOBAL", 10 },
4047 { "VMS_OVERLAID", 12 },
4048 { "VMS_SHARED", 10 },
4049 { "VMS_VECTOR", 10 },
4050 { "VMS_ALLOC_64BIT", 15 },
4051 { "VMS_PROTECTED", 13}
4054 if (do_section_details
)
4056 sprintf (buff
, "[%*.*lx]: ",
4057 field_size
, field_size
, (unsigned long) sh_flags
);
4058 p
+= field_size
+ 4;
4065 flag
= sh_flags
& - sh_flags
;
4068 if (do_section_details
)
4072 case SHF_WRITE
: index
= 0; break;
4073 case SHF_ALLOC
: index
= 1; break;
4074 case SHF_EXECINSTR
: index
= 2; break;
4075 case SHF_MERGE
: index
= 3; break;
4076 case SHF_STRINGS
: index
= 4; break;
4077 case SHF_INFO_LINK
: index
= 5; break;
4078 case SHF_LINK_ORDER
: index
= 6; break;
4079 case SHF_OS_NONCONFORMING
: index
= 7; break;
4080 case SHF_GROUP
: index
= 8; break;
4081 case SHF_TLS
: index
= 9; break;
4085 if (elf_header
.e_machine
== EM_IA_64
)
4087 if (flag
== SHF_IA_64_SHORT
)
4089 else if (flag
== SHF_IA_64_NORECOV
)
4092 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4095 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
4096 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
4097 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
4098 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
4099 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
4100 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
4110 if (p
!= buff
+ field_size
+ 4)
4112 if (size
< (10 + 2))
4119 size
-= flags
[index
].len
;
4120 p
= stpcpy (p
, flags
[index
].str
);
4122 else if (flag
& SHF_MASKOS
)
4124 else if (flag
& SHF_MASKPROC
)
4127 unknown_flags
|= flag
;
4133 case SHF_WRITE
: *p
= 'W'; break;
4134 case SHF_ALLOC
: *p
= 'A'; break;
4135 case SHF_EXECINSTR
: *p
= 'X'; break;
4136 case SHF_MERGE
: *p
= 'M'; break;
4137 case SHF_STRINGS
: *p
= 'S'; break;
4138 case SHF_INFO_LINK
: *p
= 'I'; break;
4139 case SHF_LINK_ORDER
: *p
= 'L'; break;
4140 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4141 case SHF_GROUP
: *p
= 'G'; break;
4142 case SHF_TLS
: *p
= 'T'; break;
4145 if (elf_header
.e_machine
== EM_X86_64
4146 && flag
== SHF_X86_64_LARGE
)
4148 else if (flag
& SHF_MASKOS
)
4151 sh_flags
&= ~ SHF_MASKOS
;
4153 else if (flag
& SHF_MASKPROC
)
4156 sh_flags
&= ~ SHF_MASKPROC
;
4166 if (do_section_details
)
4170 size
-= 5 + field_size
;
4171 if (p
!= buff
+ field_size
+ 4)
4179 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4180 (unsigned long) os_flags
);
4181 p
+= 5 + field_size
;
4185 size
-= 7 + field_size
;
4186 if (p
!= buff
+ field_size
+ 4)
4194 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4195 (unsigned long) proc_flags
);
4196 p
+= 7 + field_size
;
4200 size
-= 10 + field_size
;
4201 if (p
!= buff
+ field_size
+ 4)
4209 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4210 (unsigned long) unknown_flags
);
4211 p
+= 10 + field_size
;
4220 process_section_headers (FILE *file
)
4222 Elf_Internal_Shdr
*section
;
4225 section_headers
= NULL
;
4227 if (elf_header
.e_shnum
== 0)
4230 printf (_("\nThere are no sections in this file.\n"));
4235 if (do_sections
&& !do_header
)
4236 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4237 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4241 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4244 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4247 /* Read in the string table, so that we have names to display. */
4248 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4249 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4251 section
= section_headers
+ elf_header
.e_shstrndx
;
4253 if (section
->sh_size
!= 0)
4255 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4256 1, section
->sh_size
, _("string table"));
4258 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4262 /* Scan the sections for the dynamic symbol table
4263 and dynamic string table and debug sections. */
4264 dynamic_symbols
= NULL
;
4265 dynamic_strings
= NULL
;
4266 dynamic_syminfo
= NULL
;
4267 symtab_shndx_hdr
= NULL
;
4269 eh_addr_size
= is_32bit_elf
? 4 : 8;
4270 switch (elf_header
.e_machine
)
4273 case EM_MIPS_RS3_LE
:
4274 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4275 FDE addresses. However, the ABI also has a semi-official ILP32
4276 variant for which the normal FDE address size rules apply.
4278 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4279 section, where XX is the size of longs in bits. Unfortunately,
4280 earlier compilers provided no way of distinguishing ILP32 objects
4281 from LP64 objects, so if there's any doubt, we should assume that
4282 the official LP64 form is being used. */
4283 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4284 && find_section (".gcc_compiled_long32") == NULL
)
4290 switch (elf_header
.e_flags
& EF_H8_MACH
)
4292 case E_H8_MACH_H8300
:
4293 case E_H8_MACH_H8300HN
:
4294 case E_H8_MACH_H8300SN
:
4295 case E_H8_MACH_H8300SXN
:
4298 case E_H8_MACH_H8300H
:
4299 case E_H8_MACH_H8300S
:
4300 case E_H8_MACH_H8300SX
:
4308 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4310 case EF_M32C_CPU_M16C
:
4317 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4320 size_t expected_entsize \
4321 = is_32bit_elf ? size32 : size64; \
4322 if (section->sh_entsize != expected_entsize) \
4323 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4324 i, (unsigned long int) section->sh_entsize, \
4325 (unsigned long int) expected_entsize); \
4326 section->sh_entsize = expected_entsize; \
4329 #define CHECK_ENTSIZE(section, i, type) \
4330 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4331 sizeof (Elf64_External_##type))
4333 for (i
= 0, section
= section_headers
;
4334 i
< elf_header
.e_shnum
;
4337 char *name
= SECTION_NAME (section
);
4339 if (section
->sh_type
== SHT_DYNSYM
)
4341 if (dynamic_symbols
!= NULL
)
4343 error (_("File contains multiple dynamic symbol tables\n"));
4347 CHECK_ENTSIZE (section
, i
, Sym
);
4348 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4349 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4351 else if (section
->sh_type
== SHT_STRTAB
4352 && streq (name
, ".dynstr"))
4354 if (dynamic_strings
!= NULL
)
4356 error (_("File contains multiple dynamic string tables\n"));
4360 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4361 1, section
->sh_size
, _("dynamic strings"));
4362 dynamic_strings_length
= section
->sh_size
;
4364 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4366 if (symtab_shndx_hdr
!= NULL
)
4368 error (_("File contains multiple symtab shndx tables\n"));
4371 symtab_shndx_hdr
= section
;
4373 else if (section
->sh_type
== SHT_SYMTAB
)
4374 CHECK_ENTSIZE (section
, i
, Sym
);
4375 else if (section
->sh_type
== SHT_GROUP
)
4376 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4377 else if (section
->sh_type
== SHT_REL
)
4378 CHECK_ENTSIZE (section
, i
, Rel
);
4379 else if (section
->sh_type
== SHT_RELA
)
4380 CHECK_ENTSIZE (section
, i
, Rela
);
4381 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4382 || do_debug_lines
|| do_debug_lines_decoded
|| do_debug_pubnames
4383 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4384 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4385 && const_strneq (name
, ".debug_"))
4390 || (do_debug_info
&& streq (name
, "info"))
4391 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4392 || ((do_debug_lines
|| do_debug_lines_decoded
)
4393 && streq (name
, "line"))
4394 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4395 || (do_debug_aranges
&& streq (name
, "aranges"))
4396 || (do_debug_ranges
&& streq (name
, "ranges"))
4397 || (do_debug_frames
&& streq (name
, "frame"))
4398 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4399 || (do_debug_str
&& streq (name
, "str"))
4400 || (do_debug_loc
&& streq (name
, "loc"))
4402 request_dump_bynumber (i
, DEBUG_DUMP
);
4404 /* Linkonce section to be combined with .debug_info at link time. */
4405 else if ((do_debugging
|| do_debug_info
)
4406 && const_strneq (name
, ".gnu.linkonce.wi."))
4407 request_dump_bynumber (i
, DEBUG_DUMP
);
4408 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4409 request_dump_bynumber (i
, DEBUG_DUMP
);
4415 if (elf_header
.e_shnum
> 1)
4416 printf (_("\nSection Headers:\n"));
4418 printf (_("\nSection Header:\n"));
4422 if (do_section_details
)
4424 printf (_(" [Nr] Name\n"));
4425 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4429 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4433 if (do_section_details
)
4435 printf (_(" [Nr] Name\n"));
4436 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4440 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4444 if (do_section_details
)
4446 printf (_(" [Nr] Name\n"));
4447 printf (_(" Type Address Offset Link\n"));
4448 printf (_(" Size EntSize Info Align\n"));
4452 printf (_(" [Nr] Name Type Address Offset\n"));
4453 printf (_(" Size EntSize Flags Link Info Align\n"));
4457 if (do_section_details
)
4458 printf (_(" Flags\n"));
4460 for (i
= 0, section
= section_headers
;
4461 i
< elf_header
.e_shnum
;
4464 if (do_section_details
)
4466 printf (" [%2u] %s\n",
4468 SECTION_NAME (section
));
4469 if (is_32bit_elf
|| do_wide
)
4470 printf (" %-15.15s ",
4471 get_section_type_name (section
->sh_type
));
4474 printf (" [%2u] %-17.17s %-15.15s ",
4476 SECTION_NAME (section
),
4477 get_section_type_name (section
->sh_type
));
4481 print_vma (section
->sh_addr
, LONG_HEX
);
4483 printf ( " %6.6lx %6.6lx %2.2lx",
4484 (unsigned long) section
->sh_offset
,
4485 (unsigned long) section
->sh_size
,
4486 (unsigned long) section
->sh_entsize
);
4488 if (do_section_details
)
4489 fputs (" ", stdout
);
4491 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4493 printf ("%2u %3u %2lu\n",
4496 (unsigned long) section
->sh_addralign
);
4500 print_vma (section
->sh_addr
, LONG_HEX
);
4502 if ((long) section
->sh_offset
== section
->sh_offset
)
4503 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4507 print_vma (section
->sh_offset
, LONG_HEX
);
4510 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4511 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4515 print_vma (section
->sh_size
, LONG_HEX
);
4518 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4519 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4523 print_vma (section
->sh_entsize
, LONG_HEX
);
4526 if (do_section_details
)
4527 fputs (" ", stdout
);
4529 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4531 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4533 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4534 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4537 print_vma (section
->sh_addralign
, DEC
);
4541 else if (do_section_details
)
4543 printf (" %-15.15s ",
4544 get_section_type_name (section
->sh_type
));
4545 print_vma (section
->sh_addr
, LONG_HEX
);
4546 if ((long) section
->sh_offset
== section
->sh_offset
)
4547 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4551 print_vma (section
->sh_offset
, LONG_HEX
);
4553 printf (" %u\n ", section
->sh_link
);
4554 print_vma (section
->sh_size
, LONG_HEX
);
4556 print_vma (section
->sh_entsize
, LONG_HEX
);
4558 printf (" %-16u %lu\n",
4560 (unsigned long) section
->sh_addralign
);
4565 print_vma (section
->sh_addr
, LONG_HEX
);
4566 if ((long) section
->sh_offset
== section
->sh_offset
)
4567 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4571 print_vma (section
->sh_offset
, LONG_HEX
);
4574 print_vma (section
->sh_size
, LONG_HEX
);
4576 print_vma (section
->sh_entsize
, LONG_HEX
);
4578 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4580 printf (" %2u %3u %lu\n",
4583 (unsigned long) section
->sh_addralign
);
4586 if (do_section_details
)
4587 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4590 if (!do_section_details
)
4591 printf (_("Key to Flags:\n\
4592 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4593 I (info), L (link order), G (group), x (unknown)\n\
4594 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4600 get_group_flags (unsigned int flags
)
4602 static char buff
[32];
4609 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4616 process_section_groups (FILE *file
)
4618 Elf_Internal_Shdr
*section
;
4620 struct group
*group
;
4621 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4622 Elf_Internal_Sym
*symtab
;
4626 /* Don't process section groups unless needed. */
4627 if (!do_unwind
&& !do_section_groups
)
4630 if (elf_header
.e_shnum
== 0)
4632 if (do_section_groups
)
4633 printf (_("\nThere are no sections in this file.\n"));
4638 if (section_headers
== NULL
)
4640 error (_("Section headers are not available!\n"));
4644 section_headers_groups
= calloc (elf_header
.e_shnum
,
4645 sizeof (struct group
*));
4647 if (section_headers_groups
== NULL
)
4649 error (_("Out of memory\n"));
4653 /* Scan the sections for the group section. */
4655 for (i
= 0, section
= section_headers
;
4656 i
< elf_header
.e_shnum
;
4658 if (section
->sh_type
== SHT_GROUP
)
4661 if (group_count
== 0)
4663 if (do_section_groups
)
4664 printf (_("\nThere are no section groups in this file.\n"));
4669 section_groups
= calloc (group_count
, sizeof (struct group
));
4671 if (section_groups
== NULL
)
4673 error (_("Out of memory\n"));
4682 for (i
= 0, section
= section_headers
, group
= section_groups
;
4683 i
< elf_header
.e_shnum
;
4686 if (section
->sh_type
== SHT_GROUP
)
4688 char *name
= SECTION_NAME (section
);
4690 unsigned char *start
, *indices
;
4691 unsigned int entry
, j
, size
;
4692 Elf_Internal_Shdr
*sec
;
4693 Elf_Internal_Sym
*sym
;
4695 /* Get the symbol table. */
4696 if (section
->sh_link
>= elf_header
.e_shnum
4697 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4700 error (_("Bad sh_link in group section `%s'\n"), name
);
4704 if (symtab_sec
!= sec
)
4709 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4712 sym
= symtab
+ section
->sh_info
;
4714 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4716 if (sym
->st_shndx
== 0
4717 || sym
->st_shndx
>= elf_header
.e_shnum
)
4719 error (_("Bad sh_info in group section `%s'\n"), name
);
4723 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4732 /* Get the string table. */
4733 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4742 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4747 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4748 1, strtab_sec
->sh_size
,
4750 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4752 group_name
= sym
->st_name
< strtab_size
4753 ? strtab
+ sym
->st_name
: "<corrupt>";
4756 start
= get_data (NULL
, file
, section
->sh_offset
,
4757 1, section
->sh_size
, _("section data"));
4760 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4761 entry
= byte_get (indices
, 4);
4764 if (do_section_groups
)
4766 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4767 get_group_flags (entry
), i
, name
, group_name
, size
);
4769 printf (_(" [Index] Name\n"));
4772 group
->group_index
= i
;
4774 for (j
= 0; j
< size
; j
++)
4776 struct group_list
*g
;
4778 entry
= byte_get (indices
, 4);
4781 if (entry
>= elf_header
.e_shnum
)
4783 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4784 entry
, i
, elf_header
.e_shnum
- 1);
4788 if (section_headers_groups
[entry
] != NULL
)
4792 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4794 section_headers_groups
[entry
]->group_index
);
4799 /* Intel C/C++ compiler may put section 0 in a
4800 section group. We just warn it the first time
4801 and ignore it afterwards. */
4802 static int warned
= 0;
4805 error (_("section 0 in group section [%5u]\n"),
4806 section_headers_groups
[entry
]->group_index
);
4812 section_headers_groups
[entry
] = group
;
4814 if (do_section_groups
)
4816 sec
= section_headers
+ entry
;
4817 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4820 g
= xmalloc (sizeof (struct group_list
));
4821 g
->section_index
= entry
;
4822 g
->next
= group
->root
;
4846 } dynamic_relocations
[] =
4848 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4849 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4850 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4853 /* Process the reloc section. */
4856 process_relocs (FILE *file
)
4858 unsigned long rel_size
;
4859 unsigned long rel_offset
;
4865 if (do_using_dynamic
)
4869 int has_dynamic_reloc
;
4872 has_dynamic_reloc
= 0;
4874 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4876 is_rela
= dynamic_relocations
[i
].rela
;
4877 name
= dynamic_relocations
[i
].name
;
4878 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4879 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4881 has_dynamic_reloc
|= rel_size
;
4883 if (is_rela
== UNKNOWN
)
4885 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4886 switch (dynamic_info
[DT_PLTREL
])
4900 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4901 name
, rel_offset
, rel_size
);
4903 dump_relocations (file
,
4904 offset_from_vma (file
, rel_offset
, rel_size
),
4906 dynamic_symbols
, num_dynamic_syms
,
4907 dynamic_strings
, dynamic_strings_length
, is_rela
);
4911 if (! has_dynamic_reloc
)
4912 printf (_("\nThere are no dynamic relocations in this file.\n"));
4916 Elf_Internal_Shdr
*section
;
4920 for (i
= 0, section
= section_headers
;
4921 i
< elf_header
.e_shnum
;
4924 if ( section
->sh_type
!= SHT_RELA
4925 && section
->sh_type
!= SHT_REL
)
4928 rel_offset
= section
->sh_offset
;
4929 rel_size
= section
->sh_size
;
4933 Elf_Internal_Shdr
*strsec
;
4936 printf (_("\nRelocation section "));
4938 if (string_table
== NULL
)
4939 printf ("%d", section
->sh_name
);
4941 printf (_("'%s'"), SECTION_NAME (section
));
4943 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4944 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4946 is_rela
= section
->sh_type
== SHT_RELA
;
4948 if (section
->sh_link
!= 0
4949 && section
->sh_link
< elf_header
.e_shnum
)
4951 Elf_Internal_Shdr
*symsec
;
4952 Elf_Internal_Sym
*symtab
;
4953 unsigned long nsyms
;
4954 unsigned long strtablen
= 0;
4955 char *strtab
= NULL
;
4957 symsec
= section_headers
+ section
->sh_link
;
4958 if (symsec
->sh_type
!= SHT_SYMTAB
4959 && symsec
->sh_type
!= SHT_DYNSYM
)
4962 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4963 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4968 if (symsec
->sh_link
!= 0
4969 && symsec
->sh_link
< elf_header
.e_shnum
)
4971 strsec
= section_headers
+ symsec
->sh_link
;
4973 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4976 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4979 dump_relocations (file
, rel_offset
, rel_size
,
4980 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4986 dump_relocations (file
, rel_offset
, rel_size
,
4987 NULL
, 0, NULL
, 0, is_rela
);
4994 printf (_("\nThere are no relocations in this file.\n"));
5000 /* Process the unwind section. */
5002 #include "unwind-ia64.h"
5004 /* An absolute address consists of a section and an offset. If the
5005 section is NULL, the offset itself is the address, otherwise, the
5006 address equals to LOAD_ADDRESS(section) + offset. */
5010 unsigned short section
;
5014 #define ABSADDR(a) \
5016 ? section_headers [(a).section].sh_addr + (a).offset \
5019 struct ia64_unw_aux_info
5021 struct ia64_unw_table_entry
5023 struct absaddr start
;
5025 struct absaddr info
;
5027 *table
; /* Unwind table. */
5028 unsigned long table_len
; /* Length of unwind table. */
5029 unsigned char *info
; /* Unwind info. */
5030 unsigned long info_size
; /* Size of unwind info. */
5031 bfd_vma info_addr
; /* starting address of unwind info. */
5032 bfd_vma seg_base
; /* Starting address of segment. */
5033 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5034 unsigned long nsyms
; /* Number of symbols. */
5035 char *strtab
; /* The string table. */
5036 unsigned long strtab_size
; /* Size of string table. */
5040 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
5041 unsigned long nsyms
,
5043 unsigned long strtab_size
,
5044 struct absaddr addr
,
5045 const char **symname
,
5048 bfd_vma dist
= 0x100000;
5049 Elf_Internal_Sym
*sym
, *best
= NULL
;
5052 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5054 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5055 && sym
->st_name
!= 0
5056 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5057 && addr
.offset
>= sym
->st_value
5058 && addr
.offset
- sym
->st_value
< dist
)
5061 dist
= addr
.offset
- sym
->st_value
;
5068 *symname
= (best
->st_name
>= strtab_size
5069 ? "<corrupt>" : strtab
+ best
->st_name
);
5074 *offset
= addr
.offset
;
5078 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
5080 struct ia64_unw_table_entry
*tp
;
5083 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5087 const unsigned char *dp
;
5088 const unsigned char *head
;
5089 const char *procname
;
5091 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5092 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5094 fputs ("\n<", stdout
);
5098 fputs (procname
, stdout
);
5101 printf ("+%lx", (unsigned long) offset
);
5104 fputs (">: [", stdout
);
5105 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5106 fputc ('-', stdout
);
5107 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5108 printf ("], info at +0x%lx\n",
5109 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5111 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5112 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5114 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5115 (unsigned) UNW_VER (stamp
),
5116 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5117 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5118 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5119 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5121 if (UNW_VER (stamp
) != 1)
5123 printf ("\tUnknown version.\n");
5128 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5129 dp
= unw_decode (dp
, in_body
, & in_body
);
5134 slurp_ia64_unwind_table (FILE *file
,
5135 struct ia64_unw_aux_info
*aux
,
5136 Elf_Internal_Shdr
*sec
)
5138 unsigned long size
, nrelas
, i
;
5139 Elf_Internal_Phdr
*seg
;
5140 struct ia64_unw_table_entry
*tep
;
5141 Elf_Internal_Shdr
*relsec
;
5142 Elf_Internal_Rela
*rela
, *rp
;
5143 unsigned char *table
, *tp
;
5144 Elf_Internal_Sym
*sym
;
5145 const char *relname
;
5147 /* First, find the starting address of the segment that includes
5150 if (elf_header
.e_phnum
)
5152 if (! get_program_headers (file
))
5155 for (seg
= program_headers
;
5156 seg
< program_headers
+ elf_header
.e_phnum
;
5159 if (seg
->p_type
!= PT_LOAD
)
5162 if (sec
->sh_addr
>= seg
->p_vaddr
5163 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5165 aux
->seg_base
= seg
->p_vaddr
;
5171 /* Second, build the unwind table from the contents of the unwind section: */
5172 size
= sec
->sh_size
;
5173 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5177 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5179 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
5181 tep
->start
.section
= SHN_UNDEF
;
5182 tep
->end
.section
= SHN_UNDEF
;
5183 tep
->info
.section
= SHN_UNDEF
;
5186 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5187 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5188 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5192 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5193 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5194 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5196 tep
->start
.offset
+= aux
->seg_base
;
5197 tep
->end
.offset
+= aux
->seg_base
;
5198 tep
->info
.offset
+= aux
->seg_base
;
5202 /* Third, apply any relocations to the unwind table: */
5203 for (relsec
= section_headers
;
5204 relsec
< section_headers
+ elf_header
.e_shnum
;
5207 if (relsec
->sh_type
!= SHT_RELA
5208 || relsec
->sh_info
>= elf_header
.e_shnum
5209 || section_headers
+ relsec
->sh_info
!= sec
)
5212 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5216 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5218 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5219 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5221 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5223 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5227 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5229 switch (rp
->r_offset
/eh_addr_size
% 3)
5232 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5233 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5236 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5237 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5240 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5241 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5251 aux
->table_len
= size
/ (3 * eh_addr_size
);
5256 ia64_process_unwind (FILE *file
)
5258 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5259 unsigned long i
, unwcount
= 0, unwstart
= 0;
5260 struct ia64_unw_aux_info aux
;
5262 memset (& aux
, 0, sizeof (aux
));
5264 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5266 if (sec
->sh_type
== SHT_SYMTAB
5267 && sec
->sh_link
< elf_header
.e_shnum
)
5269 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5270 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5272 strsec
= section_headers
+ sec
->sh_link
;
5273 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5274 1, strsec
->sh_size
, _("string table"));
5275 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5277 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5282 printf (_("\nThere are no unwind sections in this file.\n"));
5284 while (unwcount
-- > 0)
5289 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5290 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5291 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5298 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5300 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5302 /* We need to find which section group it is in. */
5303 struct group_list
*g
= section_headers_groups
[i
]->root
;
5305 for (; g
!= NULL
; g
= g
->next
)
5307 sec
= section_headers
+ g
->section_index
;
5309 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5314 i
= elf_header
.e_shnum
;
5316 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5318 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5319 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5320 suffix
= SECTION_NAME (unwsec
) + len
;
5321 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5323 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5324 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5329 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5330 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5331 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5332 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5334 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5335 suffix
= SECTION_NAME (unwsec
) + len
;
5336 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5338 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5339 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5343 if (i
== elf_header
.e_shnum
)
5345 printf (_("\nCould not find unwind info section for "));
5347 if (string_table
== NULL
)
5348 printf ("%d", unwsec
->sh_name
);
5350 printf (_("'%s'"), SECTION_NAME (unwsec
));
5354 aux
.info_size
= sec
->sh_size
;
5355 aux
.info_addr
= sec
->sh_addr
;
5356 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5359 printf (_("\nUnwind section "));
5361 if (string_table
== NULL
)
5362 printf ("%d", unwsec
->sh_name
);
5364 printf (_("'%s'"), SECTION_NAME (unwsec
));
5366 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5367 (unsigned long) unwsec
->sh_offset
,
5368 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5370 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5372 if (aux
.table_len
> 0)
5373 dump_ia64_unwind (& aux
);
5376 free ((char *) aux
.table
);
5378 free ((char *) aux
.info
);
5387 free ((char *) aux
.strtab
);
5392 struct hppa_unw_aux_info
5394 struct hppa_unw_table_entry
5396 struct absaddr start
;
5398 unsigned int Cannot_unwind
:1; /* 0 */
5399 unsigned int Millicode
:1; /* 1 */
5400 unsigned int Millicode_save_sr0
:1; /* 2 */
5401 unsigned int Region_description
:2; /* 3..4 */
5402 unsigned int reserved1
:1; /* 5 */
5403 unsigned int Entry_SR
:1; /* 6 */
5404 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5405 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5406 unsigned int Args_stored
:1; /* 16 */
5407 unsigned int Variable_Frame
:1; /* 17 */
5408 unsigned int Separate_Package_Body
:1; /* 18 */
5409 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5410 unsigned int Stack_Overflow_Check
:1; /* 20 */
5411 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5412 unsigned int Ada_Region
:1; /* 22 */
5413 unsigned int cxx_info
:1; /* 23 */
5414 unsigned int cxx_try_catch
:1; /* 24 */
5415 unsigned int sched_entry_seq
:1; /* 25 */
5416 unsigned int reserved2
:1; /* 26 */
5417 unsigned int Save_SP
:1; /* 27 */
5418 unsigned int Save_RP
:1; /* 28 */
5419 unsigned int Save_MRP_in_frame
:1; /* 29 */
5420 unsigned int extn_ptr_defined
:1; /* 30 */
5421 unsigned int Cleanup_defined
:1; /* 31 */
5423 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5424 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5425 unsigned int Large_frame
:1; /* 2 */
5426 unsigned int Pseudo_SP_Set
:1; /* 3 */
5427 unsigned int reserved4
:1; /* 4 */
5428 unsigned int Total_frame_size
:27; /* 5..31 */
5430 *table
; /* Unwind table. */
5431 unsigned long table_len
; /* Length of unwind table. */
5432 bfd_vma seg_base
; /* Starting address of segment. */
5433 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5434 unsigned long nsyms
; /* Number of symbols. */
5435 char *strtab
; /* The string table. */
5436 unsigned long strtab_size
; /* Size of string table. */
5440 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5442 struct hppa_unw_table_entry
*tp
;
5444 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5447 const char *procname
;
5449 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5450 aux
->strtab_size
, tp
->start
, &procname
,
5453 fputs ("\n<", stdout
);
5457 fputs (procname
, stdout
);
5460 printf ("+%lx", (unsigned long) offset
);
5463 fputs (">: [", stdout
);
5464 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5465 fputc ('-', stdout
);
5466 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5469 #define PF(_m) if (tp->_m) printf (#_m " ");
5470 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5473 PF(Millicode_save_sr0
);
5474 /* PV(Region_description); */
5480 PF(Separate_Package_Body
);
5481 PF(Frame_Extension_Millicode
);
5482 PF(Stack_Overflow_Check
);
5483 PF(Two_Instruction_SP_Increment
);
5487 PF(sched_entry_seq
);
5490 PF(Save_MRP_in_frame
);
5491 PF(extn_ptr_defined
);
5492 PF(Cleanup_defined
);
5493 PF(MPE_XL_interrupt_marker
);
5494 PF(HP_UX_interrupt_marker
);
5497 PV(Total_frame_size
);
5506 slurp_hppa_unwind_table (FILE *file
,
5507 struct hppa_unw_aux_info
*aux
,
5508 Elf_Internal_Shdr
*sec
)
5510 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5511 Elf_Internal_Phdr
*seg
;
5512 struct hppa_unw_table_entry
*tep
;
5513 Elf_Internal_Shdr
*relsec
;
5514 Elf_Internal_Rela
*rela
, *rp
;
5515 unsigned char *table
, *tp
;
5516 Elf_Internal_Sym
*sym
;
5517 const char *relname
;
5519 /* First, find the starting address of the segment that includes
5522 if (elf_header
.e_phnum
)
5524 if (! get_program_headers (file
))
5527 for (seg
= program_headers
;
5528 seg
< program_headers
+ elf_header
.e_phnum
;
5531 if (seg
->p_type
!= PT_LOAD
)
5534 if (sec
->sh_addr
>= seg
->p_vaddr
5535 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5537 aux
->seg_base
= seg
->p_vaddr
;
5543 /* Second, build the unwind table from the contents of the unwind
5545 size
= sec
->sh_size
;
5546 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5551 nentries
= size
/ unw_ent_size
;
5552 size
= unw_ent_size
* nentries
;
5554 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5556 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5558 unsigned int tmp1
, tmp2
;
5560 tep
->start
.section
= SHN_UNDEF
;
5561 tep
->end
.section
= SHN_UNDEF
;
5563 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5564 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5565 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5566 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5568 tep
->start
.offset
+= aux
->seg_base
;
5569 tep
->end
.offset
+= aux
->seg_base
;
5571 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5572 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5573 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5574 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5575 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5576 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5577 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5578 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5579 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5580 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5581 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5582 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5583 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5584 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5585 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5586 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5587 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5588 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5589 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5590 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5591 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5592 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5593 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5594 tep
->Cleanup_defined
= tmp1
& 0x1;
5596 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5597 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5598 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5599 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5600 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5601 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5605 /* Third, apply any relocations to the unwind table. */
5606 for (relsec
= section_headers
;
5607 relsec
< section_headers
+ elf_header
.e_shnum
;
5610 if (relsec
->sh_type
!= SHT_RELA
5611 || relsec
->sh_info
>= elf_header
.e_shnum
5612 || section_headers
+ relsec
->sh_info
!= sec
)
5615 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5619 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5621 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5622 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5624 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5625 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5627 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5631 i
= rp
->r_offset
/ unw_ent_size
;
5633 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5636 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5637 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5640 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5641 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5651 aux
->table_len
= nentries
;
5657 hppa_process_unwind (FILE *file
)
5659 struct hppa_unw_aux_info aux
;
5660 Elf_Internal_Shdr
*unwsec
= NULL
;
5661 Elf_Internal_Shdr
*strsec
;
5662 Elf_Internal_Shdr
*sec
;
5665 memset (& aux
, 0, sizeof (aux
));
5667 if (string_table
== NULL
)
5670 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5672 if (sec
->sh_type
== SHT_SYMTAB
5673 && sec
->sh_link
< elf_header
.e_shnum
)
5675 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5676 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5678 strsec
= section_headers
+ sec
->sh_link
;
5679 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5680 1, strsec
->sh_size
, _("string table"));
5681 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5683 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5688 printf (_("\nThere are no unwind sections in this file.\n"));
5690 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5692 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5694 printf (_("\nUnwind section "));
5695 printf (_("'%s'"), SECTION_NAME (sec
));
5697 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5698 (unsigned long) sec
->sh_offset
,
5699 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5701 slurp_hppa_unwind_table (file
, &aux
, sec
);
5702 if (aux
.table_len
> 0)
5703 dump_hppa_unwind (&aux
);
5706 free ((char *) aux
.table
);
5714 free ((char *) aux
.strtab
);
5720 process_unwind (FILE *file
)
5722 struct unwind_handler
{
5724 int (*handler
)(FILE *file
);
5726 { EM_IA_64
, ia64_process_unwind
},
5727 { EM_PARISC
, hppa_process_unwind
},
5735 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5736 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5737 return handlers
[i
].handler (file
);
5739 printf (_("\nThere are no unwind sections in this file.\n"));
5744 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5746 switch (entry
->d_tag
)
5749 if (entry
->d_un
.d_val
== 0)
5753 static const char * opts
[] =
5755 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5756 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5757 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5758 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5763 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5764 if (entry
->d_un
.d_val
& (1 << cnt
))
5766 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5773 case DT_MIPS_IVERSION
:
5774 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5775 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5777 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5780 case DT_MIPS_TIME_STAMP
:
5785 time_t time
= entry
->d_un
.d_val
;
5786 tmp
= gmtime (&time
);
5787 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5788 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5789 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5790 printf ("Time Stamp: %s\n", timebuf
);
5794 case DT_MIPS_RLD_VERSION
:
5795 case DT_MIPS_LOCAL_GOTNO
:
5796 case DT_MIPS_CONFLICTNO
:
5797 case DT_MIPS_LIBLISTNO
:
5798 case DT_MIPS_SYMTABNO
:
5799 case DT_MIPS_UNREFEXTNO
:
5800 case DT_MIPS_HIPAGENO
:
5801 case DT_MIPS_DELTA_CLASS_NO
:
5802 case DT_MIPS_DELTA_INSTANCE_NO
:
5803 case DT_MIPS_DELTA_RELOC_NO
:
5804 case DT_MIPS_DELTA_SYM_NO
:
5805 case DT_MIPS_DELTA_CLASSSYM_NO
:
5806 case DT_MIPS_COMPACT_SIZE
:
5807 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5811 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5817 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5819 switch (entry
->d_tag
)
5821 case DT_HP_DLD_FLAGS
:
5830 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5831 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5832 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5833 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5834 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5835 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5836 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5837 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5838 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5839 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5840 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5841 { DT_HP_GST
, "HP_GST" },
5842 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5843 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5844 { DT_HP_NODELETE
, "HP_NODELETE" },
5845 { DT_HP_GROUP
, "HP_GROUP" },
5846 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5850 bfd_vma val
= entry
->d_un
.d_val
;
5852 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5853 if (val
& flags
[cnt
].bit
)
5857 fputs (flags
[cnt
].str
, stdout
);
5859 val
^= flags
[cnt
].bit
;
5862 if (val
!= 0 || first
)
5866 print_vma (val
, HEX
);
5872 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5879 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5881 switch (entry
->d_tag
)
5883 case DT_IA_64_PLT_RESERVE
:
5884 /* First 3 slots reserved. */
5885 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5887 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5891 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5898 get_32bit_dynamic_section (FILE *file
)
5900 Elf32_External_Dyn
*edyn
, *ext
;
5901 Elf_Internal_Dyn
*entry
;
5903 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5904 _("dynamic section"));
5908 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5909 might not have the luxury of section headers. Look for the DT_NULL
5910 terminator to determine the number of entries. */
5911 for (ext
= edyn
, dynamic_nent
= 0;
5912 (char *) ext
< (char *) edyn
+ dynamic_size
;
5916 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5920 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5921 if (dynamic_section
== NULL
)
5923 error (_("Out of memory\n"));
5928 for (ext
= edyn
, entry
= dynamic_section
;
5929 entry
< dynamic_section
+ dynamic_nent
;
5932 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5933 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5942 get_64bit_dynamic_section (FILE *file
)
5944 Elf64_External_Dyn
*edyn
, *ext
;
5945 Elf_Internal_Dyn
*entry
;
5947 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5948 _("dynamic section"));
5952 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5953 might not have the luxury of section headers. Look for the DT_NULL
5954 terminator to determine the number of entries. */
5955 for (ext
= edyn
, dynamic_nent
= 0;
5956 (char *) ext
< (char *) edyn
+ dynamic_size
;
5960 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5964 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5965 if (dynamic_section
== NULL
)
5967 error (_("Out of memory\n"));
5972 for (ext
= edyn
, entry
= dynamic_section
;
5973 entry
< dynamic_section
+ dynamic_nent
;
5976 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5977 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5986 print_dynamic_flags (bfd_vma flags
)
5994 flag
= flags
& - flags
;
6004 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6005 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6006 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6007 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6008 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6009 default: fputs ("unknown", stdout
); break;
6015 /* Parse and display the contents of the dynamic section. */
6018 process_dynamic_section (FILE *file
)
6020 Elf_Internal_Dyn
*entry
;
6022 if (dynamic_size
== 0)
6025 printf (_("\nThere is no dynamic section in this file.\n"));
6032 if (! get_32bit_dynamic_section (file
))
6035 else if (! get_64bit_dynamic_section (file
))
6038 /* Find the appropriate symbol table. */
6039 if (dynamic_symbols
== NULL
)
6041 for (entry
= dynamic_section
;
6042 entry
< dynamic_section
+ dynamic_nent
;
6045 Elf_Internal_Shdr section
;
6047 if (entry
->d_tag
!= DT_SYMTAB
)
6050 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6052 /* Since we do not know how big the symbol table is,
6053 we default to reading in the entire file (!) and
6054 processing that. This is overkill, I know, but it
6056 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6058 if (archive_file_offset
!= 0)
6059 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6062 if (fseek (file
, 0, SEEK_END
))
6063 error (_("Unable to seek to end of file!\n"));
6065 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6069 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6071 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6073 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6074 if (num_dynamic_syms
< 1)
6076 error (_("Unable to determine the number of symbols to load\n"));
6080 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6084 /* Similarly find a string table. */
6085 if (dynamic_strings
== NULL
)
6087 for (entry
= dynamic_section
;
6088 entry
< dynamic_section
+ dynamic_nent
;
6091 unsigned long offset
;
6094 if (entry
->d_tag
!= DT_STRTAB
)
6097 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6099 /* Since we do not know how big the string table is,
6100 we default to reading in the entire file (!) and
6101 processing that. This is overkill, I know, but it
6104 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6106 if (archive_file_offset
!= 0)
6107 str_tab_len
= archive_file_size
- offset
;
6110 if (fseek (file
, 0, SEEK_END
))
6111 error (_("Unable to seek to end of file\n"));
6112 str_tab_len
= ftell (file
) - offset
;
6115 if (str_tab_len
< 1)
6118 (_("Unable to determine the length of the dynamic string table\n"));
6122 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
6123 _("dynamic string table"));
6124 dynamic_strings_length
= str_tab_len
;
6129 /* And find the syminfo section if available. */
6130 if (dynamic_syminfo
== NULL
)
6132 unsigned long syminsz
= 0;
6134 for (entry
= dynamic_section
;
6135 entry
< dynamic_section
+ dynamic_nent
;
6138 if (entry
->d_tag
== DT_SYMINENT
)
6140 /* Note: these braces are necessary to avoid a syntax
6141 error from the SunOS4 C compiler. */
6142 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6144 else if (entry
->d_tag
== DT_SYMINSZ
)
6145 syminsz
= entry
->d_un
.d_val
;
6146 else if (entry
->d_tag
== DT_SYMINFO
)
6147 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6151 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6153 Elf_External_Syminfo
*extsyminfo
, *extsym
;
6154 Elf_Internal_Syminfo
*syminfo
;
6156 /* There is a syminfo section. Read the data. */
6157 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
6158 syminsz
, _("symbol information"));
6162 dynamic_syminfo
= malloc (syminsz
);
6163 if (dynamic_syminfo
== NULL
)
6165 error (_("Out of memory\n"));
6169 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6170 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6171 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6172 ++syminfo
, ++extsym
)
6174 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6175 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6182 if (do_dynamic
&& dynamic_addr
)
6183 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6184 dynamic_addr
, dynamic_nent
);
6186 printf (_(" Tag Type Name/Value\n"));
6188 for (entry
= dynamic_section
;
6189 entry
< dynamic_section
+ dynamic_nent
;
6197 print_vma (entry
->d_tag
, FULL_HEX
);
6198 dtype
= get_dynamic_type (entry
->d_tag
);
6199 printf (" (%s)%*s", dtype
,
6200 ((is_32bit_elf
? 27 : 19)
6201 - (int) strlen (dtype
)),
6205 switch (entry
->d_tag
)
6209 print_dynamic_flags (entry
->d_un
.d_val
);
6219 switch (entry
->d_tag
)
6222 printf (_("Auxiliary library"));
6226 printf (_("Filter library"));
6230 printf (_("Configuration file"));
6234 printf (_("Dependency audit library"));
6238 printf (_("Audit library"));
6242 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6243 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6247 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6256 printf (_("Flags:"));
6258 if (entry
->d_un
.d_val
== 0)
6259 printf (_(" None\n"));
6262 unsigned long int val
= entry
->d_un
.d_val
;
6264 if (val
& DTF_1_PARINIT
)
6266 printf (" PARINIT");
6267 val
^= DTF_1_PARINIT
;
6269 if (val
& DTF_1_CONFEXP
)
6271 printf (" CONFEXP");
6272 val
^= DTF_1_CONFEXP
;
6275 printf (" %lx", val
);
6284 printf (_("Flags:"));
6286 if (entry
->d_un
.d_val
== 0)
6287 printf (_(" None\n"));
6290 unsigned long int val
= entry
->d_un
.d_val
;
6292 if (val
& DF_P1_LAZYLOAD
)
6294 printf (" LAZYLOAD");
6295 val
^= DF_P1_LAZYLOAD
;
6297 if (val
& DF_P1_GROUPPERM
)
6299 printf (" GROUPPERM");
6300 val
^= DF_P1_GROUPPERM
;
6303 printf (" %lx", val
);
6312 printf (_("Flags:"));
6313 if (entry
->d_un
.d_val
== 0)
6314 printf (_(" None\n"));
6317 unsigned long int val
= entry
->d_un
.d_val
;
6324 if (val
& DF_1_GLOBAL
)
6329 if (val
& DF_1_GROUP
)
6334 if (val
& DF_1_NODELETE
)
6336 printf (" NODELETE");
6337 val
^= DF_1_NODELETE
;
6339 if (val
& DF_1_LOADFLTR
)
6341 printf (" LOADFLTR");
6342 val
^= DF_1_LOADFLTR
;
6344 if (val
& DF_1_INITFIRST
)
6346 printf (" INITFIRST");
6347 val
^= DF_1_INITFIRST
;
6349 if (val
& DF_1_NOOPEN
)
6354 if (val
& DF_1_ORIGIN
)
6359 if (val
& DF_1_DIRECT
)
6364 if (val
& DF_1_TRANS
)
6369 if (val
& DF_1_INTERPOSE
)
6371 printf (" INTERPOSE");
6372 val
^= DF_1_INTERPOSE
;
6374 if (val
& DF_1_NODEFLIB
)
6376 printf (" NODEFLIB");
6377 val
^= DF_1_NODEFLIB
;
6379 if (val
& DF_1_NODUMP
)
6384 if (val
& DF_1_CONLFAT
)
6386 printf (" CONLFAT");
6387 val
^= DF_1_CONLFAT
;
6390 printf (" %lx", val
);
6397 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6399 puts (get_dynamic_type (entry
->d_un
.d_val
));
6419 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6425 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6426 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6432 switch (entry
->d_tag
)
6435 printf (_("Shared library: [%s]"), name
);
6437 if (streq (name
, program_interpreter
))
6438 printf (_(" program interpreter"));
6442 printf (_("Library soname: [%s]"), name
);
6446 printf (_("Library rpath: [%s]"), name
);
6450 printf (_("Library runpath: [%s]"), name
);
6454 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6459 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6472 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6476 case DT_INIT_ARRAYSZ
:
6477 case DT_FINI_ARRAYSZ
:
6478 case DT_GNU_CONFLICTSZ
:
6479 case DT_GNU_LIBLISTSZ
:
6482 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6483 printf (" (bytes)\n");
6493 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6506 if (entry
->d_tag
== DT_USED
6507 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6509 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6513 printf (_("Not needed object: [%s]\n"), name
);
6518 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6524 /* The value of this entry is ignored. */
6529 case DT_GNU_PRELINKED
:
6533 time_t time
= entry
->d_un
.d_val
;
6535 tmp
= gmtime (&time
);
6536 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6537 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6538 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6544 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6547 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6553 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6554 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6559 switch (elf_header
.e_machine
)
6562 case EM_MIPS_RS3_LE
:
6563 dynamic_section_mips_val (entry
);
6566 dynamic_section_parisc_val (entry
);
6569 dynamic_section_ia64_val (entry
);
6572 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6584 get_ver_flags (unsigned int flags
)
6586 static char buff
[32];
6593 if (flags
& VER_FLG_BASE
)
6594 strcat (buff
, "BASE ");
6596 if (flags
& VER_FLG_WEAK
)
6598 if (flags
& VER_FLG_BASE
)
6599 strcat (buff
, "| ");
6601 strcat (buff
, "WEAK ");
6604 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6605 strcat (buff
, "| <unknown>");
6610 /* Display the contents of the version sections. */
6612 process_version_sections (FILE *file
)
6614 Elf_Internal_Shdr
*section
;
6621 for (i
= 0, section
= section_headers
;
6622 i
< elf_header
.e_shnum
;
6625 switch (section
->sh_type
)
6627 case SHT_GNU_verdef
:
6629 Elf_External_Verdef
*edefs
;
6637 (_("\nVersion definition section '%s' contains %u entries:\n"),
6638 SECTION_NAME (section
), section
->sh_info
);
6640 printf (_(" Addr: 0x"));
6641 printf_vma (section
->sh_addr
);
6642 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6643 (unsigned long) section
->sh_offset
, section
->sh_link
,
6644 section
->sh_link
< elf_header
.e_shnum
6645 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6648 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6650 _("version definition section"));
6651 endbuf
= (char *) edefs
+ section
->sh_size
;
6655 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6658 Elf_External_Verdef
*edef
;
6659 Elf_Internal_Verdef ent
;
6660 Elf_External_Verdaux
*eaux
;
6661 Elf_Internal_Verdaux aux
;
6665 vstart
= ((char *) edefs
) + idx
;
6666 if (vstart
+ sizeof (*edef
) > endbuf
)
6669 edef
= (Elf_External_Verdef
*) vstart
;
6671 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6672 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6673 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6674 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6675 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6676 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6677 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6679 printf (_(" %#06x: Rev: %d Flags: %s"),
6680 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6682 printf (_(" Index: %d Cnt: %d "),
6683 ent
.vd_ndx
, ent
.vd_cnt
);
6685 vstart
+= ent
.vd_aux
;
6687 eaux
= (Elf_External_Verdaux
*) vstart
;
6689 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6690 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6692 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6693 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6695 printf (_("Name index: %ld\n"), aux
.vda_name
);
6697 isum
= idx
+ ent
.vd_aux
;
6699 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6701 isum
+= aux
.vda_next
;
6702 vstart
+= aux
.vda_next
;
6704 eaux
= (Elf_External_Verdaux
*) vstart
;
6705 if (vstart
+ sizeof (*eaux
) > endbuf
)
6708 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6709 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6711 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6712 printf (_(" %#06x: Parent %d: %s\n"),
6713 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6715 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6716 isum
, j
, aux
.vda_name
);
6719 printf (_(" Version def aux past end of section\n"));
6723 if (cnt
< section
->sh_info
)
6724 printf (_(" Version definition past end of section\n"));
6730 case SHT_GNU_verneed
:
6732 Elf_External_Verneed
*eneed
;
6739 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6740 SECTION_NAME (section
), section
->sh_info
);
6742 printf (_(" Addr: 0x"));
6743 printf_vma (section
->sh_addr
);
6744 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6745 (unsigned long) section
->sh_offset
, section
->sh_link
,
6746 section
->sh_link
< elf_header
.e_shnum
6747 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6750 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6752 _("version need section"));
6753 endbuf
= (char *) eneed
+ section
->sh_size
;
6757 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6759 Elf_External_Verneed
*entry
;
6760 Elf_Internal_Verneed ent
;
6765 vstart
= ((char *) eneed
) + idx
;
6766 if (vstart
+ sizeof (*entry
) > endbuf
)
6769 entry
= (Elf_External_Verneed
*) vstart
;
6771 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6772 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6773 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6774 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6775 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6777 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6779 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6780 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6782 printf (_(" File: %lx"), ent
.vn_file
);
6784 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6786 vstart
+= ent
.vn_aux
;
6788 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6790 Elf_External_Vernaux
*eaux
;
6791 Elf_Internal_Vernaux aux
;
6793 if (vstart
+ sizeof (*eaux
) > endbuf
)
6795 eaux
= (Elf_External_Vernaux
*) vstart
;
6797 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6798 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6799 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6800 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6801 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6803 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6804 printf (_(" %#06x: Name: %s"),
6805 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6807 printf (_(" %#06x: Name index: %lx"),
6808 isum
, aux
.vna_name
);
6810 printf (_(" Flags: %s Version: %d\n"),
6811 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6813 isum
+= aux
.vna_next
;
6814 vstart
+= aux
.vna_next
;
6817 printf (_(" Version need aux past end of section\n"));
6821 if (cnt
< section
->sh_info
)
6822 printf (_(" Version need past end of section\n"));
6828 case SHT_GNU_versym
:
6830 Elf_Internal_Shdr
*link_section
;
6833 unsigned char *edata
;
6834 unsigned short *data
;
6836 Elf_Internal_Sym
*symbols
;
6837 Elf_Internal_Shdr
*string_sec
;
6840 if (section
->sh_link
>= elf_header
.e_shnum
)
6843 link_section
= section_headers
+ section
->sh_link
;
6844 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6846 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6851 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6853 string_sec
= section_headers
+ link_section
->sh_link
;
6855 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6856 string_sec
->sh_size
, _("version string table"));
6860 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6861 SECTION_NAME (section
), total
);
6863 printf (_(" Addr: "));
6864 printf_vma (section
->sh_addr
);
6865 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6866 (unsigned long) section
->sh_offset
, section
->sh_link
,
6867 SECTION_NAME (link_section
));
6869 off
= offset_from_vma (file
,
6870 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6871 total
* sizeof (short));
6872 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6873 _("version symbol data"));
6880 data
= cmalloc (total
, sizeof (short));
6882 for (cnt
= total
; cnt
--;)
6883 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6888 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6891 int check_def
, check_need
;
6894 printf (" %03x:", cnt
);
6896 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6897 switch (data
[cnt
+ j
])
6900 fputs (_(" 0 (*local*) "), stdout
);
6904 fputs (_(" 1 (*global*) "), stdout
);
6908 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6909 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6913 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6914 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6917 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6924 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6926 Elf_Internal_Verneed ivn
;
6927 unsigned long offset
;
6929 offset
= offset_from_vma
6930 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6931 sizeof (Elf_External_Verneed
));
6935 Elf_Internal_Vernaux ivna
;
6936 Elf_External_Verneed evn
;
6937 Elf_External_Vernaux evna
;
6938 unsigned long a_off
;
6940 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6943 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6944 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6946 a_off
= offset
+ ivn
.vn_aux
;
6950 get_data (&evna
, file
, a_off
, sizeof (evna
),
6951 1, _("version need aux (2)"));
6953 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6954 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6956 a_off
+= ivna
.vna_next
;
6958 while (ivna
.vna_other
!= data
[cnt
+ j
]
6959 && ivna
.vna_next
!= 0);
6961 if (ivna
.vna_other
== data
[cnt
+ j
])
6963 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6965 if (ivna
.vna_name
>= string_sec
->sh_size
)
6966 name
= _("*invalid*");
6968 name
= strtab
+ ivna
.vna_name
;
6969 nn
+= printf ("(%s%-*s",
6971 12 - (int) strlen (name
),
6977 offset
+= ivn
.vn_next
;
6979 while (ivn
.vn_next
);
6982 if (check_def
&& data
[cnt
+ j
] != 0x8001
6983 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6985 Elf_Internal_Verdef ivd
;
6986 Elf_External_Verdef evd
;
6987 unsigned long offset
;
6989 offset
= offset_from_vma
6990 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6995 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6998 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6999 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7001 offset
+= ivd
.vd_next
;
7003 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
7004 && ivd
.vd_next
!= 0);
7006 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
7008 Elf_External_Verdaux evda
;
7009 Elf_Internal_Verdaux ivda
;
7011 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7013 get_data (&evda
, file
,
7014 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7016 _("version def aux"));
7018 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7020 if (ivda
.vda_name
>= string_sec
->sh_size
)
7021 name
= _("*invalid*");
7023 name
= strtab
+ ivda
.vda_name
;
7024 nn
+= printf ("(%s%-*s",
7026 12 - (int) strlen (name
),
7032 printf ("%*c", 18 - nn
, ' ');
7050 printf (_("\nNo version information found in this file.\n"));
7056 get_symbol_binding (unsigned int binding
)
7058 static char buff
[32];
7062 case STB_LOCAL
: return "LOCAL";
7063 case STB_GLOBAL
: return "GLOBAL";
7064 case STB_WEAK
: return "WEAK";
7066 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7067 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7069 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7070 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7072 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7078 get_symbol_type (unsigned int type
)
7080 static char buff
[32];
7084 case STT_NOTYPE
: return "NOTYPE";
7085 case STT_OBJECT
: return "OBJECT";
7086 case STT_FUNC
: return "FUNC";
7087 case STT_SECTION
: return "SECTION";
7088 case STT_FILE
: return "FILE";
7089 case STT_COMMON
: return "COMMON";
7090 case STT_TLS
: return "TLS";
7091 case STT_RELC
: return "RELC";
7092 case STT_SRELC
: return "SRELC";
7094 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7096 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7097 return "THUMB_FUNC";
7099 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7102 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7103 return "PARISC_MILLI";
7105 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7107 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7109 if (elf_header
.e_machine
== EM_PARISC
)
7111 if (type
== STT_HP_OPAQUE
)
7113 if (type
== STT_HP_STUB
)
7117 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7120 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7126 get_symbol_visibility (unsigned int visibility
)
7130 case STV_DEFAULT
: return "DEFAULT";
7131 case STV_INTERNAL
: return "INTERNAL";
7132 case STV_HIDDEN
: return "HIDDEN";
7133 case STV_PROTECTED
: return "PROTECTED";
7139 get_mips_symbol_other (unsigned int other
)
7143 case STO_OPTIONAL
: return "OPTIONAL";
7144 case STO_MIPS16
: return "MIPS16";
7145 default: return NULL
;
7150 get_symbol_other (unsigned int other
)
7152 const char * result
= NULL
;
7153 static char buff
[32];
7158 switch (elf_header
.e_machine
)
7161 result
= get_mips_symbol_other (other
);
7169 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7174 get_symbol_index_type (unsigned int type
)
7176 static char buff
[32];
7180 case SHN_UNDEF
: return "UND";
7181 case SHN_ABS
: return "ABS";
7182 case SHN_COMMON
: return "COM";
7184 if (type
== SHN_IA_64_ANSI_COMMON
7185 && elf_header
.e_machine
== EM_IA_64
7186 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7188 else if (elf_header
.e_machine
== EM_X86_64
7189 && type
== SHN_X86_64_LCOMMON
)
7191 else if (type
== SHN_MIPS_SCOMMON
7192 && elf_header
.e_machine
== EM_MIPS
)
7194 else if (type
== SHN_MIPS_SUNDEFINED
7195 && elf_header
.e_machine
== EM_MIPS
)
7197 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7198 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7199 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7200 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7201 else if (type
>= SHN_LORESERVE
)
7202 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7204 sprintf (buff
, "%3d", type
);
7212 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7214 unsigned char *e_data
;
7217 e_data
= cmalloc (number
, ent_size
);
7221 error (_("Out of memory\n"));
7225 if (fread (e_data
, ent_size
, number
, file
) != number
)
7227 error (_("Unable to read in dynamic data\n"));
7231 i_data
= cmalloc (number
, sizeof (*i_data
));
7235 error (_("Out of memory\n"));
7241 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7249 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7251 Elf_Internal_Sym
*psym
;
7254 psym
= dynamic_symbols
+ si
;
7256 n
= print_vma (si
, DEC_5
);
7258 fputs (" " + n
, stdout
);
7259 printf (" %3lu: ", hn
);
7260 print_vma (psym
->st_value
, LONG_HEX
);
7262 print_vma (psym
->st_size
, DEC_5
);
7264 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7265 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7266 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7267 /* Check to see if any other bits in the st_other field are set.
7268 Note - displaying this information disrupts the layout of the
7269 table being generated, but for the moment this case is very
7271 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7272 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7273 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7274 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7275 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7277 printf (" <corrupt: %14ld>", psym
->st_name
);
7281 /* Dump the symbol table. */
7283 process_symbol_table (FILE *file
)
7285 Elf_Internal_Shdr
*section
;
7286 bfd_vma nbuckets
= 0;
7287 bfd_vma nchains
= 0;
7288 bfd_vma
*buckets
= NULL
;
7289 bfd_vma
*chains
= NULL
;
7290 bfd_vma ngnubuckets
= 0;
7291 bfd_vma
*gnubuckets
= NULL
;
7292 bfd_vma
*gnuchains
= NULL
;
7293 bfd_vma gnusymidx
= 0;
7295 if (! do_syms
&& !do_histogram
)
7298 if (dynamic_info
[DT_HASH
]
7300 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7302 unsigned char nb
[8];
7303 unsigned char nc
[8];
7304 int hash_ent_size
= 4;
7306 if ((elf_header
.e_machine
== EM_ALPHA
7307 || elf_header
.e_machine
== EM_S390
7308 || elf_header
.e_machine
== EM_S390_OLD
)
7309 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7313 (archive_file_offset
7314 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7315 sizeof nb
+ sizeof nc
)),
7318 error (_("Unable to seek to start of dynamic information\n"));
7322 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7324 error (_("Failed to read in number of buckets\n"));
7328 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7330 error (_("Failed to read in number of chains\n"));
7334 nbuckets
= byte_get (nb
, hash_ent_size
);
7335 nchains
= byte_get (nc
, hash_ent_size
);
7337 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7338 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7340 if (buckets
== NULL
|| chains
== NULL
)
7344 if (dynamic_info_DT_GNU_HASH
7346 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7348 unsigned char nb
[16];
7349 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7350 bfd_vma buckets_vma
;
7353 (archive_file_offset
7354 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7358 error (_("Unable to seek to start of dynamic information\n"));
7362 if (fread (nb
, 16, 1, file
) != 1)
7364 error (_("Failed to read in number of buckets\n"));
7368 ngnubuckets
= byte_get (nb
, 4);
7369 gnusymidx
= byte_get (nb
+ 4, 4);
7370 bitmaskwords
= byte_get (nb
+ 8, 4);
7371 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7373 buckets_vma
+= bitmaskwords
* 4;
7375 buckets_vma
+= bitmaskwords
* 8;
7378 (archive_file_offset
7379 + offset_from_vma (file
, buckets_vma
, 4)),
7382 error (_("Unable to seek to start of dynamic information\n"));
7386 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7388 if (gnubuckets
== NULL
)
7391 for (i
= 0; i
< ngnubuckets
; i
++)
7392 if (gnubuckets
[i
] != 0)
7394 if (gnubuckets
[i
] < gnusymidx
)
7397 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7398 maxchain
= gnubuckets
[i
];
7401 if (maxchain
== 0xffffffff)
7404 maxchain
-= gnusymidx
;
7407 (archive_file_offset
7408 + offset_from_vma (file
, buckets_vma
7409 + 4 * (ngnubuckets
+ maxchain
), 4)),
7412 error (_("Unable to seek to start of dynamic information\n"));
7418 if (fread (nb
, 4, 1, file
) != 1)
7420 error (_("Failed to determine last chain length\n"));
7424 if (maxchain
+ 1 == 0)
7429 while ((byte_get (nb
, 4) & 1) == 0);
7432 (archive_file_offset
7433 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7436 error (_("Unable to seek to start of dynamic information\n"));
7440 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7442 if (gnuchains
== NULL
)
7446 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7449 && dynamic_strings
!= NULL
)
7453 if (dynamic_info
[DT_HASH
])
7457 printf (_("\nSymbol table for image:\n"));
7459 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7461 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7463 for (hn
= 0; hn
< nbuckets
; hn
++)
7468 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7469 print_dynamic_symbol (si
, hn
);
7473 if (dynamic_info_DT_GNU_HASH
)
7475 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7477 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7479 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7481 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7482 if (gnubuckets
[hn
] != 0)
7484 bfd_vma si
= gnubuckets
[hn
];
7485 bfd_vma off
= si
- gnusymidx
;
7489 print_dynamic_symbol (si
, hn
);
7492 while ((gnuchains
[off
++] & 1) == 0);
7496 else if (do_syms
&& !do_using_dynamic
)
7500 for (i
= 0, section
= section_headers
;
7501 i
< elf_header
.e_shnum
;
7505 char *strtab
= NULL
;
7506 unsigned long int strtab_size
= 0;
7507 Elf_Internal_Sym
*symtab
;
7508 Elf_Internal_Sym
*psym
;
7511 if ( section
->sh_type
!= SHT_SYMTAB
7512 && section
->sh_type
!= SHT_DYNSYM
)
7515 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7516 SECTION_NAME (section
),
7517 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7519 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7521 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7523 symtab
= GET_ELF_SYMBOLS (file
, section
);
7527 if (section
->sh_link
== elf_header
.e_shstrndx
)
7529 strtab
= string_table
;
7530 strtab_size
= string_table_length
;
7532 else if (section
->sh_link
< elf_header
.e_shnum
)
7534 Elf_Internal_Shdr
*string_sec
;
7536 string_sec
= section_headers
+ section
->sh_link
;
7538 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7539 1, string_sec
->sh_size
, _("string table"));
7540 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7543 for (si
= 0, psym
= symtab
;
7544 si
< section
->sh_size
/ section
->sh_entsize
;
7547 printf ("%6d: ", si
);
7548 print_vma (psym
->st_value
, LONG_HEX
);
7550 print_vma (psym
->st_size
, DEC_5
);
7551 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7552 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7553 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7554 /* Check to see if any other bits in the st_other field are set.
7555 Note - displaying this information disrupts the layout of the
7556 table being generated, but for the moment this case is very rare. */
7557 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7558 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7559 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7560 print_symbol (25, psym
->st_name
< strtab_size
7561 ? strtab
+ psym
->st_name
: "<corrupt>");
7563 if (section
->sh_type
== SHT_DYNSYM
&&
7564 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7566 unsigned char data
[2];
7567 unsigned short vers_data
;
7568 unsigned long offset
;
7572 offset
= offset_from_vma
7573 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7574 sizeof data
+ si
* sizeof (vers_data
));
7576 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7577 sizeof (data
), 1, _("version data"));
7579 vers_data
= byte_get (data
, 2);
7581 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7582 && section_headers
[psym
->st_shndx
].sh_type
7585 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7587 if ((vers_data
& 0x8000) || vers_data
> 1)
7589 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7590 && (is_nobits
|| ! check_def
))
7592 Elf_External_Verneed evn
;
7593 Elf_Internal_Verneed ivn
;
7594 Elf_Internal_Vernaux ivna
;
7596 /* We must test both. */
7597 offset
= offset_from_vma
7598 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7603 unsigned long vna_off
;
7605 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7608 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7609 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7611 vna_off
= offset
+ ivn
.vn_aux
;
7615 Elf_External_Vernaux evna
;
7617 get_data (&evna
, file
, vna_off
,
7619 _("version need aux (3)"));
7621 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7622 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7623 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7625 vna_off
+= ivna
.vna_next
;
7627 while (ivna
.vna_other
!= vers_data
7628 && ivna
.vna_next
!= 0);
7630 if (ivna
.vna_other
== vers_data
)
7633 offset
+= ivn
.vn_next
;
7635 while (ivn
.vn_next
!= 0);
7637 if (ivna
.vna_other
== vers_data
)
7640 ivna
.vna_name
< strtab_size
7641 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7645 else if (! is_nobits
)
7646 error (_("bad dynamic symbol\n"));
7653 if (vers_data
!= 0x8001
7654 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7656 Elf_Internal_Verdef ivd
;
7657 Elf_Internal_Verdaux ivda
;
7658 Elf_External_Verdaux evda
;
7659 unsigned long offset
;
7661 offset
= offset_from_vma
7663 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7664 sizeof (Elf_External_Verdef
));
7668 Elf_External_Verdef evd
;
7670 get_data (&evd
, file
, offset
, sizeof (evd
),
7671 1, _("version def"));
7673 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7674 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7675 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7677 offset
+= ivd
.vd_next
;
7679 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7680 && ivd
.vd_next
!= 0);
7682 offset
-= ivd
.vd_next
;
7683 offset
+= ivd
.vd_aux
;
7685 get_data (&evda
, file
, offset
, sizeof (evda
),
7686 1, _("version def aux"));
7688 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7690 if (psym
->st_name
!= ivda
.vda_name
)
7691 printf ((vers_data
& 0x8000)
7693 ivda
.vda_name
< strtab_size
7694 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7704 if (strtab
!= string_table
)
7710 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7712 if (do_histogram
&& buckets
!= NULL
)
7714 unsigned long *lengths
;
7715 unsigned long *counts
;
7718 unsigned long maxlength
= 0;
7719 unsigned long nzero_counts
= 0;
7720 unsigned long nsyms
= 0;
7722 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7723 (unsigned long) nbuckets
);
7724 printf (_(" Length Number %% of total Coverage\n"));
7726 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7727 if (lengths
== NULL
)
7729 error (_("Out of memory\n"));
7732 for (hn
= 0; hn
< nbuckets
; ++hn
)
7734 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7737 if (maxlength
< ++lengths
[hn
])
7742 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7745 error (_("Out of memory\n"));
7749 for (hn
= 0; hn
< nbuckets
; ++hn
)
7750 ++counts
[lengths
[hn
]];
7755 printf (" 0 %-10lu (%5.1f%%)\n",
7756 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7757 for (i
= 1; i
<= maxlength
; ++i
)
7759 nzero_counts
+= counts
[i
] * i
;
7760 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7761 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7762 (nzero_counts
* 100.0) / nsyms
);
7770 if (buckets
!= NULL
)
7776 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7778 unsigned long *lengths
;
7779 unsigned long *counts
;
7781 unsigned long maxlength
= 0;
7782 unsigned long nzero_counts
= 0;
7783 unsigned long nsyms
= 0;
7785 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7786 if (lengths
== NULL
)
7788 error (_("Out of memory\n"));
7792 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7793 (unsigned long) ngnubuckets
);
7794 printf (_(" Length Number %% of total Coverage\n"));
7796 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7797 if (gnubuckets
[hn
] != 0)
7799 bfd_vma off
, length
= 1;
7801 for (off
= gnubuckets
[hn
] - gnusymidx
;
7802 (gnuchains
[off
] & 1) == 0; ++off
)
7804 lengths
[hn
] = length
;
7805 if (length
> maxlength
)
7810 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7813 error (_("Out of memory\n"));
7817 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7818 ++counts
[lengths
[hn
]];
7820 if (ngnubuckets
> 0)
7823 printf (" 0 %-10lu (%5.1f%%)\n",
7824 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7825 for (j
= 1; j
<= maxlength
; ++j
)
7827 nzero_counts
+= counts
[j
] * j
;
7828 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7829 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7830 (nzero_counts
* 100.0) / nsyms
);
7844 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7848 if (dynamic_syminfo
== NULL
7850 /* No syminfo, this is ok. */
7853 /* There better should be a dynamic symbol section. */
7854 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7858 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7859 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7861 printf (_(" Num: Name BoundTo Flags\n"));
7862 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7864 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7866 printf ("%4d: ", i
);
7867 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7868 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7870 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7873 switch (dynamic_syminfo
[i
].si_boundto
)
7875 case SYMINFO_BT_SELF
:
7876 fputs ("SELF ", stdout
);
7878 case SYMINFO_BT_PARENT
:
7879 fputs ("PARENT ", stdout
);
7882 if (dynamic_syminfo
[i
].si_boundto
> 0
7883 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7884 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7886 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7890 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7894 if (flags
& SYMINFO_FLG_DIRECT
)
7896 if (flags
& SYMINFO_FLG_PASSTHRU
)
7897 printf (" PASSTHRU");
7898 if (flags
& SYMINFO_FLG_COPY
)
7900 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7901 printf (" LAZYLOAD");
7909 #ifdef SUPPORT_DISASSEMBLY
7911 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7913 printf (_("\nAssembly dump of section %s\n"),
7914 SECTION_NAME (section
));
7916 /* XXX -- to be done --- XXX */
7923 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7925 Elf_Internal_Shdr
*relsec
;
7926 bfd_size_type num_bytes
;
7931 char *name
= SECTION_NAME (section
);
7932 bfd_boolean some_strings_shown
;
7934 num_bytes
= section
->sh_size
;
7936 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7938 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7942 addr
= section
->sh_addr
;
7944 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7949 printf (_("\nString dump of section '%s':\n"), name
);
7951 /* If the section being dumped has relocations against it the user might
7952 be expecting these relocations to have been applied. Check for this
7953 case and issue a warning message in order to avoid confusion.
7954 FIXME: Maybe we ought to have an option that dumps a section with
7956 for (relsec
= section_headers
;
7957 relsec
< section_headers
+ elf_header
.e_shnum
;
7960 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7961 || relsec
->sh_info
>= elf_header
.e_shnum
7962 || section_headers
+ relsec
->sh_info
!= section
7963 || relsec
->sh_size
== 0
7964 || relsec
->sh_link
>= elf_header
.e_shnum
)
7967 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7972 end
= start
+ num_bytes
;
7973 some_strings_shown
= FALSE
;
7977 while (!ISPRINT (* data
))
7984 printf (" [%6tx] %s\n", data
- start
, data
);
7986 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7988 data
+= strlen (data
);
7989 some_strings_shown
= TRUE
;
7993 if (! some_strings_shown
)
7994 printf (_(" No strings found in this section."));
8004 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
8006 Elf_Internal_Shdr
*relsec
;
8007 bfd_size_type bytes
;
8009 unsigned char *data
;
8010 unsigned char *start
;
8012 bytes
= section
->sh_size
;
8014 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8016 printf (_("\nSection '%s' has no data to dump.\n"),
8017 SECTION_NAME (section
));
8021 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8023 addr
= section
->sh_addr
;
8025 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
8030 /* If the section being dumped has relocations against it the user might
8031 be expecting these relocations to have been applied. Check for this
8032 case and issue a warning message in order to avoid confusion.
8033 FIXME: Maybe we ought to have an option that dumps a section with
8035 for (relsec
= section_headers
;
8036 relsec
< section_headers
+ elf_header
.e_shnum
;
8039 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8040 || relsec
->sh_info
>= elf_header
.e_shnum
8041 || section_headers
+ relsec
->sh_info
!= section
8042 || relsec
->sh_size
== 0
8043 || relsec
->sh_link
>= elf_header
.e_shnum
)
8046 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8058 lbytes
= (bytes
> 16 ? 16 : bytes
);
8060 printf (" 0x%8.8lx ", (unsigned long) addr
);
8062 for (j
= 0; j
< 16; j
++)
8065 printf ("%2.2x", data
[j
]);
8073 for (j
= 0; j
< lbytes
; j
++)
8076 if (k
>= ' ' && k
< 0x7f)
8095 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8096 DWARF debug sections. This is a target specific test. Note - we do not
8097 go through the whole including-target-headers-multiple-times route, (as
8098 we have already done with <elf/h8.h>) because this would become very
8099 messy and even then this function would have to contain target specific
8100 information (the names of the relocs instead of their numeric values).
8101 FIXME: This is not the correct way to solve this problem. The proper way
8102 is to have target specific reloc sizing and typing functions created by
8103 the reloc-macros.h header, in the same way that it already creates the
8104 reloc naming functions. */
8107 is_32bit_abs_reloc (unsigned int reloc_type
)
8109 switch (elf_header
.e_machine
)
8113 return reloc_type
== 1; /* R_386_32. */
8115 return reloc_type
== 1; /* R_68K_32. */
8117 return reloc_type
== 1; /* R_860_32. */
8119 return reloc_type
== 1; /* XXX Is this right ? */
8121 return reloc_type
== 1; /* R_ARC_32. */
8123 return reloc_type
== 2; /* R_ARM_ABS32 */
8126 return reloc_type
== 1;
8128 return reloc_type
== 0x12; /* R_byte4_data. */
8130 return reloc_type
== 3; /* R_CRIS_32. */
8132 return reloc_type
== 3; /* R_CR16_NUM32. */
8134 return reloc_type
== 15; /* R_CRX_NUM32. */
8136 return reloc_type
== 1;
8137 case EM_CYGNUS_D10V
:
8139 return reloc_type
== 6; /* R_D10V_32. */
8140 case EM_CYGNUS_D30V
:
8142 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8144 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8145 case EM_CYGNUS_FR30
:
8147 return reloc_type
== 3; /* R_FR30_32. */
8151 return reloc_type
== 1; /* R_H8_DIR32. */
8153 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8156 return reloc_type
== 2; /* R_IP2K_32. */
8158 return reloc_type
== 2; /* R_IQ2000_32. */
8161 return reloc_type
== 3; /* R_M32C_32. */
8163 return reloc_type
== 34; /* R_M32R_32_RELA. */
8165 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8167 return reloc_type
== 4; /* R_MEP_32. */
8169 return reloc_type
== 2; /* R_MIPS_32. */
8171 return reloc_type
== 4; /* R_MMIX_32. */
8172 case EM_CYGNUS_MN10200
:
8174 return reloc_type
== 1; /* R_MN10200_32. */
8175 case EM_CYGNUS_MN10300
:
8177 return reloc_type
== 1; /* R_MN10300_32. */
8180 return reloc_type
== 1; /* R_MSP43_32. */
8182 return reloc_type
== 2; /* R_MT_32. */
8183 case EM_ALTERA_NIOS2
:
8185 return reloc_type
== 1; /* R_NIOS_32. */
8188 return reloc_type
== 1; /* R_OR32_32. */
8190 return reloc_type
== 1; /* R_PARISC_DIR32. */
8193 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8195 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8197 return reloc_type
== 1; /* R_PPC_ADDR32. */
8199 return reloc_type
== 1; /* R_I370_ADDR31. */
8202 return reloc_type
== 4; /* R_S390_32. */
8204 return reloc_type
== 8; /* R_SCORE_ABS32. */
8206 return reloc_type
== 1; /* R_SH_DIR32. */
8207 case EM_SPARC32PLUS
:
8210 return reloc_type
== 3 /* R_SPARC_32. */
8211 || reloc_type
== 23; /* R_SPARC_UA32. */
8213 return reloc_type
== 6; /* R_SPU_ADDR32 */
8214 case EM_CYGNUS_V850
:
8216 return reloc_type
== 6; /* R_V850_ABS32. */
8218 return reloc_type
== 1; /* R_VAX_32. */
8220 return reloc_type
== 10; /* R_X86_64_32. */
8222 return reloc_type
== 1; /* R_XSTROMY16_32. */
8225 return reloc_type
== 1; /* R_XTENSA_32. */
8228 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8229 elf_header
.e_machine
);
8234 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8235 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8238 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8240 switch (elf_header
.e_machine
)
8244 return reloc_type
== 2; /* R_386_PC32. */
8246 return reloc_type
== 4; /* R_68K_PC32. */
8248 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8250 return reloc_type
== 3; /* R_ARM_REL32 */
8252 return reloc_type
== 0; /* R_PARISC_NONE. *//* FIXME: This reloc is generated, but it may be a bug. */
8254 return reloc_type
== 26; /* R_PPC_REL32. */
8256 return reloc_type
== 26; /* R_PPC64_REL32. */
8259 return reloc_type
== 5; /* R_390_PC32. */
8261 return reloc_type
== 2; /* R_SH_REL32. */
8262 case EM_SPARC32PLUS
:
8265 return reloc_type
== 6; /* R_SPARC_DISP32. */
8267 return reloc_type
== 13; /* R_SPU_REL32. */
8269 return reloc_type
== 2; /* R_X86_64_PC32. */
8272 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8274 /* Do not abort or issue an error message here. Not all targets use
8275 pc-relative 32-bit relocs in their DWARF debug information and we
8276 have already tested for target coverage in is_32bit_abs_reloc. A
8277 more helpful warning message will be generated by
8278 debug_apply_relocations anyway, so just return. */
8283 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8284 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8287 is_64bit_abs_reloc (unsigned int reloc_type
)
8289 switch (elf_header
.e_machine
)
8292 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8294 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8296 return reloc_type
== 80; /* R_PARISC_DIR64. */
8298 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8299 case EM_SPARC32PLUS
:
8302 return reloc_type
== 54; /* R_SPARC_UA64. */
8304 return reloc_type
== 1; /* R_X86_64_64. */
8307 return reloc_type
== 22; /* R_S390_64 */
8313 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8314 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8317 is_16bit_abs_reloc (unsigned int reloc_type
)
8319 switch (elf_header
.e_machine
)
8323 return reloc_type
== 4; /* R_AVR_16. */
8324 case EM_CYGNUS_D10V
:
8326 return reloc_type
== 3; /* R_D10V_16. */
8330 return reloc_type
== R_H8_DIR16
;
8333 return reloc_type
== 1; /* R_IP2K_16. */
8336 return reloc_type
== 1; /* R_M32C_16 */
8339 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8340 case EM_ALTERA_NIOS2
:
8342 return reloc_type
== 9; /* R_NIOS_16. */
8348 /* Apply relocations to a debug section. */
8351 debug_apply_relocations (void *file
,
8352 Elf_Internal_Shdr
*section
,
8353 unsigned char *start
)
8355 Elf_Internal_Shdr
*relsec
;
8356 unsigned char *end
= start
+ section
->sh_size
;
8358 if (elf_header
.e_type
!= ET_REL
)
8361 /* Find the reloc section associated with the debug section. */
8362 for (relsec
= section_headers
;
8363 relsec
< section_headers
+ elf_header
.e_shnum
;
8366 bfd_boolean is_rela
;
8367 unsigned long num_relocs
;
8368 Elf_Internal_Rela
*relocs
, *rp
;
8369 Elf_Internal_Shdr
*symsec
;
8370 Elf_Internal_Sym
*symtab
;
8371 Elf_Internal_Sym
*sym
;
8373 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8374 || relsec
->sh_info
>= elf_header
.e_shnum
8375 || section_headers
+ relsec
->sh_info
!= section
8376 || relsec
->sh_size
== 0
8377 || relsec
->sh_link
>= elf_header
.e_shnum
)
8380 is_rela
= relsec
->sh_type
== SHT_RELA
;
8384 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8385 & relocs
, & num_relocs
))
8390 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8391 & relocs
, & num_relocs
))
8395 /* SH uses RELA but uses in place value instead of the addend field. */
8396 if (elf_header
.e_machine
== EM_SH
)
8399 symsec
= section_headers
+ relsec
->sh_link
;
8400 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8402 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8405 unsigned int reloc_type
;
8406 unsigned int reloc_size
;
8407 unsigned char * loc
;
8409 /* In MIPS little-endian objects, r_info isn't really a
8410 64-bit little-endian value: it has a 32-bit little-endian
8411 symbol index followed by four individual byte fields.
8412 Reorder INFO accordingly. */
8414 && elf_header
.e_machine
== EM_MIPS
8415 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
8416 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
8417 | ((rp
->r_info
>> 56) & 0xff)
8418 | ((rp
->r_info
>> 40) & 0xff00)
8419 | ((rp
->r_info
>> 24) & 0xff0000)
8420 | ((rp
->r_info
>> 8) & 0xff000000));
8422 reloc_type
= get_reloc_type (rp
->r_info
);
8424 if (is_32bit_abs_reloc (reloc_type
)
8425 || is_32bit_pcrel_reloc (reloc_type
))
8427 else if (is_64bit_abs_reloc (reloc_type
))
8429 else if (is_16bit_abs_reloc (reloc_type
))
8433 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8434 reloc_type
, SECTION_NAME (section
));
8438 loc
= start
+ rp
->r_offset
;
8439 if ((loc
+ reloc_size
) > end
)
8441 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8442 (unsigned long) rp
->r_offset
,
8443 SECTION_NAME (section
));
8447 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8449 /* If the reloc has a symbol associated with it,
8450 make sure that it is of an appropriate type. */
8452 && ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
8453 /* Relocations against symbols without type can happen.
8454 Gcc -feliminate-dwarf2-dups may generate symbols
8455 without type for debug info. */
8456 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8457 /* Relocations against object symbols can happen,
8458 eg when referencing a global array. For an
8459 example of this see the _clz.o binary in libgcc.a. */
8460 && ELF_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8462 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8463 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8464 (long int)(rp
- relocs
),
8465 SECTION_NAME (relsec
));
8469 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8471 if (is_32bit_pcrel_reloc (reloc_type
))
8472 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8475 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8485 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8487 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8488 Elf_Internal_Shdr
*sec
;
8491 /* If it is already loaded, do nothing. */
8492 if (section
->start
!= NULL
)
8495 /* Locate the debug section. */
8496 sec
= find_section (section
->name
);
8500 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8501 section
->address
= sec
->sh_addr
;
8502 section
->size
= sec
->sh_size
;
8503 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8506 if (debug_displays
[debug
].relocate
)
8507 debug_apply_relocations (file
, sec
, section
->start
);
8509 return section
->start
!= NULL
;
8513 free_debug_section (enum dwarf_section_display_enum debug
)
8515 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8517 if (section
->start
== NULL
)
8520 free ((char *) section
->start
);
8521 section
->start
= NULL
;
8522 section
->address
= 0;
8527 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8529 char *name
= SECTION_NAME (section
);
8530 bfd_size_type length
;
8532 enum dwarf_section_display_enum i
;
8534 length
= section
->sh_size
;
8537 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8541 if (const_strneq (name
, ".gnu.linkonce.wi."))
8542 name
= ".debug_info";
8544 /* See if we know how to display the contents of this section. */
8545 for (i
= 0; i
< max
; i
++)
8546 if (streq (debug_displays
[i
].section
.name
, name
))
8548 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8550 if (load_debug_section (i
, file
))
8552 result
&= debug_displays
[i
].display (sec
, file
);
8554 if (i
!= info
&& i
!= abbrev
)
8555 free_debug_section (i
);
8563 printf (_("Unrecognized debug section: %s\n"), name
);
8570 /* Set DUMP_SECTS for all sections where dumps were requested
8571 based on section name. */
8574 initialise_dumps_byname (void)
8576 struct dump_list_entry
*cur
;
8578 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8583 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8584 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8586 request_dump_bynumber (i
, cur
->type
);
8591 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8597 process_section_contents (FILE *file
)
8599 Elf_Internal_Shdr
*section
;
8605 initialise_dumps_byname ();
8607 for (i
= 0, section
= section_headers
;
8608 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8611 #ifdef SUPPORT_DISASSEMBLY
8612 if (dump_sects
[i
] & DISASS_DUMP
)
8613 disassemble_section (section
, file
);
8615 if (dump_sects
[i
] & HEX_DUMP
)
8616 dump_section_as_bytes (section
, file
);
8618 if (dump_sects
[i
] & DEBUG_DUMP
)
8619 display_debug_section (section
, file
);
8621 if (dump_sects
[i
] & STRING_DUMP
)
8622 dump_section_as_strings (section
, file
);
8625 /* Check to see if the user requested a
8626 dump of a section that does not exist. */
8627 while (i
++ < num_dump_sects
)
8629 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8633 process_mips_fpe_exception (int mask
)
8638 if (mask
& OEX_FPU_INEX
)
8639 fputs ("INEX", stdout
), first
= 0;
8640 if (mask
& OEX_FPU_UFLO
)
8641 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8642 if (mask
& OEX_FPU_OFLO
)
8643 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8644 if (mask
& OEX_FPU_DIV0
)
8645 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8646 if (mask
& OEX_FPU_INVAL
)
8647 printf ("%sINVAL", first
? "" : "|");
8650 fputs ("0", stdout
);
8653 /* ARM EABI attributes section. */
8658 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8661 } arm_attr_public_tag
;
8663 static const char *arm_attr_tag_CPU_arch
[] =
8664 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8666 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8667 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8668 {"No", "Thumb-1", "Thumb-2"};
8669 static const char *arm_attr_tag_VFP_arch
[] =
8670 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8671 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8672 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8673 static const char *arm_attr_tag_ABI_PCS_config
[] =
8674 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8675 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8676 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8677 {"V6", "SB", "TLS", "Unused"};
8678 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8679 {"Absolute", "PC-relative", "SB-relative", "None"};
8680 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8681 {"Absolute", "PC-relative", "None"};
8682 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8683 {"None", "direct", "GOT-indirect"};
8684 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8685 {"None", "??? 1", "2", "??? 3", "4"};
8686 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8687 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8688 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8689 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8690 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8691 {"Unused", "Finite", "RTABI", "IEEE 754"};
8692 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8693 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8694 {"No", "Yes, except leaf SP", "Yes"};
8695 static const char *arm_attr_tag_ABI_enum_size
[] =
8696 {"Unused", "small", "int", "forced to int"};
8697 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8698 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8699 static const char *arm_attr_tag_ABI_VFP_args
[] =
8700 {"AAPCS", "VFP registers", "custom"};
8701 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8702 {"AAPCS", "WMMX registers", "custom"};
8703 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8704 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8705 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8706 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8707 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8708 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8710 #define LOOKUP(id, name) \
8711 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8712 static arm_attr_public_tag arm_attr_public_tags
[] =
8714 {4, "CPU_raw_name", 1, NULL
},
8715 {5, "CPU_name", 1, NULL
},
8716 LOOKUP(6, CPU_arch
),
8717 {7, "CPU_arch_profile", 0, NULL
},
8718 LOOKUP(8, ARM_ISA_use
),
8719 LOOKUP(9, THUMB_ISA_use
),
8720 LOOKUP(10, VFP_arch
),
8721 LOOKUP(11, WMMX_arch
),
8722 LOOKUP(12, NEON_arch
),
8723 LOOKUP(13, ABI_PCS_config
),
8724 LOOKUP(14, ABI_PCS_R9_use
),
8725 LOOKUP(15, ABI_PCS_RW_data
),
8726 LOOKUP(16, ABI_PCS_RO_DATA
),
8727 LOOKUP(17, ABI_PCS_GOT_use
),
8728 LOOKUP(18, ABI_PCS_wchar_t
),
8729 LOOKUP(19, ABI_FP_rounding
),
8730 LOOKUP(20, ABI_FP_denormal
),
8731 LOOKUP(21, ABI_FP_exceptions
),
8732 LOOKUP(22, ABI_FP_user_exceptions
),
8733 LOOKUP(23, ABI_FP_number_model
),
8734 LOOKUP(24, ABI_align8_needed
),
8735 LOOKUP(25, ABI_align8_preserved
),
8736 LOOKUP(26, ABI_enum_size
),
8737 LOOKUP(27, ABI_HardFP_use
),
8738 LOOKUP(28, ABI_VFP_args
),
8739 LOOKUP(29, ABI_WMMX_args
),
8740 LOOKUP(30, ABI_optimization_goals
),
8741 LOOKUP(31, ABI_FP_optimization_goals
),
8742 {32, "compatibility", 0, NULL
}
8746 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8749 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8763 val
|= ((unsigned int)c
& 0x7f) << shift
;
8772 static unsigned char *
8773 display_arm_attribute (unsigned char *p
)
8778 arm_attr_public_tag
*attr
;
8782 tag
= read_uleb128 (p
, &len
);
8785 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8787 if (arm_attr_public_tags
[i
].tag
== tag
)
8789 attr
= &arm_attr_public_tags
[i
];
8796 printf (" Tag_%s: ", attr
->name
);
8802 case 7: /* Tag_CPU_arch_profile. */
8803 val
= read_uleb128 (p
, &len
);
8807 case 0: printf ("None\n"); break;
8808 case 'A': printf ("Application\n"); break;
8809 case 'R': printf ("Realtime\n"); break;
8810 case 'M': printf ("Microcontroller\n"); break;
8811 default: printf ("??? (%d)\n", val
); break;
8815 case 32: /* Tag_compatibility. */
8816 val
= read_uleb128 (p
, &len
);
8818 printf ("flag = %d, vendor = %s\n", val
, p
);
8819 p
+= strlen((char *)p
) + 1;
8833 assert (attr
->type
& 0x80);
8834 val
= read_uleb128 (p
, &len
);
8836 type
= attr
->type
& 0x7f;
8838 printf ("??? (%d)\n", val
);
8840 printf ("%s\n", attr
->table
[val
]);
8847 type
= 1; /* String. */
8849 type
= 2; /* uleb128. */
8850 printf (" Tag_unknown_%d: ", tag
);
8855 printf ("\"%s\"\n", p
);
8856 p
+= strlen((char *)p
) + 1;
8860 val
= read_uleb128 (p
, &len
);
8862 printf ("%d (0x%x)\n", val
, val
);
8868 static unsigned char *
8869 display_gnu_attribute (unsigned char * p
,
8870 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8877 tag
= read_uleb128 (p
, &len
);
8880 /* Tag_compatibility is the only generic GNU attribute defined at
8884 val
= read_uleb128 (p
, &len
);
8886 printf ("flag = %d, vendor = %s\n", val
, p
);
8887 p
+= strlen ((char *) p
) + 1;
8891 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8892 return display_proc_gnu_attribute (p
, tag
);
8895 type
= 1; /* String. */
8897 type
= 2; /* uleb128. */
8898 printf (" Tag_unknown_%d: ", tag
);
8902 printf ("\"%s\"\n", p
);
8903 p
+= strlen ((char *) p
) + 1;
8907 val
= read_uleb128 (p
, &len
);
8909 printf ("%d (0x%x)\n", val
, val
);
8915 static unsigned char *
8916 display_power_gnu_attribute (unsigned char *p
, int tag
)
8922 if (tag
== Tag_GNU_Power_ABI_FP
)
8924 val
= read_uleb128 (p
, &len
);
8926 printf (" Tag_GNU_Power_ABI_FP: ");
8931 printf ("Hard or soft float\n");
8934 printf ("Hard float\n");
8937 printf ("Soft float\n");
8940 printf ("??? (%d)\n", val
);
8946 if (tag
== Tag_GNU_Power_ABI_Vector
)
8948 val
= read_uleb128 (p
, &len
);
8950 printf (" Tag_GNU_Power_ABI_Vector: ");
8957 printf ("Generic\n");
8960 printf ("AltiVec\n");
8966 printf ("??? (%d)\n", val
);
8973 type
= 1; /* String. */
8975 type
= 2; /* uleb128. */
8976 printf (" Tag_unknown_%d: ", tag
);
8980 printf ("\"%s\"\n", p
);
8981 p
+= strlen ((char *) p
) + 1;
8985 val
= read_uleb128 (p
, &len
);
8987 printf ("%d (0x%x)\n", val
, val
);
8993 static unsigned char *
8994 display_mips_gnu_attribute (unsigned char *p
, int tag
)
9000 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9002 val
= read_uleb128 (p
, &len
);
9004 printf (" Tag_GNU_MIPS_ABI_FP: ");
9009 printf ("Hard or soft float\n");
9012 printf ("Hard float (-mdouble-float)\n");
9015 printf ("Hard float (-msingle-float)\n");
9018 printf ("Soft float\n");
9021 printf ("64-bit float (-mips32r2 -mfp64)\n");
9024 printf ("??? (%d)\n", val
);
9031 type
= 1; /* String. */
9033 type
= 2; /* uleb128. */
9034 printf (" Tag_unknown_%d: ", tag
);
9038 printf ("\"%s\"\n", p
);
9039 p
+= strlen ((char *) p
) + 1;
9043 val
= read_uleb128 (p
, &len
);
9045 printf ("%d (0x%x)\n", val
, val
);
9052 process_attributes (FILE * file
,
9053 const char * public_name
,
9054 unsigned int proc_type
,
9055 unsigned char * (* display_pub_attribute
) (unsigned char *),
9056 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9058 Elf_Internal_Shdr
*sect
;
9059 unsigned char *contents
;
9062 bfd_vma section_len
;
9066 /* Find the section header so that we get the size. */
9067 for (i
= 0, sect
= section_headers
;
9068 i
< elf_header
.e_shnum
;
9071 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9074 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9076 if (contents
== NULL
)
9082 len
= sect
->sh_size
- 1;
9088 bfd_boolean public_section
;
9089 bfd_boolean gnu_section
;
9091 section_len
= byte_get (p
, 4);
9094 if (section_len
> len
)
9096 printf (_("ERROR: Bad section length (%d > %d)\n"),
9097 (int) section_len
, (int) len
);
9102 printf ("Attribute Section: %s\n", p
);
9104 if (public_name
&& streq ((char *) p
, public_name
))
9105 public_section
= TRUE
;
9107 public_section
= FALSE
;
9109 if (streq ((char *) p
, "gnu"))
9112 gnu_section
= FALSE
;
9114 namelen
= strlen ((char *) p
) + 1;
9116 section_len
-= namelen
+ 4;
9118 while (section_len
> 0)
9124 size
= byte_get (p
, 4);
9125 if (size
> section_len
)
9127 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9128 (int) size
, (int) section_len
);
9132 section_len
-= size
;
9139 printf ("File Attributes\n");
9142 printf ("Section Attributes:");
9145 printf ("Symbol Attributes:");
9151 val
= read_uleb128 (p
, &i
);
9155 printf (" %d", val
);
9160 printf ("Unknown tag: %d\n", tag
);
9161 public_section
= FALSE
;
9168 p
= display_pub_attribute (p
);
9170 else if (gnu_section
)
9173 p
= display_gnu_attribute (p
,
9174 display_proc_gnu_attribute
);
9178 /* ??? Do something sensible, like dump hex. */
9179 printf (" Unknown section contexts\n");
9186 printf (_("Unknown format '%c'\n"), *p
);
9194 process_arm_specific (FILE *file
)
9196 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9197 display_arm_attribute
, NULL
);
9201 process_power_specific (FILE *file
)
9203 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9204 display_power_gnu_attribute
);
9207 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9208 Print the Address, Access and Initial fields of an entry at VMA ADDR
9209 and return the VMA of the next entry. */
9212 print_mips_got_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9215 print_vma (addr
, LONG_HEX
);
9217 if (addr
< pltgot
+ 0xfff0)
9218 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9220 printf ("%10s", "");
9223 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9228 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9229 print_vma (entry
, LONG_HEX
);
9231 return addr
+ (is_32bit_elf
? 4 : 8);
9235 process_mips_specific (FILE *file
)
9237 Elf_Internal_Dyn
*entry
;
9238 size_t liblist_offset
= 0;
9239 size_t liblistno
= 0;
9240 size_t conflictsno
= 0;
9241 size_t options_offset
= 0;
9242 size_t conflicts_offset
= 0;
9244 bfd_vma local_gotno
= 0;
9246 bfd_vma symtabno
= 0;
9248 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9249 display_mips_gnu_attribute
);
9251 /* We have a lot of special sections. Thanks SGI! */
9252 if (dynamic_section
== NULL
)
9253 /* No information available. */
9256 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9257 switch (entry
->d_tag
)
9259 case DT_MIPS_LIBLIST
:
9261 = offset_from_vma (file
, entry
->d_un
.d_val
,
9262 liblistno
* sizeof (Elf32_External_Lib
));
9264 case DT_MIPS_LIBLISTNO
:
9265 liblistno
= entry
->d_un
.d_val
;
9267 case DT_MIPS_OPTIONS
:
9268 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9270 case DT_MIPS_CONFLICT
:
9272 = offset_from_vma (file
, entry
->d_un
.d_val
,
9273 conflictsno
* sizeof (Elf32_External_Conflict
));
9275 case DT_MIPS_CONFLICTNO
:
9276 conflictsno
= entry
->d_un
.d_val
;
9279 pltgot
= entry
->d_un
.d_val
;
9280 case DT_MIPS_LOCAL_GOTNO
:
9281 local_gotno
= entry
->d_un
.d_val
;
9283 case DT_MIPS_GOTSYM
:
9284 gotsym
= entry
->d_un
.d_val
;
9286 case DT_MIPS_SYMTABNO
:
9287 symtabno
= entry
->d_un
.d_val
;
9293 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9295 Elf32_External_Lib
*elib
;
9298 elib
= get_data (NULL
, file
, liblist_offset
,
9299 liblistno
, sizeof (Elf32_External_Lib
),
9303 printf ("\nSection '.liblist' contains %lu entries:\n",
9304 (unsigned long) liblistno
);
9305 fputs (" Library Time Stamp Checksum Version Flags\n",
9308 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9315 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9316 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9317 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9318 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9319 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9321 tmp
= gmtime (&time
);
9322 snprintf (timebuf
, sizeof (timebuf
),
9323 "%04u-%02u-%02uT%02u:%02u:%02u",
9324 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9325 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9327 printf ("%3lu: ", (unsigned long) cnt
);
9328 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9329 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9331 printf ("<corrupt: %9ld>", liblist
.l_name
);
9332 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9335 if (liblist
.l_flags
== 0)
9346 { " EXACT_MATCH", LL_EXACT_MATCH
},
9347 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9348 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9349 { " EXPORTS", LL_EXPORTS
},
9350 { " DELAY_LOAD", LL_DELAY_LOAD
},
9351 { " DELTA", LL_DELTA
}
9353 int flags
= liblist
.l_flags
;
9356 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9357 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9359 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9360 flags
^= l_flags_vals
[fcnt
].bit
;
9363 printf (" %#x", (unsigned int) flags
);
9373 if (options_offset
!= 0)
9375 Elf_External_Options
*eopt
;
9376 Elf_Internal_Shdr
*sect
= section_headers
;
9377 Elf_Internal_Options
*iopt
;
9378 Elf_Internal_Options
*option
;
9382 /* Find the section header so that we get the size. */
9383 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9386 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9390 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
9393 error (_("Out of memory\n"));
9400 while (offset
< sect
->sh_size
)
9402 Elf_External_Options
*eoption
;
9404 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9406 option
->kind
= BYTE_GET (eoption
->kind
);
9407 option
->size
= BYTE_GET (eoption
->size
);
9408 option
->section
= BYTE_GET (eoption
->section
);
9409 option
->info
= BYTE_GET (eoption
->info
);
9411 offset
+= option
->size
;
9417 printf (_("\nSection '%s' contains %d entries:\n"),
9418 SECTION_NAME (sect
), cnt
);
9426 switch (option
->kind
)
9429 /* This shouldn't happen. */
9430 printf (" NULL %d %lx", option
->section
, option
->info
);
9433 printf (" REGINFO ");
9434 if (elf_header
.e_machine
== EM_MIPS
)
9437 Elf32_External_RegInfo
*ereg
;
9438 Elf32_RegInfo reginfo
;
9440 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9441 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9442 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9443 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9444 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9445 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9446 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9448 printf ("GPR %08lx GP 0x%lx\n",
9450 (unsigned long) reginfo
.ri_gp_value
);
9451 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9452 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9453 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9458 Elf64_External_RegInfo
*ereg
;
9459 Elf64_Internal_RegInfo reginfo
;
9461 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9462 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9463 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9464 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9465 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9466 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9467 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9469 printf ("GPR %08lx GP 0x",
9470 reginfo
.ri_gprmask
);
9471 printf_vma (reginfo
.ri_gp_value
);
9474 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9475 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9476 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9480 case ODK_EXCEPTIONS
:
9481 fputs (" EXCEPTIONS fpe_min(", stdout
);
9482 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9483 fputs (") fpe_max(", stdout
);
9484 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9485 fputs (")", stdout
);
9487 if (option
->info
& OEX_PAGE0
)
9488 fputs (" PAGE0", stdout
);
9489 if (option
->info
& OEX_SMM
)
9490 fputs (" SMM", stdout
);
9491 if (option
->info
& OEX_FPDBUG
)
9492 fputs (" FPDBUG", stdout
);
9493 if (option
->info
& OEX_DISMISS
)
9494 fputs (" DISMISS", stdout
);
9497 fputs (" PAD ", stdout
);
9498 if (option
->info
& OPAD_PREFIX
)
9499 fputs (" PREFIX", stdout
);
9500 if (option
->info
& OPAD_POSTFIX
)
9501 fputs (" POSTFIX", stdout
);
9502 if (option
->info
& OPAD_SYMBOL
)
9503 fputs (" SYMBOL", stdout
);
9506 fputs (" HWPATCH ", stdout
);
9507 if (option
->info
& OHW_R4KEOP
)
9508 fputs (" R4KEOP", stdout
);
9509 if (option
->info
& OHW_R8KPFETCH
)
9510 fputs (" R8KPFETCH", stdout
);
9511 if (option
->info
& OHW_R5KEOP
)
9512 fputs (" R5KEOP", stdout
);
9513 if (option
->info
& OHW_R5KCVTL
)
9514 fputs (" R5KCVTL", stdout
);
9517 fputs (" FILL ", stdout
);
9518 /* XXX Print content of info word? */
9521 fputs (" TAGS ", stdout
);
9522 /* XXX Print content of info word? */
9525 fputs (" HWAND ", stdout
);
9526 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9527 fputs (" R4KEOP_CHECKED", stdout
);
9528 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9529 fputs (" R4KEOP_CLEAN", stdout
);
9532 fputs (" HWOR ", stdout
);
9533 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9534 fputs (" R4KEOP_CHECKED", stdout
);
9535 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9536 fputs (" R4KEOP_CLEAN", stdout
);
9539 printf (" GP_GROUP %#06lx self-contained %#06lx",
9540 option
->info
& OGP_GROUP
,
9541 (option
->info
& OGP_SELF
) >> 16);
9544 printf (" IDENT %#06lx self-contained %#06lx",
9545 option
->info
& OGP_GROUP
,
9546 (option
->info
& OGP_SELF
) >> 16);
9549 /* This shouldn't happen. */
9550 printf (" %3d ??? %d %lx",
9551 option
->kind
, option
->section
, option
->info
);
9555 len
= sizeof (*eopt
);
9556 while (len
< option
->size
)
9557 if (((char *) option
)[len
] >= ' '
9558 && ((char *) option
)[len
] < 0x7f)
9559 printf ("%c", ((char *) option
)[len
++]);
9561 printf ("\\%03o", ((char *) option
)[len
++]);
9563 fputs ("\n", stdout
);
9571 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9573 Elf32_Conflict
*iconf
;
9576 if (dynamic_symbols
== NULL
)
9578 error (_("conflict list found without a dynamic symbol table\n"));
9582 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9585 error (_("Out of memory\n"));
9591 Elf32_External_Conflict
*econf32
;
9593 econf32
= get_data (NULL
, file
, conflicts_offset
,
9594 conflictsno
, sizeof (*econf32
), _("conflict"));
9598 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9599 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9605 Elf64_External_Conflict
*econf64
;
9607 econf64
= get_data (NULL
, file
, conflicts_offset
,
9608 conflictsno
, sizeof (*econf64
), _("conflict"));
9612 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9613 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9618 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9619 (unsigned long) conflictsno
);
9620 puts (_(" Num: Index Value Name"));
9622 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9624 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9626 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9627 print_vma (psym
->st_value
, FULL_HEX
);
9629 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9630 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9632 printf ("<corrupt: %14ld>", psym
->st_name
);
9639 if (pltgot
!= 0 && local_gotno
!= 0)
9641 bfd_vma entry
, local_end
, global_end
;
9643 unsigned char *data
;
9647 addr_size
= (is_32bit_elf
? 4 : 8);
9648 local_end
= pltgot
+ local_gotno
* addr_size
;
9649 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9651 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9652 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9653 printf (_("\nPrimary GOT:\n"));
9654 printf (_(" Canonical gp value: "));
9655 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9658 printf (_(" Reserved entries:\n"));
9659 printf (_(" %*s %10s %*s Purpose\n"),
9660 addr_size
* 2, "Address", "Access",
9661 addr_size
* 2, "Initial");
9662 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9663 printf (" Lazy resolver\n");
9665 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9666 >> (addr_size
* 8 - 1)) != 0)
9668 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9669 printf (" Module pointer (GNU extension)\n");
9673 if (entry
< local_end
)
9675 printf (_(" Local entries:\n"));
9676 printf (_(" %*s %10s %*s\n"),
9677 addr_size
* 2, "Address", "Access",
9678 addr_size
* 2, "Initial");
9679 while (entry
< local_end
)
9681 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9687 if (gotsym
< symtabno
)
9691 printf (_(" Global entries:\n"));
9692 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9693 addr_size
* 2, "Address", "Access",
9694 addr_size
* 2, "Initial",
9695 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9696 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9697 for (i
= gotsym
; i
< symtabno
; i
++)
9699 Elf_Internal_Sym
*psym
;
9701 psym
= dynamic_symbols
+ i
;
9702 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9704 print_vma (psym
->st_value
, LONG_HEX
);
9705 printf (" %-7s %3s ",
9706 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9707 get_symbol_index_type (psym
->st_shndx
));
9708 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9709 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9711 printf ("<corrupt: %14ld>", psym
->st_name
);
9725 process_gnu_liblist (FILE *file
)
9727 Elf_Internal_Shdr
*section
, *string_sec
;
9728 Elf32_External_Lib
*elib
;
9737 for (i
= 0, section
= section_headers
;
9738 i
< elf_header
.e_shnum
;
9741 switch (section
->sh_type
)
9743 case SHT_GNU_LIBLIST
:
9744 if (section
->sh_link
>= elf_header
.e_shnum
)
9747 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9752 string_sec
= section_headers
+ section
->sh_link
;
9754 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9755 string_sec
->sh_size
, _("liblist string table"));
9756 strtab_size
= string_sec
->sh_size
;
9759 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9765 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9766 SECTION_NAME (section
),
9767 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9769 puts (" Library Time Stamp Checksum Version Flags");
9771 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9779 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9780 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9781 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9782 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9783 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9785 tmp
= gmtime (&time
);
9786 snprintf (timebuf
, sizeof (timebuf
),
9787 "%04u-%02u-%02uT%02u:%02u:%02u",
9788 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9789 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9791 printf ("%3lu: ", (unsigned long) cnt
);
9793 printf ("%-20s", liblist
.l_name
< strtab_size
9794 ? strtab
+ liblist
.l_name
: "<corrupt>");
9796 printf ("%-20.20s", liblist
.l_name
< strtab_size
9797 ? strtab
+ liblist
.l_name
: "<corrupt>");
9798 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9799 liblist
.l_version
, liblist
.l_flags
);
9810 get_note_type (unsigned e_type
)
9812 static char buff
[64];
9814 if (elf_header
.e_type
== ET_CORE
)
9818 return _("NT_AUXV (auxiliary vector)");
9820 return _("NT_PRSTATUS (prstatus structure)");
9822 return _("NT_FPREGSET (floating point registers)");
9824 return _("NT_PRPSINFO (prpsinfo structure)");
9826 return _("NT_TASKSTRUCT (task structure)");
9828 return _("NT_PRXFPREG (user_xfpregs structure)");
9830 return _("NT_PPC_VMX (ppc Altivec registers)");
9832 return _("NT_PSTATUS (pstatus structure)");
9834 return _("NT_FPREGS (floating point registers)");
9836 return _("NT_PSINFO (psinfo structure)");
9838 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9840 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9841 case NT_WIN32PSTATUS
:
9842 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9850 return _("NT_VERSION (version)");
9852 return _("NT_ARCH (architecture)");
9857 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9862 get_gnu_elf_note_type (unsigned e_type
)
9864 static char buff
[64];
9868 case NT_GNU_ABI_TAG
:
9869 return _("NT_GNU_ABI_TAG (ABI version tag)");
9871 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9872 case NT_GNU_BUILD_ID
:
9873 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9874 case NT_GNU_GOLD_VERSION
:
9875 return _("NT_GNU_GOLD_VERSION (gold version)");
9880 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9885 get_netbsd_elfcore_note_type (unsigned e_type
)
9887 static char buff
[64];
9889 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9891 /* NetBSD core "procinfo" structure. */
9892 return _("NetBSD procinfo structure");
9895 /* As of Jan 2002 there are no other machine-independent notes
9896 defined for NetBSD core files. If the note type is less
9897 than the start of the machine-dependent note types, we don't
9900 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9902 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9906 switch (elf_header
.e_machine
)
9908 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9909 and PT_GETFPREGS == mach+2. */
9914 case EM_SPARC32PLUS
:
9918 case NT_NETBSDCORE_FIRSTMACH
+0:
9919 return _("PT_GETREGS (reg structure)");
9920 case NT_NETBSDCORE_FIRSTMACH
+2:
9921 return _("PT_GETFPREGS (fpreg structure)");
9927 /* On all other arch's, PT_GETREGS == mach+1 and
9928 PT_GETFPREGS == mach+3. */
9932 case NT_NETBSDCORE_FIRSTMACH
+1:
9933 return _("PT_GETREGS (reg structure)");
9934 case NT_NETBSDCORE_FIRSTMACH
+3:
9935 return _("PT_GETFPREGS (fpreg structure)");
9941 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
9942 e_type
- NT_NETBSDCORE_FIRSTMACH
);
9946 /* Note that by the ELF standard, the name field is already null byte
9947 terminated, and namesz includes the terminating null byte.
9948 I.E. the value of namesz for the name "FSF" is 4.
9950 If the value of namesz is zero, there is no name present. */
9952 process_note (Elf_Internal_Note
*pnote
)
9954 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
9957 if (pnote
->namesz
== 0)
9958 /* If there is no note name, then use the default set of
9959 note type strings. */
9960 nt
= get_note_type (pnote
->type
);
9962 else if (const_strneq (pnote
->namedata
, "GNU"))
9963 /* GNU-specific object file notes. */
9964 nt
= get_gnu_elf_note_type (pnote
->type
);
9966 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
9967 /* NetBSD-specific core file notes. */
9968 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9970 else if (strneq (pnote
->namedata
, "SPU/", 4))
9972 /* SPU-specific core file notes. */
9973 nt
= pnote
->namedata
+ 4;
9978 /* Don't recognize this note name; just use the default set of
9979 note type strings. */
9980 nt
= get_note_type (pnote
->type
);
9982 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
9988 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
9990 Elf_External_Note
*pnotes
;
9991 Elf_External_Note
*external
;
9997 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10003 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10004 (unsigned long) offset
, (unsigned long) length
);
10005 printf (_(" Owner\t\tData size\tDescription\n"));
10007 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10009 Elf_External_Note
*next
;
10010 Elf_Internal_Note inote
;
10013 inote
.type
= BYTE_GET (external
->type
);
10014 inote
.namesz
= BYTE_GET (external
->namesz
);
10015 inote
.namedata
= external
->name
;
10016 inote
.descsz
= BYTE_GET (external
->descsz
);
10017 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10018 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10020 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10022 if (((char *) next
) > (((char *) pnotes
) + length
))
10024 warn (_("corrupt note found at offset %lx into core notes\n"),
10025 (long)((char *)external
- (char *)pnotes
));
10026 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10027 inote
.type
, inote
.namesz
, inote
.descsz
);
10033 /* Verify that name is null terminated. It appears that at least
10034 one version of Linux (RedHat 6.0) generates corefiles that don't
10035 comply with the ELF spec by failing to include the null byte in
10037 if (inote
.namedata
[inote
.namesz
] != '\0')
10039 temp
= malloc (inote
.namesz
+ 1);
10043 error (_("Out of memory\n"));
10048 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10049 temp
[inote
.namesz
] = 0;
10051 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10052 inote
.namedata
= temp
;
10055 res
&= process_note (& inote
);
10070 process_corefile_note_segments (FILE *file
)
10072 Elf_Internal_Phdr
*segment
;
10076 if (! get_program_headers (file
))
10079 for (i
= 0, segment
= program_headers
;
10080 i
< elf_header
.e_phnum
;
10083 if (segment
->p_type
== PT_NOTE
)
10084 res
&= process_corefile_note_segment (file
,
10085 (bfd_vma
) segment
->p_offset
,
10086 (bfd_vma
) segment
->p_filesz
);
10093 process_note_sections (FILE *file
)
10095 Elf_Internal_Shdr
*section
;
10099 for (i
= 0, section
= section_headers
;
10100 i
< elf_header
.e_shnum
;
10102 if (section
->sh_type
== SHT_NOTE
)
10103 res
&= process_corefile_note_segment (file
,
10104 (bfd_vma
) section
->sh_offset
,
10105 (bfd_vma
) section
->sh_size
);
10111 process_notes (FILE *file
)
10113 /* If we have not been asked to display the notes then do nothing. */
10117 if (elf_header
.e_type
!= ET_CORE
)
10118 return process_note_sections (file
);
10120 /* No program headers means no NOTE segment. */
10121 if (elf_header
.e_phnum
> 0)
10122 return process_corefile_note_segments (file
);
10124 printf (_("No note segments present in the core file.\n"));
10129 process_arch_specific (FILE *file
)
10134 switch (elf_header
.e_machine
)
10137 return process_arm_specific (file
);
10139 case EM_MIPS_RS3_LE
:
10140 return process_mips_specific (file
);
10143 return process_power_specific (file
);
10152 get_file_header (FILE *file
)
10154 /* Read in the identity array. */
10155 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10158 /* Determine how to read the rest of the header. */
10159 switch (elf_header
.e_ident
[EI_DATA
])
10161 default: /* fall through */
10162 case ELFDATANONE
: /* fall through */
10164 byte_get
= byte_get_little_endian
;
10165 byte_put
= byte_put_little_endian
;
10168 byte_get
= byte_get_big_endian
;
10169 byte_put
= byte_put_big_endian
;
10173 /* For now we only support 32 bit and 64 bit ELF files. */
10174 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10176 /* Read in the rest of the header. */
10179 Elf32_External_Ehdr ehdr32
;
10181 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10184 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10185 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10186 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10187 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10188 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10189 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10190 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10191 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10192 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10193 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10194 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10195 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10196 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10200 Elf64_External_Ehdr ehdr64
;
10202 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10203 we will not be able to cope with the 64bit data found in
10204 64 ELF files. Detect this now and abort before we start
10205 overwriting things. */
10206 if (sizeof (bfd_vma
) < 8)
10208 error (_("This instance of readelf has been built without support for a\n\
10209 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10213 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10216 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10217 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10218 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10219 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10220 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10221 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10222 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10223 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10224 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10225 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10226 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10227 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10228 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10231 if (elf_header
.e_shoff
)
10233 /* There may be some extensions in the first section header. Don't
10234 bomb if we can't read it. */
10236 get_32bit_section_headers (file
, 1);
10238 get_64bit_section_headers (file
, 1);
10244 /* Process one ELF object file according to the command line options.
10245 This file may actually be stored in an archive. The file is
10246 positioned at the start of the ELF object. */
10249 process_object (char *file_name
, FILE *file
)
10253 if (! get_file_header (file
))
10255 error (_("%s: Failed to read file header\n"), file_name
);
10259 /* Initialise per file variables. */
10260 for (i
= ARRAY_SIZE (version_info
); i
--;)
10261 version_info
[i
] = 0;
10263 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10264 dynamic_info
[i
] = 0;
10266 /* Process the file. */
10268 printf (_("\nFile: %s\n"), file_name
);
10270 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10271 Note we do this even if cmdline_dump_sects is empty because we
10272 must make sure that the dump_sets array is zeroed out before each
10273 object file is processed. */
10274 if (num_dump_sects
> num_cmdline_dump_sects
)
10275 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10277 if (num_cmdline_dump_sects
> 0)
10279 if (num_dump_sects
== 0)
10280 /* A sneaky way of allocating the dump_sects array. */
10281 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10283 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10284 memcpy (dump_sects
, cmdline_dump_sects
,
10285 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10288 if (! process_file_header ())
10291 if (! process_section_headers (file
))
10293 /* Without loaded section headers we cannot process lots of
10295 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10297 if (! do_using_dynamic
)
10298 do_syms
= do_reloc
= 0;
10301 if (! process_section_groups (file
))
10303 /* Without loaded section groups we cannot process unwind. */
10307 if (process_program_headers (file
))
10308 process_dynamic_section (file
);
10310 process_relocs (file
);
10312 process_unwind (file
);
10314 process_symbol_table (file
);
10316 process_syminfo (file
);
10318 process_version_sections (file
);
10320 process_section_contents (file
);
10322 process_notes (file
);
10324 process_gnu_liblist (file
);
10326 process_arch_specific (file
);
10328 if (program_headers
)
10330 free (program_headers
);
10331 program_headers
= NULL
;
10334 if (section_headers
)
10336 free (section_headers
);
10337 section_headers
= NULL
;
10342 free (string_table
);
10343 string_table
= NULL
;
10344 string_table_length
= 0;
10347 if (dynamic_strings
)
10349 free (dynamic_strings
);
10350 dynamic_strings
= NULL
;
10351 dynamic_strings_length
= 0;
10354 if (dynamic_symbols
)
10356 free (dynamic_symbols
);
10357 dynamic_symbols
= NULL
;
10358 num_dynamic_syms
= 0;
10361 if (dynamic_syminfo
)
10363 free (dynamic_syminfo
);
10364 dynamic_syminfo
= NULL
;
10367 if (section_headers_groups
)
10369 free (section_headers_groups
);
10370 section_headers_groups
= NULL
;
10373 if (section_groups
)
10375 struct group_list
*g
, *next
;
10377 for (i
= 0; i
< group_count
; i
++)
10379 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10386 free (section_groups
);
10387 section_groups
= NULL
;
10390 free_debug_memory ();
10395 /* Process an ELF archive.
10396 On entry the file is positioned just after the ARMAG string. */
10399 process_archive (char *file_name
, FILE *file
)
10401 struct ar_hdr arhdr
;
10403 unsigned long size
;
10404 unsigned long index_num
= 0;
10405 unsigned long *index_array
= NULL
;
10406 char *sym_table
= NULL
;
10407 unsigned long sym_size
= 0;
10408 char *longnames
= NULL
;
10409 unsigned long longnames_size
= 0;
10410 size_t file_name_size
;
10415 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10416 if (got
!= sizeof arhdr
)
10421 error (_("%s: failed to read archive header\n"), file_name
);
10425 /* See if this is the archive symbol table. */
10426 if (const_strneq (arhdr
.ar_name
, "/ ")
10427 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
10429 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10430 size
= size
+ (size
& 1);
10432 if (do_archive_index
)
10435 /* A buffer used to hold numbers read in from an archive index.
10436 These are always 4 bytes long and stored in big-endian format. */
10437 #define SIZEOF_AR_INDEX_NUMBERS 4
10438 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10439 unsigned char * index_buffer
;
10441 /* Check the size of the archive index. */
10442 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10444 error (_("%s: the archive index is empty\n"), file_name
);
10448 /* Read the numer of entries in the archive index. */
10449 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10450 if (got
!= sizeof (integer_buffer
))
10452 error (_("%s: failed to read archive index\n"), file_name
);
10455 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10456 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10458 /* Read in the archive index. */
10459 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10461 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10462 file_name
, index_num
);
10465 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10466 if (index_buffer
== NULL
)
10468 error (_("Out of memory whilst trying to read archive symbol index\n"));
10471 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
10472 if (got
!= index_num
)
10474 free (index_buffer
);
10475 error (_("%s: failed to read archive index\n"), file_name
);
10479 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10481 /* Convert the index numbers into the host's numeric format. */
10482 index_array
= malloc (index_num
* sizeof (* index_array
));
10483 if (index_array
== NULL
)
10485 free (index_buffer
);
10486 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10490 for (i
= 0; i
< index_num
; i
++)
10491 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10492 SIZEOF_AR_INDEX_NUMBERS
);
10493 free (index_buffer
);
10495 /* The remaining space in the header is taken up by the symbol table. */
10498 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10502 sym_table
= malloc (size
);
10504 if (sym_table
== NULL
)
10506 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10510 got
= fread (sym_table
, 1, size
, file
);
10513 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10520 if (fseek (file
, size
, SEEK_CUR
) != 0)
10522 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10527 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10528 if (got
!= sizeof arhdr
)
10536 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10541 else if (do_archive_index
)
10542 printf (_("%s has no archive index\n"), file_name
);
10544 if (const_strneq (arhdr
.ar_name
, "// "))
10546 /* This is the archive string table holding long member
10549 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10550 longnames
= malloc (longnames_size
);
10551 if (longnames
== NULL
)
10553 error (_("Out of memory reading long symbol names in archive\n"));
10558 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10561 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10566 if ((longnames_size
& 1) != 0)
10569 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10570 if (got
!= sizeof arhdr
)
10576 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10583 if (do_archive_index
)
10585 if (sym_table
== NULL
)
10586 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10589 unsigned int i
, j
, k
, l
;
10591 unsigned long current_pos
;
10593 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10594 file_name
, index_num
, sym_size
);
10595 current_pos
= ftell (file
);
10597 for (i
= l
= 0; i
< index_num
; i
++)
10599 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10601 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10603 error (_("%s: failed to seek to next file name\n"), file_name
);
10607 got
= fread (elf_name
, 1, 16, file
);
10610 error (_("%s: failed to read file name\n"), file_name
);
10615 if (elf_name
[0] == '/')
10617 /* We have a long name. */
10618 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10619 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10621 longnames
[j
] = '\0';
10622 printf (_("Binary %s contains:\n"), longnames
+ k
);
10623 longnames
[j
] = '/';
10628 while ((elf_name
[j
] != '/') && (j
< 16))
10630 elf_name
[j
] = '\0';
10631 printf(_("Binary %s contains:\n"), elf_name
);
10636 error (_("%s: end of the symbol table reached before the end of the index\n"),
10640 printf ("\t%s\n", sym_table
+ l
);
10641 l
+= strlen (sym_table
+ l
) + 1;
10645 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10648 free (index_array
);
10649 index_array
= NULL
;
10652 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10654 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10659 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10660 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10661 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10662 && !do_section_groups
)
10663 return 0; /* Archive index only. */
10666 file_name_size
= strlen (file_name
);
10675 if (arhdr
.ar_name
[0] == '/')
10679 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10680 if (off
>= longnames_size
)
10682 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10687 name
= longnames
+ off
;
10688 nameend
= memchr (name
, '/', longnames_size
- off
);
10692 name
= arhdr
.ar_name
;
10693 nameend
= memchr (name
, '/', 16);
10696 if (nameend
== NULL
)
10698 error (_("%s: bad archive file name\n"), file_name
);
10703 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10704 if (namealc
== NULL
)
10706 error (_("Out of memory\n"));
10711 memcpy (namealc
, file_name
, file_name_size
);
10712 namealc
[file_name_size
] = '(';
10713 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10714 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10715 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10717 archive_file_offset
= ftell (file
);
10718 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10720 ret
|= process_object (namealc
, file
);
10725 (archive_file_offset
10726 + archive_file_size
10727 + (archive_file_size
& 1)),
10730 error (_("%s: failed to seek to next archive header\n"), file_name
);
10735 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10736 if (got
!= sizeof arhdr
)
10741 error (_("%s: failed to read archive header\n"), file_name
);
10748 if (index_array
!= NULL
)
10749 free (index_array
);
10750 if (sym_table
!= NULL
)
10752 if (longnames
!= NULL
)
10759 process_file (char *file_name
)
10762 struct stat statbuf
;
10763 char armag
[SARMAG
];
10766 if (stat (file_name
, &statbuf
) < 0)
10768 if (errno
== ENOENT
)
10769 error (_("'%s': No such file\n"), file_name
);
10771 error (_("Could not locate '%s'. System error message: %s\n"),
10772 file_name
, strerror (errno
));
10776 if (! S_ISREG (statbuf
.st_mode
))
10778 error (_("'%s' is not an ordinary file\n"), file_name
);
10782 file
= fopen (file_name
, "rb");
10785 error (_("Input file '%s' is not readable.\n"), file_name
);
10789 if (fread (armag
, SARMAG
, 1, file
) != 1)
10791 error (_("%s: Failed to read file's magic number\n"), file_name
);
10796 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10797 ret
= process_archive (file_name
, file
);
10800 if (do_archive_index
)
10801 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10805 archive_file_size
= archive_file_offset
= 0;
10806 ret
= process_object (file_name
, file
);
10814 #ifdef SUPPORT_DISASSEMBLY
10815 /* Needed by the i386 disassembler. For extra credit, someone could
10816 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10820 print_address (unsigned int addr
, FILE *outfile
)
10822 fprintf (outfile
,"0x%8.8x", addr
);
10825 /* Needed by the i386 disassembler. */
10827 db_task_printsym (unsigned int addr
)
10829 print_address (addr
, stderr
);
10834 main (int argc
, char **argv
)
10838 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10839 setlocale (LC_MESSAGES
, "");
10841 #if defined (HAVE_SETLOCALE)
10842 setlocale (LC_CTYPE
, "");
10844 bindtextdomain (PACKAGE
, LOCALEDIR
);
10845 textdomain (PACKAGE
);
10847 expandargv (&argc
, &argv
);
10849 parse_args (argc
, argv
);
10851 if (num_dump_sects
> 0)
10853 /* Make a copy of the dump_sects array. */
10854 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10855 if (cmdline_dump_sects
== NULL
)
10856 error (_("Out of memory allocating dump request table.\n"));
10859 memcpy (cmdline_dump_sects
, dump_sects
,
10860 num_dump_sects
* sizeof (* dump_sects
));
10861 num_cmdline_dump_sects
= num_dump_sects
;
10865 if (optind
< (argc
- 1))
10869 while (optind
< argc
)
10870 err
|= process_file (argv
[optind
++]);
10872 if (dump_sects
!= NULL
)
10874 if (cmdline_dump_sects
!= NULL
)
10875 free (cmdline_dump_sects
);