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
:
726 case EM_CYGNUS_MN10200
:
728 case EM_CYGNUS_MN10300
:
769 warn (_("Don't know about relocations on this machine architecture\n"));
775 slurp_rela_relocs (FILE *file
,
776 unsigned long rel_offset
,
777 unsigned long rel_size
,
778 Elf_Internal_Rela
**relasp
,
779 unsigned long *nrelasp
)
781 Elf_Internal_Rela
*relas
;
782 unsigned long nrelas
;
787 Elf32_External_Rela
*erelas
;
789 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
793 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
795 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
800 error (_("out of memory parsing relocs\n"));
804 for (i
= 0; i
< nrelas
; i
++)
806 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
807 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
808 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
815 Elf64_External_Rela
*erelas
;
817 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
821 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
823 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
828 error (_("out of memory parsing relocs\n"));
832 for (i
= 0; i
< nrelas
; i
++)
834 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
835 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
836 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
847 slurp_rel_relocs (FILE *file
,
848 unsigned long rel_offset
,
849 unsigned long rel_size
,
850 Elf_Internal_Rela
**relsp
,
851 unsigned long *nrelsp
)
853 Elf_Internal_Rela
*rels
;
859 Elf32_External_Rel
*erels
;
861 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
865 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
867 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
872 error (_("out of memory parsing relocs\n"));
876 for (i
= 0; i
< nrels
; i
++)
878 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
879 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
880 rels
[i
].r_addend
= 0;
887 Elf64_External_Rel
*erels
;
889 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
893 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
895 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
900 error (_("out of memory parsing relocs\n"));
904 for (i
= 0; i
< nrels
; i
++)
906 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
907 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
908 rels
[i
].r_addend
= 0;
918 /* Returns the reloc type extracted from the reloc info field. */
921 get_reloc_type (bfd_vma reloc_info
)
924 return ELF32_R_TYPE (reloc_info
);
926 switch (elf_header
.e_machine
)
929 /* Note: We assume that reloc_info has already been adjusted for us. */
930 return ELF64_MIPS_R_TYPE (reloc_info
);
933 return ELF64_R_TYPE_ID (reloc_info
);
936 return ELF64_R_TYPE (reloc_info
);
940 /* Return the symbol index extracted from the reloc info field. */
943 get_reloc_symindex (bfd_vma reloc_info
)
945 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
948 /* Display the contents of the relocation data found at the specified
952 dump_relocations (FILE *file
,
953 unsigned long rel_offset
,
954 unsigned long rel_size
,
955 Elf_Internal_Sym
*symtab
,
958 unsigned long strtablen
,
962 Elf_Internal_Rela
*rels
;
965 if (is_rela
== UNKNOWN
)
966 is_rela
= guess_is_rela (elf_header
.e_machine
);
970 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
975 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
984 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
986 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
991 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
993 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1001 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1003 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1008 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1010 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1014 for (i
= 0; i
< rel_size
; i
++)
1019 bfd_vma symtab_index
;
1022 offset
= rels
[i
].r_offset
;
1023 info
= rels
[i
].r_info
;
1025 /* The #ifdef BFD64 below is to prevent a compile time warning.
1026 We know that if we do not have a 64 bit data type that we
1027 will never execute this code anyway. */
1030 && elf_header
.e_machine
== EM_MIPS
1031 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1033 /* In little-endian objects, r_info isn't really a 64-bit
1034 little-endian value: it has a 32-bit little-endian
1035 symbol index followed by four individual byte fields.
1036 Reorder INFO accordingly. */
1037 info
= (((info
& 0xffffffff) << 32)
1038 | ((info
>> 56) & 0xff)
1039 | ((info
>> 40) & 0xff00)
1040 | ((info
>> 24) & 0xff0000)
1041 | ((info
>> 8) & 0xff000000));
1045 type
= get_reloc_type (info
);
1046 symtab_index
= get_reloc_symindex (info
);
1050 printf ("%8.8lx %8.8lx ",
1051 (unsigned long) offset
& 0xffffffff,
1052 (unsigned long) info
& 0xffffffff);
1056 #if BFD_HOST_64BIT_LONG
1058 ? "%16.16lx %16.16lx "
1059 : "%12.12lx %12.12lx ",
1061 #elif BFD_HOST_64BIT_LONG_LONG
1064 ? "%16.16llx %16.16llx "
1065 : "%12.12llx %12.12llx ",
1069 ? "%16.16I64x %16.16I64x "
1070 : "%12.12I64x %12.12I64x ",
1075 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1076 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1077 _bfd_int64_high (offset
),
1078 _bfd_int64_low (offset
),
1079 _bfd_int64_high (info
),
1080 _bfd_int64_low (info
));
1084 switch (elf_header
.e_machine
)
1091 case EM_CYGNUS_M32R
:
1092 rtype
= elf_m32r_reloc_type (type
);
1097 rtype
= elf_i386_reloc_type (type
);
1102 rtype
= elf_m68hc11_reloc_type (type
);
1106 rtype
= elf_m68k_reloc_type (type
);
1110 rtype
= elf_i960_reloc_type (type
);
1115 rtype
= elf_avr_reloc_type (type
);
1118 case EM_OLD_SPARCV9
:
1119 case EM_SPARC32PLUS
:
1122 rtype
= elf_sparc_reloc_type (type
);
1126 rtype
= elf_spu_reloc_type (type
);
1130 case EM_CYGNUS_V850
:
1131 rtype
= v850_reloc_type (type
);
1135 case EM_CYGNUS_D10V
:
1136 rtype
= elf_d10v_reloc_type (type
);
1140 case EM_CYGNUS_D30V
:
1141 rtype
= elf_d30v_reloc_type (type
);
1145 rtype
= elf_dlx_reloc_type (type
);
1149 rtype
= elf_sh_reloc_type (type
);
1153 case EM_CYGNUS_MN10300
:
1154 rtype
= elf_mn10300_reloc_type (type
);
1158 case EM_CYGNUS_MN10200
:
1159 rtype
= elf_mn10200_reloc_type (type
);
1163 case EM_CYGNUS_FR30
:
1164 rtype
= elf_fr30_reloc_type (type
);
1168 rtype
= elf_frv_reloc_type (type
);
1172 rtype
= elf_mcore_reloc_type (type
);
1176 rtype
= elf_mmix_reloc_type (type
);
1181 rtype
= elf_msp430_reloc_type (type
);
1185 rtype
= elf_ppc_reloc_type (type
);
1189 rtype
= elf_ppc64_reloc_type (type
);
1193 case EM_MIPS_RS3_LE
:
1194 rtype
= elf_mips_reloc_type (type
);
1198 rtype
= elf_alpha_reloc_type (type
);
1202 rtype
= elf_arm_reloc_type (type
);
1206 rtype
= elf_arc_reloc_type (type
);
1210 rtype
= elf_hppa_reloc_type (type
);
1216 rtype
= elf_h8_reloc_type (type
);
1221 rtype
= elf_or32_reloc_type (type
);
1226 rtype
= elf_pj_reloc_type (type
);
1229 rtype
= elf_ia64_reloc_type (type
);
1233 rtype
= elf_cris_reloc_type (type
);
1237 rtype
= elf_i860_reloc_type (type
);
1241 rtype
= elf_x86_64_reloc_type (type
);
1245 rtype
= i370_reloc_type (type
);
1250 rtype
= elf_s390_reloc_type (type
);
1254 rtype
= elf_score_reloc_type (type
);
1258 rtype
= elf_xstormy16_reloc_type (type
);
1262 rtype
= elf_crx_reloc_type (type
);
1266 rtype
= elf_vax_reloc_type (type
);
1271 rtype
= elf_ip2k_reloc_type (type
);
1275 rtype
= elf_iq2000_reloc_type (type
);
1280 rtype
= elf_xtensa_reloc_type (type
);
1284 rtype
= elf_m32c_reloc_type (type
);
1288 rtype
= elf_mt_reloc_type (type
);
1292 rtype
= elf_bfin_reloc_type (type
);
1296 rtype
= elf_mep_reloc_type (type
);
1300 rtype
= elf_cr16_reloc_type (type
);
1305 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1307 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1309 if (elf_header
.e_machine
== EM_ALPHA
1311 && streq (rtype
, "R_ALPHA_LITUSE")
1314 switch (rels
[i
].r_addend
)
1316 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1317 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1318 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1319 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1320 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1321 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1322 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1323 default: rtype
= NULL
;
1326 printf (" (%s)", rtype
);
1330 printf (_("<unknown addend: %lx>"),
1331 (unsigned long) rels
[i
].r_addend
);
1334 else if (symtab_index
)
1336 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1337 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1340 Elf_Internal_Sym
*psym
;
1342 psym
= symtab
+ symtab_index
;
1345 print_vma (psym
->st_value
, LONG_HEX
);
1346 printf (is_32bit_elf
? " " : " ");
1348 if (psym
->st_name
== 0)
1350 const char *sec_name
= "<null>";
1353 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1355 if (psym
->st_shndx
< elf_header
.e_shnum
)
1357 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1358 else if (psym
->st_shndx
== SHN_ABS
)
1360 else if (psym
->st_shndx
== SHN_COMMON
)
1361 sec_name
= "COMMON";
1362 else if (elf_header
.e_machine
== EM_MIPS
1363 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1364 sec_name
= "SCOMMON";
1365 else if (elf_header
.e_machine
== EM_MIPS
1366 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1367 sec_name
= "SUNDEF";
1368 else if (elf_header
.e_machine
== EM_X86_64
1369 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1370 sec_name
= "LARGE_COMMON";
1371 else if (elf_header
.e_machine
== EM_IA_64
1372 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1373 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1374 sec_name
= "ANSI_COM";
1375 else if (elf_header
.e_machine
== EM_IA_64
1376 && (elf_header
.e_ident
[EI_OSABI
]
1377 == ELFOSABI_OPENVMS
)
1378 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1379 sec_name
= "VMS_SYMVEC";
1382 sprintf (name_buf
, "<section 0x%x>",
1383 (unsigned int) psym
->st_shndx
);
1384 sec_name
= name_buf
;
1387 print_symbol (22, sec_name
);
1389 else if (strtab
== NULL
)
1390 printf (_("<string table index: %3ld>"), psym
->st_name
);
1391 else if (psym
->st_name
>= strtablen
)
1392 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1394 print_symbol (22, strtab
+ psym
->st_name
);
1397 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1402 printf ("%*c", is_32bit_elf
?
1403 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1404 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1407 if (elf_header
.e_machine
== EM_SPARCV9
1409 && streq (rtype
, "R_SPARC_OLO10"))
1410 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1415 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1417 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1418 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1419 const char *rtype2
= elf_mips_reloc_type (type2
);
1420 const char *rtype3
= elf_mips_reloc_type (type3
);
1422 printf (" Type2: ");
1425 printf (_("unrecognized: %-7lx"),
1426 (unsigned long) type2
& 0xffffffff);
1428 printf ("%-17.17s", rtype2
);
1430 printf ("\n Type3: ");
1433 printf (_("unrecognized: %-7lx"),
1434 (unsigned long) type3
& 0xffffffff);
1436 printf ("%-17.17s", rtype3
);
1447 get_mips_dynamic_type (unsigned long type
)
1451 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1452 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1453 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1454 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1455 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1456 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1457 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1458 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1459 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1460 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1461 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1462 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1463 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1464 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1465 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1466 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1467 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1468 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1469 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1470 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1471 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1472 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1473 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1474 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1475 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1476 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1477 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1478 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1479 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1480 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1481 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1482 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1483 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1484 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1485 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1486 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1487 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1488 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1489 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1490 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1491 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1492 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1493 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1500 get_sparc64_dynamic_type (unsigned long type
)
1504 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1511 get_ppc_dynamic_type (unsigned long type
)
1515 case DT_PPC_GOT
: return "PPC_GOT";
1522 get_ppc64_dynamic_type (unsigned long type
)
1526 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1527 case DT_PPC64_OPD
: return "PPC64_OPD";
1528 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1535 get_parisc_dynamic_type (unsigned long type
)
1539 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1540 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1541 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1542 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1543 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1544 case DT_HP_PREINIT
: return "HP_PREINIT";
1545 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1546 case DT_HP_NEEDED
: return "HP_NEEDED";
1547 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1548 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1549 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1550 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1551 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1552 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1553 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1554 case DT_HP_FILTERED
: return "HP_FILTERED";
1555 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1556 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1557 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1558 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1559 case DT_PLT
: return "PLT";
1560 case DT_PLT_SIZE
: return "PLT_SIZE";
1561 case DT_DLT
: return "DLT";
1562 case DT_DLT_SIZE
: return "DLT_SIZE";
1569 get_ia64_dynamic_type (unsigned long type
)
1573 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1574 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1575 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1576 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1577 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1578 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1579 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1580 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1581 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1582 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1583 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1584 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1585 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1586 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1587 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1588 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1589 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1590 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1591 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1592 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1593 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1594 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1595 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1596 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1597 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1598 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1599 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1600 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1601 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1602 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1603 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1610 get_alpha_dynamic_type (unsigned long type
)
1614 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1621 get_score_dynamic_type (unsigned long type
)
1625 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1626 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1627 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1628 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1629 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1630 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1638 get_dynamic_type (unsigned long type
)
1640 static char buff
[64];
1644 case DT_NULL
: return "NULL";
1645 case DT_NEEDED
: return "NEEDED";
1646 case DT_PLTRELSZ
: return "PLTRELSZ";
1647 case DT_PLTGOT
: return "PLTGOT";
1648 case DT_HASH
: return "HASH";
1649 case DT_STRTAB
: return "STRTAB";
1650 case DT_SYMTAB
: return "SYMTAB";
1651 case DT_RELA
: return "RELA";
1652 case DT_RELASZ
: return "RELASZ";
1653 case DT_RELAENT
: return "RELAENT";
1654 case DT_STRSZ
: return "STRSZ";
1655 case DT_SYMENT
: return "SYMENT";
1656 case DT_INIT
: return "INIT";
1657 case DT_FINI
: return "FINI";
1658 case DT_SONAME
: return "SONAME";
1659 case DT_RPATH
: return "RPATH";
1660 case DT_SYMBOLIC
: return "SYMBOLIC";
1661 case DT_REL
: return "REL";
1662 case DT_RELSZ
: return "RELSZ";
1663 case DT_RELENT
: return "RELENT";
1664 case DT_PLTREL
: return "PLTREL";
1665 case DT_DEBUG
: return "DEBUG";
1666 case DT_TEXTREL
: return "TEXTREL";
1667 case DT_JMPREL
: return "JMPREL";
1668 case DT_BIND_NOW
: return "BIND_NOW";
1669 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1670 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1671 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1672 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1673 case DT_RUNPATH
: return "RUNPATH";
1674 case DT_FLAGS
: return "FLAGS";
1676 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1677 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1679 case DT_CHECKSUM
: return "CHECKSUM";
1680 case DT_PLTPADSZ
: return "PLTPADSZ";
1681 case DT_MOVEENT
: return "MOVEENT";
1682 case DT_MOVESZ
: return "MOVESZ";
1683 case DT_FEATURE
: return "FEATURE";
1684 case DT_POSFLAG_1
: return "POSFLAG_1";
1685 case DT_SYMINSZ
: return "SYMINSZ";
1686 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1688 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1689 case DT_CONFIG
: return "CONFIG";
1690 case DT_DEPAUDIT
: return "DEPAUDIT";
1691 case DT_AUDIT
: return "AUDIT";
1692 case DT_PLTPAD
: return "PLTPAD";
1693 case DT_MOVETAB
: return "MOVETAB";
1694 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1696 case DT_VERSYM
: return "VERSYM";
1698 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1699 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1700 case DT_RELACOUNT
: return "RELACOUNT";
1701 case DT_RELCOUNT
: return "RELCOUNT";
1702 case DT_FLAGS_1
: return "FLAGS_1";
1703 case DT_VERDEF
: return "VERDEF";
1704 case DT_VERDEFNUM
: return "VERDEFNUM";
1705 case DT_VERNEED
: return "VERNEED";
1706 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1708 case DT_AUXILIARY
: return "AUXILIARY";
1709 case DT_USED
: return "USED";
1710 case DT_FILTER
: return "FILTER";
1712 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1713 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1714 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1715 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1716 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1717 case DT_GNU_HASH
: return "GNU_HASH";
1720 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1724 switch (elf_header
.e_machine
)
1727 case EM_MIPS_RS3_LE
:
1728 result
= get_mips_dynamic_type (type
);
1731 result
= get_sparc64_dynamic_type (type
);
1734 result
= get_ppc_dynamic_type (type
);
1737 result
= get_ppc64_dynamic_type (type
);
1740 result
= get_ia64_dynamic_type (type
);
1743 result
= get_alpha_dynamic_type (type
);
1746 result
= get_score_dynamic_type (type
);
1756 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1758 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1759 || (elf_header
.e_machine
== EM_PARISC
1760 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1764 switch (elf_header
.e_machine
)
1767 result
= get_parisc_dynamic_type (type
);
1770 result
= get_ia64_dynamic_type (type
);
1780 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1784 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1791 get_file_type (unsigned e_type
)
1793 static char buff
[32];
1797 case ET_NONE
: return _("NONE (None)");
1798 case ET_REL
: return _("REL (Relocatable file)");
1799 case ET_EXEC
: return _("EXEC (Executable file)");
1800 case ET_DYN
: return _("DYN (Shared object file)");
1801 case ET_CORE
: return _("CORE (Core file)");
1804 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1805 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1806 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1807 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1809 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1815 get_machine_name (unsigned e_machine
)
1817 static char buff
[64]; /* XXX */
1821 case EM_NONE
: return _("None");
1822 case EM_M32
: return "WE32100";
1823 case EM_SPARC
: return "Sparc";
1824 case EM_SPU
: return "SPU";
1825 case EM_386
: return "Intel 80386";
1826 case EM_68K
: return "MC68000";
1827 case EM_88K
: return "MC88000";
1828 case EM_486
: return "Intel 80486";
1829 case EM_860
: return "Intel 80860";
1830 case EM_MIPS
: return "MIPS R3000";
1831 case EM_S370
: return "IBM System/370";
1832 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1833 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1834 case EM_PARISC
: return "HPPA";
1835 case EM_PPC_OLD
: return "Power PC (old)";
1836 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1837 case EM_960
: return "Intel 90860";
1838 case EM_PPC
: return "PowerPC";
1839 case EM_PPC64
: return "PowerPC64";
1840 case EM_V800
: return "NEC V800";
1841 case EM_FR20
: return "Fujitsu FR20";
1842 case EM_RH32
: return "TRW RH32";
1843 case EM_MCORE
: return "MCORE";
1844 case EM_ARM
: return "ARM";
1845 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1846 case EM_SH
: return "Renesas / SuperH SH";
1847 case EM_SPARCV9
: return "Sparc v9";
1848 case EM_TRICORE
: return "Siemens Tricore";
1849 case EM_ARC
: return "ARC";
1850 case EM_H8_300
: return "Renesas H8/300";
1851 case EM_H8_300H
: return "Renesas H8/300H";
1852 case EM_H8S
: return "Renesas H8S";
1853 case EM_H8_500
: return "Renesas H8/500";
1854 case EM_IA_64
: return "Intel IA-64";
1855 case EM_MIPS_X
: return "Stanford MIPS-X";
1856 case EM_COLDFIRE
: return "Motorola Coldfire";
1857 case EM_68HC12
: return "Motorola M68HC12";
1858 case EM_ALPHA
: return "Alpha";
1859 case EM_CYGNUS_D10V
:
1860 case EM_D10V
: return "d10v";
1861 case EM_CYGNUS_D30V
:
1862 case EM_D30V
: return "d30v";
1863 case EM_CYGNUS_M32R
:
1864 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1865 case EM_CYGNUS_V850
:
1866 case EM_V850
: return "NEC v850";
1867 case EM_CYGNUS_MN10300
:
1868 case EM_MN10300
: return "mn10300";
1869 case EM_CYGNUS_MN10200
:
1870 case EM_MN10200
: return "mn10200";
1871 case EM_CYGNUS_FR30
:
1872 case EM_FR30
: return "Fujitsu FR30";
1873 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1875 case EM_PJ
: return "picoJava";
1876 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1877 case EM_PCP
: return "Siemens PCP";
1878 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1879 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1880 case EM_STARCORE
: return "Motorola Star*Core processor";
1881 case EM_ME16
: return "Toyota ME16 processor";
1882 case EM_ST100
: return "STMicroelectronics ST100 processor";
1883 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1884 case EM_FX66
: return "Siemens FX66 microcontroller";
1885 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1886 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1887 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1888 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1889 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1890 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1891 case EM_SVX
: return "Silicon Graphics SVx";
1892 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1893 case EM_VAX
: return "Digital VAX";
1895 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1896 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1897 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1898 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1899 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1900 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1901 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1902 case EM_PRISM
: return "Vitesse Prism";
1903 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1905 case EM_S390
: return "IBM S/390";
1906 case EM_SCORE
: return "SUNPLUS S+Core";
1907 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1909 case EM_OR32
: return "OpenRISC";
1910 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1911 case EM_DLX
: return "OpenDLX";
1913 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1914 case EM_IQ2000
: return "Vitesse IQ2000";
1916 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1917 case EM_M32C
: return "Renesas M32c";
1918 case EM_MT
: return "Morpho Techologies MT processor";
1919 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1920 case EM_NIOS32
: return "Altera Nios";
1921 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1922 case EM_XC16X
: return "Infineon Technologies xc16x";
1923 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1924 case EM_CR16
: return "National Semiconductor's CR16";
1926 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1932 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1937 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1938 e_flags
&= ~ EF_ARM_EABIMASK
;
1940 /* Handle "generic" ARM flags. */
1941 if (e_flags
& EF_ARM_RELEXEC
)
1943 strcat (buf
, ", relocatable executable");
1944 e_flags
&= ~ EF_ARM_RELEXEC
;
1947 if (e_flags
& EF_ARM_HASENTRY
)
1949 strcat (buf
, ", has entry point");
1950 e_flags
&= ~ EF_ARM_HASENTRY
;
1953 /* Now handle EABI specific flags. */
1957 strcat (buf
, ", <unrecognized EABI>");
1962 case EF_ARM_EABI_VER1
:
1963 strcat (buf
, ", Version1 EABI");
1968 /* Process flags one bit at a time. */
1969 flag
= e_flags
& - e_flags
;
1974 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1975 strcat (buf
, ", sorted symbol tables");
1985 case EF_ARM_EABI_VER2
:
1986 strcat (buf
, ", Version2 EABI");
1991 /* Process flags one bit at a time. */
1992 flag
= e_flags
& - e_flags
;
1997 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1998 strcat (buf
, ", sorted symbol tables");
2001 case EF_ARM_DYNSYMSUSESEGIDX
:
2002 strcat (buf
, ", dynamic symbols use segment index");
2005 case EF_ARM_MAPSYMSFIRST
:
2006 strcat (buf
, ", mapping symbols precede others");
2016 case EF_ARM_EABI_VER3
:
2017 strcat (buf
, ", Version3 EABI");
2020 case EF_ARM_EABI_VER4
:
2021 strcat (buf
, ", Version4 EABI");
2024 case EF_ARM_EABI_VER5
:
2025 strcat (buf
, ", Version5 EABI");
2031 /* Process flags one bit at a time. */
2032 flag
= e_flags
& - e_flags
;
2038 strcat (buf
, ", BE8");
2042 strcat (buf
, ", LE8");
2052 case EF_ARM_EABI_UNKNOWN
:
2053 strcat (buf
, ", GNU EABI");
2058 /* Process flags one bit at a time. */
2059 flag
= e_flags
& - e_flags
;
2064 case EF_ARM_INTERWORK
:
2065 strcat (buf
, ", interworking enabled");
2068 case EF_ARM_APCS_26
:
2069 strcat (buf
, ", uses APCS/26");
2072 case EF_ARM_APCS_FLOAT
:
2073 strcat (buf
, ", uses APCS/float");
2077 strcat (buf
, ", position independent");
2081 strcat (buf
, ", 8 bit structure alignment");
2084 case EF_ARM_NEW_ABI
:
2085 strcat (buf
, ", uses new ABI");
2088 case EF_ARM_OLD_ABI
:
2089 strcat (buf
, ", uses old ABI");
2092 case EF_ARM_SOFT_FLOAT
:
2093 strcat (buf
, ", software FP");
2096 case EF_ARM_VFP_FLOAT
:
2097 strcat (buf
, ", VFP");
2100 case EF_ARM_MAVERICK_FLOAT
:
2101 strcat (buf
, ", Maverick FP");
2112 strcat (buf
,", <unknown>");
2116 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2118 static char buf
[1024];
2130 decode_ARM_machine_flags (e_flags
, buf
);
2134 switch (e_flags
& EF_FRV_CPU_MASK
)
2136 case EF_FRV_CPU_GENERIC
:
2140 strcat (buf
, ", fr???");
2143 case EF_FRV_CPU_FR300
:
2144 strcat (buf
, ", fr300");
2147 case EF_FRV_CPU_FR400
:
2148 strcat (buf
, ", fr400");
2150 case EF_FRV_CPU_FR405
:
2151 strcat (buf
, ", fr405");
2154 case EF_FRV_CPU_FR450
:
2155 strcat (buf
, ", fr450");
2158 case EF_FRV_CPU_FR500
:
2159 strcat (buf
, ", fr500");
2161 case EF_FRV_CPU_FR550
:
2162 strcat (buf
, ", fr550");
2165 case EF_FRV_CPU_SIMPLE
:
2166 strcat (buf
, ", simple");
2168 case EF_FRV_CPU_TOMCAT
:
2169 strcat (buf
, ", tomcat");
2175 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2176 strcat (buf
, ", m68000");
2177 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2178 strcat (buf
, ", cpu32");
2179 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2180 strcat (buf
, ", fido_a");
2183 char const *isa
= _("unknown");
2184 char const *mac
= _("unknown mac");
2185 char const *additional
= NULL
;
2187 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2189 case EF_M68K_CF_ISA_A_NODIV
:
2191 additional
= ", nodiv";
2193 case EF_M68K_CF_ISA_A
:
2196 case EF_M68K_CF_ISA_A_PLUS
:
2199 case EF_M68K_CF_ISA_B_NOUSP
:
2201 additional
= ", nousp";
2203 case EF_M68K_CF_ISA_B
:
2207 strcat (buf
, ", cf, isa ");
2210 strcat (buf
, additional
);
2211 if (e_flags
& EF_M68K_CF_FLOAT
)
2212 strcat (buf
, ", float");
2213 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2218 case EF_M68K_CF_MAC
:
2221 case EF_M68K_CF_EMAC
:
2234 if (e_flags
& EF_PPC_EMB
)
2235 strcat (buf
, ", emb");
2237 if (e_flags
& EF_PPC_RELOCATABLE
)
2238 strcat (buf
, ", relocatable");
2240 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2241 strcat (buf
, ", relocatable-lib");
2245 case EM_CYGNUS_V850
:
2246 switch (e_flags
& EF_V850_ARCH
)
2249 strcat (buf
, ", v850e1");
2252 strcat (buf
, ", v850e");
2255 strcat (buf
, ", v850");
2258 strcat (buf
, ", unknown v850 architecture variant");
2264 case EM_CYGNUS_M32R
:
2265 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2266 strcat (buf
, ", m32r");
2270 case EM_MIPS_RS3_LE
:
2271 if (e_flags
& EF_MIPS_NOREORDER
)
2272 strcat (buf
, ", noreorder");
2274 if (e_flags
& EF_MIPS_PIC
)
2275 strcat (buf
, ", pic");
2277 if (e_flags
& EF_MIPS_CPIC
)
2278 strcat (buf
, ", cpic");
2280 if (e_flags
& EF_MIPS_UCODE
)
2281 strcat (buf
, ", ugen_reserved");
2283 if (e_flags
& EF_MIPS_ABI2
)
2284 strcat (buf
, ", abi2");
2286 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2287 strcat (buf
, ", odk first");
2289 if (e_flags
& EF_MIPS_32BITMODE
)
2290 strcat (buf
, ", 32bitmode");
2292 switch ((e_flags
& EF_MIPS_MACH
))
2294 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2295 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2296 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2297 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2298 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2299 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2300 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2301 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2302 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2303 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2304 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2305 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2306 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2308 /* We simply ignore the field in this case to avoid confusion:
2309 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2312 default: strcat (buf
, ", unknown CPU"); break;
2315 switch ((e_flags
& EF_MIPS_ABI
))
2317 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2318 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2319 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2320 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2322 /* We simply ignore the field in this case to avoid confusion:
2323 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2324 This means it is likely to be an o32 file, but not for
2327 default: strcat (buf
, ", unknown ABI"); break;
2330 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2331 strcat (buf
, ", mdmx");
2333 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2334 strcat (buf
, ", mips16");
2336 switch ((e_flags
& EF_MIPS_ARCH
))
2338 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2339 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2340 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2341 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2342 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2343 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2344 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2345 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2346 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2347 default: strcat (buf
, ", unknown ISA"); break;
2353 switch ((e_flags
& EF_SH_MACH_MASK
))
2355 case EF_SH1
: strcat (buf
, ", sh1"); break;
2356 case EF_SH2
: strcat (buf
, ", sh2"); break;
2357 case EF_SH3
: strcat (buf
, ", sh3"); break;
2358 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2359 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2360 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2361 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2362 case EF_SH4
: strcat (buf
, ", sh4"); break;
2363 case EF_SH5
: strcat (buf
, ", sh5"); break;
2364 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2365 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2366 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2367 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2368 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2369 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2370 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2371 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2372 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2373 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2374 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2375 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2376 default: strcat (buf
, ", unknown ISA"); break;
2382 if (e_flags
& EF_SPARC_32PLUS
)
2383 strcat (buf
, ", v8+");
2385 if (e_flags
& EF_SPARC_SUN_US1
)
2386 strcat (buf
, ", ultrasparcI");
2388 if (e_flags
& EF_SPARC_SUN_US3
)
2389 strcat (buf
, ", ultrasparcIII");
2391 if (e_flags
& EF_SPARC_HAL_R1
)
2392 strcat (buf
, ", halr1");
2394 if (e_flags
& EF_SPARC_LEDATA
)
2395 strcat (buf
, ", ledata");
2397 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2398 strcat (buf
, ", tso");
2400 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2401 strcat (buf
, ", pso");
2403 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2404 strcat (buf
, ", rmo");
2408 switch (e_flags
& EF_PARISC_ARCH
)
2410 case EFA_PARISC_1_0
:
2411 strcpy (buf
, ", PA-RISC 1.0");
2413 case EFA_PARISC_1_1
:
2414 strcpy (buf
, ", PA-RISC 1.1");
2416 case EFA_PARISC_2_0
:
2417 strcpy (buf
, ", PA-RISC 2.0");
2422 if (e_flags
& EF_PARISC_TRAPNIL
)
2423 strcat (buf
, ", trapnil");
2424 if (e_flags
& EF_PARISC_EXT
)
2425 strcat (buf
, ", ext");
2426 if (e_flags
& EF_PARISC_LSB
)
2427 strcat (buf
, ", lsb");
2428 if (e_flags
& EF_PARISC_WIDE
)
2429 strcat (buf
, ", wide");
2430 if (e_flags
& EF_PARISC_NO_KABP
)
2431 strcat (buf
, ", no kabp");
2432 if (e_flags
& EF_PARISC_LAZYSWAP
)
2433 strcat (buf
, ", lazyswap");
2438 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2439 strcat (buf
, ", new calling convention");
2441 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2442 strcat (buf
, ", gnu calling convention");
2446 if ((e_flags
& EF_IA_64_ABI64
))
2447 strcat (buf
, ", 64-bit");
2449 strcat (buf
, ", 32-bit");
2450 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2451 strcat (buf
, ", reduced fp model");
2452 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2453 strcat (buf
, ", no function descriptors, constant gp");
2454 else if ((e_flags
& EF_IA_64_CONS_GP
))
2455 strcat (buf
, ", constant gp");
2456 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2457 strcat (buf
, ", absolute");
2461 if ((e_flags
& EF_VAX_NONPIC
))
2462 strcat (buf
, ", non-PIC");
2463 if ((e_flags
& EF_VAX_DFLOAT
))
2464 strcat (buf
, ", D-Float");
2465 if ((e_flags
& EF_VAX_GFLOAT
))
2466 strcat (buf
, ", G-Float");
2475 get_osabi_name (unsigned int osabi
)
2477 static char buff
[32];
2481 case ELFOSABI_NONE
: return "UNIX - System V";
2482 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2483 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2484 case ELFOSABI_LINUX
: return "UNIX - Linux";
2485 case ELFOSABI_HURD
: return "GNU/Hurd";
2486 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2487 case ELFOSABI_AIX
: return "UNIX - AIX";
2488 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2489 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2490 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2491 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2492 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2493 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2494 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2495 case ELFOSABI_AROS
: return "Amiga Research OS";
2496 case ELFOSABI_STANDALONE
: return _("Standalone App");
2497 case ELFOSABI_ARM
: return "ARM";
2499 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2505 get_arm_segment_type (unsigned long type
)
2519 get_mips_segment_type (unsigned long type
)
2523 case PT_MIPS_REGINFO
:
2525 case PT_MIPS_RTPROC
:
2527 case PT_MIPS_OPTIONS
:
2537 get_parisc_segment_type (unsigned long type
)
2541 case PT_HP_TLS
: return "HP_TLS";
2542 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2543 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2544 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2545 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2546 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2547 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2548 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2549 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2550 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2551 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2552 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2553 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2554 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2555 case PT_HP_STACK
: return "HP_STACK";
2556 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2557 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2558 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2559 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2568 get_ia64_segment_type (unsigned long type
)
2572 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2573 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2574 case PT_HP_TLS
: return "HP_TLS";
2575 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2576 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2577 case PT_IA_64_HP_STACK
: return "HP_STACK";
2586 get_segment_type (unsigned long p_type
)
2588 static char buff
[32];
2592 case PT_NULL
: return "NULL";
2593 case PT_LOAD
: return "LOAD";
2594 case PT_DYNAMIC
: return "DYNAMIC";
2595 case PT_INTERP
: return "INTERP";
2596 case PT_NOTE
: return "NOTE";
2597 case PT_SHLIB
: return "SHLIB";
2598 case PT_PHDR
: return "PHDR";
2599 case PT_TLS
: return "TLS";
2601 case PT_GNU_EH_FRAME
:
2602 return "GNU_EH_FRAME";
2603 case PT_GNU_STACK
: return "GNU_STACK";
2604 case PT_GNU_RELRO
: return "GNU_RELRO";
2607 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2611 switch (elf_header
.e_machine
)
2614 result
= get_arm_segment_type (p_type
);
2617 case EM_MIPS_RS3_LE
:
2618 result
= get_mips_segment_type (p_type
);
2621 result
= get_parisc_segment_type (p_type
);
2624 result
= get_ia64_segment_type (p_type
);
2634 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2636 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2640 switch (elf_header
.e_machine
)
2643 result
= get_parisc_segment_type (p_type
);
2646 result
= get_ia64_segment_type (p_type
);
2656 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2659 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2666 get_mips_section_type_name (unsigned int sh_type
)
2670 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2671 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2672 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2673 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2674 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2675 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2676 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2677 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2678 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2679 case SHT_MIPS_RELD
: return "MIPS_RELD";
2680 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2681 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2682 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2683 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2684 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2685 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2686 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2687 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2688 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2689 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2690 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2691 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2692 case SHT_MIPS_LINE
: return "MIPS_LINE";
2693 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2694 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2695 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2696 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2697 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2698 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2699 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2700 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2701 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2702 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2703 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2704 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2705 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2706 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2707 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2708 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2716 get_parisc_section_type_name (unsigned int sh_type
)
2720 case SHT_PARISC_EXT
: return "PARISC_EXT";
2721 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2722 case SHT_PARISC_DOC
: return "PARISC_DOC";
2723 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2724 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2725 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2726 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2734 get_ia64_section_type_name (unsigned int sh_type
)
2736 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2737 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2738 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2742 case SHT_IA_64_EXT
: return "IA_64_EXT";
2743 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2744 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2745 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2746 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2747 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2748 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2749 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2750 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2751 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2759 get_x86_64_section_type_name (unsigned int sh_type
)
2763 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2771 get_arm_section_type_name (unsigned int sh_type
)
2777 case SHT_ARM_PREEMPTMAP
:
2778 return "ARM_PREEMPTMAP";
2779 case SHT_ARM_ATTRIBUTES
:
2780 return "ARM_ATTRIBUTES";
2788 get_section_type_name (unsigned int sh_type
)
2790 static char buff
[32];
2794 case SHT_NULL
: return "NULL";
2795 case SHT_PROGBITS
: return "PROGBITS";
2796 case SHT_SYMTAB
: return "SYMTAB";
2797 case SHT_STRTAB
: return "STRTAB";
2798 case SHT_RELA
: return "RELA";
2799 case SHT_HASH
: return "HASH";
2800 case SHT_DYNAMIC
: return "DYNAMIC";
2801 case SHT_NOTE
: return "NOTE";
2802 case SHT_NOBITS
: return "NOBITS";
2803 case SHT_REL
: return "REL";
2804 case SHT_SHLIB
: return "SHLIB";
2805 case SHT_DYNSYM
: return "DYNSYM";
2806 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2807 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2808 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2809 case SHT_GNU_HASH
: return "GNU_HASH";
2810 case SHT_GROUP
: return "GROUP";
2811 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2812 case SHT_GNU_verdef
: return "VERDEF";
2813 case SHT_GNU_verneed
: return "VERNEED";
2814 case SHT_GNU_versym
: return "VERSYM";
2815 case 0x6ffffff0: return "VERSYM";
2816 case 0x6ffffffc: return "VERDEF";
2817 case 0x7ffffffd: return "AUXILIARY";
2818 case 0x7fffffff: return "FILTER";
2819 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2822 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2826 switch (elf_header
.e_machine
)
2829 case EM_MIPS_RS3_LE
:
2830 result
= get_mips_section_type_name (sh_type
);
2833 result
= get_parisc_section_type_name (sh_type
);
2836 result
= get_ia64_section_type_name (sh_type
);
2839 result
= get_x86_64_section_type_name (sh_type
);
2842 result
= get_arm_section_type_name (sh_type
);
2852 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2854 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2858 switch (elf_header
.e_machine
)
2861 result
= get_ia64_section_type_name (sh_type
);
2871 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2873 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2874 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2876 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2882 #define OPTION_DEBUG_DUMP 512
2884 static struct option options
[] =
2886 {"all", no_argument
, 0, 'a'},
2887 {"file-header", no_argument
, 0, 'h'},
2888 {"program-headers", no_argument
, 0, 'l'},
2889 {"headers", no_argument
, 0, 'e'},
2890 {"histogram", no_argument
, 0, 'I'},
2891 {"segments", no_argument
, 0, 'l'},
2892 {"sections", no_argument
, 0, 'S'},
2893 {"section-headers", no_argument
, 0, 'S'},
2894 {"section-groups", no_argument
, 0, 'g'},
2895 {"section-details", no_argument
, 0, 't'},
2896 {"full-section-name",no_argument
, 0, 'N'},
2897 {"symbols", no_argument
, 0, 's'},
2898 {"syms", no_argument
, 0, 's'},
2899 {"relocs", no_argument
, 0, 'r'},
2900 {"notes", no_argument
, 0, 'n'},
2901 {"dynamic", no_argument
, 0, 'd'},
2902 {"arch-specific", no_argument
, 0, 'A'},
2903 {"version-info", no_argument
, 0, 'V'},
2904 {"use-dynamic", no_argument
, 0, 'D'},
2905 {"unwind", no_argument
, 0, 'u'},
2906 {"archive-index", no_argument
, 0, 'c'},
2907 {"hex-dump", required_argument
, 0, 'x'},
2908 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2909 {"string-dump", required_argument
, 0, 'p'},
2910 #ifdef SUPPORT_DISASSEMBLY
2911 {"instruction-dump", required_argument
, 0, 'i'},
2914 {"version", no_argument
, 0, 'v'},
2915 {"wide", no_argument
, 0, 'W'},
2916 {"help", no_argument
, 0, 'H'},
2917 {0, no_argument
, 0, 0}
2921 usage (FILE *stream
)
2923 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2924 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2925 fprintf (stream
, _(" Options are:\n\
2926 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2927 -h --file-header Display the ELF file header\n\
2928 -l --program-headers Display the program headers\n\
2929 --segments An alias for --program-headers\n\
2930 -S --section-headers Display the sections' header\n\
2931 --sections An alias for --section-headers\n\
2932 -g --section-groups Display the section groups\n\
2933 -t --section-details Display the section details\n\
2934 -e --headers Equivalent to: -h -l -S\n\
2935 -s --syms Display the symbol table\n\
2936 --symbols An alias for --syms\n\
2937 -n --notes Display the core notes (if present)\n\
2938 -r --relocs Display the relocations (if present)\n\
2939 -u --unwind Display the unwind info (if present)\n\
2940 -d --dynamic Display the dynamic section (if present)\n\
2941 -V --version-info Display the version sections (if present)\n\
2942 -A --arch-specific Display architecture specific information (if any).\n\
2943 -c --archive-index Display the symbol/file index in an archive\n\
2944 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2945 -x --hex-dump=<number|name>\n\
2946 Dump the contents of section <number|name> as bytes\n\
2947 -p --string-dump=<number|name>\n\
2948 Dump the contents of section <number|name> as strings\n\
2949 -w[lLiaprmfFsoR] or\n\
2950 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2951 Display the contents of DWARF2 debug sections\n"));
2952 #ifdef SUPPORT_DISASSEMBLY
2953 fprintf (stream
, _("\
2954 -i --instruction-dump=<number|name>\n\
2955 Disassemble the contents of section <number|name>\n"));
2957 fprintf (stream
, _("\
2958 -I --histogram Display histogram of bucket list lengths\n\
2959 -W --wide Allow output width to exceed 80 characters\n\
2960 @<file> Read options from <file>\n\
2961 -H --help Display this information\n\
2962 -v --version Display the version number of readelf\n"));
2964 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2965 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2967 exit (stream
== stdout
? 0 : 1);
2970 /* Record the fact that the user wants the contents of section number
2971 SECTION to be displayed using the method(s) encoded as flags bits
2972 in TYPE. Note, TYPE can be zero if we are creating the array for
2976 request_dump_bynumber (unsigned int section
, dump_type type
)
2978 if (section
>= num_dump_sects
)
2980 dump_type
*new_dump_sects
;
2982 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2984 if (new_dump_sects
== NULL
)
2985 error (_("Out of memory allocating dump request table.\n"));
2988 /* Copy current flag settings. */
2989 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2993 dump_sects
= new_dump_sects
;
2994 num_dump_sects
= section
+ 1;
2999 dump_sects
[section
] |= type
;
3004 /* Request a dump by section name. */
3007 request_dump_byname (const char *section
, dump_type type
)
3009 struct dump_list_entry
*new_request
;
3011 new_request
= malloc (sizeof (struct dump_list_entry
));
3013 error (_("Out of memory allocating dump request table.\n"));
3015 new_request
->name
= strdup (section
);
3016 if (!new_request
->name
)
3017 error (_("Out of memory allocating dump request table.\n"));
3019 new_request
->type
= type
;
3021 new_request
->next
= dump_sects_byname
;
3022 dump_sects_byname
= new_request
;
3026 parse_args (int argc
, char **argv
)
3033 while ((c
= getopt_long
3034 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3055 do_section_groups
++;
3063 do_section_groups
++;
3068 do_section_details
++;
3113 section
= strtoul (optarg
, & cp
, 0);
3114 if (! *cp
&& section
>= 0)
3115 request_dump_bynumber (section
, HEX_DUMP
);
3117 request_dump_byname (optarg
, HEX_DUMP
);
3121 section
= strtoul (optarg
, & cp
, 0);
3122 if (! *cp
&& section
>= 0)
3123 request_dump_bynumber (section
, STRING_DUMP
);
3125 request_dump_byname (optarg
, STRING_DUMP
);
3133 unsigned int index
= 0;
3137 while (optarg
[index
])
3138 switch (optarg
[index
++])
3145 do_debug_abbrevs
= 1;
3153 do_debug_lines_decoded
= 1;
3157 do_debug_pubnames
= 1;
3161 do_debug_aranges
= 1;
3165 do_debug_ranges
= 1;
3169 do_debug_frames_interp
= 1;
3171 do_debug_frames
= 1;
3175 do_debug_macinfo
= 1;
3187 warn (_("Unrecognized debug option '%s'\n"), optarg
);
3192 case OPTION_DEBUG_DUMP
:
3200 const char * option
;
3203 debug_dump_long_opts
;
3205 debug_dump_long_opts opts_table
[] =
3207 /* Please keep this table alpha- sorted. */
3208 { "Ranges", & do_debug_ranges
},
3209 { "abbrev", & do_debug_abbrevs
},
3210 { "aranges", & do_debug_aranges
},
3211 { "frames", & do_debug_frames
},
3212 { "frames-interp", & do_debug_frames_interp
},
3213 { "info", & do_debug_info
},
3214 { "line", & do_debug_lines
}, /* For backwards compatibility. */
3215 { "rawline", & do_debug_lines
},
3216 { "decodedline", & do_debug_lines_decoded
},
3217 { "loc", & do_debug_loc
},
3218 { "macro", & do_debug_macinfo
},
3219 { "pubnames", & do_debug_pubnames
},
3220 /* This entry is for compatability
3221 with earlier versions of readelf. */
3222 { "ranges", & do_debug_aranges
},
3223 { "str", & do_debug_str
},
3234 debug_dump_long_opts
* entry
;
3236 for (entry
= opts_table
; entry
->option
; entry
++)
3238 size_t len
= strlen (entry
->option
);
3240 if (strneq (p
, entry
->option
, len
)
3241 && (p
[len
] == ',' || p
[len
] == '\0'))
3243 * entry
->variable
= 1;
3245 /* The --debug-dump=frames-interp option also
3246 enables the --debug-dump=frames option. */
3247 if (do_debug_frames_interp
)
3248 do_debug_frames
= 1;
3255 if (entry
->option
== NULL
)
3257 warn (_("Unrecognized debug option '%s'\n"), p
);
3258 p
= strchr (p
, ',');
3268 #ifdef SUPPORT_DISASSEMBLY
3271 section
= strtoul (optarg
, & cp
, 0);
3272 if (! *cp
&& section
>= 0)
3273 request_dump_bynumber (section
, DISASS_DUMP
);
3275 request_dump_byname (optarg
, DISASS_DUMP
);
3278 print_version (program_name
);
3287 /* xgettext:c-format */
3288 error (_("Invalid option '-%c'\n"), c
);
3295 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3296 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3297 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3298 && !do_section_groups
&& !do_archive_index
)
3302 warn (_("Nothing to do.\n"));
3308 get_elf_class (unsigned int elf_class
)
3310 static char buff
[32];
3314 case ELFCLASSNONE
: return _("none");
3315 case ELFCLASS32
: return "ELF32";
3316 case ELFCLASS64
: return "ELF64";
3318 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3324 get_data_encoding (unsigned int encoding
)
3326 static char buff
[32];
3330 case ELFDATANONE
: return _("none");
3331 case ELFDATA2LSB
: return _("2's complement, little endian");
3332 case ELFDATA2MSB
: return _("2's complement, big endian");
3334 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3339 /* Decode the data held in 'elf_header'. */
3342 process_file_header (void)
3344 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3345 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3346 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3347 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3350 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3354 init_dwarf_regnames (elf_header
.e_machine
);
3360 printf (_("ELF Header:\n"));
3361 printf (_(" Magic: "));
3362 for (i
= 0; i
< EI_NIDENT
; i
++)
3363 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3365 printf (_(" Class: %s\n"),
3366 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3367 printf (_(" Data: %s\n"),
3368 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3369 printf (_(" Version: %d %s\n"),
3370 elf_header
.e_ident
[EI_VERSION
],
3371 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3373 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3376 printf (_(" OS/ABI: %s\n"),
3377 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3378 printf (_(" ABI Version: %d\n"),
3379 elf_header
.e_ident
[EI_ABIVERSION
]);
3380 printf (_(" Type: %s\n"),
3381 get_file_type (elf_header
.e_type
));
3382 printf (_(" Machine: %s\n"),
3383 get_machine_name (elf_header
.e_machine
));
3384 printf (_(" Version: 0x%lx\n"),
3385 (unsigned long) elf_header
.e_version
);
3387 printf (_(" Entry point address: "));
3388 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3389 printf (_("\n Start of program headers: "));
3390 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3391 printf (_(" (bytes into file)\n Start of section headers: "));
3392 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3393 printf (_(" (bytes into file)\n"));
3395 printf (_(" Flags: 0x%lx%s\n"),
3396 (unsigned long) elf_header
.e_flags
,
3397 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3398 printf (_(" Size of this header: %ld (bytes)\n"),
3399 (long) elf_header
.e_ehsize
);
3400 printf (_(" Size of program headers: %ld (bytes)\n"),
3401 (long) elf_header
.e_phentsize
);
3402 printf (_(" Number of program headers: %ld\n"),
3403 (long) elf_header
.e_phnum
);
3404 printf (_(" Size of section headers: %ld (bytes)\n"),
3405 (long) elf_header
.e_shentsize
);
3406 printf (_(" Number of section headers: %ld"),
3407 (long) elf_header
.e_shnum
);
3408 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3409 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3410 putc ('\n', stdout
);
3411 printf (_(" Section header string table index: %ld"),
3412 (long) elf_header
.e_shstrndx
);
3413 if (section_headers
!= NULL
3414 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3415 printf (" (%u)", section_headers
[0].sh_link
);
3416 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3417 printf (" <corrupt: out of range>");
3418 putc ('\n', stdout
);
3421 if (section_headers
!= NULL
)
3423 if (elf_header
.e_shnum
== SHN_UNDEF
)
3424 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3425 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3426 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3427 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3428 elf_header
.e_shstrndx
= SHN_UNDEF
;
3429 free (section_headers
);
3430 section_headers
= NULL
;
3438 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3440 Elf32_External_Phdr
*phdrs
;
3441 Elf32_External_Phdr
*external
;
3442 Elf_Internal_Phdr
*internal
;
3445 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3446 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3447 _("program headers"));
3451 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3452 i
< elf_header
.e_phnum
;
3453 i
++, internal
++, external
++)
3455 internal
->p_type
= BYTE_GET (external
->p_type
);
3456 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3457 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3458 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3459 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3460 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3461 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3462 internal
->p_align
= BYTE_GET (external
->p_align
);
3471 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3473 Elf64_External_Phdr
*phdrs
;
3474 Elf64_External_Phdr
*external
;
3475 Elf_Internal_Phdr
*internal
;
3478 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3479 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3480 _("program headers"));
3484 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3485 i
< elf_header
.e_phnum
;
3486 i
++, internal
++, external
++)
3488 internal
->p_type
= BYTE_GET (external
->p_type
);
3489 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3490 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3491 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3492 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3493 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3494 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3495 internal
->p_align
= BYTE_GET (external
->p_align
);
3503 /* Returns 1 if the program headers were read into `program_headers'. */
3506 get_program_headers (FILE *file
)
3508 Elf_Internal_Phdr
*phdrs
;
3510 /* Check cache of prior read. */
3511 if (program_headers
!= NULL
)
3514 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3518 error (_("Out of memory\n"));
3523 ? get_32bit_program_headers (file
, phdrs
)
3524 : get_64bit_program_headers (file
, phdrs
))
3526 program_headers
= phdrs
;
3534 /* Returns 1 if the program headers were loaded. */
3537 process_program_headers (FILE *file
)
3539 Elf_Internal_Phdr
*segment
;
3542 if (elf_header
.e_phnum
== 0)
3545 printf (_("\nThere are no program headers in this file.\n"));
3549 if (do_segments
&& !do_header
)
3551 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3552 printf (_("Entry point "));
3553 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3554 printf (_("\nThere are %d program headers, starting at offset "),
3555 elf_header
.e_phnum
);
3556 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3560 if (! get_program_headers (file
))
3565 if (elf_header
.e_phnum
> 1)
3566 printf (_("\nProgram Headers:\n"));
3568 printf (_("\nProgram Headers:\n"));
3572 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3575 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3579 (_(" Type Offset VirtAddr PhysAddr\n"));
3581 (_(" FileSiz MemSiz Flags Align\n"));
3588 for (i
= 0, segment
= program_headers
;
3589 i
< elf_header
.e_phnum
;
3594 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3598 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3599 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3600 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3601 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3602 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3604 (segment
->p_flags
& PF_R
? 'R' : ' '),
3605 (segment
->p_flags
& PF_W
? 'W' : ' '),
3606 (segment
->p_flags
& PF_X
? 'E' : ' '));
3607 printf ("%#lx", (unsigned long) segment
->p_align
);
3611 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3612 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3615 print_vma (segment
->p_offset
, FULL_HEX
);
3619 print_vma (segment
->p_vaddr
, FULL_HEX
);
3621 print_vma (segment
->p_paddr
, FULL_HEX
);
3624 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3625 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3628 print_vma (segment
->p_filesz
, FULL_HEX
);
3632 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3633 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3636 print_vma (segment
->p_offset
, FULL_HEX
);
3640 (segment
->p_flags
& PF_R
? 'R' : ' '),
3641 (segment
->p_flags
& PF_W
? 'W' : ' '),
3642 (segment
->p_flags
& PF_X
? 'E' : ' '));
3644 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3645 printf ("%#lx", (unsigned long) segment
->p_align
);
3648 print_vma (segment
->p_align
, PREFIX_HEX
);
3653 print_vma (segment
->p_offset
, FULL_HEX
);
3655 print_vma (segment
->p_vaddr
, FULL_HEX
);
3657 print_vma (segment
->p_paddr
, FULL_HEX
);
3659 print_vma (segment
->p_filesz
, FULL_HEX
);
3661 print_vma (segment
->p_memsz
, FULL_HEX
);
3663 (segment
->p_flags
& PF_R
? 'R' : ' '),
3664 (segment
->p_flags
& PF_W
? 'W' : ' '),
3665 (segment
->p_flags
& PF_X
? 'E' : ' '));
3666 print_vma (segment
->p_align
, HEX
);
3670 switch (segment
->p_type
)
3674 error (_("more than one dynamic segment\n"));
3676 /* By default, assume that the .dynamic section is the first
3677 section in the DYNAMIC segment. */
3678 dynamic_addr
= segment
->p_offset
;
3679 dynamic_size
= segment
->p_filesz
;
3681 /* Try to locate the .dynamic section. If there is
3682 a section header table, we can easily locate it. */
3683 if (section_headers
!= NULL
)
3685 Elf_Internal_Shdr
*sec
;
3687 sec
= find_section (".dynamic");
3688 if (sec
== NULL
|| sec
->sh_size
== 0)
3690 error (_("no .dynamic section in the dynamic segment\n"));
3694 if (sec
->sh_type
== SHT_NOBITS
)
3700 dynamic_addr
= sec
->sh_offset
;
3701 dynamic_size
= sec
->sh_size
;
3703 if (dynamic_addr
< segment
->p_offset
3704 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3705 warn (_("the .dynamic section is not contained"
3706 " within the dynamic segment\n"));
3707 else if (dynamic_addr
> segment
->p_offset
)
3708 warn (_("the .dynamic section is not the first section"
3709 " in the dynamic segment.\n"));
3714 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3716 error (_("Unable to find program interpreter name\n"));
3720 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3722 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3723 error (_("Internal error: failed to create format string to display program interpreter\n"));
3725 program_interpreter
[0] = 0;
3726 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3727 error (_("Unable to read program interpreter name\n"));
3730 printf (_("\n [Requesting program interpreter: %s]"),
3731 program_interpreter
);
3737 putc ('\n', stdout
);
3740 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3742 printf (_("\n Section to Segment mapping:\n"));
3743 printf (_(" Segment Sections...\n"));
3745 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3748 Elf_Internal_Shdr
*section
;
3750 segment
= program_headers
+ i
;
3751 section
= section_headers
+ 1;
3753 printf (" %2.2d ", i
);
3755 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3757 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3758 printf ("%s ", SECTION_NAME (section
));
3769 /* Find the file offset corresponding to VMA by using the program headers. */
3772 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3774 Elf_Internal_Phdr
*seg
;
3776 if (! get_program_headers (file
))
3778 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3782 for (seg
= program_headers
;
3783 seg
< program_headers
+ elf_header
.e_phnum
;
3786 if (seg
->p_type
!= PT_LOAD
)
3789 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3790 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3791 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3794 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3801 get_32bit_section_headers (FILE *file
, unsigned int num
)
3803 Elf32_External_Shdr
*shdrs
;
3804 Elf_Internal_Shdr
*internal
;
3807 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3808 elf_header
.e_shentsize
, num
, _("section headers"));
3812 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3814 if (section_headers
== NULL
)
3816 error (_("Out of memory\n"));
3820 for (i
= 0, internal
= section_headers
;
3824 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3825 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3826 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3827 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3828 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3829 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3830 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3831 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3832 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3833 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3842 get_64bit_section_headers (FILE *file
, unsigned int num
)
3844 Elf64_External_Shdr
*shdrs
;
3845 Elf_Internal_Shdr
*internal
;
3848 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3849 elf_header
.e_shentsize
, num
, _("section headers"));
3853 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3855 if (section_headers
== NULL
)
3857 error (_("Out of memory\n"));
3861 for (i
= 0, internal
= section_headers
;
3865 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3866 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3867 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3868 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3869 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3870 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3871 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3872 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3873 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3874 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3882 static Elf_Internal_Sym
*
3883 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3885 unsigned long number
;
3886 Elf32_External_Sym
*esyms
;
3887 Elf_External_Sym_Shndx
*shndx
;
3888 Elf_Internal_Sym
*isyms
;
3889 Elf_Internal_Sym
*psym
;
3892 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3898 if (symtab_shndx_hdr
!= NULL
3899 && (symtab_shndx_hdr
->sh_link
3900 == (unsigned long) (section
- section_headers
)))
3902 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3903 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3911 number
= section
->sh_size
/ section
->sh_entsize
;
3912 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3916 error (_("Out of memory\n"));
3923 for (j
= 0, psym
= isyms
;
3927 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3928 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3929 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3930 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3931 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3933 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3934 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3935 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3936 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3937 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3947 static Elf_Internal_Sym
*
3948 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3950 unsigned long number
;
3951 Elf64_External_Sym
*esyms
;
3952 Elf_External_Sym_Shndx
*shndx
;
3953 Elf_Internal_Sym
*isyms
;
3954 Elf_Internal_Sym
*psym
;
3957 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3963 if (symtab_shndx_hdr
!= NULL
3964 && (symtab_shndx_hdr
->sh_link
3965 == (unsigned long) (section
- section_headers
)))
3967 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3968 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3976 number
= section
->sh_size
/ section
->sh_entsize
;
3977 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3981 error (_("Out of memory\n"));
3988 for (j
= 0, psym
= isyms
;
3992 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3993 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3994 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3995 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3996 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3998 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3999 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4000 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4001 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4002 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4013 get_elf_section_flags (bfd_vma sh_flags
)
4015 static char buff
[1024];
4017 int field_size
= is_32bit_elf
? 8 : 16;
4018 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
4019 bfd_vma os_flags
= 0;
4020 bfd_vma proc_flags
= 0;
4021 bfd_vma unknown_flags
= 0;
4035 { "LINK ORDER", 10 },
4036 { "OS NONCONF", 10 },
4039 /* IA-64 specific. */
4042 /* IA-64 OpenVMS specific. */
4043 { "VMS_GLOBAL", 10 },
4044 { "VMS_OVERLAID", 12 },
4045 { "VMS_SHARED", 10 },
4046 { "VMS_VECTOR", 10 },
4047 { "VMS_ALLOC_64BIT", 15 },
4048 { "VMS_PROTECTED", 13}
4051 if (do_section_details
)
4053 sprintf (buff
, "[%*.*lx]: ",
4054 field_size
, field_size
, (unsigned long) sh_flags
);
4055 p
+= field_size
+ 4;
4062 flag
= sh_flags
& - sh_flags
;
4065 if (do_section_details
)
4069 case SHF_WRITE
: index
= 0; break;
4070 case SHF_ALLOC
: index
= 1; break;
4071 case SHF_EXECINSTR
: index
= 2; break;
4072 case SHF_MERGE
: index
= 3; break;
4073 case SHF_STRINGS
: index
= 4; break;
4074 case SHF_INFO_LINK
: index
= 5; break;
4075 case SHF_LINK_ORDER
: index
= 6; break;
4076 case SHF_OS_NONCONFORMING
: index
= 7; break;
4077 case SHF_GROUP
: index
= 8; break;
4078 case SHF_TLS
: index
= 9; break;
4082 if (elf_header
.e_machine
== EM_IA_64
)
4084 if (flag
== SHF_IA_64_SHORT
)
4086 else if (flag
== SHF_IA_64_NORECOV
)
4089 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4092 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
4093 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
4094 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
4095 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
4096 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
4097 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
4107 if (p
!= buff
+ field_size
+ 4)
4109 if (size
< (10 + 2))
4116 size
-= flags
[index
].len
;
4117 p
= stpcpy (p
, flags
[index
].str
);
4119 else if (flag
& SHF_MASKOS
)
4121 else if (flag
& SHF_MASKPROC
)
4124 unknown_flags
|= flag
;
4130 case SHF_WRITE
: *p
= 'W'; break;
4131 case SHF_ALLOC
: *p
= 'A'; break;
4132 case SHF_EXECINSTR
: *p
= 'X'; break;
4133 case SHF_MERGE
: *p
= 'M'; break;
4134 case SHF_STRINGS
: *p
= 'S'; break;
4135 case SHF_INFO_LINK
: *p
= 'I'; break;
4136 case SHF_LINK_ORDER
: *p
= 'L'; break;
4137 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4138 case SHF_GROUP
: *p
= 'G'; break;
4139 case SHF_TLS
: *p
= 'T'; break;
4142 if (elf_header
.e_machine
== EM_X86_64
4143 && flag
== SHF_X86_64_LARGE
)
4145 else if (flag
& SHF_MASKOS
)
4148 sh_flags
&= ~ SHF_MASKOS
;
4150 else if (flag
& SHF_MASKPROC
)
4153 sh_flags
&= ~ SHF_MASKPROC
;
4163 if (do_section_details
)
4167 size
-= 5 + field_size
;
4168 if (p
!= buff
+ field_size
+ 4)
4176 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4177 (unsigned long) os_flags
);
4178 p
+= 5 + field_size
;
4182 size
-= 7 + field_size
;
4183 if (p
!= buff
+ field_size
+ 4)
4191 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4192 (unsigned long) proc_flags
);
4193 p
+= 7 + field_size
;
4197 size
-= 10 + field_size
;
4198 if (p
!= buff
+ field_size
+ 4)
4206 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4207 (unsigned long) unknown_flags
);
4208 p
+= 10 + field_size
;
4217 process_section_headers (FILE *file
)
4219 Elf_Internal_Shdr
*section
;
4222 section_headers
= NULL
;
4224 if (elf_header
.e_shnum
== 0)
4227 printf (_("\nThere are no sections in this file.\n"));
4232 if (do_sections
&& !do_header
)
4233 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4234 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4238 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4241 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4244 /* Read in the string table, so that we have names to display. */
4245 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4246 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4248 section
= section_headers
+ elf_header
.e_shstrndx
;
4250 if (section
->sh_size
!= 0)
4252 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4253 1, section
->sh_size
, _("string table"));
4255 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4259 /* Scan the sections for the dynamic symbol table
4260 and dynamic string table and debug sections. */
4261 dynamic_symbols
= NULL
;
4262 dynamic_strings
= NULL
;
4263 dynamic_syminfo
= NULL
;
4264 symtab_shndx_hdr
= NULL
;
4266 eh_addr_size
= is_32bit_elf
? 4 : 8;
4267 switch (elf_header
.e_machine
)
4270 case EM_MIPS_RS3_LE
:
4271 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4272 FDE addresses. However, the ABI also has a semi-official ILP32
4273 variant for which the normal FDE address size rules apply.
4275 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4276 section, where XX is the size of longs in bits. Unfortunately,
4277 earlier compilers provided no way of distinguishing ILP32 objects
4278 from LP64 objects, so if there's any doubt, we should assume that
4279 the official LP64 form is being used. */
4280 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4281 && find_section (".gcc_compiled_long32") == NULL
)
4287 switch (elf_header
.e_flags
& EF_H8_MACH
)
4289 case E_H8_MACH_H8300
:
4290 case E_H8_MACH_H8300HN
:
4291 case E_H8_MACH_H8300SN
:
4292 case E_H8_MACH_H8300SXN
:
4295 case E_H8_MACH_H8300H
:
4296 case E_H8_MACH_H8300S
:
4297 case E_H8_MACH_H8300SX
:
4304 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4306 case EF_M32C_CPU_M16C
:
4313 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4316 size_t expected_entsize \
4317 = is_32bit_elf ? size32 : size64; \
4318 if (section->sh_entsize != expected_entsize) \
4319 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4320 i, (unsigned long int) section->sh_entsize, \
4321 (unsigned long int) expected_entsize); \
4322 section->sh_entsize = expected_entsize; \
4325 #define CHECK_ENTSIZE(section, i, type) \
4326 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4327 sizeof (Elf64_External_##type))
4329 for (i
= 0, section
= section_headers
;
4330 i
< elf_header
.e_shnum
;
4333 char *name
= SECTION_NAME (section
);
4335 if (section
->sh_type
== SHT_DYNSYM
)
4337 if (dynamic_symbols
!= NULL
)
4339 error (_("File contains multiple dynamic symbol tables\n"));
4343 CHECK_ENTSIZE (section
, i
, Sym
);
4344 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4345 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4347 else if (section
->sh_type
== SHT_STRTAB
4348 && streq (name
, ".dynstr"))
4350 if (dynamic_strings
!= NULL
)
4352 error (_("File contains multiple dynamic string tables\n"));
4356 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4357 1, section
->sh_size
, _("dynamic strings"));
4358 dynamic_strings_length
= section
->sh_size
;
4360 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4362 if (symtab_shndx_hdr
!= NULL
)
4364 error (_("File contains multiple symtab shndx tables\n"));
4367 symtab_shndx_hdr
= section
;
4369 else if (section
->sh_type
== SHT_SYMTAB
)
4370 CHECK_ENTSIZE (section
, i
, Sym
);
4371 else if (section
->sh_type
== SHT_GROUP
)
4372 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4373 else if (section
->sh_type
== SHT_REL
)
4374 CHECK_ENTSIZE (section
, i
, Rel
);
4375 else if (section
->sh_type
== SHT_RELA
)
4376 CHECK_ENTSIZE (section
, i
, Rela
);
4377 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4378 || do_debug_lines
|| do_debug_lines_decoded
|| do_debug_pubnames
4379 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4380 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4381 && const_strneq (name
, ".debug_"))
4386 || (do_debug_info
&& streq (name
, "info"))
4387 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4388 || ((do_debug_lines
|| do_debug_lines_decoded
)
4389 && streq (name
, "line"))
4390 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4391 || (do_debug_aranges
&& streq (name
, "aranges"))
4392 || (do_debug_ranges
&& streq (name
, "ranges"))
4393 || (do_debug_frames
&& streq (name
, "frame"))
4394 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4395 || (do_debug_str
&& streq (name
, "str"))
4396 || (do_debug_loc
&& streq (name
, "loc"))
4398 request_dump_bynumber (i
, DEBUG_DUMP
);
4400 /* Linkonce section to be combined with .debug_info at link time. */
4401 else if ((do_debugging
|| do_debug_info
)
4402 && const_strneq (name
, ".gnu.linkonce.wi."))
4403 request_dump_bynumber (i
, DEBUG_DUMP
);
4404 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4405 request_dump_bynumber (i
, DEBUG_DUMP
);
4411 if (elf_header
.e_shnum
> 1)
4412 printf (_("\nSection Headers:\n"));
4414 printf (_("\nSection Header:\n"));
4418 if (do_section_details
)
4420 printf (_(" [Nr] Name\n"));
4421 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4425 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4429 if (do_section_details
)
4431 printf (_(" [Nr] Name\n"));
4432 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4436 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4440 if (do_section_details
)
4442 printf (_(" [Nr] Name\n"));
4443 printf (_(" Type Address Offset Link\n"));
4444 printf (_(" Size EntSize Info Align\n"));
4448 printf (_(" [Nr] Name Type Address Offset\n"));
4449 printf (_(" Size EntSize Flags Link Info Align\n"));
4453 if (do_section_details
)
4454 printf (_(" Flags\n"));
4456 for (i
= 0, section
= section_headers
;
4457 i
< elf_header
.e_shnum
;
4460 if (do_section_details
)
4462 printf (" [%2u] %s\n",
4464 SECTION_NAME (section
));
4465 if (is_32bit_elf
|| do_wide
)
4466 printf (" %-15.15s ",
4467 get_section_type_name (section
->sh_type
));
4470 printf (" [%2u] %-17.17s %-15.15s ",
4472 SECTION_NAME (section
),
4473 get_section_type_name (section
->sh_type
));
4477 print_vma (section
->sh_addr
, LONG_HEX
);
4479 printf ( " %6.6lx %6.6lx %2.2lx",
4480 (unsigned long) section
->sh_offset
,
4481 (unsigned long) section
->sh_size
,
4482 (unsigned long) section
->sh_entsize
);
4484 if (do_section_details
)
4485 fputs (" ", stdout
);
4487 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4489 printf ("%2u %3u %2lu\n",
4492 (unsigned long) section
->sh_addralign
);
4496 print_vma (section
->sh_addr
, LONG_HEX
);
4498 if ((long) section
->sh_offset
== section
->sh_offset
)
4499 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4503 print_vma (section
->sh_offset
, LONG_HEX
);
4506 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4507 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4511 print_vma (section
->sh_size
, LONG_HEX
);
4514 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4515 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4519 print_vma (section
->sh_entsize
, LONG_HEX
);
4522 if (do_section_details
)
4523 fputs (" ", stdout
);
4525 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4527 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4529 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4530 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4533 print_vma (section
->sh_addralign
, DEC
);
4537 else if (do_section_details
)
4539 printf (" %-15.15s ",
4540 get_section_type_name (section
->sh_type
));
4541 print_vma (section
->sh_addr
, LONG_HEX
);
4542 if ((long) section
->sh_offset
== section
->sh_offset
)
4543 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4547 print_vma (section
->sh_offset
, LONG_HEX
);
4549 printf (" %u\n ", section
->sh_link
);
4550 print_vma (section
->sh_size
, LONG_HEX
);
4552 print_vma (section
->sh_entsize
, LONG_HEX
);
4554 printf (" %-16u %lu\n",
4556 (unsigned long) section
->sh_addralign
);
4561 print_vma (section
->sh_addr
, LONG_HEX
);
4562 if ((long) section
->sh_offset
== section
->sh_offset
)
4563 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4567 print_vma (section
->sh_offset
, LONG_HEX
);
4570 print_vma (section
->sh_size
, LONG_HEX
);
4572 print_vma (section
->sh_entsize
, LONG_HEX
);
4574 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4576 printf (" %2u %3u %lu\n",
4579 (unsigned long) section
->sh_addralign
);
4582 if (do_section_details
)
4583 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4586 if (!do_section_details
)
4587 printf (_("Key to Flags:\n\
4588 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4589 I (info), L (link order), G (group), x (unknown)\n\
4590 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4596 get_group_flags (unsigned int flags
)
4598 static char buff
[32];
4605 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4612 process_section_groups (FILE *file
)
4614 Elf_Internal_Shdr
*section
;
4616 struct group
*group
;
4617 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4618 Elf_Internal_Sym
*symtab
;
4622 /* Don't process section groups unless needed. */
4623 if (!do_unwind
&& !do_section_groups
)
4626 if (elf_header
.e_shnum
== 0)
4628 if (do_section_groups
)
4629 printf (_("\nThere are no sections in this file.\n"));
4634 if (section_headers
== NULL
)
4636 error (_("Section headers are not available!\n"));
4640 section_headers_groups
= calloc (elf_header
.e_shnum
,
4641 sizeof (struct group
*));
4643 if (section_headers_groups
== NULL
)
4645 error (_("Out of memory\n"));
4649 /* Scan the sections for the group section. */
4651 for (i
= 0, section
= section_headers
;
4652 i
< elf_header
.e_shnum
;
4654 if (section
->sh_type
== SHT_GROUP
)
4657 if (group_count
== 0)
4659 if (do_section_groups
)
4660 printf (_("\nThere are no section groups in this file.\n"));
4665 section_groups
= calloc (group_count
, sizeof (struct group
));
4667 if (section_groups
== NULL
)
4669 error (_("Out of memory\n"));
4678 for (i
= 0, section
= section_headers
, group
= section_groups
;
4679 i
< elf_header
.e_shnum
;
4682 if (section
->sh_type
== SHT_GROUP
)
4684 char *name
= SECTION_NAME (section
);
4686 unsigned char *start
, *indices
;
4687 unsigned int entry
, j
, size
;
4688 Elf_Internal_Shdr
*sec
;
4689 Elf_Internal_Sym
*sym
;
4691 /* Get the symbol table. */
4692 if (section
->sh_link
>= elf_header
.e_shnum
4693 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4696 error (_("Bad sh_link in group section `%s'\n"), name
);
4700 if (symtab_sec
!= sec
)
4705 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4708 sym
= symtab
+ section
->sh_info
;
4710 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4712 if (sym
->st_shndx
== 0
4713 || sym
->st_shndx
>= elf_header
.e_shnum
)
4715 error (_("Bad sh_info in group section `%s'\n"), name
);
4719 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4728 /* Get the string table. */
4729 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4738 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4743 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4744 1, strtab_sec
->sh_size
,
4746 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4748 group_name
= sym
->st_name
< strtab_size
4749 ? strtab
+ sym
->st_name
: "<corrupt>";
4752 start
= get_data (NULL
, file
, section
->sh_offset
,
4753 1, section
->sh_size
, _("section data"));
4756 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4757 entry
= byte_get (indices
, 4);
4760 if (do_section_groups
)
4762 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4763 get_group_flags (entry
), i
, name
, group_name
, size
);
4765 printf (_(" [Index] Name\n"));
4768 group
->group_index
= i
;
4770 for (j
= 0; j
< size
; j
++)
4772 struct group_list
*g
;
4774 entry
= byte_get (indices
, 4);
4777 if (entry
>= elf_header
.e_shnum
)
4779 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4780 entry
, i
, elf_header
.e_shnum
- 1);
4784 if (section_headers_groups
[entry
] != NULL
)
4788 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4790 section_headers_groups
[entry
]->group_index
);
4795 /* Intel C/C++ compiler may put section 0 in a
4796 section group. We just warn it the first time
4797 and ignore it afterwards. */
4798 static int warned
= 0;
4801 error (_("section 0 in group section [%5u]\n"),
4802 section_headers_groups
[entry
]->group_index
);
4808 section_headers_groups
[entry
] = group
;
4810 if (do_section_groups
)
4812 sec
= section_headers
+ entry
;
4813 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4816 g
= xmalloc (sizeof (struct group_list
));
4817 g
->section_index
= entry
;
4818 g
->next
= group
->root
;
4842 } dynamic_relocations
[] =
4844 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4845 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4846 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4849 /* Process the reloc section. */
4852 process_relocs (FILE *file
)
4854 unsigned long rel_size
;
4855 unsigned long rel_offset
;
4861 if (do_using_dynamic
)
4865 int has_dynamic_reloc
;
4868 has_dynamic_reloc
= 0;
4870 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4872 is_rela
= dynamic_relocations
[i
].rela
;
4873 name
= dynamic_relocations
[i
].name
;
4874 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4875 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4877 has_dynamic_reloc
|= rel_size
;
4879 if (is_rela
== UNKNOWN
)
4881 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4882 switch (dynamic_info
[DT_PLTREL
])
4896 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4897 name
, rel_offset
, rel_size
);
4899 dump_relocations (file
,
4900 offset_from_vma (file
, rel_offset
, rel_size
),
4902 dynamic_symbols
, num_dynamic_syms
,
4903 dynamic_strings
, dynamic_strings_length
, is_rela
);
4907 if (! has_dynamic_reloc
)
4908 printf (_("\nThere are no dynamic relocations in this file.\n"));
4912 Elf_Internal_Shdr
*section
;
4916 for (i
= 0, section
= section_headers
;
4917 i
< elf_header
.e_shnum
;
4920 if ( section
->sh_type
!= SHT_RELA
4921 && section
->sh_type
!= SHT_REL
)
4924 rel_offset
= section
->sh_offset
;
4925 rel_size
= section
->sh_size
;
4929 Elf_Internal_Shdr
*strsec
;
4932 printf (_("\nRelocation section "));
4934 if (string_table
== NULL
)
4935 printf ("%d", section
->sh_name
);
4937 printf (_("'%s'"), SECTION_NAME (section
));
4939 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4940 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4942 is_rela
= section
->sh_type
== SHT_RELA
;
4944 if (section
->sh_link
!= 0
4945 && section
->sh_link
< elf_header
.e_shnum
)
4947 Elf_Internal_Shdr
*symsec
;
4948 Elf_Internal_Sym
*symtab
;
4949 unsigned long nsyms
;
4950 unsigned long strtablen
= 0;
4951 char *strtab
= NULL
;
4953 symsec
= section_headers
+ section
->sh_link
;
4954 if (symsec
->sh_type
!= SHT_SYMTAB
4955 && symsec
->sh_type
!= SHT_DYNSYM
)
4958 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4959 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4964 if (symsec
->sh_link
!= 0
4965 && symsec
->sh_link
< elf_header
.e_shnum
)
4967 strsec
= section_headers
+ symsec
->sh_link
;
4969 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4972 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4975 dump_relocations (file
, rel_offset
, rel_size
,
4976 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4982 dump_relocations (file
, rel_offset
, rel_size
,
4983 NULL
, 0, NULL
, 0, is_rela
);
4990 printf (_("\nThere are no relocations in this file.\n"));
4996 /* Process the unwind section. */
4998 #include "unwind-ia64.h"
5000 /* An absolute address consists of a section and an offset. If the
5001 section is NULL, the offset itself is the address, otherwise, the
5002 address equals to LOAD_ADDRESS(section) + offset. */
5006 unsigned short section
;
5010 #define ABSADDR(a) \
5012 ? section_headers [(a).section].sh_addr + (a).offset \
5015 struct ia64_unw_aux_info
5017 struct ia64_unw_table_entry
5019 struct absaddr start
;
5021 struct absaddr info
;
5023 *table
; /* Unwind table. */
5024 unsigned long table_len
; /* Length of unwind table. */
5025 unsigned char *info
; /* Unwind info. */
5026 unsigned long info_size
; /* Size of unwind info. */
5027 bfd_vma info_addr
; /* starting address of unwind info. */
5028 bfd_vma seg_base
; /* Starting address of segment. */
5029 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5030 unsigned long nsyms
; /* Number of symbols. */
5031 char *strtab
; /* The string table. */
5032 unsigned long strtab_size
; /* Size of string table. */
5036 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
5037 unsigned long nsyms
,
5039 unsigned long strtab_size
,
5040 struct absaddr addr
,
5041 const char **symname
,
5044 bfd_vma dist
= 0x100000;
5045 Elf_Internal_Sym
*sym
, *best
= NULL
;
5048 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5050 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5051 && sym
->st_name
!= 0
5052 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5053 && addr
.offset
>= sym
->st_value
5054 && addr
.offset
- sym
->st_value
< dist
)
5057 dist
= addr
.offset
- sym
->st_value
;
5064 *symname
= (best
->st_name
>= strtab_size
5065 ? "<corrupt>" : strtab
+ best
->st_name
);
5070 *offset
= addr
.offset
;
5074 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
5076 struct ia64_unw_table_entry
*tp
;
5079 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5083 const unsigned char *dp
;
5084 const unsigned char *head
;
5085 const char *procname
;
5087 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5088 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5090 fputs ("\n<", stdout
);
5094 fputs (procname
, stdout
);
5097 printf ("+%lx", (unsigned long) offset
);
5100 fputs (">: [", stdout
);
5101 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5102 fputc ('-', stdout
);
5103 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5104 printf ("], info at +0x%lx\n",
5105 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5107 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5108 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5110 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5111 (unsigned) UNW_VER (stamp
),
5112 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5113 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5114 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5115 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5117 if (UNW_VER (stamp
) != 1)
5119 printf ("\tUnknown version.\n");
5124 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5125 dp
= unw_decode (dp
, in_body
, & in_body
);
5130 slurp_ia64_unwind_table (FILE *file
,
5131 struct ia64_unw_aux_info
*aux
,
5132 Elf_Internal_Shdr
*sec
)
5134 unsigned long size
, nrelas
, i
;
5135 Elf_Internal_Phdr
*seg
;
5136 struct ia64_unw_table_entry
*tep
;
5137 Elf_Internal_Shdr
*relsec
;
5138 Elf_Internal_Rela
*rela
, *rp
;
5139 unsigned char *table
, *tp
;
5140 Elf_Internal_Sym
*sym
;
5141 const char *relname
;
5143 /* First, find the starting address of the segment that includes
5146 if (elf_header
.e_phnum
)
5148 if (! get_program_headers (file
))
5151 for (seg
= program_headers
;
5152 seg
< program_headers
+ elf_header
.e_phnum
;
5155 if (seg
->p_type
!= PT_LOAD
)
5158 if (sec
->sh_addr
>= seg
->p_vaddr
5159 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5161 aux
->seg_base
= seg
->p_vaddr
;
5167 /* Second, build the unwind table from the contents of the unwind section: */
5168 size
= sec
->sh_size
;
5169 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5173 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5175 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
5177 tep
->start
.section
= SHN_UNDEF
;
5178 tep
->end
.section
= SHN_UNDEF
;
5179 tep
->info
.section
= SHN_UNDEF
;
5182 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5183 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5184 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5188 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5189 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5190 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5192 tep
->start
.offset
+= aux
->seg_base
;
5193 tep
->end
.offset
+= aux
->seg_base
;
5194 tep
->info
.offset
+= aux
->seg_base
;
5198 /* Third, apply any relocations to the unwind table: */
5199 for (relsec
= section_headers
;
5200 relsec
< section_headers
+ elf_header
.e_shnum
;
5203 if (relsec
->sh_type
!= SHT_RELA
5204 || relsec
->sh_info
>= elf_header
.e_shnum
5205 || section_headers
+ relsec
->sh_info
!= sec
)
5208 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5212 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5214 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5215 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5217 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5219 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5223 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5225 switch (rp
->r_offset
/eh_addr_size
% 3)
5228 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5229 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5232 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5233 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5236 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5237 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5247 aux
->table_len
= size
/ (3 * eh_addr_size
);
5252 ia64_process_unwind (FILE *file
)
5254 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5255 unsigned long i
, unwcount
= 0, unwstart
= 0;
5256 struct ia64_unw_aux_info aux
;
5258 memset (& aux
, 0, sizeof (aux
));
5260 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5262 if (sec
->sh_type
== SHT_SYMTAB
5263 && sec
->sh_link
< elf_header
.e_shnum
)
5265 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5266 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5268 strsec
= section_headers
+ sec
->sh_link
;
5269 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5270 1, strsec
->sh_size
, _("string table"));
5271 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5273 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5278 printf (_("\nThere are no unwind sections in this file.\n"));
5280 while (unwcount
-- > 0)
5285 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5286 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5287 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5294 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5296 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5298 /* We need to find which section group it is in. */
5299 struct group_list
*g
= section_headers_groups
[i
]->root
;
5301 for (; g
!= NULL
; g
= g
->next
)
5303 sec
= section_headers
+ g
->section_index
;
5305 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5310 i
= elf_header
.e_shnum
;
5312 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5314 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5315 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5316 suffix
= SECTION_NAME (unwsec
) + len
;
5317 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5319 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5320 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5325 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5326 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5327 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5328 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5330 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5331 suffix
= SECTION_NAME (unwsec
) + len
;
5332 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5334 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5335 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5339 if (i
== elf_header
.e_shnum
)
5341 printf (_("\nCould not find unwind info section for "));
5343 if (string_table
== NULL
)
5344 printf ("%d", unwsec
->sh_name
);
5346 printf (_("'%s'"), SECTION_NAME (unwsec
));
5350 aux
.info_size
= sec
->sh_size
;
5351 aux
.info_addr
= sec
->sh_addr
;
5352 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5355 printf (_("\nUnwind section "));
5357 if (string_table
== NULL
)
5358 printf ("%d", unwsec
->sh_name
);
5360 printf (_("'%s'"), SECTION_NAME (unwsec
));
5362 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5363 (unsigned long) unwsec
->sh_offset
,
5364 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5366 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5368 if (aux
.table_len
> 0)
5369 dump_ia64_unwind (& aux
);
5372 free ((char *) aux
.table
);
5374 free ((char *) aux
.info
);
5383 free ((char *) aux
.strtab
);
5388 struct hppa_unw_aux_info
5390 struct hppa_unw_table_entry
5392 struct absaddr start
;
5394 unsigned int Cannot_unwind
:1; /* 0 */
5395 unsigned int Millicode
:1; /* 1 */
5396 unsigned int Millicode_save_sr0
:1; /* 2 */
5397 unsigned int Region_description
:2; /* 3..4 */
5398 unsigned int reserved1
:1; /* 5 */
5399 unsigned int Entry_SR
:1; /* 6 */
5400 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5401 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5402 unsigned int Args_stored
:1; /* 16 */
5403 unsigned int Variable_Frame
:1; /* 17 */
5404 unsigned int Separate_Package_Body
:1; /* 18 */
5405 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5406 unsigned int Stack_Overflow_Check
:1; /* 20 */
5407 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5408 unsigned int Ada_Region
:1; /* 22 */
5409 unsigned int cxx_info
:1; /* 23 */
5410 unsigned int cxx_try_catch
:1; /* 24 */
5411 unsigned int sched_entry_seq
:1; /* 25 */
5412 unsigned int reserved2
:1; /* 26 */
5413 unsigned int Save_SP
:1; /* 27 */
5414 unsigned int Save_RP
:1; /* 28 */
5415 unsigned int Save_MRP_in_frame
:1; /* 29 */
5416 unsigned int extn_ptr_defined
:1; /* 30 */
5417 unsigned int Cleanup_defined
:1; /* 31 */
5419 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5420 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5421 unsigned int Large_frame
:1; /* 2 */
5422 unsigned int Pseudo_SP_Set
:1; /* 3 */
5423 unsigned int reserved4
:1; /* 4 */
5424 unsigned int Total_frame_size
:27; /* 5..31 */
5426 *table
; /* Unwind table. */
5427 unsigned long table_len
; /* Length of unwind table. */
5428 bfd_vma seg_base
; /* Starting address of segment. */
5429 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5430 unsigned long nsyms
; /* Number of symbols. */
5431 char *strtab
; /* The string table. */
5432 unsigned long strtab_size
; /* Size of string table. */
5436 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5438 struct hppa_unw_table_entry
*tp
;
5440 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5443 const char *procname
;
5445 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5446 aux
->strtab_size
, tp
->start
, &procname
,
5449 fputs ("\n<", stdout
);
5453 fputs (procname
, stdout
);
5456 printf ("+%lx", (unsigned long) offset
);
5459 fputs (">: [", stdout
);
5460 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5461 fputc ('-', stdout
);
5462 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5465 #define PF(_m) if (tp->_m) printf (#_m " ");
5466 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5469 PF(Millicode_save_sr0
);
5470 /* PV(Region_description); */
5476 PF(Separate_Package_Body
);
5477 PF(Frame_Extension_Millicode
);
5478 PF(Stack_Overflow_Check
);
5479 PF(Two_Instruction_SP_Increment
);
5483 PF(sched_entry_seq
);
5486 PF(Save_MRP_in_frame
);
5487 PF(extn_ptr_defined
);
5488 PF(Cleanup_defined
);
5489 PF(MPE_XL_interrupt_marker
);
5490 PF(HP_UX_interrupt_marker
);
5493 PV(Total_frame_size
);
5502 slurp_hppa_unwind_table (FILE *file
,
5503 struct hppa_unw_aux_info
*aux
,
5504 Elf_Internal_Shdr
*sec
)
5506 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5507 Elf_Internal_Phdr
*seg
;
5508 struct hppa_unw_table_entry
*tep
;
5509 Elf_Internal_Shdr
*relsec
;
5510 Elf_Internal_Rela
*rela
, *rp
;
5511 unsigned char *table
, *tp
;
5512 Elf_Internal_Sym
*sym
;
5513 const char *relname
;
5515 /* First, find the starting address of the segment that includes
5518 if (elf_header
.e_phnum
)
5520 if (! get_program_headers (file
))
5523 for (seg
= program_headers
;
5524 seg
< program_headers
+ elf_header
.e_phnum
;
5527 if (seg
->p_type
!= PT_LOAD
)
5530 if (sec
->sh_addr
>= seg
->p_vaddr
5531 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5533 aux
->seg_base
= seg
->p_vaddr
;
5539 /* Second, build the unwind table from the contents of the unwind
5541 size
= sec
->sh_size
;
5542 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5547 nentries
= size
/ unw_ent_size
;
5548 size
= unw_ent_size
* nentries
;
5550 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5552 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5554 unsigned int tmp1
, tmp2
;
5556 tep
->start
.section
= SHN_UNDEF
;
5557 tep
->end
.section
= SHN_UNDEF
;
5559 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5560 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5561 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5562 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5564 tep
->start
.offset
+= aux
->seg_base
;
5565 tep
->end
.offset
+= aux
->seg_base
;
5567 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5568 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5569 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5570 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5571 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5572 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5573 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5574 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5575 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5576 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5577 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5578 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5579 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5580 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5581 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5582 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5583 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5584 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5585 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5586 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5587 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5588 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5589 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5590 tep
->Cleanup_defined
= tmp1
& 0x1;
5592 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5593 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5594 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5595 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5596 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5597 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5601 /* Third, apply any relocations to the unwind table. */
5602 for (relsec
= section_headers
;
5603 relsec
< section_headers
+ elf_header
.e_shnum
;
5606 if (relsec
->sh_type
!= SHT_RELA
5607 || relsec
->sh_info
>= elf_header
.e_shnum
5608 || section_headers
+ relsec
->sh_info
!= sec
)
5611 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5615 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5617 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5618 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5620 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5621 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5623 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5627 i
= rp
->r_offset
/ unw_ent_size
;
5629 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5632 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5633 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5636 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5637 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5647 aux
->table_len
= nentries
;
5653 hppa_process_unwind (FILE *file
)
5655 struct hppa_unw_aux_info aux
;
5656 Elf_Internal_Shdr
*unwsec
= NULL
;
5657 Elf_Internal_Shdr
*strsec
;
5658 Elf_Internal_Shdr
*sec
;
5661 memset (& aux
, 0, sizeof (aux
));
5663 if (string_table
== NULL
)
5666 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5668 if (sec
->sh_type
== SHT_SYMTAB
5669 && sec
->sh_link
< elf_header
.e_shnum
)
5671 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5672 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5674 strsec
= section_headers
+ sec
->sh_link
;
5675 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5676 1, strsec
->sh_size
, _("string table"));
5677 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5679 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5684 printf (_("\nThere are no unwind sections in this file.\n"));
5686 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5688 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5690 printf (_("\nUnwind section "));
5691 printf (_("'%s'"), SECTION_NAME (sec
));
5693 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5694 (unsigned long) sec
->sh_offset
,
5695 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5697 slurp_hppa_unwind_table (file
, &aux
, sec
);
5698 if (aux
.table_len
> 0)
5699 dump_hppa_unwind (&aux
);
5702 free ((char *) aux
.table
);
5710 free ((char *) aux
.strtab
);
5716 process_unwind (FILE *file
)
5718 struct unwind_handler
{
5720 int (*handler
)(FILE *file
);
5722 { EM_IA_64
, ia64_process_unwind
},
5723 { EM_PARISC
, hppa_process_unwind
},
5731 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5732 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5733 return handlers
[i
].handler (file
);
5735 printf (_("\nThere are no unwind sections in this file.\n"));
5740 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5742 switch (entry
->d_tag
)
5745 if (entry
->d_un
.d_val
== 0)
5749 static const char * opts
[] =
5751 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5752 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5753 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5754 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5759 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5760 if (entry
->d_un
.d_val
& (1 << cnt
))
5762 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5769 case DT_MIPS_IVERSION
:
5770 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5771 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5773 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5776 case DT_MIPS_TIME_STAMP
:
5781 time_t time
= entry
->d_un
.d_val
;
5782 tmp
= gmtime (&time
);
5783 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5784 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5785 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5786 printf ("Time Stamp: %s\n", timebuf
);
5790 case DT_MIPS_RLD_VERSION
:
5791 case DT_MIPS_LOCAL_GOTNO
:
5792 case DT_MIPS_CONFLICTNO
:
5793 case DT_MIPS_LIBLISTNO
:
5794 case DT_MIPS_SYMTABNO
:
5795 case DT_MIPS_UNREFEXTNO
:
5796 case DT_MIPS_HIPAGENO
:
5797 case DT_MIPS_DELTA_CLASS_NO
:
5798 case DT_MIPS_DELTA_INSTANCE_NO
:
5799 case DT_MIPS_DELTA_RELOC_NO
:
5800 case DT_MIPS_DELTA_SYM_NO
:
5801 case DT_MIPS_DELTA_CLASSSYM_NO
:
5802 case DT_MIPS_COMPACT_SIZE
:
5803 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5807 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5813 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5815 switch (entry
->d_tag
)
5817 case DT_HP_DLD_FLAGS
:
5826 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5827 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5828 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5829 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5830 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5831 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5832 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5833 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5834 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5835 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5836 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5837 { DT_HP_GST
, "HP_GST" },
5838 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5839 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5840 { DT_HP_NODELETE
, "HP_NODELETE" },
5841 { DT_HP_GROUP
, "HP_GROUP" },
5842 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5846 bfd_vma val
= entry
->d_un
.d_val
;
5848 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5849 if (val
& flags
[cnt
].bit
)
5853 fputs (flags
[cnt
].str
, stdout
);
5855 val
^= flags
[cnt
].bit
;
5858 if (val
!= 0 || first
)
5862 print_vma (val
, HEX
);
5868 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5875 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5877 switch (entry
->d_tag
)
5879 case DT_IA_64_PLT_RESERVE
:
5880 /* First 3 slots reserved. */
5881 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5883 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5887 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5894 get_32bit_dynamic_section (FILE *file
)
5896 Elf32_External_Dyn
*edyn
, *ext
;
5897 Elf_Internal_Dyn
*entry
;
5899 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5900 _("dynamic section"));
5904 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5905 might not have the luxury of section headers. Look for the DT_NULL
5906 terminator to determine the number of entries. */
5907 for (ext
= edyn
, dynamic_nent
= 0;
5908 (char *) ext
< (char *) edyn
+ dynamic_size
;
5912 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5916 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5917 if (dynamic_section
== NULL
)
5919 error (_("Out of memory\n"));
5924 for (ext
= edyn
, entry
= dynamic_section
;
5925 entry
< dynamic_section
+ dynamic_nent
;
5928 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5929 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5938 get_64bit_dynamic_section (FILE *file
)
5940 Elf64_External_Dyn
*edyn
, *ext
;
5941 Elf_Internal_Dyn
*entry
;
5943 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5944 _("dynamic section"));
5948 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5949 might not have the luxury of section headers. Look for the DT_NULL
5950 terminator to determine the number of entries. */
5951 for (ext
= edyn
, dynamic_nent
= 0;
5952 (char *) ext
< (char *) edyn
+ dynamic_size
;
5956 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5960 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5961 if (dynamic_section
== NULL
)
5963 error (_("Out of memory\n"));
5968 for (ext
= edyn
, entry
= dynamic_section
;
5969 entry
< dynamic_section
+ dynamic_nent
;
5972 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5973 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5982 print_dynamic_flags (bfd_vma flags
)
5990 flag
= flags
& - flags
;
6000 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6001 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6002 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6003 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6004 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6005 default: fputs ("unknown", stdout
); break;
6011 /* Parse and display the contents of the dynamic section. */
6014 process_dynamic_section (FILE *file
)
6016 Elf_Internal_Dyn
*entry
;
6018 if (dynamic_size
== 0)
6021 printf (_("\nThere is no dynamic section in this file.\n"));
6028 if (! get_32bit_dynamic_section (file
))
6031 else if (! get_64bit_dynamic_section (file
))
6034 /* Find the appropriate symbol table. */
6035 if (dynamic_symbols
== NULL
)
6037 for (entry
= dynamic_section
;
6038 entry
< dynamic_section
+ dynamic_nent
;
6041 Elf_Internal_Shdr section
;
6043 if (entry
->d_tag
!= DT_SYMTAB
)
6046 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6048 /* Since we do not know how big the symbol table is,
6049 we default to reading in the entire file (!) and
6050 processing that. This is overkill, I know, but it
6052 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6054 if (archive_file_offset
!= 0)
6055 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6058 if (fseek (file
, 0, SEEK_END
))
6059 error (_("Unable to seek to end of file!\n"));
6061 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6065 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6067 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6069 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6070 if (num_dynamic_syms
< 1)
6072 error (_("Unable to determine the number of symbols to load\n"));
6076 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6080 /* Similarly find a string table. */
6081 if (dynamic_strings
== NULL
)
6083 for (entry
= dynamic_section
;
6084 entry
< dynamic_section
+ dynamic_nent
;
6087 unsigned long offset
;
6090 if (entry
->d_tag
!= DT_STRTAB
)
6093 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6095 /* Since we do not know how big the string table is,
6096 we default to reading in the entire file (!) and
6097 processing that. This is overkill, I know, but it
6100 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6102 if (archive_file_offset
!= 0)
6103 str_tab_len
= archive_file_size
- offset
;
6106 if (fseek (file
, 0, SEEK_END
))
6107 error (_("Unable to seek to end of file\n"));
6108 str_tab_len
= ftell (file
) - offset
;
6111 if (str_tab_len
< 1)
6114 (_("Unable to determine the length of the dynamic string table\n"));
6118 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
6119 _("dynamic string table"));
6120 dynamic_strings_length
= str_tab_len
;
6125 /* And find the syminfo section if available. */
6126 if (dynamic_syminfo
== NULL
)
6128 unsigned long syminsz
= 0;
6130 for (entry
= dynamic_section
;
6131 entry
< dynamic_section
+ dynamic_nent
;
6134 if (entry
->d_tag
== DT_SYMINENT
)
6136 /* Note: these braces are necessary to avoid a syntax
6137 error from the SunOS4 C compiler. */
6138 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6140 else if (entry
->d_tag
== DT_SYMINSZ
)
6141 syminsz
= entry
->d_un
.d_val
;
6142 else if (entry
->d_tag
== DT_SYMINFO
)
6143 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6147 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6149 Elf_External_Syminfo
*extsyminfo
, *extsym
;
6150 Elf_Internal_Syminfo
*syminfo
;
6152 /* There is a syminfo section. Read the data. */
6153 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
6154 syminsz
, _("symbol information"));
6158 dynamic_syminfo
= malloc (syminsz
);
6159 if (dynamic_syminfo
== NULL
)
6161 error (_("Out of memory\n"));
6165 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6166 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6167 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6168 ++syminfo
, ++extsym
)
6170 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6171 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6178 if (do_dynamic
&& dynamic_addr
)
6179 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6180 dynamic_addr
, dynamic_nent
);
6182 printf (_(" Tag Type Name/Value\n"));
6184 for (entry
= dynamic_section
;
6185 entry
< dynamic_section
+ dynamic_nent
;
6193 print_vma (entry
->d_tag
, FULL_HEX
);
6194 dtype
= get_dynamic_type (entry
->d_tag
);
6195 printf (" (%s)%*s", dtype
,
6196 ((is_32bit_elf
? 27 : 19)
6197 - (int) strlen (dtype
)),
6201 switch (entry
->d_tag
)
6205 print_dynamic_flags (entry
->d_un
.d_val
);
6215 switch (entry
->d_tag
)
6218 printf (_("Auxiliary library"));
6222 printf (_("Filter library"));
6226 printf (_("Configuration file"));
6230 printf (_("Dependency audit library"));
6234 printf (_("Audit library"));
6238 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6239 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6243 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6252 printf (_("Flags:"));
6254 if (entry
->d_un
.d_val
== 0)
6255 printf (_(" None\n"));
6258 unsigned long int val
= entry
->d_un
.d_val
;
6260 if (val
& DTF_1_PARINIT
)
6262 printf (" PARINIT");
6263 val
^= DTF_1_PARINIT
;
6265 if (val
& DTF_1_CONFEXP
)
6267 printf (" CONFEXP");
6268 val
^= DTF_1_CONFEXP
;
6271 printf (" %lx", val
);
6280 printf (_("Flags:"));
6282 if (entry
->d_un
.d_val
== 0)
6283 printf (_(" None\n"));
6286 unsigned long int val
= entry
->d_un
.d_val
;
6288 if (val
& DF_P1_LAZYLOAD
)
6290 printf (" LAZYLOAD");
6291 val
^= DF_P1_LAZYLOAD
;
6293 if (val
& DF_P1_GROUPPERM
)
6295 printf (" GROUPPERM");
6296 val
^= DF_P1_GROUPPERM
;
6299 printf (" %lx", val
);
6308 printf (_("Flags:"));
6309 if (entry
->d_un
.d_val
== 0)
6310 printf (_(" None\n"));
6313 unsigned long int val
= entry
->d_un
.d_val
;
6320 if (val
& DF_1_GLOBAL
)
6325 if (val
& DF_1_GROUP
)
6330 if (val
& DF_1_NODELETE
)
6332 printf (" NODELETE");
6333 val
^= DF_1_NODELETE
;
6335 if (val
& DF_1_LOADFLTR
)
6337 printf (" LOADFLTR");
6338 val
^= DF_1_LOADFLTR
;
6340 if (val
& DF_1_INITFIRST
)
6342 printf (" INITFIRST");
6343 val
^= DF_1_INITFIRST
;
6345 if (val
& DF_1_NOOPEN
)
6350 if (val
& DF_1_ORIGIN
)
6355 if (val
& DF_1_DIRECT
)
6360 if (val
& DF_1_TRANS
)
6365 if (val
& DF_1_INTERPOSE
)
6367 printf (" INTERPOSE");
6368 val
^= DF_1_INTERPOSE
;
6370 if (val
& DF_1_NODEFLIB
)
6372 printf (" NODEFLIB");
6373 val
^= DF_1_NODEFLIB
;
6375 if (val
& DF_1_NODUMP
)
6380 if (val
& DF_1_CONLFAT
)
6382 printf (" CONLFAT");
6383 val
^= DF_1_CONLFAT
;
6386 printf (" %lx", val
);
6393 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6395 puts (get_dynamic_type (entry
->d_un
.d_val
));
6415 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6421 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6422 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6428 switch (entry
->d_tag
)
6431 printf (_("Shared library: [%s]"), name
);
6433 if (streq (name
, program_interpreter
))
6434 printf (_(" program interpreter"));
6438 printf (_("Library soname: [%s]"), name
);
6442 printf (_("Library rpath: [%s]"), name
);
6446 printf (_("Library runpath: [%s]"), name
);
6450 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6455 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6468 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6472 case DT_INIT_ARRAYSZ
:
6473 case DT_FINI_ARRAYSZ
:
6474 case DT_GNU_CONFLICTSZ
:
6475 case DT_GNU_LIBLISTSZ
:
6478 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6479 printf (" (bytes)\n");
6489 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6502 if (entry
->d_tag
== DT_USED
6503 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6505 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6509 printf (_("Not needed object: [%s]\n"), name
);
6514 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6520 /* The value of this entry is ignored. */
6525 case DT_GNU_PRELINKED
:
6529 time_t time
= entry
->d_un
.d_val
;
6531 tmp
= gmtime (&time
);
6532 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6533 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6534 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6540 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6543 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6549 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6550 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6555 switch (elf_header
.e_machine
)
6558 case EM_MIPS_RS3_LE
:
6559 dynamic_section_mips_val (entry
);
6562 dynamic_section_parisc_val (entry
);
6565 dynamic_section_ia64_val (entry
);
6568 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6580 get_ver_flags (unsigned int flags
)
6582 static char buff
[32];
6589 if (flags
& VER_FLG_BASE
)
6590 strcat (buff
, "BASE ");
6592 if (flags
& VER_FLG_WEAK
)
6594 if (flags
& VER_FLG_BASE
)
6595 strcat (buff
, "| ");
6597 strcat (buff
, "WEAK ");
6600 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6601 strcat (buff
, "| <unknown>");
6606 /* Display the contents of the version sections. */
6608 process_version_sections (FILE *file
)
6610 Elf_Internal_Shdr
*section
;
6617 for (i
= 0, section
= section_headers
;
6618 i
< elf_header
.e_shnum
;
6621 switch (section
->sh_type
)
6623 case SHT_GNU_verdef
:
6625 Elf_External_Verdef
*edefs
;
6633 (_("\nVersion definition section '%s' contains %u entries:\n"),
6634 SECTION_NAME (section
), section
->sh_info
);
6636 printf (_(" Addr: 0x"));
6637 printf_vma (section
->sh_addr
);
6638 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6639 (unsigned long) section
->sh_offset
, section
->sh_link
,
6640 section
->sh_link
< elf_header
.e_shnum
6641 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6644 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6646 _("version definition section"));
6647 endbuf
= (char *) edefs
+ section
->sh_size
;
6651 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6654 Elf_External_Verdef
*edef
;
6655 Elf_Internal_Verdef ent
;
6656 Elf_External_Verdaux
*eaux
;
6657 Elf_Internal_Verdaux aux
;
6661 vstart
= ((char *) edefs
) + idx
;
6662 if (vstart
+ sizeof (*edef
) > endbuf
)
6665 edef
= (Elf_External_Verdef
*) vstart
;
6667 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6668 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6669 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6670 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6671 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6672 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6673 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6675 printf (_(" %#06x: Rev: %d Flags: %s"),
6676 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6678 printf (_(" Index: %d Cnt: %d "),
6679 ent
.vd_ndx
, ent
.vd_cnt
);
6681 vstart
+= ent
.vd_aux
;
6683 eaux
= (Elf_External_Verdaux
*) vstart
;
6685 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6686 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6688 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6689 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6691 printf (_("Name index: %ld\n"), aux
.vda_name
);
6693 isum
= idx
+ ent
.vd_aux
;
6695 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6697 isum
+= aux
.vda_next
;
6698 vstart
+= aux
.vda_next
;
6700 eaux
= (Elf_External_Verdaux
*) vstart
;
6701 if (vstart
+ sizeof (*eaux
) > endbuf
)
6704 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6705 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6707 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6708 printf (_(" %#06x: Parent %d: %s\n"),
6709 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6711 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6712 isum
, j
, aux
.vda_name
);
6715 printf (_(" Version def aux past end of section\n"));
6719 if (cnt
< section
->sh_info
)
6720 printf (_(" Version definition past end of section\n"));
6726 case SHT_GNU_verneed
:
6728 Elf_External_Verneed
*eneed
;
6735 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6736 SECTION_NAME (section
), section
->sh_info
);
6738 printf (_(" Addr: 0x"));
6739 printf_vma (section
->sh_addr
);
6740 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6741 (unsigned long) section
->sh_offset
, section
->sh_link
,
6742 section
->sh_link
< elf_header
.e_shnum
6743 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6746 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6748 _("version need section"));
6749 endbuf
= (char *) eneed
+ section
->sh_size
;
6753 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6755 Elf_External_Verneed
*entry
;
6756 Elf_Internal_Verneed ent
;
6761 vstart
= ((char *) eneed
) + idx
;
6762 if (vstart
+ sizeof (*entry
) > endbuf
)
6765 entry
= (Elf_External_Verneed
*) vstart
;
6767 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6768 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6769 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6770 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6771 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6773 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6775 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6776 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6778 printf (_(" File: %lx"), ent
.vn_file
);
6780 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6782 vstart
+= ent
.vn_aux
;
6784 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6786 Elf_External_Vernaux
*eaux
;
6787 Elf_Internal_Vernaux aux
;
6789 if (vstart
+ sizeof (*eaux
) > endbuf
)
6791 eaux
= (Elf_External_Vernaux
*) vstart
;
6793 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6794 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6795 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6796 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6797 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6799 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6800 printf (_(" %#06x: Name: %s"),
6801 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6803 printf (_(" %#06x: Name index: %lx"),
6804 isum
, aux
.vna_name
);
6806 printf (_(" Flags: %s Version: %d\n"),
6807 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6809 isum
+= aux
.vna_next
;
6810 vstart
+= aux
.vna_next
;
6813 printf (_(" Version need aux past end of section\n"));
6817 if (cnt
< section
->sh_info
)
6818 printf (_(" Version need past end of section\n"));
6824 case SHT_GNU_versym
:
6826 Elf_Internal_Shdr
*link_section
;
6829 unsigned char *edata
;
6830 unsigned short *data
;
6832 Elf_Internal_Sym
*symbols
;
6833 Elf_Internal_Shdr
*string_sec
;
6836 if (section
->sh_link
>= elf_header
.e_shnum
)
6839 link_section
= section_headers
+ section
->sh_link
;
6840 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6842 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6847 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6849 string_sec
= section_headers
+ link_section
->sh_link
;
6851 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6852 string_sec
->sh_size
, _("version string table"));
6856 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6857 SECTION_NAME (section
), total
);
6859 printf (_(" Addr: "));
6860 printf_vma (section
->sh_addr
);
6861 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6862 (unsigned long) section
->sh_offset
, section
->sh_link
,
6863 SECTION_NAME (link_section
));
6865 off
= offset_from_vma (file
,
6866 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6867 total
* sizeof (short));
6868 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6869 _("version symbol data"));
6876 data
= cmalloc (total
, sizeof (short));
6878 for (cnt
= total
; cnt
--;)
6879 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6884 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6887 int check_def
, check_need
;
6890 printf (" %03x:", cnt
);
6892 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6893 switch (data
[cnt
+ j
])
6896 fputs (_(" 0 (*local*) "), stdout
);
6900 fputs (_(" 1 (*global*) "), stdout
);
6904 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6905 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6909 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6910 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6913 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6920 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6922 Elf_Internal_Verneed ivn
;
6923 unsigned long offset
;
6925 offset
= offset_from_vma
6926 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6927 sizeof (Elf_External_Verneed
));
6931 Elf_Internal_Vernaux ivna
;
6932 Elf_External_Verneed evn
;
6933 Elf_External_Vernaux evna
;
6934 unsigned long a_off
;
6936 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6939 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6940 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6942 a_off
= offset
+ ivn
.vn_aux
;
6946 get_data (&evna
, file
, a_off
, sizeof (evna
),
6947 1, _("version need aux (2)"));
6949 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6950 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6952 a_off
+= ivna
.vna_next
;
6954 while (ivna
.vna_other
!= data
[cnt
+ j
]
6955 && ivna
.vna_next
!= 0);
6957 if (ivna
.vna_other
== data
[cnt
+ j
])
6959 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6961 if (ivna
.vna_name
>= string_sec
->sh_size
)
6962 name
= _("*invalid*");
6964 name
= strtab
+ ivna
.vna_name
;
6965 nn
+= printf ("(%s%-*s",
6967 12 - (int) strlen (name
),
6973 offset
+= ivn
.vn_next
;
6975 while (ivn
.vn_next
);
6978 if (check_def
&& data
[cnt
+ j
] != 0x8001
6979 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6981 Elf_Internal_Verdef ivd
;
6982 Elf_External_Verdef evd
;
6983 unsigned long offset
;
6985 offset
= offset_from_vma
6986 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6991 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6994 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6995 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6997 offset
+= ivd
.vd_next
;
6999 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
7000 && ivd
.vd_next
!= 0);
7002 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
7004 Elf_External_Verdaux evda
;
7005 Elf_Internal_Verdaux ivda
;
7007 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7009 get_data (&evda
, file
,
7010 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7012 _("version def aux"));
7014 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7016 if (ivda
.vda_name
>= string_sec
->sh_size
)
7017 name
= _("*invalid*");
7019 name
= strtab
+ ivda
.vda_name
;
7020 nn
+= printf ("(%s%-*s",
7022 12 - (int) strlen (name
),
7028 printf ("%*c", 18 - nn
, ' ');
7046 printf (_("\nNo version information found in this file.\n"));
7052 get_symbol_binding (unsigned int binding
)
7054 static char buff
[32];
7058 case STB_LOCAL
: return "LOCAL";
7059 case STB_GLOBAL
: return "GLOBAL";
7060 case STB_WEAK
: return "WEAK";
7062 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7063 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7065 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7066 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7068 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7074 get_symbol_type (unsigned int type
)
7076 static char buff
[32];
7080 case STT_NOTYPE
: return "NOTYPE";
7081 case STT_OBJECT
: return "OBJECT";
7082 case STT_FUNC
: return "FUNC";
7083 case STT_SECTION
: return "SECTION";
7084 case STT_FILE
: return "FILE";
7085 case STT_COMMON
: return "COMMON";
7086 case STT_TLS
: return "TLS";
7087 case STT_RELC
: return "RELC";
7088 case STT_SRELC
: return "SRELC";
7090 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7092 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7093 return "THUMB_FUNC";
7095 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7098 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7099 return "PARISC_MILLI";
7101 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7103 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7105 if (elf_header
.e_machine
== EM_PARISC
)
7107 if (type
== STT_HP_OPAQUE
)
7109 if (type
== STT_HP_STUB
)
7113 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7116 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7122 get_symbol_visibility (unsigned int visibility
)
7126 case STV_DEFAULT
: return "DEFAULT";
7127 case STV_INTERNAL
: return "INTERNAL";
7128 case STV_HIDDEN
: return "HIDDEN";
7129 case STV_PROTECTED
: return "PROTECTED";
7135 get_mips_symbol_other (unsigned int other
)
7139 case STO_OPTIONAL
: return "OPTIONAL";
7140 case STO_MIPS16
: return "MIPS16";
7141 default: return NULL
;
7146 get_symbol_other (unsigned int other
)
7148 const char * result
= NULL
;
7149 static char buff
[32];
7154 switch (elf_header
.e_machine
)
7157 result
= get_mips_symbol_other (other
);
7165 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7170 get_symbol_index_type (unsigned int type
)
7172 static char buff
[32];
7176 case SHN_UNDEF
: return "UND";
7177 case SHN_ABS
: return "ABS";
7178 case SHN_COMMON
: return "COM";
7180 if (type
== SHN_IA_64_ANSI_COMMON
7181 && elf_header
.e_machine
== EM_IA_64
7182 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7184 else if (elf_header
.e_machine
== EM_X86_64
7185 && type
== SHN_X86_64_LCOMMON
)
7187 else if (type
== SHN_MIPS_SCOMMON
7188 && elf_header
.e_machine
== EM_MIPS
)
7190 else if (type
== SHN_MIPS_SUNDEFINED
7191 && elf_header
.e_machine
== EM_MIPS
)
7193 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7194 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7195 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7196 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7197 else if (type
>= SHN_LORESERVE
)
7198 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7200 sprintf (buff
, "%3d", type
);
7208 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7210 unsigned char *e_data
;
7213 e_data
= cmalloc (number
, ent_size
);
7217 error (_("Out of memory\n"));
7221 if (fread (e_data
, ent_size
, number
, file
) != number
)
7223 error (_("Unable to read in dynamic data\n"));
7227 i_data
= cmalloc (number
, sizeof (*i_data
));
7231 error (_("Out of memory\n"));
7237 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7245 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7247 Elf_Internal_Sym
*psym
;
7250 psym
= dynamic_symbols
+ si
;
7252 n
= print_vma (si
, DEC_5
);
7254 fputs (" " + n
, stdout
);
7255 printf (" %3lu: ", hn
);
7256 print_vma (psym
->st_value
, LONG_HEX
);
7258 print_vma (psym
->st_size
, DEC_5
);
7260 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7261 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7262 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7263 /* Check to see if any other bits in the st_other field are set.
7264 Note - displaying this information disrupts the layout of the
7265 table being generated, but for the moment this case is very
7267 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7268 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7269 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7270 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7271 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7273 printf (" <corrupt: %14ld>", psym
->st_name
);
7277 /* Dump the symbol table. */
7279 process_symbol_table (FILE *file
)
7281 Elf_Internal_Shdr
*section
;
7282 bfd_vma nbuckets
= 0;
7283 bfd_vma nchains
= 0;
7284 bfd_vma
*buckets
= NULL
;
7285 bfd_vma
*chains
= NULL
;
7286 bfd_vma ngnubuckets
= 0;
7287 bfd_vma
*gnubuckets
= NULL
;
7288 bfd_vma
*gnuchains
= NULL
;
7289 bfd_vma gnusymidx
= 0;
7291 if (! do_syms
&& !do_histogram
)
7294 if (dynamic_info
[DT_HASH
]
7296 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7298 unsigned char nb
[8];
7299 unsigned char nc
[8];
7300 int hash_ent_size
= 4;
7302 if ((elf_header
.e_machine
== EM_ALPHA
7303 || elf_header
.e_machine
== EM_S390
7304 || elf_header
.e_machine
== EM_S390_OLD
)
7305 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7309 (archive_file_offset
7310 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7311 sizeof nb
+ sizeof nc
)),
7314 error (_("Unable to seek to start of dynamic information\n"));
7318 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7320 error (_("Failed to read in number of buckets\n"));
7324 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7326 error (_("Failed to read in number of chains\n"));
7330 nbuckets
= byte_get (nb
, hash_ent_size
);
7331 nchains
= byte_get (nc
, hash_ent_size
);
7333 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7334 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7336 if (buckets
== NULL
|| chains
== NULL
)
7340 if (dynamic_info_DT_GNU_HASH
7342 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7344 unsigned char nb
[16];
7345 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7346 bfd_vma buckets_vma
;
7349 (archive_file_offset
7350 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7354 error (_("Unable to seek to start of dynamic information\n"));
7358 if (fread (nb
, 16, 1, file
) != 1)
7360 error (_("Failed to read in number of buckets\n"));
7364 ngnubuckets
= byte_get (nb
, 4);
7365 gnusymidx
= byte_get (nb
+ 4, 4);
7366 bitmaskwords
= byte_get (nb
+ 8, 4);
7367 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7369 buckets_vma
+= bitmaskwords
* 4;
7371 buckets_vma
+= bitmaskwords
* 8;
7374 (archive_file_offset
7375 + offset_from_vma (file
, buckets_vma
, 4)),
7378 error (_("Unable to seek to start of dynamic information\n"));
7382 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7384 if (gnubuckets
== NULL
)
7387 for (i
= 0; i
< ngnubuckets
; i
++)
7388 if (gnubuckets
[i
] != 0)
7390 if (gnubuckets
[i
] < gnusymidx
)
7393 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7394 maxchain
= gnubuckets
[i
];
7397 if (maxchain
== 0xffffffff)
7400 maxchain
-= gnusymidx
;
7403 (archive_file_offset
7404 + offset_from_vma (file
, buckets_vma
7405 + 4 * (ngnubuckets
+ maxchain
), 4)),
7408 error (_("Unable to seek to start of dynamic information\n"));
7414 if (fread (nb
, 4, 1, file
) != 1)
7416 error (_("Failed to determine last chain length\n"));
7420 if (maxchain
+ 1 == 0)
7425 while ((byte_get (nb
, 4) & 1) == 0);
7428 (archive_file_offset
7429 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7432 error (_("Unable to seek to start of dynamic information\n"));
7436 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7438 if (gnuchains
== NULL
)
7442 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7445 && dynamic_strings
!= NULL
)
7449 if (dynamic_info
[DT_HASH
])
7453 printf (_("\nSymbol table for image:\n"));
7455 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7457 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7459 for (hn
= 0; hn
< nbuckets
; hn
++)
7464 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7465 print_dynamic_symbol (si
, hn
);
7469 if (dynamic_info_DT_GNU_HASH
)
7471 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7473 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7475 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7477 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7478 if (gnubuckets
[hn
] != 0)
7480 bfd_vma si
= gnubuckets
[hn
];
7481 bfd_vma off
= si
- gnusymidx
;
7485 print_dynamic_symbol (si
, hn
);
7488 while ((gnuchains
[off
++] & 1) == 0);
7492 else if (do_syms
&& !do_using_dynamic
)
7496 for (i
= 0, section
= section_headers
;
7497 i
< elf_header
.e_shnum
;
7501 char *strtab
= NULL
;
7502 unsigned long int strtab_size
= 0;
7503 Elf_Internal_Sym
*symtab
;
7504 Elf_Internal_Sym
*psym
;
7507 if ( section
->sh_type
!= SHT_SYMTAB
7508 && section
->sh_type
!= SHT_DYNSYM
)
7511 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7512 SECTION_NAME (section
),
7513 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7515 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7517 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7519 symtab
= GET_ELF_SYMBOLS (file
, section
);
7523 if (section
->sh_link
== elf_header
.e_shstrndx
)
7525 strtab
= string_table
;
7526 strtab_size
= string_table_length
;
7528 else if (section
->sh_link
< elf_header
.e_shnum
)
7530 Elf_Internal_Shdr
*string_sec
;
7532 string_sec
= section_headers
+ section
->sh_link
;
7534 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7535 1, string_sec
->sh_size
, _("string table"));
7536 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7539 for (si
= 0, psym
= symtab
;
7540 si
< section
->sh_size
/ section
->sh_entsize
;
7543 printf ("%6d: ", si
);
7544 print_vma (psym
->st_value
, LONG_HEX
);
7546 print_vma (psym
->st_size
, DEC_5
);
7547 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7548 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7549 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7550 /* Check to see if any other bits in the st_other field are set.
7551 Note - displaying this information disrupts the layout of the
7552 table being generated, but for the moment this case is very rare. */
7553 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7554 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7555 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7556 print_symbol (25, psym
->st_name
< strtab_size
7557 ? strtab
+ psym
->st_name
: "<corrupt>");
7559 if (section
->sh_type
== SHT_DYNSYM
&&
7560 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7562 unsigned char data
[2];
7563 unsigned short vers_data
;
7564 unsigned long offset
;
7568 offset
= offset_from_vma
7569 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7570 sizeof data
+ si
* sizeof (vers_data
));
7572 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7573 sizeof (data
), 1, _("version data"));
7575 vers_data
= byte_get (data
, 2);
7577 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7578 && section_headers
[psym
->st_shndx
].sh_type
7581 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7583 if ((vers_data
& 0x8000) || vers_data
> 1)
7585 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7586 && (is_nobits
|| ! check_def
))
7588 Elf_External_Verneed evn
;
7589 Elf_Internal_Verneed ivn
;
7590 Elf_Internal_Vernaux ivna
;
7592 /* We must test both. */
7593 offset
= offset_from_vma
7594 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7599 unsigned long vna_off
;
7601 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7604 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7605 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7607 vna_off
= offset
+ ivn
.vn_aux
;
7611 Elf_External_Vernaux evna
;
7613 get_data (&evna
, file
, vna_off
,
7615 _("version need aux (3)"));
7617 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7618 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7619 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7621 vna_off
+= ivna
.vna_next
;
7623 while (ivna
.vna_other
!= vers_data
7624 && ivna
.vna_next
!= 0);
7626 if (ivna
.vna_other
== vers_data
)
7629 offset
+= ivn
.vn_next
;
7631 while (ivn
.vn_next
!= 0);
7633 if (ivna
.vna_other
== vers_data
)
7636 ivna
.vna_name
< strtab_size
7637 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7641 else if (! is_nobits
)
7642 error (_("bad dynamic symbol\n"));
7649 if (vers_data
!= 0x8001
7650 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7652 Elf_Internal_Verdef ivd
;
7653 Elf_Internal_Verdaux ivda
;
7654 Elf_External_Verdaux evda
;
7655 unsigned long offset
;
7657 offset
= offset_from_vma
7659 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7660 sizeof (Elf_External_Verdef
));
7664 Elf_External_Verdef evd
;
7666 get_data (&evd
, file
, offset
, sizeof (evd
),
7667 1, _("version def"));
7669 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7670 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7671 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7673 offset
+= ivd
.vd_next
;
7675 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7676 && ivd
.vd_next
!= 0);
7678 offset
-= ivd
.vd_next
;
7679 offset
+= ivd
.vd_aux
;
7681 get_data (&evda
, file
, offset
, sizeof (evda
),
7682 1, _("version def aux"));
7684 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7686 if (psym
->st_name
!= ivda
.vda_name
)
7687 printf ((vers_data
& 0x8000)
7689 ivda
.vda_name
< strtab_size
7690 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7700 if (strtab
!= string_table
)
7706 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7708 if (do_histogram
&& buckets
!= NULL
)
7710 unsigned long *lengths
;
7711 unsigned long *counts
;
7714 unsigned long maxlength
= 0;
7715 unsigned long nzero_counts
= 0;
7716 unsigned long nsyms
= 0;
7718 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7719 (unsigned long) nbuckets
);
7720 printf (_(" Length Number %% of total Coverage\n"));
7722 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7723 if (lengths
== NULL
)
7725 error (_("Out of memory\n"));
7728 for (hn
= 0; hn
< nbuckets
; ++hn
)
7730 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7733 if (maxlength
< ++lengths
[hn
])
7738 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7741 error (_("Out of memory\n"));
7745 for (hn
= 0; hn
< nbuckets
; ++hn
)
7746 ++counts
[lengths
[hn
]];
7751 printf (" 0 %-10lu (%5.1f%%)\n",
7752 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7753 for (i
= 1; i
<= maxlength
; ++i
)
7755 nzero_counts
+= counts
[i
] * i
;
7756 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7757 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7758 (nzero_counts
* 100.0) / nsyms
);
7766 if (buckets
!= NULL
)
7772 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7774 unsigned long *lengths
;
7775 unsigned long *counts
;
7777 unsigned long maxlength
= 0;
7778 unsigned long nzero_counts
= 0;
7779 unsigned long nsyms
= 0;
7781 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7782 if (lengths
== NULL
)
7784 error (_("Out of memory\n"));
7788 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7789 (unsigned long) ngnubuckets
);
7790 printf (_(" Length Number %% of total Coverage\n"));
7792 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7793 if (gnubuckets
[hn
] != 0)
7795 bfd_vma off
, length
= 1;
7797 for (off
= gnubuckets
[hn
] - gnusymidx
;
7798 (gnuchains
[off
] & 1) == 0; ++off
)
7800 lengths
[hn
] = length
;
7801 if (length
> maxlength
)
7806 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7809 error (_("Out of memory\n"));
7813 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7814 ++counts
[lengths
[hn
]];
7816 if (ngnubuckets
> 0)
7819 printf (" 0 %-10lu (%5.1f%%)\n",
7820 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7821 for (j
= 1; j
<= maxlength
; ++j
)
7823 nzero_counts
+= counts
[j
] * j
;
7824 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7825 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7826 (nzero_counts
* 100.0) / nsyms
);
7840 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7844 if (dynamic_syminfo
== NULL
7846 /* No syminfo, this is ok. */
7849 /* There better should be a dynamic symbol section. */
7850 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7854 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7855 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7857 printf (_(" Num: Name BoundTo Flags\n"));
7858 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7860 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7862 printf ("%4d: ", i
);
7863 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7864 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7866 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7869 switch (dynamic_syminfo
[i
].si_boundto
)
7871 case SYMINFO_BT_SELF
:
7872 fputs ("SELF ", stdout
);
7874 case SYMINFO_BT_PARENT
:
7875 fputs ("PARENT ", stdout
);
7878 if (dynamic_syminfo
[i
].si_boundto
> 0
7879 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7880 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7882 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7886 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7890 if (flags
& SYMINFO_FLG_DIRECT
)
7892 if (flags
& SYMINFO_FLG_PASSTHRU
)
7893 printf (" PASSTHRU");
7894 if (flags
& SYMINFO_FLG_COPY
)
7896 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7897 printf (" LAZYLOAD");
7905 #ifdef SUPPORT_DISASSEMBLY
7907 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7909 printf (_("\nAssembly dump of section %s\n"),
7910 SECTION_NAME (section
));
7912 /* XXX -- to be done --- XXX */
7919 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7921 Elf_Internal_Shdr
*relsec
;
7922 bfd_size_type num_bytes
;
7927 char *name
= SECTION_NAME (section
);
7928 bfd_boolean some_strings_shown
;
7930 num_bytes
= section
->sh_size
;
7932 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7934 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7938 addr
= section
->sh_addr
;
7940 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7945 printf (_("\nString dump of section '%s':\n"), name
);
7947 /* If the section being dumped has relocations against it the user might
7948 be expecting these relocations to have been applied. Check for this
7949 case and issue a warning message in order to avoid confusion.
7950 FIXME: Maybe we ought to have an option that dumps a section with
7952 for (relsec
= section_headers
;
7953 relsec
< section_headers
+ elf_header
.e_shnum
;
7956 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7957 || relsec
->sh_info
>= elf_header
.e_shnum
7958 || section_headers
+ relsec
->sh_info
!= section
7959 || relsec
->sh_size
== 0
7960 || relsec
->sh_link
>= elf_header
.e_shnum
)
7963 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7968 end
= start
+ num_bytes
;
7969 some_strings_shown
= FALSE
;
7973 while (!ISPRINT (* data
))
7980 printf (" [%6tx] %s\n", data
- start
, data
);
7982 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7984 data
+= strlen (data
);
7985 some_strings_shown
= TRUE
;
7989 if (! some_strings_shown
)
7990 printf (_(" No strings found in this section."));
8000 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
8002 Elf_Internal_Shdr
*relsec
;
8003 bfd_size_type bytes
;
8005 unsigned char *data
;
8006 unsigned char *start
;
8008 bytes
= section
->sh_size
;
8010 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8012 printf (_("\nSection '%s' has no data to dump.\n"),
8013 SECTION_NAME (section
));
8017 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8019 addr
= section
->sh_addr
;
8021 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
8026 /* If the section being dumped has relocations against it the user might
8027 be expecting these relocations to have been applied. Check for this
8028 case and issue a warning message in order to avoid confusion.
8029 FIXME: Maybe we ought to have an option that dumps a section with
8031 for (relsec
= section_headers
;
8032 relsec
< section_headers
+ elf_header
.e_shnum
;
8035 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8036 || relsec
->sh_info
>= elf_header
.e_shnum
8037 || section_headers
+ relsec
->sh_info
!= section
8038 || relsec
->sh_size
== 0
8039 || relsec
->sh_link
>= elf_header
.e_shnum
)
8042 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8054 lbytes
= (bytes
> 16 ? 16 : bytes
);
8056 printf (" 0x%8.8lx ", (unsigned long) addr
);
8058 for (j
= 0; j
< 16; j
++)
8061 printf ("%2.2x", data
[j
]);
8069 for (j
= 0; j
< lbytes
; j
++)
8072 if (k
>= ' ' && k
< 0x7f)
8091 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8092 DWARF debug sections. This is a target specific test. Note - we do not
8093 go through the whole including-target-headers-multiple-times route, (as
8094 we have already done with <elf/h8.h>) because this would become very
8095 messy and even then this function would have to contain target specific
8096 information (the names of the relocs instead of their numeric values).
8097 FIXME: This is not the correct way to solve this problem. The proper way
8098 is to have target specific reloc sizing and typing functions created by
8099 the reloc-macros.h header, in the same way that it already creates the
8100 reloc naming functions. */
8103 is_32bit_abs_reloc (unsigned int reloc_type
)
8105 switch (elf_header
.e_machine
)
8109 return reloc_type
== 1; /* R_386_32. */
8111 return reloc_type
== 1; /* R_68K_32. */
8113 return reloc_type
== 1; /* R_860_32. */
8115 return reloc_type
== 1; /* XXX Is this right ? */
8117 return reloc_type
== 1; /* R_ARC_32. */
8119 return reloc_type
== 2; /* R_ARM_ABS32 */
8122 return reloc_type
== 1;
8124 return reloc_type
== 0x12; /* R_byte4_data. */
8126 return reloc_type
== 3; /* R_CRIS_32. */
8128 return reloc_type
== 3; /* R_CR16_NUM32. */
8130 return reloc_type
== 15; /* R_CRX_NUM32. */
8132 return reloc_type
== 1;
8133 case EM_CYGNUS_D10V
:
8135 return reloc_type
== 6; /* R_D10V_32. */
8136 case EM_CYGNUS_D30V
:
8138 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8140 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8141 case EM_CYGNUS_FR30
:
8143 return reloc_type
== 3; /* R_FR30_32. */
8147 return reloc_type
== 1; /* R_H8_DIR32. */
8149 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8152 return reloc_type
== 2; /* R_IP2K_32. */
8154 return reloc_type
== 2; /* R_IQ2000_32. */
8156 return reloc_type
== 3; /* R_M32C_32. */
8158 return reloc_type
== 34; /* R_M32R_32_RELA. */
8160 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8162 return reloc_type
== 4; /* R_MEP_32. */
8164 return reloc_type
== 2; /* R_MIPS_32. */
8166 return reloc_type
== 4; /* R_MMIX_32. */
8167 case EM_CYGNUS_MN10200
:
8169 return reloc_type
== 1; /* R_MN10200_32. */
8170 case EM_CYGNUS_MN10300
:
8172 return reloc_type
== 1; /* R_MN10300_32. */
8175 return reloc_type
== 1; /* R_MSP43_32. */
8177 return reloc_type
== 2; /* R_MT_32. */
8178 case EM_ALTERA_NIOS2
:
8180 return reloc_type
== 1; /* R_NIOS_32. */
8183 return reloc_type
== 1; /* R_OR32_32. */
8185 return reloc_type
== 1; /* R_PARISC_DIR32. */
8188 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8190 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8192 return reloc_type
== 1; /* R_PPC_ADDR32. */
8194 return reloc_type
== 1; /* R_I370_ADDR31. */
8197 return reloc_type
== 4; /* R_S390_32. */
8199 return reloc_type
== 8; /* R_SCORE_ABS32. */
8201 return reloc_type
== 1; /* R_SH_DIR32. */
8202 case EM_SPARC32PLUS
:
8205 return reloc_type
== 3 /* R_SPARC_32. */
8206 || reloc_type
== 23; /* R_SPARC_UA32. */
8208 return reloc_type
== 6; /* R_SPU_ADDR32 */
8209 case EM_CYGNUS_V850
:
8211 return reloc_type
== 6; /* R_V850_ABS32. */
8213 return reloc_type
== 1; /* R_VAX_32. */
8215 return reloc_type
== 10; /* R_X86_64_32. */
8217 return reloc_type
== 1; /* R_XSTROMY16_32. */
8220 return reloc_type
== 1; /* R_XTENSA_32. */
8223 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8224 elf_header
.e_machine
);
8229 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8230 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8233 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8235 switch (elf_header
.e_machine
)
8239 return reloc_type
== 2; /* R_386_PC32. */
8241 return reloc_type
== 4; /* R_68K_PC32. */
8243 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8245 return reloc_type
== 3; /* R_ARM_REL32 */
8247 return reloc_type
== 0; /* R_PARISC_NONE. *//* FIXME: This reloc is generated, but it may be a bug. */
8249 return reloc_type
== 26; /* R_PPC_REL32. */
8251 return reloc_type
== 26; /* R_PPC64_REL32. */
8254 return reloc_type
== 5; /* R_390_PC32. */
8256 return reloc_type
== 2; /* R_SH_REL32. */
8257 case EM_SPARC32PLUS
:
8260 return reloc_type
== 6; /* R_SPARC_DISP32. */
8262 return reloc_type
== 13; /* R_SPU_REL32. */
8264 return reloc_type
== 2; /* R_X86_64_PC32. */
8267 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8269 /* Do not abort or issue an error message here. Not all targets use
8270 pc-relative 32-bit relocs in their DWARF debug information and we
8271 have already tested for target coverage in is_32bit_abs_reloc. A
8272 more helpful warning message will be generated by
8273 debug_apply_relocations anyway, so just return. */
8278 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8279 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8282 is_64bit_abs_reloc (unsigned int reloc_type
)
8284 switch (elf_header
.e_machine
)
8287 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8289 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8291 return reloc_type
== 80; /* R_PARISC_DIR64. */
8293 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8294 case EM_SPARC32PLUS
:
8297 return reloc_type
== 54; /* R_SPARC_UA64. */
8299 return reloc_type
== 1; /* R_X86_64_64. */
8302 return reloc_type
== 22; /* R_S390_64 */
8308 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8309 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8312 is_16bit_abs_reloc (unsigned int reloc_type
)
8314 switch (elf_header
.e_machine
)
8318 return reloc_type
== 4; /* R_AVR_16. */
8319 case EM_CYGNUS_D10V
:
8321 return reloc_type
== 3; /* R_D10V_16. */
8325 return reloc_type
== R_H8_DIR16
;
8328 return reloc_type
== 1; /* R_IP2K_16. */
8330 return reloc_type
== 1; /* R_M32C_16 */
8333 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8334 case EM_ALTERA_NIOS2
:
8336 return reloc_type
== 9; /* R_NIOS_16. */
8342 /* Apply relocations to a debug section. */
8345 debug_apply_relocations (void *file
,
8346 Elf_Internal_Shdr
*section
,
8347 unsigned char *start
)
8349 Elf_Internal_Shdr
*relsec
;
8350 unsigned char *end
= start
+ section
->sh_size
;
8352 if (elf_header
.e_type
!= ET_REL
)
8355 /* Find the reloc section associated with the debug section. */
8356 for (relsec
= section_headers
;
8357 relsec
< section_headers
+ elf_header
.e_shnum
;
8360 bfd_boolean is_rela
;
8361 unsigned long num_relocs
;
8362 Elf_Internal_Rela
*relocs
, *rp
;
8363 Elf_Internal_Shdr
*symsec
;
8364 Elf_Internal_Sym
*symtab
;
8365 Elf_Internal_Sym
*sym
;
8367 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8368 || relsec
->sh_info
>= elf_header
.e_shnum
8369 || section_headers
+ relsec
->sh_info
!= section
8370 || relsec
->sh_size
== 0
8371 || relsec
->sh_link
>= elf_header
.e_shnum
)
8374 is_rela
= relsec
->sh_type
== SHT_RELA
;
8378 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8379 & relocs
, & num_relocs
))
8384 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8385 & relocs
, & num_relocs
))
8389 /* SH uses RELA but uses in place value instead of the addend field. */
8390 if (elf_header
.e_machine
== EM_SH
)
8393 symsec
= section_headers
+ relsec
->sh_link
;
8394 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8396 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8399 unsigned int reloc_type
;
8400 unsigned int reloc_size
;
8401 unsigned char * loc
;
8403 /* In MIPS little-endian objects, r_info isn't really a
8404 64-bit little-endian value: it has a 32-bit little-endian
8405 symbol index followed by four individual byte fields.
8406 Reorder INFO accordingly. */
8408 && elf_header
.e_machine
== EM_MIPS
8409 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
8410 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
8411 | ((rp
->r_info
>> 56) & 0xff)
8412 | ((rp
->r_info
>> 40) & 0xff00)
8413 | ((rp
->r_info
>> 24) & 0xff0000)
8414 | ((rp
->r_info
>> 8) & 0xff000000));
8416 reloc_type
= get_reloc_type (rp
->r_info
);
8418 if (is_32bit_abs_reloc (reloc_type
)
8419 || is_32bit_pcrel_reloc (reloc_type
))
8421 else if (is_64bit_abs_reloc (reloc_type
))
8423 else if (is_16bit_abs_reloc (reloc_type
))
8427 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8428 reloc_type
, SECTION_NAME (section
));
8432 loc
= start
+ rp
->r_offset
;
8433 if ((loc
+ reloc_size
) > end
)
8435 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8436 (unsigned long) rp
->r_offset
,
8437 SECTION_NAME (section
));
8441 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8443 /* If the reloc has a symbol associated with it,
8444 make sure that it is of an appropriate type. */
8446 && ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
8447 /* Relocations against symbols without type can happen.
8448 Gcc -feliminate-dwarf2-dups may generate symbols
8449 without type for debug info. */
8450 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8451 /* Relocations against object symbols can happen,
8452 eg when referencing a global array. For an
8453 example of this see the _clz.o binary in libgcc.a. */
8454 && ELF_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8456 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8457 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8458 (long int)(rp
- relocs
),
8459 SECTION_NAME (relsec
));
8463 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8465 if (is_32bit_pcrel_reloc (reloc_type
))
8466 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8469 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8479 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8481 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8482 Elf_Internal_Shdr
*sec
;
8485 /* If it is already loaded, do nothing. */
8486 if (section
->start
!= NULL
)
8489 /* Locate the debug section. */
8490 sec
= find_section (section
->name
);
8494 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8495 section
->address
= sec
->sh_addr
;
8496 section
->size
= sec
->sh_size
;
8497 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8500 if (debug_displays
[debug
].relocate
)
8501 debug_apply_relocations (file
, sec
, section
->start
);
8503 return section
->start
!= NULL
;
8507 free_debug_section (enum dwarf_section_display_enum debug
)
8509 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8511 if (section
->start
== NULL
)
8514 free ((char *) section
->start
);
8515 section
->start
= NULL
;
8516 section
->address
= 0;
8521 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8523 char *name
= SECTION_NAME (section
);
8524 bfd_size_type length
;
8526 enum dwarf_section_display_enum i
;
8528 length
= section
->sh_size
;
8531 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8535 if (const_strneq (name
, ".gnu.linkonce.wi."))
8536 name
= ".debug_info";
8538 /* See if we know how to display the contents of this section. */
8539 for (i
= 0; i
< max
; i
++)
8540 if (streq (debug_displays
[i
].section
.name
, name
))
8542 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8544 if (load_debug_section (i
, file
))
8546 result
&= debug_displays
[i
].display (sec
, file
);
8548 if (i
!= info
&& i
!= abbrev
)
8549 free_debug_section (i
);
8557 printf (_("Unrecognized debug section: %s\n"), name
);
8564 /* Set DUMP_SECTS for all sections where dumps were requested
8565 based on section name. */
8568 initialise_dumps_byname (void)
8570 struct dump_list_entry
*cur
;
8572 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8577 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8578 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8580 request_dump_bynumber (i
, cur
->type
);
8585 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8591 process_section_contents (FILE *file
)
8593 Elf_Internal_Shdr
*section
;
8599 initialise_dumps_byname ();
8601 for (i
= 0, section
= section_headers
;
8602 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8605 #ifdef SUPPORT_DISASSEMBLY
8606 if (dump_sects
[i
] & DISASS_DUMP
)
8607 disassemble_section (section
, file
);
8609 if (dump_sects
[i
] & HEX_DUMP
)
8610 dump_section_as_bytes (section
, file
);
8612 if (dump_sects
[i
] & DEBUG_DUMP
)
8613 display_debug_section (section
, file
);
8615 if (dump_sects
[i
] & STRING_DUMP
)
8616 dump_section_as_strings (section
, file
);
8619 /* Check to see if the user requested a
8620 dump of a section that does not exist. */
8621 while (i
++ < num_dump_sects
)
8623 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8627 process_mips_fpe_exception (int mask
)
8632 if (mask
& OEX_FPU_INEX
)
8633 fputs ("INEX", stdout
), first
= 0;
8634 if (mask
& OEX_FPU_UFLO
)
8635 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8636 if (mask
& OEX_FPU_OFLO
)
8637 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8638 if (mask
& OEX_FPU_DIV0
)
8639 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8640 if (mask
& OEX_FPU_INVAL
)
8641 printf ("%sINVAL", first
? "" : "|");
8644 fputs ("0", stdout
);
8647 /* ARM EABI attributes section. */
8652 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8655 } arm_attr_public_tag
;
8657 static const char *arm_attr_tag_CPU_arch
[] =
8658 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8660 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8661 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8662 {"No", "Thumb-1", "Thumb-2"};
8663 static const char *arm_attr_tag_VFP_arch
[] =
8664 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8665 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8666 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8667 static const char *arm_attr_tag_ABI_PCS_config
[] =
8668 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8669 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8670 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8671 {"V6", "SB", "TLS", "Unused"};
8672 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8673 {"Absolute", "PC-relative", "SB-relative", "None"};
8674 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8675 {"Absolute", "PC-relative", "None"};
8676 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8677 {"None", "direct", "GOT-indirect"};
8678 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8679 {"None", "??? 1", "2", "??? 3", "4"};
8680 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8681 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8682 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8683 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8684 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8685 {"Unused", "Finite", "RTABI", "IEEE 754"};
8686 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8687 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8688 {"No", "Yes, except leaf SP", "Yes"};
8689 static const char *arm_attr_tag_ABI_enum_size
[] =
8690 {"Unused", "small", "int", "forced to int"};
8691 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8692 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8693 static const char *arm_attr_tag_ABI_VFP_args
[] =
8694 {"AAPCS", "VFP registers", "custom"};
8695 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8696 {"AAPCS", "WMMX registers", "custom"};
8697 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8698 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8699 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8700 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8701 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8702 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8704 #define LOOKUP(id, name) \
8705 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8706 static arm_attr_public_tag arm_attr_public_tags
[] =
8708 {4, "CPU_raw_name", 1, NULL
},
8709 {5, "CPU_name", 1, NULL
},
8710 LOOKUP(6, CPU_arch
),
8711 {7, "CPU_arch_profile", 0, NULL
},
8712 LOOKUP(8, ARM_ISA_use
),
8713 LOOKUP(9, THUMB_ISA_use
),
8714 LOOKUP(10, VFP_arch
),
8715 LOOKUP(11, WMMX_arch
),
8716 LOOKUP(12, NEON_arch
),
8717 LOOKUP(13, ABI_PCS_config
),
8718 LOOKUP(14, ABI_PCS_R9_use
),
8719 LOOKUP(15, ABI_PCS_RW_data
),
8720 LOOKUP(16, ABI_PCS_RO_DATA
),
8721 LOOKUP(17, ABI_PCS_GOT_use
),
8722 LOOKUP(18, ABI_PCS_wchar_t
),
8723 LOOKUP(19, ABI_FP_rounding
),
8724 LOOKUP(20, ABI_FP_denormal
),
8725 LOOKUP(21, ABI_FP_exceptions
),
8726 LOOKUP(22, ABI_FP_user_exceptions
),
8727 LOOKUP(23, ABI_FP_number_model
),
8728 LOOKUP(24, ABI_align8_needed
),
8729 LOOKUP(25, ABI_align8_preserved
),
8730 LOOKUP(26, ABI_enum_size
),
8731 LOOKUP(27, ABI_HardFP_use
),
8732 LOOKUP(28, ABI_VFP_args
),
8733 LOOKUP(29, ABI_WMMX_args
),
8734 LOOKUP(30, ABI_optimization_goals
),
8735 LOOKUP(31, ABI_FP_optimization_goals
),
8736 {32, "compatibility", 0, NULL
}
8740 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8743 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8757 val
|= ((unsigned int)c
& 0x7f) << shift
;
8766 static unsigned char *
8767 display_arm_attribute (unsigned char *p
)
8772 arm_attr_public_tag
*attr
;
8776 tag
= read_uleb128 (p
, &len
);
8779 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8781 if (arm_attr_public_tags
[i
].tag
== tag
)
8783 attr
= &arm_attr_public_tags
[i
];
8790 printf (" Tag_%s: ", attr
->name
);
8796 case 7: /* Tag_CPU_arch_profile. */
8797 val
= read_uleb128 (p
, &len
);
8801 case 0: printf ("None\n"); break;
8802 case 'A': printf ("Application\n"); break;
8803 case 'R': printf ("Realtime\n"); break;
8804 case 'M': printf ("Microcontroller\n"); break;
8805 default: printf ("??? (%d)\n", val
); break;
8809 case 32: /* Tag_compatibility. */
8810 val
= read_uleb128 (p
, &len
);
8812 printf ("flag = %d, vendor = %s\n", val
, p
);
8813 p
+= strlen((char *)p
) + 1;
8827 assert (attr
->type
& 0x80);
8828 val
= read_uleb128 (p
, &len
);
8830 type
= attr
->type
& 0x7f;
8832 printf ("??? (%d)\n", val
);
8834 printf ("%s\n", attr
->table
[val
]);
8841 type
= 1; /* String. */
8843 type
= 2; /* uleb128. */
8844 printf (" Tag_unknown_%d: ", tag
);
8849 printf ("\"%s\"\n", p
);
8850 p
+= strlen((char *)p
) + 1;
8854 val
= read_uleb128 (p
, &len
);
8856 printf ("%d (0x%x)\n", val
, val
);
8862 static unsigned char *
8863 display_gnu_attribute (unsigned char * p
,
8864 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8871 tag
= read_uleb128 (p
, &len
);
8874 /* Tag_compatibility is the only generic GNU attribute defined at
8878 val
= read_uleb128 (p
, &len
);
8880 printf ("flag = %d, vendor = %s\n", val
, p
);
8881 p
+= strlen ((char *) p
) + 1;
8885 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8886 return display_proc_gnu_attribute (p
, tag
);
8889 type
= 1; /* String. */
8891 type
= 2; /* uleb128. */
8892 printf (" Tag_unknown_%d: ", tag
);
8896 printf ("\"%s\"\n", p
);
8897 p
+= strlen ((char *) p
) + 1;
8901 val
= read_uleb128 (p
, &len
);
8903 printf ("%d (0x%x)\n", val
, val
);
8909 static unsigned char *
8910 display_power_gnu_attribute (unsigned char *p
, int tag
)
8916 if (tag
== Tag_GNU_Power_ABI_FP
)
8918 val
= read_uleb128 (p
, &len
);
8920 printf (" Tag_GNU_Power_ABI_FP: ");
8925 printf ("Hard or soft float\n");
8928 printf ("Hard float\n");
8931 printf ("Soft float\n");
8934 printf ("??? (%d)\n", val
);
8940 if (tag
== Tag_GNU_Power_ABI_Vector
)
8942 val
= read_uleb128 (p
, &len
);
8944 printf (" Tag_GNU_Power_ABI_Vector: ");
8951 printf ("Generic\n");
8954 printf ("AltiVec\n");
8960 printf ("??? (%d)\n", val
);
8967 type
= 1; /* String. */
8969 type
= 2; /* uleb128. */
8970 printf (" Tag_unknown_%d: ", tag
);
8974 printf ("\"%s\"\n", p
);
8975 p
+= strlen ((char *) p
) + 1;
8979 val
= read_uleb128 (p
, &len
);
8981 printf ("%d (0x%x)\n", val
, val
);
8987 static unsigned char *
8988 display_mips_gnu_attribute (unsigned char *p
, int tag
)
8994 if (tag
== Tag_GNU_MIPS_ABI_FP
)
8996 val
= read_uleb128 (p
, &len
);
8998 printf (" Tag_GNU_MIPS_ABI_FP: ");
9003 printf ("Hard or soft float\n");
9006 printf ("Hard float (-mdouble-float)\n");
9009 printf ("Hard float (-msingle-float)\n");
9012 printf ("Soft float\n");
9015 printf ("64-bit float (-mips32r2 -mfp64)\n");
9018 printf ("??? (%d)\n", val
);
9025 type
= 1; /* String. */
9027 type
= 2; /* uleb128. */
9028 printf (" Tag_unknown_%d: ", tag
);
9032 printf ("\"%s\"\n", p
);
9033 p
+= strlen ((char *) p
) + 1;
9037 val
= read_uleb128 (p
, &len
);
9039 printf ("%d (0x%x)\n", val
, val
);
9046 process_attributes (FILE * file
,
9047 const char * public_name
,
9048 unsigned int proc_type
,
9049 unsigned char * (* display_pub_attribute
) (unsigned char *),
9050 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9052 Elf_Internal_Shdr
*sect
;
9053 unsigned char *contents
;
9056 bfd_vma section_len
;
9060 /* Find the section header so that we get the size. */
9061 for (i
= 0, sect
= section_headers
;
9062 i
< elf_header
.e_shnum
;
9065 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9068 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9070 if (contents
== NULL
)
9076 len
= sect
->sh_size
- 1;
9082 bfd_boolean public_section
;
9083 bfd_boolean gnu_section
;
9085 section_len
= byte_get (p
, 4);
9088 if (section_len
> len
)
9090 printf (_("ERROR: Bad section length (%d > %d)\n"),
9091 (int) section_len
, (int) len
);
9096 printf ("Attribute Section: %s\n", p
);
9098 if (public_name
&& streq ((char *) p
, public_name
))
9099 public_section
= TRUE
;
9101 public_section
= FALSE
;
9103 if (streq ((char *) p
, "gnu"))
9106 gnu_section
= FALSE
;
9108 namelen
= strlen ((char *) p
) + 1;
9110 section_len
-= namelen
+ 4;
9112 while (section_len
> 0)
9118 size
= byte_get (p
, 4);
9119 if (size
> section_len
)
9121 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9122 (int) size
, (int) section_len
);
9126 section_len
-= size
;
9133 printf ("File Attributes\n");
9136 printf ("Section Attributes:");
9139 printf ("Symbol Attributes:");
9145 val
= read_uleb128 (p
, &i
);
9149 printf (" %d", val
);
9154 printf ("Unknown tag: %d\n", tag
);
9155 public_section
= FALSE
;
9162 p
= display_pub_attribute (p
);
9164 else if (gnu_section
)
9167 p
= display_gnu_attribute (p
,
9168 display_proc_gnu_attribute
);
9172 /* ??? Do something sensible, like dump hex. */
9173 printf (" Unknown section contexts\n");
9180 printf (_("Unknown format '%c'\n"), *p
);
9188 process_arm_specific (FILE *file
)
9190 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9191 display_arm_attribute
, NULL
);
9195 process_power_specific (FILE *file
)
9197 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9198 display_power_gnu_attribute
);
9201 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9202 Print the Address, Access and Initial fields of an entry at VMA ADDR
9203 and return the VMA of the next entry. */
9206 print_mips_got_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9209 print_vma (addr
, LONG_HEX
);
9211 if (addr
< pltgot
+ 0xfff0)
9212 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9214 printf ("%10s", "");
9217 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9222 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9223 print_vma (entry
, LONG_HEX
);
9225 return addr
+ (is_32bit_elf
? 4 : 8);
9229 process_mips_specific (FILE *file
)
9231 Elf_Internal_Dyn
*entry
;
9232 size_t liblist_offset
= 0;
9233 size_t liblistno
= 0;
9234 size_t conflictsno
= 0;
9235 size_t options_offset
= 0;
9236 size_t conflicts_offset
= 0;
9238 bfd_vma local_gotno
= 0;
9240 bfd_vma symtabno
= 0;
9242 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9243 display_mips_gnu_attribute
);
9245 /* We have a lot of special sections. Thanks SGI! */
9246 if (dynamic_section
== NULL
)
9247 /* No information available. */
9250 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9251 switch (entry
->d_tag
)
9253 case DT_MIPS_LIBLIST
:
9255 = offset_from_vma (file
, entry
->d_un
.d_val
,
9256 liblistno
* sizeof (Elf32_External_Lib
));
9258 case DT_MIPS_LIBLISTNO
:
9259 liblistno
= entry
->d_un
.d_val
;
9261 case DT_MIPS_OPTIONS
:
9262 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9264 case DT_MIPS_CONFLICT
:
9266 = offset_from_vma (file
, entry
->d_un
.d_val
,
9267 conflictsno
* sizeof (Elf32_External_Conflict
));
9269 case DT_MIPS_CONFLICTNO
:
9270 conflictsno
= entry
->d_un
.d_val
;
9273 pltgot
= entry
->d_un
.d_val
;
9274 case DT_MIPS_LOCAL_GOTNO
:
9275 local_gotno
= entry
->d_un
.d_val
;
9277 case DT_MIPS_GOTSYM
:
9278 gotsym
= entry
->d_un
.d_val
;
9280 case DT_MIPS_SYMTABNO
:
9281 symtabno
= entry
->d_un
.d_val
;
9287 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9289 Elf32_External_Lib
*elib
;
9292 elib
= get_data (NULL
, file
, liblist_offset
,
9293 liblistno
, sizeof (Elf32_External_Lib
),
9297 printf ("\nSection '.liblist' contains %lu entries:\n",
9298 (unsigned long) liblistno
);
9299 fputs (" Library Time Stamp Checksum Version Flags\n",
9302 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9309 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9310 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9311 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9312 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9313 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9315 tmp
= gmtime (&time
);
9316 snprintf (timebuf
, sizeof (timebuf
),
9317 "%04u-%02u-%02uT%02u:%02u:%02u",
9318 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9319 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9321 printf ("%3lu: ", (unsigned long) cnt
);
9322 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9323 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9325 printf ("<corrupt: %9ld>", liblist
.l_name
);
9326 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9329 if (liblist
.l_flags
== 0)
9340 { " EXACT_MATCH", LL_EXACT_MATCH
},
9341 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9342 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9343 { " EXPORTS", LL_EXPORTS
},
9344 { " DELAY_LOAD", LL_DELAY_LOAD
},
9345 { " DELTA", LL_DELTA
}
9347 int flags
= liblist
.l_flags
;
9350 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9351 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9353 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9354 flags
^= l_flags_vals
[fcnt
].bit
;
9357 printf (" %#x", (unsigned int) flags
);
9367 if (options_offset
!= 0)
9369 Elf_External_Options
*eopt
;
9370 Elf_Internal_Shdr
*sect
= section_headers
;
9371 Elf_Internal_Options
*iopt
;
9372 Elf_Internal_Options
*option
;
9376 /* Find the section header so that we get the size. */
9377 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9380 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9384 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
9387 error (_("Out of memory\n"));
9394 while (offset
< sect
->sh_size
)
9396 Elf_External_Options
*eoption
;
9398 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9400 option
->kind
= BYTE_GET (eoption
->kind
);
9401 option
->size
= BYTE_GET (eoption
->size
);
9402 option
->section
= BYTE_GET (eoption
->section
);
9403 option
->info
= BYTE_GET (eoption
->info
);
9405 offset
+= option
->size
;
9411 printf (_("\nSection '%s' contains %d entries:\n"),
9412 SECTION_NAME (sect
), cnt
);
9420 switch (option
->kind
)
9423 /* This shouldn't happen. */
9424 printf (" NULL %d %lx", option
->section
, option
->info
);
9427 printf (" REGINFO ");
9428 if (elf_header
.e_machine
== EM_MIPS
)
9431 Elf32_External_RegInfo
*ereg
;
9432 Elf32_RegInfo reginfo
;
9434 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9435 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9436 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9437 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9438 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9439 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9440 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9442 printf ("GPR %08lx GP 0x%lx\n",
9444 (unsigned long) reginfo
.ri_gp_value
);
9445 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9446 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9447 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9452 Elf64_External_RegInfo
*ereg
;
9453 Elf64_Internal_RegInfo reginfo
;
9455 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9456 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9457 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9458 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9459 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9460 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9461 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9463 printf ("GPR %08lx GP 0x",
9464 reginfo
.ri_gprmask
);
9465 printf_vma (reginfo
.ri_gp_value
);
9468 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9469 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9470 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9474 case ODK_EXCEPTIONS
:
9475 fputs (" EXCEPTIONS fpe_min(", stdout
);
9476 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9477 fputs (") fpe_max(", stdout
);
9478 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9479 fputs (")", stdout
);
9481 if (option
->info
& OEX_PAGE0
)
9482 fputs (" PAGE0", stdout
);
9483 if (option
->info
& OEX_SMM
)
9484 fputs (" SMM", stdout
);
9485 if (option
->info
& OEX_FPDBUG
)
9486 fputs (" FPDBUG", stdout
);
9487 if (option
->info
& OEX_DISMISS
)
9488 fputs (" DISMISS", stdout
);
9491 fputs (" PAD ", stdout
);
9492 if (option
->info
& OPAD_PREFIX
)
9493 fputs (" PREFIX", stdout
);
9494 if (option
->info
& OPAD_POSTFIX
)
9495 fputs (" POSTFIX", stdout
);
9496 if (option
->info
& OPAD_SYMBOL
)
9497 fputs (" SYMBOL", stdout
);
9500 fputs (" HWPATCH ", stdout
);
9501 if (option
->info
& OHW_R4KEOP
)
9502 fputs (" R4KEOP", stdout
);
9503 if (option
->info
& OHW_R8KPFETCH
)
9504 fputs (" R8KPFETCH", stdout
);
9505 if (option
->info
& OHW_R5KEOP
)
9506 fputs (" R5KEOP", stdout
);
9507 if (option
->info
& OHW_R5KCVTL
)
9508 fputs (" R5KCVTL", stdout
);
9511 fputs (" FILL ", stdout
);
9512 /* XXX Print content of info word? */
9515 fputs (" TAGS ", stdout
);
9516 /* XXX Print content of info word? */
9519 fputs (" HWAND ", stdout
);
9520 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9521 fputs (" R4KEOP_CHECKED", stdout
);
9522 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9523 fputs (" R4KEOP_CLEAN", stdout
);
9526 fputs (" HWOR ", stdout
);
9527 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9528 fputs (" R4KEOP_CHECKED", stdout
);
9529 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9530 fputs (" R4KEOP_CLEAN", stdout
);
9533 printf (" GP_GROUP %#06lx self-contained %#06lx",
9534 option
->info
& OGP_GROUP
,
9535 (option
->info
& OGP_SELF
) >> 16);
9538 printf (" IDENT %#06lx self-contained %#06lx",
9539 option
->info
& OGP_GROUP
,
9540 (option
->info
& OGP_SELF
) >> 16);
9543 /* This shouldn't happen. */
9544 printf (" %3d ??? %d %lx",
9545 option
->kind
, option
->section
, option
->info
);
9549 len
= sizeof (*eopt
);
9550 while (len
< option
->size
)
9551 if (((char *) option
)[len
] >= ' '
9552 && ((char *) option
)[len
] < 0x7f)
9553 printf ("%c", ((char *) option
)[len
++]);
9555 printf ("\\%03o", ((char *) option
)[len
++]);
9557 fputs ("\n", stdout
);
9565 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9567 Elf32_Conflict
*iconf
;
9570 if (dynamic_symbols
== NULL
)
9572 error (_("conflict list found without a dynamic symbol table\n"));
9576 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9579 error (_("Out of memory\n"));
9585 Elf32_External_Conflict
*econf32
;
9587 econf32
= get_data (NULL
, file
, conflicts_offset
,
9588 conflictsno
, sizeof (*econf32
), _("conflict"));
9592 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9593 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9599 Elf64_External_Conflict
*econf64
;
9601 econf64
= get_data (NULL
, file
, conflicts_offset
,
9602 conflictsno
, sizeof (*econf64
), _("conflict"));
9606 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9607 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9612 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9613 (unsigned long) conflictsno
);
9614 puts (_(" Num: Index Value Name"));
9616 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9618 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9620 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9621 print_vma (psym
->st_value
, FULL_HEX
);
9623 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9624 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9626 printf ("<corrupt: %14ld>", psym
->st_name
);
9633 if (pltgot
!= 0 && local_gotno
!= 0)
9635 bfd_vma entry
, local_end
, global_end
;
9637 unsigned char *data
;
9641 addr_size
= (is_32bit_elf
? 4 : 8);
9642 local_end
= pltgot
+ local_gotno
* addr_size
;
9643 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9645 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9646 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9647 printf (_("\nPrimary GOT:\n"));
9648 printf (_(" Canonical gp value: "));
9649 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9652 printf (_(" Reserved entries:\n"));
9653 printf (_(" %*s %10s %*s Purpose\n"),
9654 addr_size
* 2, "Address", "Access",
9655 addr_size
* 2, "Initial");
9656 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9657 printf (" Lazy resolver\n");
9659 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9660 >> (addr_size
* 8 - 1)) != 0)
9662 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9663 printf (" Module pointer (GNU extension)\n");
9667 if (entry
< local_end
)
9669 printf (_(" Local entries:\n"));
9670 printf (_(" %*s %10s %*s\n"),
9671 addr_size
* 2, "Address", "Access",
9672 addr_size
* 2, "Initial");
9673 while (entry
< local_end
)
9675 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9681 if (gotsym
< symtabno
)
9685 printf (_(" Global entries:\n"));
9686 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9687 addr_size
* 2, "Address", "Access",
9688 addr_size
* 2, "Initial",
9689 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9690 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9691 for (i
= gotsym
; i
< symtabno
; i
++)
9693 Elf_Internal_Sym
*psym
;
9695 psym
= dynamic_symbols
+ i
;
9696 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9698 print_vma (psym
->st_value
, LONG_HEX
);
9699 printf (" %-7s %3s ",
9700 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9701 get_symbol_index_type (psym
->st_shndx
));
9702 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9703 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9705 printf ("<corrupt: %14ld>", psym
->st_name
);
9719 process_gnu_liblist (FILE *file
)
9721 Elf_Internal_Shdr
*section
, *string_sec
;
9722 Elf32_External_Lib
*elib
;
9731 for (i
= 0, section
= section_headers
;
9732 i
< elf_header
.e_shnum
;
9735 switch (section
->sh_type
)
9737 case SHT_GNU_LIBLIST
:
9738 if (section
->sh_link
>= elf_header
.e_shnum
)
9741 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9746 string_sec
= section_headers
+ section
->sh_link
;
9748 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9749 string_sec
->sh_size
, _("liblist string table"));
9750 strtab_size
= string_sec
->sh_size
;
9753 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9759 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9760 SECTION_NAME (section
),
9761 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9763 puts (" Library Time Stamp Checksum Version Flags");
9765 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9773 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9774 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9775 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9776 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9777 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9779 tmp
= gmtime (&time
);
9780 snprintf (timebuf
, sizeof (timebuf
),
9781 "%04u-%02u-%02uT%02u:%02u:%02u",
9782 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9783 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9785 printf ("%3lu: ", (unsigned long) cnt
);
9787 printf ("%-20s", liblist
.l_name
< strtab_size
9788 ? strtab
+ liblist
.l_name
: "<corrupt>");
9790 printf ("%-20.20s", liblist
.l_name
< strtab_size
9791 ? strtab
+ liblist
.l_name
: "<corrupt>");
9792 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9793 liblist
.l_version
, liblist
.l_flags
);
9804 get_note_type (unsigned e_type
)
9806 static char buff
[64];
9808 if (elf_header
.e_type
== ET_CORE
)
9812 return _("NT_AUXV (auxiliary vector)");
9814 return _("NT_PRSTATUS (prstatus structure)");
9816 return _("NT_FPREGSET (floating point registers)");
9818 return _("NT_PRPSINFO (prpsinfo structure)");
9820 return _("NT_TASKSTRUCT (task structure)");
9822 return _("NT_PRXFPREG (user_xfpregs structure)");
9824 return _("NT_PPC_VMX (ppc Altivec registers)");
9826 return _("NT_PSTATUS (pstatus structure)");
9828 return _("NT_FPREGS (floating point registers)");
9830 return _("NT_PSINFO (psinfo structure)");
9832 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9834 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9835 case NT_WIN32PSTATUS
:
9836 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9844 return _("NT_VERSION (version)");
9846 return _("NT_ARCH (architecture)");
9851 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9856 get_gnu_elf_note_type (unsigned e_type
)
9858 static char buff
[64];
9862 case NT_GNU_ABI_TAG
:
9863 return _("NT_GNU_ABI_TAG (ABI version tag)");
9865 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9866 case NT_GNU_BUILD_ID
:
9867 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9868 case NT_GNU_GOLD_VERSION
:
9869 return _("NT_GNU_GOLD_VERSION (gold version)");
9874 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9879 get_netbsd_elfcore_note_type (unsigned e_type
)
9881 static char buff
[64];
9883 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9885 /* NetBSD core "procinfo" structure. */
9886 return _("NetBSD procinfo structure");
9889 /* As of Jan 2002 there are no other machine-independent notes
9890 defined for NetBSD core files. If the note type is less
9891 than the start of the machine-dependent note types, we don't
9894 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9896 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9900 switch (elf_header
.e_machine
)
9902 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9903 and PT_GETFPREGS == mach+2. */
9908 case EM_SPARC32PLUS
:
9912 case NT_NETBSDCORE_FIRSTMACH
+0:
9913 return _("PT_GETREGS (reg structure)");
9914 case NT_NETBSDCORE_FIRSTMACH
+2:
9915 return _("PT_GETFPREGS (fpreg structure)");
9921 /* On all other arch's, PT_GETREGS == mach+1 and
9922 PT_GETFPREGS == mach+3. */
9926 case NT_NETBSDCORE_FIRSTMACH
+1:
9927 return _("PT_GETREGS (reg structure)");
9928 case NT_NETBSDCORE_FIRSTMACH
+3:
9929 return _("PT_GETFPREGS (fpreg structure)");
9935 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
9936 e_type
- NT_NETBSDCORE_FIRSTMACH
);
9940 /* Note that by the ELF standard, the name field is already null byte
9941 terminated, and namesz includes the terminating null byte.
9942 I.E. the value of namesz for the name "FSF" is 4.
9944 If the value of namesz is zero, there is no name present. */
9946 process_note (Elf_Internal_Note
*pnote
)
9948 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
9951 if (pnote
->namesz
== 0)
9952 /* If there is no note name, then use the default set of
9953 note type strings. */
9954 nt
= get_note_type (pnote
->type
);
9956 else if (const_strneq (pnote
->namedata
, "GNU"))
9957 /* GNU-specific object file notes. */
9958 nt
= get_gnu_elf_note_type (pnote
->type
);
9960 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
9961 /* NetBSD-specific core file notes. */
9962 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9964 else if (strneq (pnote
->namedata
, "SPU/", 4))
9966 /* SPU-specific core file notes. */
9967 nt
= pnote
->namedata
+ 4;
9972 /* Don't recognize this note name; just use the default set of
9973 note type strings. */
9974 nt
= get_note_type (pnote
->type
);
9976 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
9982 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
9984 Elf_External_Note
*pnotes
;
9985 Elf_External_Note
*external
;
9991 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
9997 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9998 (unsigned long) offset
, (unsigned long) length
);
9999 printf (_(" Owner\t\tData size\tDescription\n"));
10001 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10003 Elf_External_Note
*next
;
10004 Elf_Internal_Note inote
;
10007 inote
.type
= BYTE_GET (external
->type
);
10008 inote
.namesz
= BYTE_GET (external
->namesz
);
10009 inote
.namedata
= external
->name
;
10010 inote
.descsz
= BYTE_GET (external
->descsz
);
10011 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10012 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10014 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10016 if (((char *) next
) > (((char *) pnotes
) + length
))
10018 warn (_("corrupt note found at offset %lx into core notes\n"),
10019 (long)((char *)external
- (char *)pnotes
));
10020 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10021 inote
.type
, inote
.namesz
, inote
.descsz
);
10027 /* Verify that name is null terminated. It appears that at least
10028 one version of Linux (RedHat 6.0) generates corefiles that don't
10029 comply with the ELF spec by failing to include the null byte in
10031 if (inote
.namedata
[inote
.namesz
] != '\0')
10033 temp
= malloc (inote
.namesz
+ 1);
10037 error (_("Out of memory\n"));
10042 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10043 temp
[inote
.namesz
] = 0;
10045 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10046 inote
.namedata
= temp
;
10049 res
&= process_note (& inote
);
10064 process_corefile_note_segments (FILE *file
)
10066 Elf_Internal_Phdr
*segment
;
10070 if (! get_program_headers (file
))
10073 for (i
= 0, segment
= program_headers
;
10074 i
< elf_header
.e_phnum
;
10077 if (segment
->p_type
== PT_NOTE
)
10078 res
&= process_corefile_note_segment (file
,
10079 (bfd_vma
) segment
->p_offset
,
10080 (bfd_vma
) segment
->p_filesz
);
10087 process_note_sections (FILE *file
)
10089 Elf_Internal_Shdr
*section
;
10093 for (i
= 0, section
= section_headers
;
10094 i
< elf_header
.e_shnum
;
10096 if (section
->sh_type
== SHT_NOTE
)
10097 res
&= process_corefile_note_segment (file
,
10098 (bfd_vma
) section
->sh_offset
,
10099 (bfd_vma
) section
->sh_size
);
10105 process_notes (FILE *file
)
10107 /* If we have not been asked to display the notes then do nothing. */
10111 if (elf_header
.e_type
!= ET_CORE
)
10112 return process_note_sections (file
);
10114 /* No program headers means no NOTE segment. */
10115 if (elf_header
.e_phnum
> 0)
10116 return process_corefile_note_segments (file
);
10118 printf (_("No note segments present in the core file.\n"));
10123 process_arch_specific (FILE *file
)
10128 switch (elf_header
.e_machine
)
10131 return process_arm_specific (file
);
10133 case EM_MIPS_RS3_LE
:
10134 return process_mips_specific (file
);
10137 return process_power_specific (file
);
10146 get_file_header (FILE *file
)
10148 /* Read in the identity array. */
10149 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10152 /* Determine how to read the rest of the header. */
10153 switch (elf_header
.e_ident
[EI_DATA
])
10155 default: /* fall through */
10156 case ELFDATANONE
: /* fall through */
10158 byte_get
= byte_get_little_endian
;
10159 byte_put
= byte_put_little_endian
;
10162 byte_get
= byte_get_big_endian
;
10163 byte_put
= byte_put_big_endian
;
10167 /* For now we only support 32 bit and 64 bit ELF files. */
10168 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10170 /* Read in the rest of the header. */
10173 Elf32_External_Ehdr ehdr32
;
10175 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10178 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10179 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10180 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10181 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10182 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10183 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10184 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10185 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10186 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10187 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10188 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10189 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10190 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10194 Elf64_External_Ehdr ehdr64
;
10196 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10197 we will not be able to cope with the 64bit data found in
10198 64 ELF files. Detect this now and abort before we start
10199 overwriting things. */
10200 if (sizeof (bfd_vma
) < 8)
10202 error (_("This instance of readelf has been built without support for a\n\
10203 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10207 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10210 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10211 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10212 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10213 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10214 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10215 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10216 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10217 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10218 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10219 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10220 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10221 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10222 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10225 if (elf_header
.e_shoff
)
10227 /* There may be some extensions in the first section header. Don't
10228 bomb if we can't read it. */
10230 get_32bit_section_headers (file
, 1);
10232 get_64bit_section_headers (file
, 1);
10238 /* Process one ELF object file according to the command line options.
10239 This file may actually be stored in an archive. The file is
10240 positioned at the start of the ELF object. */
10243 process_object (char *file_name
, FILE *file
)
10247 if (! get_file_header (file
))
10249 error (_("%s: Failed to read file header\n"), file_name
);
10253 /* Initialise per file variables. */
10254 for (i
= ARRAY_SIZE (version_info
); i
--;)
10255 version_info
[i
] = 0;
10257 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10258 dynamic_info
[i
] = 0;
10260 /* Process the file. */
10262 printf (_("\nFile: %s\n"), file_name
);
10264 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10265 Note we do this even if cmdline_dump_sects is empty because we
10266 must make sure that the dump_sets array is zeroed out before each
10267 object file is processed. */
10268 if (num_dump_sects
> num_cmdline_dump_sects
)
10269 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10271 if (num_cmdline_dump_sects
> 0)
10273 if (num_dump_sects
== 0)
10274 /* A sneaky way of allocating the dump_sects array. */
10275 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10277 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10278 memcpy (dump_sects
, cmdline_dump_sects
,
10279 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10282 if (! process_file_header ())
10285 if (! process_section_headers (file
))
10287 /* Without loaded section headers we cannot process lots of
10289 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10291 if (! do_using_dynamic
)
10292 do_syms
= do_reloc
= 0;
10295 if (! process_section_groups (file
))
10297 /* Without loaded section groups we cannot process unwind. */
10301 if (process_program_headers (file
))
10302 process_dynamic_section (file
);
10304 process_relocs (file
);
10306 process_unwind (file
);
10308 process_symbol_table (file
);
10310 process_syminfo (file
);
10312 process_version_sections (file
);
10314 process_section_contents (file
);
10316 process_notes (file
);
10318 process_gnu_liblist (file
);
10320 process_arch_specific (file
);
10322 if (program_headers
)
10324 free (program_headers
);
10325 program_headers
= NULL
;
10328 if (section_headers
)
10330 free (section_headers
);
10331 section_headers
= NULL
;
10336 free (string_table
);
10337 string_table
= NULL
;
10338 string_table_length
= 0;
10341 if (dynamic_strings
)
10343 free (dynamic_strings
);
10344 dynamic_strings
= NULL
;
10345 dynamic_strings_length
= 0;
10348 if (dynamic_symbols
)
10350 free (dynamic_symbols
);
10351 dynamic_symbols
= NULL
;
10352 num_dynamic_syms
= 0;
10355 if (dynamic_syminfo
)
10357 free (dynamic_syminfo
);
10358 dynamic_syminfo
= NULL
;
10361 if (section_headers_groups
)
10363 free (section_headers_groups
);
10364 section_headers_groups
= NULL
;
10367 if (section_groups
)
10369 struct group_list
*g
, *next
;
10371 for (i
= 0; i
< group_count
; i
++)
10373 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10380 free (section_groups
);
10381 section_groups
= NULL
;
10384 free_debug_memory ();
10389 /* Process an ELF archive.
10390 On entry the file is positioned just after the ARMAG string. */
10393 process_archive (char *file_name
, FILE *file
)
10395 struct ar_hdr arhdr
;
10397 unsigned long size
;
10398 unsigned long index_num
= 0;
10399 unsigned long *index_array
= NULL
;
10400 char *sym_table
= NULL
;
10401 unsigned long sym_size
= 0;
10402 char *longnames
= NULL
;
10403 unsigned long longnames_size
= 0;
10404 size_t file_name_size
;
10409 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10410 if (got
!= sizeof arhdr
)
10415 error (_("%s: failed to read archive header\n"), file_name
);
10419 /* See if this is the archive symbol table. */
10420 if (const_strneq (arhdr
.ar_name
, "/ ")
10421 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
10423 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10424 size
= size
+ (size
& 1);
10426 if (do_archive_index
)
10429 /* A buffer used to hold numbers read in from an archive index.
10430 These are always 4 bytes long and stored in big-endian format. */
10431 #define SIZEOF_AR_INDEX_NUMBERS 4
10432 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10433 unsigned char * index_buffer
;
10435 /* Check the size of the archive index. */
10436 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10438 error (_("%s: the archive index is empty\n"), file_name
);
10442 /* Read the numer of entries in the archive index. */
10443 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10444 if (got
!= sizeof (integer_buffer
))
10446 error (_("%s: failed to read archive index\n"), file_name
);
10449 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10450 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10452 /* Read in the archive index. */
10453 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10455 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10456 file_name
, index_num
);
10459 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10460 if (index_buffer
== NULL
)
10462 error (_("Out of memory whilst trying to read archive symbol index\n"));
10465 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
10466 if (got
!= index_num
)
10468 free (index_buffer
);
10469 error (_("%s: failed to read archive index\n"), file_name
);
10473 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10475 /* Convert the index numbers into the host's numeric format. */
10476 index_array
= malloc (index_num
* sizeof (* index_array
));
10477 if (index_array
== NULL
)
10479 free (index_buffer
);
10480 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10484 for (i
= 0; i
< index_num
; i
++)
10485 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10486 SIZEOF_AR_INDEX_NUMBERS
);
10487 free (index_buffer
);
10489 /* The remaining space in the header is taken up by the symbol table. */
10492 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10496 sym_table
= malloc (size
);
10498 if (sym_table
== NULL
)
10500 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10504 got
= fread (sym_table
, 1, size
, file
);
10507 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10514 if (fseek (file
, size
, SEEK_CUR
) != 0)
10516 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10521 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10522 if (got
!= sizeof arhdr
)
10530 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10535 else if (do_archive_index
)
10536 printf (_("%s has no archive index\n"), file_name
);
10538 if (const_strneq (arhdr
.ar_name
, "// "))
10540 /* This is the archive string table holding long member
10543 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10544 longnames
= malloc (longnames_size
);
10545 if (longnames
== NULL
)
10547 error (_("Out of memory reading long symbol names in archive\n"));
10552 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10555 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10560 if ((longnames_size
& 1) != 0)
10563 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10564 if (got
!= sizeof arhdr
)
10570 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10577 if (do_archive_index
)
10579 if (sym_table
== NULL
)
10580 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10583 unsigned int i
, j
, k
, l
;
10585 unsigned long current_pos
;
10587 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10588 file_name
, index_num
, sym_size
);
10589 current_pos
= ftell (file
);
10591 for (i
= l
= 0; i
< index_num
; i
++)
10593 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10595 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10597 error (_("%s: failed to seek to next file name\n"), file_name
);
10601 got
= fread (elf_name
, 1, 16, file
);
10604 error (_("%s: failed to read file name\n"), file_name
);
10609 if (elf_name
[0] == '/')
10611 /* We have a long name. */
10612 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10613 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10615 longnames
[j
] = '\0';
10616 printf (_("Binary %s contains:\n"), longnames
+ k
);
10617 longnames
[j
] = '/';
10622 while ((elf_name
[j
] != '/') && (j
< 16))
10624 elf_name
[j
] = '\0';
10625 printf(_("Binary %s contains:\n"), elf_name
);
10630 error (_("%s: end of the symbol table reached before the end of the index\n"),
10634 printf ("\t%s\n", sym_table
+ l
);
10635 l
+= strlen (sym_table
+ l
) + 1;
10639 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10642 free (index_array
);
10643 index_array
= NULL
;
10646 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10648 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10653 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10654 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10655 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10656 && !do_section_groups
)
10657 return 0; /* Archive index only. */
10660 file_name_size
= strlen (file_name
);
10669 if (arhdr
.ar_name
[0] == '/')
10673 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10674 if (off
>= longnames_size
)
10676 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10681 name
= longnames
+ off
;
10682 nameend
= memchr (name
, '/', longnames_size
- off
);
10686 name
= arhdr
.ar_name
;
10687 nameend
= memchr (name
, '/', 16);
10690 if (nameend
== NULL
)
10692 error (_("%s: bad archive file name\n"), file_name
);
10697 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10698 if (namealc
== NULL
)
10700 error (_("Out of memory\n"));
10705 memcpy (namealc
, file_name
, file_name_size
);
10706 namealc
[file_name_size
] = '(';
10707 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10708 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10709 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10711 archive_file_offset
= ftell (file
);
10712 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10714 ret
|= process_object (namealc
, file
);
10719 (archive_file_offset
10720 + archive_file_size
10721 + (archive_file_size
& 1)),
10724 error (_("%s: failed to seek to next archive header\n"), file_name
);
10729 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10730 if (got
!= sizeof arhdr
)
10735 error (_("%s: failed to read archive header\n"), file_name
);
10742 if (index_array
!= NULL
)
10743 free (index_array
);
10744 if (sym_table
!= NULL
)
10746 if (longnames
!= NULL
)
10753 process_file (char *file_name
)
10756 struct stat statbuf
;
10757 char armag
[SARMAG
];
10760 if (stat (file_name
, &statbuf
) < 0)
10762 if (errno
== ENOENT
)
10763 error (_("'%s': No such file\n"), file_name
);
10765 error (_("Could not locate '%s'. System error message: %s\n"),
10766 file_name
, strerror (errno
));
10770 if (! S_ISREG (statbuf
.st_mode
))
10772 error (_("'%s' is not an ordinary file\n"), file_name
);
10776 file
= fopen (file_name
, "rb");
10779 error (_("Input file '%s' is not readable.\n"), file_name
);
10783 if (fread (armag
, SARMAG
, 1, file
) != 1)
10785 error (_("%s: Failed to read file's magic number\n"), file_name
);
10790 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10791 ret
= process_archive (file_name
, file
);
10794 if (do_archive_index
)
10795 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10799 archive_file_size
= archive_file_offset
= 0;
10800 ret
= process_object (file_name
, file
);
10808 #ifdef SUPPORT_DISASSEMBLY
10809 /* Needed by the i386 disassembler. For extra credit, someone could
10810 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10814 print_address (unsigned int addr
, FILE *outfile
)
10816 fprintf (outfile
,"0x%8.8x", addr
);
10819 /* Needed by the i386 disassembler. */
10821 db_task_printsym (unsigned int addr
)
10823 print_address (addr
, stderr
);
10828 main (int argc
, char **argv
)
10832 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10833 setlocale (LC_MESSAGES
, "");
10835 #if defined (HAVE_SETLOCALE)
10836 setlocale (LC_CTYPE
, "");
10838 bindtextdomain (PACKAGE
, LOCALEDIR
);
10839 textdomain (PACKAGE
);
10841 expandargv (&argc
, &argv
);
10843 parse_args (argc
, argv
);
10845 if (num_dump_sects
> 0)
10847 /* Make a copy of the dump_sects array. */
10848 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10849 if (cmdline_dump_sects
== NULL
)
10850 error (_("Out of memory allocating dump request table.\n"));
10853 memcpy (cmdline_dump_sects
, dump_sects
,
10854 num_dump_sects
* sizeof (* dump_sects
));
10855 num_cmdline_dump_sects
= num_dump_sects
;
10859 if (optind
< (argc
- 1))
10863 while (optind
< argc
)
10864 err
|= process_file (argv
[optind
++]);
10866 if (dump_sects
!= NULL
)
10868 if (cmdline_dump_sects
!= NULL
)
10869 free (cmdline_dump_sects
);