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. */
60 # ifdef HAVE_SYS_PARAM_H
61 # include <sys/param.h>
65 # define PATH_MAX MAXPATHLEN
67 # define PATH_MAX 1024
73 /* Define BFD64 here, even if our default architecture is 32 bit ELF
74 as this will allow us to read in and parse 64bit and 32bit ELF files.
75 Only do this if we believe that the compiler can support a 64 bit
76 data type. For now we only rely on GCC being able to do this. */
84 #include "elf/common.h"
85 #include "elf/external.h"
86 #include "elf/internal.h"
89 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
90 we can obtain the H8 reloc numbers. We need these for the
91 get_reloc_size() function. We include h8.h again after defining
92 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
97 /* Undo the effects of #including reloc-macros.h. */
99 #undef START_RELOC_NUMBERS
103 #undef END_RELOC_NUMBERS
104 #undef _RELOC_MACROS_H
106 /* The following headers use the elf/reloc-macros.h file to
107 automatically generate relocation recognition functions
108 such as elf_mips_reloc_type() */
110 #define RELOC_MACROS_GEN_FUNC
112 #include "elf/alpha.h"
116 #include "elf/bfin.h"
117 #include "elf/cr16.h"
118 #include "elf/cris.h"
120 #include "elf/d10v.h"
121 #include "elf/d30v.h"
123 #include "elf/fr30.h"
126 #include "elf/hppa.h"
127 #include "elf/i386.h"
128 #include "elf/i370.h"
129 #include "elf/i860.h"
130 #include "elf/i960.h"
131 #include "elf/ia64.h"
132 #include "elf/ip2k.h"
133 #include "elf/iq2000.h"
134 #include "elf/m32c.h"
135 #include "elf/m32r.h"
136 #include "elf/m68k.h"
137 #include "elf/m68hc11.h"
138 #include "elf/mcore.h"
140 #include "elf/mips.h"
141 #include "elf/mmix.h"
142 #include "elf/mn10200.h"
143 #include "elf/mn10300.h"
145 #include "elf/msp430.h"
146 #include "elf/or32.h"
149 #include "elf/ppc64.h"
150 #include "elf/s390.h"
151 #include "elf/score.h"
153 #include "elf/sparc.h"
155 #include "elf/v850.h"
157 #include "elf/x86-64.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
164 #include "libiberty.h"
165 #include "safe-ctype.h"
167 char *program_name
= "readelf";
169 static long archive_file_offset
;
170 static unsigned long archive_file_size
;
171 static unsigned long dynamic_addr
;
172 static bfd_size_type dynamic_size
;
173 static unsigned int dynamic_nent
;
174 static char *dynamic_strings
;
175 static unsigned long dynamic_strings_length
;
176 static char *string_table
;
177 static unsigned long string_table_length
;
178 static unsigned long num_dynamic_syms
;
179 static Elf_Internal_Sym
*dynamic_symbols
;
180 static Elf_Internal_Syminfo
*dynamic_syminfo
;
181 static unsigned long dynamic_syminfo_offset
;
182 static unsigned int dynamic_syminfo_nent
;
183 static char program_interpreter
[PATH_MAX
];
184 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
185 static bfd_vma dynamic_info_DT_GNU_HASH
;
186 static bfd_vma version_info
[16];
187 static Elf_Internal_Ehdr elf_header
;
188 static Elf_Internal_Shdr
*section_headers
;
189 static Elf_Internal_Phdr
*program_headers
;
190 static Elf_Internal_Dyn
*dynamic_section
;
191 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
192 static int show_name
;
193 static int do_dynamic
;
196 static int do_sections
;
197 static int do_section_groups
;
198 static int do_section_details
;
199 static int do_segments
;
200 static int do_unwind
;
201 static int do_using_dynamic
;
202 static int do_header
;
204 static int do_version
;
205 static int do_histogram
;
206 static int do_debugging
;
209 static int do_archive_index
;
210 static int is_32bit_elf
;
214 struct group_list
*next
;
215 unsigned int section_index
;
220 struct group_list
*root
;
221 unsigned int group_index
;
224 static size_t group_count
;
225 static struct group
*section_groups
;
226 static struct group
**section_headers_groups
;
229 /* Flag bits indicating particular types of dump. */
230 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
231 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
232 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
233 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
235 typedef unsigned char dump_type
;
237 /* A linked list of the section names for which dumps were requested. */
238 struct dump_list_entry
242 struct dump_list_entry
*next
;
244 static struct dump_list_entry
*dump_sects_byname
;
246 /* A dynamic array of flags indicating for which sections a dump
247 has been requested via command line switches. */
248 static dump_type
* cmdline_dump_sects
= NULL
;
249 static unsigned int num_cmdline_dump_sects
= 0;
251 /* A dynamic array of flags indicating for which sections a dump of
252 some kind has been requested. It is reset on a per-object file
253 basis and then initialised from the cmdline_dump_sects array,
254 the results of interpreting the -w switch, and the
255 dump_sects_byname list. */
256 static dump_type
* dump_sects
= NULL
;
257 static unsigned int num_dump_sects
= 0;
260 /* How to print a vma value. */
261 typedef enum print_mode
273 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
277 #define SECTION_NAME(X) \
278 ((X) == NULL ? "<none>" \
279 : string_table == NULL ? "<no-name>" \
280 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
281 : string_table + (X)->sh_name))
283 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
285 #define BYTE_GET(field) byte_get (field, sizeof (field))
287 #define GET_ELF_SYMBOLS(file, section) \
288 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
289 : get_64bit_elf_symbols (file, section))
291 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
292 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
293 already been called and verified that the string exists. */
294 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
296 /* This is just a bit of syntatic sugar. */
297 #define streq(a,b) (strcmp ((a), (b)) == 0)
298 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
299 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
302 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
307 if (size
== 0 || nmemb
== 0)
310 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
312 error (_("Unable to seek to 0x%lx for %s\n"),
313 (unsigned long) archive_file_offset
+ offset
, reason
);
320 /* Check for overflow. */
321 if (nmemb
< (~(size_t) 0 - 1) / size
)
322 /* + 1 so that we can '\0' terminate invalid string table sections. */
323 mvar
= malloc (size
* nmemb
+ 1);
327 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
328 (unsigned long)(size
* nmemb
), reason
);
332 ((char *) mvar
)[size
* nmemb
] = '\0';
335 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
337 error (_("Unable to read in 0x%lx bytes of %s\n"),
338 (unsigned long)(size
* nmemb
), reason
);
348 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
353 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
354 field
[6] = ((value
>> 24) >> 24) & 0xff;
355 field
[5] = ((value
>> 24) >> 16) & 0xff;
356 field
[4] = ((value
>> 24) >> 8) & 0xff;
359 field
[3] = (value
>> 24) & 0xff;
360 field
[2] = (value
>> 16) & 0xff;
363 field
[1] = (value
>> 8) & 0xff;
366 field
[0] = value
& 0xff;
370 error (_("Unhandled data length: %d\n"), size
);
375 /* Print a VMA value. */
377 print_vma (bfd_vma vma
, print_mode mode
)
390 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
397 return printf ("%5" BFD_VMA_FMT
"d", vma
);
405 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
408 return printf ("%" BFD_VMA_FMT
"d", vma
);
411 return printf ("%" BFD_VMA_FMT
"u", vma
);
416 /* Display a symbol on stdout. Handles the display of
417 non-printing characters.
418 If DO_WIDE is not true then format the symbol to be
419 at most WIDTH characters, truncating as necessary.
420 If WIDTH is negative then format the string to be
421 exactly - WIDTH characters, truncating or padding
425 print_symbol (int width
, const char *symbol
)
427 const char * format_string
;
432 format_string
= "%.*s";
433 /* Set the width to a very large value. This simplifies the code below. */
438 format_string
= "%-*.*2s";
439 /* Keep the width positive. This also helps. */
444 format_string
= "%-.*s";
453 /* Look for non-printing symbols inside the symbol's name.
454 This test is triggered in particular by the names generated
455 by the assembler for local labels. */
456 while (ISPRINT (* c
))
466 printf (format_string
, len
, symbol
);
471 if (* c
== 0 || width
== 0)
474 /* Now display the non-printing character, if
475 there is room left in which to dipslay it. */
481 printf ("^%c", *c
+ 0x40);
490 printf ("<0x%.2x>", *c
);
500 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
505 field
[7] = value
& 0xff;
506 field
[6] = (value
>> 8) & 0xff;
507 field
[5] = (value
>> 16) & 0xff;
508 field
[4] = (value
>> 24) & 0xff;
513 field
[3] = value
& 0xff;
514 field
[2] = (value
>> 8) & 0xff;
518 field
[1] = value
& 0xff;
522 field
[0] = value
& 0xff;
526 error (_("Unhandled data length: %d\n"), size
);
531 /* Return a pointer to section NAME, or NULL if no such section exists. */
533 static Elf_Internal_Shdr
*
534 find_section (const char *name
)
538 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
539 if (streq (SECTION_NAME (section_headers
+ i
), name
))
540 return section_headers
+ i
;
545 /* Guess the relocation size commonly used by the specific machines. */
548 guess_is_rela (unsigned int e_machine
)
552 /* Targets that use REL relocations. */
568 /* Targets that use RELA relocations. */
572 case EM_ALTERA_NIOS2
:
599 case EM_CYGNUS_MN10200
:
601 case EM_CYGNUS_MN10300
:
642 warn (_("Don't know about relocations on this machine architecture\n"));
648 slurp_rela_relocs (FILE *file
,
649 unsigned long rel_offset
,
650 unsigned long rel_size
,
651 Elf_Internal_Rela
**relasp
,
652 unsigned long *nrelasp
)
654 Elf_Internal_Rela
*relas
;
655 unsigned long nrelas
;
660 Elf32_External_Rela
*erelas
;
662 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
666 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
668 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
673 error (_("out of memory parsing relocs\n"));
677 for (i
= 0; i
< nrelas
; i
++)
679 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
680 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
681 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
688 Elf64_External_Rela
*erelas
;
690 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
694 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
696 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
701 error (_("out of memory parsing relocs\n"));
705 for (i
= 0; i
< nrelas
; i
++)
707 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
708 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
709 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
711 /* The #ifdef BFD64 below is to prevent a compile time
712 warning. We know that if we do not have a 64 bit data
713 type that we will never execute this code anyway. */
715 if (elf_header
.e_machine
== EM_MIPS
716 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
718 /* In little-endian objects, r_info isn't really a
719 64-bit little-endian value: it has a 32-bit
720 little-endian symbol index followed by four
721 individual byte fields. Reorder INFO
723 bfd_vma info
= relas
[i
].r_info
;
724 info
= (((info
& 0xffffffff) << 32)
725 | ((info
>> 56) & 0xff)
726 | ((info
>> 40) & 0xff00)
727 | ((info
>> 24) & 0xff0000)
728 | ((info
>> 8) & 0xff000000));
729 relas
[i
].r_info
= info
;
742 slurp_rel_relocs (FILE *file
,
743 unsigned long rel_offset
,
744 unsigned long rel_size
,
745 Elf_Internal_Rela
**relsp
,
746 unsigned long *nrelsp
)
748 Elf_Internal_Rela
*rels
;
754 Elf32_External_Rel
*erels
;
756 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
760 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
762 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
767 error (_("out of memory parsing relocs\n"));
771 for (i
= 0; i
< nrels
; i
++)
773 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
774 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
775 rels
[i
].r_addend
= 0;
782 Elf64_External_Rel
*erels
;
784 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
788 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
790 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
795 error (_("out of memory parsing relocs\n"));
799 for (i
= 0; i
< nrels
; i
++)
801 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
802 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
803 rels
[i
].r_addend
= 0;
805 /* The #ifdef BFD64 below is to prevent a compile time
806 warning. We know that if we do not have a 64 bit data
807 type that we will never execute this code anyway. */
809 if (elf_header
.e_machine
== EM_MIPS
810 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
812 /* In little-endian objects, r_info isn't really a
813 64-bit little-endian value: it has a 32-bit
814 little-endian symbol index followed by four
815 individual byte fields. Reorder INFO
817 bfd_vma info
= rels
[i
].r_info
;
818 info
= (((info
& 0xffffffff) << 32)
819 | ((info
>> 56) & 0xff)
820 | ((info
>> 40) & 0xff00)
821 | ((info
>> 24) & 0xff0000)
822 | ((info
>> 8) & 0xff000000));
823 rels
[i
].r_info
= info
;
835 /* Returns the reloc type extracted from the reloc info field. */
838 get_reloc_type (bfd_vma reloc_info
)
841 return ELF32_R_TYPE (reloc_info
);
843 switch (elf_header
.e_machine
)
846 /* Note: We assume that reloc_info has already been adjusted for us. */
847 return ELF64_MIPS_R_TYPE (reloc_info
);
850 return ELF64_R_TYPE_ID (reloc_info
);
853 return ELF64_R_TYPE (reloc_info
);
857 /* Return the symbol index extracted from the reloc info field. */
860 get_reloc_symindex (bfd_vma reloc_info
)
862 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
865 /* Display the contents of the relocation data found at the specified
869 dump_relocations (FILE *file
,
870 unsigned long rel_offset
,
871 unsigned long rel_size
,
872 Elf_Internal_Sym
*symtab
,
875 unsigned long strtablen
,
879 Elf_Internal_Rela
*rels
;
882 if (is_rela
== UNKNOWN
)
883 is_rela
= guess_is_rela (elf_header
.e_machine
);
887 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
892 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
901 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
903 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
908 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
910 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
918 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
920 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
925 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
927 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
931 for (i
= 0; i
< rel_size
; i
++)
936 bfd_vma symtab_index
;
939 offset
= rels
[i
].r_offset
;
940 info
= rels
[i
].r_info
;
942 type
= get_reloc_type (info
);
943 symtab_index
= get_reloc_symindex (info
);
947 printf ("%8.8lx %8.8lx ",
948 (unsigned long) offset
& 0xffffffff,
949 (unsigned long) info
& 0xffffffff);
953 #if BFD_HOST_64BIT_LONG
955 ? "%16.16lx %16.16lx "
956 : "%12.12lx %12.12lx ",
958 #elif BFD_HOST_64BIT_LONG_LONG
961 ? "%16.16llx %16.16llx "
962 : "%12.12llx %12.12llx ",
966 ? "%16.16I64x %16.16I64x "
967 : "%12.12I64x %12.12I64x ",
972 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
973 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
974 _bfd_int64_high (offset
),
975 _bfd_int64_low (offset
),
976 _bfd_int64_high (info
),
977 _bfd_int64_low (info
));
981 switch (elf_header
.e_machine
)
989 rtype
= elf_m32r_reloc_type (type
);
994 rtype
= elf_i386_reloc_type (type
);
999 rtype
= elf_m68hc11_reloc_type (type
);
1003 rtype
= elf_m68k_reloc_type (type
);
1007 rtype
= elf_i960_reloc_type (type
);
1012 rtype
= elf_avr_reloc_type (type
);
1015 case EM_OLD_SPARCV9
:
1016 case EM_SPARC32PLUS
:
1019 rtype
= elf_sparc_reloc_type (type
);
1023 rtype
= elf_spu_reloc_type (type
);
1027 case EM_CYGNUS_V850
:
1028 rtype
= v850_reloc_type (type
);
1032 case EM_CYGNUS_D10V
:
1033 rtype
= elf_d10v_reloc_type (type
);
1037 case EM_CYGNUS_D30V
:
1038 rtype
= elf_d30v_reloc_type (type
);
1042 rtype
= elf_dlx_reloc_type (type
);
1046 rtype
= elf_sh_reloc_type (type
);
1050 case EM_CYGNUS_MN10300
:
1051 rtype
= elf_mn10300_reloc_type (type
);
1055 case EM_CYGNUS_MN10200
:
1056 rtype
= elf_mn10200_reloc_type (type
);
1060 case EM_CYGNUS_FR30
:
1061 rtype
= elf_fr30_reloc_type (type
);
1065 rtype
= elf_frv_reloc_type (type
);
1069 rtype
= elf_mcore_reloc_type (type
);
1073 rtype
= elf_mmix_reloc_type (type
);
1078 rtype
= elf_msp430_reloc_type (type
);
1082 rtype
= elf_ppc_reloc_type (type
);
1086 rtype
= elf_ppc64_reloc_type (type
);
1090 case EM_MIPS_RS3_LE
:
1091 rtype
= elf_mips_reloc_type (type
);
1095 rtype
= elf_alpha_reloc_type (type
);
1099 rtype
= elf_arm_reloc_type (type
);
1103 rtype
= elf_arc_reloc_type (type
);
1107 rtype
= elf_hppa_reloc_type (type
);
1113 rtype
= elf_h8_reloc_type (type
);
1118 rtype
= elf_or32_reloc_type (type
);
1123 rtype
= elf_pj_reloc_type (type
);
1126 rtype
= elf_ia64_reloc_type (type
);
1130 rtype
= elf_cris_reloc_type (type
);
1134 rtype
= elf_i860_reloc_type (type
);
1138 rtype
= elf_x86_64_reloc_type (type
);
1142 rtype
= i370_reloc_type (type
);
1147 rtype
= elf_s390_reloc_type (type
);
1151 rtype
= elf_score_reloc_type (type
);
1155 rtype
= elf_xstormy16_reloc_type (type
);
1159 rtype
= elf_crx_reloc_type (type
);
1163 rtype
= elf_vax_reloc_type (type
);
1168 rtype
= elf_ip2k_reloc_type (type
);
1172 rtype
= elf_iq2000_reloc_type (type
);
1177 rtype
= elf_xtensa_reloc_type (type
);
1182 rtype
= elf_m32c_reloc_type (type
);
1186 rtype
= elf_mt_reloc_type (type
);
1190 rtype
= elf_bfin_reloc_type (type
);
1194 rtype
= elf_mep_reloc_type (type
);
1199 rtype
= elf_cr16_reloc_type (type
);
1204 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1206 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1208 if (elf_header
.e_machine
== EM_ALPHA
1210 && streq (rtype
, "R_ALPHA_LITUSE")
1213 switch (rels
[i
].r_addend
)
1215 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1216 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1217 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1218 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1219 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1220 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1221 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1222 default: rtype
= NULL
;
1225 printf (" (%s)", rtype
);
1229 printf (_("<unknown addend: %lx>"),
1230 (unsigned long) rels
[i
].r_addend
);
1233 else if (symtab_index
)
1235 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1236 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1239 Elf_Internal_Sym
*psym
;
1241 psym
= symtab
+ symtab_index
;
1244 print_vma (psym
->st_value
, LONG_HEX
);
1245 printf (is_32bit_elf
? " " : " ");
1247 if (psym
->st_name
== 0)
1249 const char *sec_name
= "<null>";
1252 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1254 if (psym
->st_shndx
< elf_header
.e_shnum
)
1256 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1257 else if (psym
->st_shndx
== SHN_ABS
)
1259 else if (psym
->st_shndx
== SHN_COMMON
)
1260 sec_name
= "COMMON";
1261 else if (elf_header
.e_machine
== EM_MIPS
1262 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1263 sec_name
= "SCOMMON";
1264 else if (elf_header
.e_machine
== EM_MIPS
1265 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1266 sec_name
= "SUNDEF";
1267 else if (elf_header
.e_machine
== EM_X86_64
1268 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1269 sec_name
= "LARGE_COMMON";
1270 else if (elf_header
.e_machine
== EM_IA_64
1271 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1272 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1273 sec_name
= "ANSI_COM";
1274 else if (elf_header
.e_machine
== EM_IA_64
1275 && (elf_header
.e_ident
[EI_OSABI
]
1276 == ELFOSABI_OPENVMS
)
1277 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1278 sec_name
= "VMS_SYMVEC";
1281 sprintf (name_buf
, "<section 0x%x>",
1282 (unsigned int) psym
->st_shndx
);
1283 sec_name
= name_buf
;
1286 print_symbol (22, sec_name
);
1288 else if (strtab
== NULL
)
1289 printf (_("<string table index: %3ld>"), psym
->st_name
);
1290 else if (psym
->st_name
>= strtablen
)
1291 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1293 print_symbol (22, strtab
+ psym
->st_name
);
1296 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1301 printf ("%*c", is_32bit_elf
?
1302 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1303 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1306 if (elf_header
.e_machine
== EM_SPARCV9
1308 && streq (rtype
, "R_SPARC_OLO10"))
1309 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1314 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1316 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1317 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1318 const char *rtype2
= elf_mips_reloc_type (type2
);
1319 const char *rtype3
= elf_mips_reloc_type (type3
);
1321 printf (" Type2: ");
1324 printf (_("unrecognized: %-7lx"),
1325 (unsigned long) type2
& 0xffffffff);
1327 printf ("%-17.17s", rtype2
);
1329 printf ("\n Type3: ");
1332 printf (_("unrecognized: %-7lx"),
1333 (unsigned long) type3
& 0xffffffff);
1335 printf ("%-17.17s", rtype3
);
1346 get_mips_dynamic_type (unsigned long type
)
1350 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1351 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1352 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1353 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1354 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1355 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1356 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1357 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1358 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1359 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1360 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1361 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1362 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1363 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1364 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1365 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1366 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1367 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1368 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1369 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1370 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1371 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1372 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1373 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1374 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1375 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1376 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1377 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1378 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1379 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1380 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1381 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1382 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1383 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1384 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1385 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1386 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1387 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1388 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1389 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1390 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1391 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1392 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1393 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1394 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1401 get_sparc64_dynamic_type (unsigned long type
)
1405 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1412 get_ppc_dynamic_type (unsigned long type
)
1416 case DT_PPC_GOT
: return "PPC_GOT";
1423 get_ppc64_dynamic_type (unsigned long type
)
1427 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1428 case DT_PPC64_OPD
: return "PPC64_OPD";
1429 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1436 get_parisc_dynamic_type (unsigned long type
)
1440 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1441 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1442 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1443 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1444 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1445 case DT_HP_PREINIT
: return "HP_PREINIT";
1446 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1447 case DT_HP_NEEDED
: return "HP_NEEDED";
1448 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1449 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1450 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1451 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1452 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1453 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1454 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1455 case DT_HP_FILTERED
: return "HP_FILTERED";
1456 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1457 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1458 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1459 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1460 case DT_PLT
: return "PLT";
1461 case DT_PLT_SIZE
: return "PLT_SIZE";
1462 case DT_DLT
: return "DLT";
1463 case DT_DLT_SIZE
: return "DLT_SIZE";
1470 get_ia64_dynamic_type (unsigned long type
)
1474 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1475 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1476 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1477 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1478 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1479 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1480 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1481 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1482 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1483 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1484 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1485 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1486 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1487 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1488 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1489 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1490 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1491 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1492 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1493 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1494 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1495 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1496 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1497 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1498 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1499 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1500 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1501 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1502 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1503 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1504 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1511 get_alpha_dynamic_type (unsigned long type
)
1515 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1522 get_score_dynamic_type (unsigned long type
)
1526 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1527 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1528 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1529 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1530 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1531 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1539 get_dynamic_type (unsigned long type
)
1541 static char buff
[64];
1545 case DT_NULL
: return "NULL";
1546 case DT_NEEDED
: return "NEEDED";
1547 case DT_PLTRELSZ
: return "PLTRELSZ";
1548 case DT_PLTGOT
: return "PLTGOT";
1549 case DT_HASH
: return "HASH";
1550 case DT_STRTAB
: return "STRTAB";
1551 case DT_SYMTAB
: return "SYMTAB";
1552 case DT_RELA
: return "RELA";
1553 case DT_RELASZ
: return "RELASZ";
1554 case DT_RELAENT
: return "RELAENT";
1555 case DT_STRSZ
: return "STRSZ";
1556 case DT_SYMENT
: return "SYMENT";
1557 case DT_INIT
: return "INIT";
1558 case DT_FINI
: return "FINI";
1559 case DT_SONAME
: return "SONAME";
1560 case DT_RPATH
: return "RPATH";
1561 case DT_SYMBOLIC
: return "SYMBOLIC";
1562 case DT_REL
: return "REL";
1563 case DT_RELSZ
: return "RELSZ";
1564 case DT_RELENT
: return "RELENT";
1565 case DT_PLTREL
: return "PLTREL";
1566 case DT_DEBUG
: return "DEBUG";
1567 case DT_TEXTREL
: return "TEXTREL";
1568 case DT_JMPREL
: return "JMPREL";
1569 case DT_BIND_NOW
: return "BIND_NOW";
1570 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1571 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1572 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1573 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1574 case DT_RUNPATH
: return "RUNPATH";
1575 case DT_FLAGS
: return "FLAGS";
1577 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1578 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1580 case DT_CHECKSUM
: return "CHECKSUM";
1581 case DT_PLTPADSZ
: return "PLTPADSZ";
1582 case DT_MOVEENT
: return "MOVEENT";
1583 case DT_MOVESZ
: return "MOVESZ";
1584 case DT_FEATURE
: return "FEATURE";
1585 case DT_POSFLAG_1
: return "POSFLAG_1";
1586 case DT_SYMINSZ
: return "SYMINSZ";
1587 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1589 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1590 case DT_CONFIG
: return "CONFIG";
1591 case DT_DEPAUDIT
: return "DEPAUDIT";
1592 case DT_AUDIT
: return "AUDIT";
1593 case DT_PLTPAD
: return "PLTPAD";
1594 case DT_MOVETAB
: return "MOVETAB";
1595 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1597 case DT_VERSYM
: return "VERSYM";
1599 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1600 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1601 case DT_RELACOUNT
: return "RELACOUNT";
1602 case DT_RELCOUNT
: return "RELCOUNT";
1603 case DT_FLAGS_1
: return "FLAGS_1";
1604 case DT_VERDEF
: return "VERDEF";
1605 case DT_VERDEFNUM
: return "VERDEFNUM";
1606 case DT_VERNEED
: return "VERNEED";
1607 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1609 case DT_AUXILIARY
: return "AUXILIARY";
1610 case DT_USED
: return "USED";
1611 case DT_FILTER
: return "FILTER";
1613 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1614 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1615 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1616 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1617 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1618 case DT_GNU_HASH
: return "GNU_HASH";
1621 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1625 switch (elf_header
.e_machine
)
1628 case EM_MIPS_RS3_LE
:
1629 result
= get_mips_dynamic_type (type
);
1632 result
= get_sparc64_dynamic_type (type
);
1635 result
= get_ppc_dynamic_type (type
);
1638 result
= get_ppc64_dynamic_type (type
);
1641 result
= get_ia64_dynamic_type (type
);
1644 result
= get_alpha_dynamic_type (type
);
1647 result
= get_score_dynamic_type (type
);
1657 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1659 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1660 || (elf_header
.e_machine
== EM_PARISC
1661 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1665 switch (elf_header
.e_machine
)
1668 result
= get_parisc_dynamic_type (type
);
1671 result
= get_ia64_dynamic_type (type
);
1681 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1685 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1692 get_file_type (unsigned e_type
)
1694 static char buff
[32];
1698 case ET_NONE
: return _("NONE (None)");
1699 case ET_REL
: return _("REL (Relocatable file)");
1700 case ET_EXEC
: return _("EXEC (Executable file)");
1701 case ET_DYN
: return _("DYN (Shared object file)");
1702 case ET_CORE
: return _("CORE (Core file)");
1705 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1706 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1707 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1708 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1710 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1716 get_machine_name (unsigned e_machine
)
1718 static char buff
[64]; /* XXX */
1722 case EM_NONE
: return _("None");
1723 case EM_M32
: return "WE32100";
1724 case EM_SPARC
: return "Sparc";
1725 case EM_SPU
: return "SPU";
1726 case EM_386
: return "Intel 80386";
1727 case EM_68K
: return "MC68000";
1728 case EM_88K
: return "MC88000";
1729 case EM_486
: return "Intel 80486";
1730 case EM_860
: return "Intel 80860";
1731 case EM_MIPS
: return "MIPS R3000";
1732 case EM_S370
: return "IBM System/370";
1733 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1734 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1735 case EM_PARISC
: return "HPPA";
1736 case EM_PPC_OLD
: return "Power PC (old)";
1737 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1738 case EM_960
: return "Intel 90860";
1739 case EM_PPC
: return "PowerPC";
1740 case EM_PPC64
: return "PowerPC64";
1741 case EM_V800
: return "NEC V800";
1742 case EM_FR20
: return "Fujitsu FR20";
1743 case EM_RH32
: return "TRW RH32";
1744 case EM_MCORE
: return "MCORE";
1745 case EM_ARM
: return "ARM";
1746 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1747 case EM_SH
: return "Renesas / SuperH SH";
1748 case EM_SPARCV9
: return "Sparc v9";
1749 case EM_TRICORE
: return "Siemens Tricore";
1750 case EM_ARC
: return "ARC";
1751 case EM_H8_300
: return "Renesas H8/300";
1752 case EM_H8_300H
: return "Renesas H8/300H";
1753 case EM_H8S
: return "Renesas H8S";
1754 case EM_H8_500
: return "Renesas H8/500";
1755 case EM_IA_64
: return "Intel IA-64";
1756 case EM_MIPS_X
: return "Stanford MIPS-X";
1757 case EM_COLDFIRE
: return "Motorola Coldfire";
1758 case EM_68HC12
: return "Motorola M68HC12";
1759 case EM_ALPHA
: return "Alpha";
1760 case EM_CYGNUS_D10V
:
1761 case EM_D10V
: return "d10v";
1762 case EM_CYGNUS_D30V
:
1763 case EM_D30V
: return "d30v";
1764 case EM_CYGNUS_M32R
:
1765 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1766 case EM_CYGNUS_V850
:
1767 case EM_V850
: return "NEC v850";
1768 case EM_CYGNUS_MN10300
:
1769 case EM_MN10300
: return "mn10300";
1770 case EM_CYGNUS_MN10200
:
1771 case EM_MN10200
: return "mn10200";
1772 case EM_CYGNUS_FR30
:
1773 case EM_FR30
: return "Fujitsu FR30";
1774 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1776 case EM_PJ
: return "picoJava";
1777 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1778 case EM_PCP
: return "Siemens PCP";
1779 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1780 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1781 case EM_STARCORE
: return "Motorola Star*Core processor";
1782 case EM_ME16
: return "Toyota ME16 processor";
1783 case EM_ST100
: return "STMicroelectronics ST100 processor";
1784 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1785 case EM_FX66
: return "Siemens FX66 microcontroller";
1786 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1787 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1788 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1789 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1790 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1791 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1792 case EM_SVX
: return "Silicon Graphics SVx";
1793 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1794 case EM_VAX
: return "Digital VAX";
1796 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1797 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1798 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1799 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1800 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1801 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1802 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1803 case EM_PRISM
: return "Vitesse Prism";
1804 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1806 case EM_S390
: return "IBM S/390";
1807 case EM_SCORE
: return "SUNPLUS S+Core";
1808 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1810 case EM_OR32
: return "OpenRISC";
1811 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1812 case EM_DLX
: return "OpenDLX";
1814 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1815 case EM_IQ2000
: return "Vitesse IQ2000";
1817 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1819 case EM_M32C
: return "Renesas M32c";
1820 case EM_MT
: return "Morpho Techologies MT processor";
1821 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1822 case EM_NIOS32
: return "Altera Nios";
1823 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1824 case EM_XC16X
: return "Infineon Technologies xc16x";
1825 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1827 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1829 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1835 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1840 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1841 e_flags
&= ~ EF_ARM_EABIMASK
;
1843 /* Handle "generic" ARM flags. */
1844 if (e_flags
& EF_ARM_RELEXEC
)
1846 strcat (buf
, ", relocatable executable");
1847 e_flags
&= ~ EF_ARM_RELEXEC
;
1850 if (e_flags
& EF_ARM_HASENTRY
)
1852 strcat (buf
, ", has entry point");
1853 e_flags
&= ~ EF_ARM_HASENTRY
;
1856 /* Now handle EABI specific flags. */
1860 strcat (buf
, ", <unrecognized EABI>");
1865 case EF_ARM_EABI_VER1
:
1866 strcat (buf
, ", Version1 EABI");
1871 /* Process flags one bit at a time. */
1872 flag
= e_flags
& - e_flags
;
1877 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1878 strcat (buf
, ", sorted symbol tables");
1888 case EF_ARM_EABI_VER2
:
1889 strcat (buf
, ", Version2 EABI");
1894 /* Process flags one bit at a time. */
1895 flag
= e_flags
& - e_flags
;
1900 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1901 strcat (buf
, ", sorted symbol tables");
1904 case EF_ARM_DYNSYMSUSESEGIDX
:
1905 strcat (buf
, ", dynamic symbols use segment index");
1908 case EF_ARM_MAPSYMSFIRST
:
1909 strcat (buf
, ", mapping symbols precede others");
1919 case EF_ARM_EABI_VER3
:
1920 strcat (buf
, ", Version3 EABI");
1923 case EF_ARM_EABI_VER4
:
1924 strcat (buf
, ", Version4 EABI");
1927 case EF_ARM_EABI_VER5
:
1928 strcat (buf
, ", Version5 EABI");
1934 /* Process flags one bit at a time. */
1935 flag
= e_flags
& - e_flags
;
1941 strcat (buf
, ", BE8");
1945 strcat (buf
, ", LE8");
1955 case EF_ARM_EABI_UNKNOWN
:
1956 strcat (buf
, ", GNU EABI");
1961 /* Process flags one bit at a time. */
1962 flag
= e_flags
& - e_flags
;
1967 case EF_ARM_INTERWORK
:
1968 strcat (buf
, ", interworking enabled");
1971 case EF_ARM_APCS_26
:
1972 strcat (buf
, ", uses APCS/26");
1975 case EF_ARM_APCS_FLOAT
:
1976 strcat (buf
, ", uses APCS/float");
1980 strcat (buf
, ", position independent");
1984 strcat (buf
, ", 8 bit structure alignment");
1987 case EF_ARM_NEW_ABI
:
1988 strcat (buf
, ", uses new ABI");
1991 case EF_ARM_OLD_ABI
:
1992 strcat (buf
, ", uses old ABI");
1995 case EF_ARM_SOFT_FLOAT
:
1996 strcat (buf
, ", software FP");
1999 case EF_ARM_VFP_FLOAT
:
2000 strcat (buf
, ", VFP");
2003 case EF_ARM_MAVERICK_FLOAT
:
2004 strcat (buf
, ", Maverick FP");
2015 strcat (buf
,", <unknown>");
2019 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2021 static char buf
[1024];
2033 decode_ARM_machine_flags (e_flags
, buf
);
2037 switch (e_flags
& EF_FRV_CPU_MASK
)
2039 case EF_FRV_CPU_GENERIC
:
2043 strcat (buf
, ", fr???");
2046 case EF_FRV_CPU_FR300
:
2047 strcat (buf
, ", fr300");
2050 case EF_FRV_CPU_FR400
:
2051 strcat (buf
, ", fr400");
2053 case EF_FRV_CPU_FR405
:
2054 strcat (buf
, ", fr405");
2057 case EF_FRV_CPU_FR450
:
2058 strcat (buf
, ", fr450");
2061 case EF_FRV_CPU_FR500
:
2062 strcat (buf
, ", fr500");
2064 case EF_FRV_CPU_FR550
:
2065 strcat (buf
, ", fr550");
2068 case EF_FRV_CPU_SIMPLE
:
2069 strcat (buf
, ", simple");
2071 case EF_FRV_CPU_TOMCAT
:
2072 strcat (buf
, ", tomcat");
2078 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2079 strcat (buf
, ", m68000");
2080 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2081 strcat (buf
, ", cpu32");
2082 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2083 strcat (buf
, ", fido_a");
2086 char const *isa
= _("unknown");
2087 char const *mac
= _("unknown mac");
2088 char const *additional
= NULL
;
2090 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2092 case EF_M68K_CF_ISA_A_NODIV
:
2094 additional
= ", nodiv";
2096 case EF_M68K_CF_ISA_A
:
2099 case EF_M68K_CF_ISA_A_PLUS
:
2102 case EF_M68K_CF_ISA_B_NOUSP
:
2104 additional
= ", nousp";
2106 case EF_M68K_CF_ISA_B
:
2110 strcat (buf
, ", cf, isa ");
2113 strcat (buf
, additional
);
2114 if (e_flags
& EF_M68K_CF_FLOAT
)
2115 strcat (buf
, ", float");
2116 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2121 case EF_M68K_CF_MAC
:
2124 case EF_M68K_CF_EMAC
:
2137 if (e_flags
& EF_PPC_EMB
)
2138 strcat (buf
, ", emb");
2140 if (e_flags
& EF_PPC_RELOCATABLE
)
2141 strcat (buf
, ", relocatable");
2143 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2144 strcat (buf
, ", relocatable-lib");
2148 case EM_CYGNUS_V850
:
2149 switch (e_flags
& EF_V850_ARCH
)
2152 strcat (buf
, ", v850e1");
2155 strcat (buf
, ", v850e");
2158 strcat (buf
, ", v850");
2161 strcat (buf
, ", unknown v850 architecture variant");
2167 case EM_CYGNUS_M32R
:
2168 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2169 strcat (buf
, ", m32r");
2173 case EM_MIPS_RS3_LE
:
2174 if (e_flags
& EF_MIPS_NOREORDER
)
2175 strcat (buf
, ", noreorder");
2177 if (e_flags
& EF_MIPS_PIC
)
2178 strcat (buf
, ", pic");
2180 if (e_flags
& EF_MIPS_CPIC
)
2181 strcat (buf
, ", cpic");
2183 if (e_flags
& EF_MIPS_UCODE
)
2184 strcat (buf
, ", ugen_reserved");
2186 if (e_flags
& EF_MIPS_ABI2
)
2187 strcat (buf
, ", abi2");
2189 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2190 strcat (buf
, ", odk first");
2192 if (e_flags
& EF_MIPS_32BITMODE
)
2193 strcat (buf
, ", 32bitmode");
2195 switch ((e_flags
& EF_MIPS_MACH
))
2197 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2198 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2199 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2200 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2201 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2202 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2203 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2204 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2205 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2206 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2207 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2208 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2209 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2211 /* We simply ignore the field in this case to avoid confusion:
2212 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2215 default: strcat (buf
, ", unknown CPU"); break;
2218 switch ((e_flags
& EF_MIPS_ABI
))
2220 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2221 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2222 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2223 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2225 /* We simply ignore the field in this case to avoid confusion:
2226 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2227 This means it is likely to be an o32 file, but not for
2230 default: strcat (buf
, ", unknown ABI"); break;
2233 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2234 strcat (buf
, ", mdmx");
2236 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2237 strcat (buf
, ", mips16");
2239 switch ((e_flags
& EF_MIPS_ARCH
))
2241 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2242 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2243 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2244 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2245 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2246 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2247 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2248 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2249 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2250 default: strcat (buf
, ", unknown ISA"); break;
2256 switch ((e_flags
& EF_SH_MACH_MASK
))
2258 case EF_SH1
: strcat (buf
, ", sh1"); break;
2259 case EF_SH2
: strcat (buf
, ", sh2"); break;
2260 case EF_SH3
: strcat (buf
, ", sh3"); break;
2261 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2262 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2263 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2264 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2265 case EF_SH4
: strcat (buf
, ", sh4"); break;
2266 case EF_SH5
: strcat (buf
, ", sh5"); break;
2267 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2268 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2269 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2270 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2271 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2272 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2273 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2274 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2275 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2276 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2277 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2278 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2279 default: strcat (buf
, ", unknown ISA"); break;
2285 if (e_flags
& EF_SPARC_32PLUS
)
2286 strcat (buf
, ", v8+");
2288 if (e_flags
& EF_SPARC_SUN_US1
)
2289 strcat (buf
, ", ultrasparcI");
2291 if (e_flags
& EF_SPARC_SUN_US3
)
2292 strcat (buf
, ", ultrasparcIII");
2294 if (e_flags
& EF_SPARC_HAL_R1
)
2295 strcat (buf
, ", halr1");
2297 if (e_flags
& EF_SPARC_LEDATA
)
2298 strcat (buf
, ", ledata");
2300 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2301 strcat (buf
, ", tso");
2303 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2304 strcat (buf
, ", pso");
2306 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2307 strcat (buf
, ", rmo");
2311 switch (e_flags
& EF_PARISC_ARCH
)
2313 case EFA_PARISC_1_0
:
2314 strcpy (buf
, ", PA-RISC 1.0");
2316 case EFA_PARISC_1_1
:
2317 strcpy (buf
, ", PA-RISC 1.1");
2319 case EFA_PARISC_2_0
:
2320 strcpy (buf
, ", PA-RISC 2.0");
2325 if (e_flags
& EF_PARISC_TRAPNIL
)
2326 strcat (buf
, ", trapnil");
2327 if (e_flags
& EF_PARISC_EXT
)
2328 strcat (buf
, ", ext");
2329 if (e_flags
& EF_PARISC_LSB
)
2330 strcat (buf
, ", lsb");
2331 if (e_flags
& EF_PARISC_WIDE
)
2332 strcat (buf
, ", wide");
2333 if (e_flags
& EF_PARISC_NO_KABP
)
2334 strcat (buf
, ", no kabp");
2335 if (e_flags
& EF_PARISC_LAZYSWAP
)
2336 strcat (buf
, ", lazyswap");
2341 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2342 strcat (buf
, ", new calling convention");
2344 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2345 strcat (buf
, ", gnu calling convention");
2349 if ((e_flags
& EF_IA_64_ABI64
))
2350 strcat (buf
, ", 64-bit");
2352 strcat (buf
, ", 32-bit");
2353 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2354 strcat (buf
, ", reduced fp model");
2355 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2356 strcat (buf
, ", no function descriptors, constant gp");
2357 else if ((e_flags
& EF_IA_64_CONS_GP
))
2358 strcat (buf
, ", constant gp");
2359 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2360 strcat (buf
, ", absolute");
2364 if ((e_flags
& EF_VAX_NONPIC
))
2365 strcat (buf
, ", non-PIC");
2366 if ((e_flags
& EF_VAX_DFLOAT
))
2367 strcat (buf
, ", D-Float");
2368 if ((e_flags
& EF_VAX_GFLOAT
))
2369 strcat (buf
, ", G-Float");
2378 get_osabi_name (unsigned int osabi
)
2380 static char buff
[32];
2384 case ELFOSABI_NONE
: return "UNIX - System V";
2385 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2386 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2387 case ELFOSABI_LINUX
: return "UNIX - Linux";
2388 case ELFOSABI_HURD
: return "GNU/Hurd";
2389 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2390 case ELFOSABI_AIX
: return "UNIX - AIX";
2391 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2392 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2393 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2394 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2395 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2396 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2397 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2398 case ELFOSABI_AROS
: return "AROS";
2399 case ELFOSABI_STANDALONE
: return _("Standalone App");
2400 case ELFOSABI_ARM
: return "ARM";
2402 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2408 get_arm_segment_type (unsigned long type
)
2422 get_mips_segment_type (unsigned long type
)
2426 case PT_MIPS_REGINFO
:
2428 case PT_MIPS_RTPROC
:
2430 case PT_MIPS_OPTIONS
:
2440 get_parisc_segment_type (unsigned long type
)
2444 case PT_HP_TLS
: return "HP_TLS";
2445 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2446 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2447 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2448 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2449 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2450 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2451 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2452 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2453 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2454 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2455 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2456 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2457 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2458 case PT_HP_STACK
: return "HP_STACK";
2459 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2460 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2461 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2462 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2471 get_ia64_segment_type (unsigned long type
)
2475 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2476 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2477 case PT_HP_TLS
: return "HP_TLS";
2478 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2479 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2480 case PT_IA_64_HP_STACK
: return "HP_STACK";
2489 get_segment_type (unsigned long p_type
)
2491 static char buff
[32];
2495 case PT_NULL
: return "NULL";
2496 case PT_LOAD
: return "LOAD";
2497 case PT_DYNAMIC
: return "DYNAMIC";
2498 case PT_INTERP
: return "INTERP";
2499 case PT_NOTE
: return "NOTE";
2500 case PT_SHLIB
: return "SHLIB";
2501 case PT_PHDR
: return "PHDR";
2502 case PT_TLS
: return "TLS";
2504 case PT_GNU_EH_FRAME
:
2505 return "GNU_EH_FRAME";
2506 case PT_GNU_STACK
: return "GNU_STACK";
2507 case PT_GNU_RELRO
: return "GNU_RELRO";
2510 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2514 switch (elf_header
.e_machine
)
2517 result
= get_arm_segment_type (p_type
);
2520 case EM_MIPS_RS3_LE
:
2521 result
= get_mips_segment_type (p_type
);
2524 result
= get_parisc_segment_type (p_type
);
2527 result
= get_ia64_segment_type (p_type
);
2537 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2539 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2543 switch (elf_header
.e_machine
)
2546 result
= get_parisc_segment_type (p_type
);
2549 result
= get_ia64_segment_type (p_type
);
2559 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2562 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2569 get_mips_section_type_name (unsigned int sh_type
)
2573 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2574 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2575 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2576 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2577 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2578 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2579 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2580 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2581 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2582 case SHT_MIPS_RELD
: return "MIPS_RELD";
2583 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2584 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2585 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2586 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2587 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2588 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2589 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2590 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2591 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2592 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2593 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2594 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2595 case SHT_MIPS_LINE
: return "MIPS_LINE";
2596 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2597 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2598 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2599 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2600 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2601 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2602 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2603 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2604 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2605 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2606 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2607 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2608 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2609 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2610 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2611 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2619 get_parisc_section_type_name (unsigned int sh_type
)
2623 case SHT_PARISC_EXT
: return "PARISC_EXT";
2624 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2625 case SHT_PARISC_DOC
: return "PARISC_DOC";
2626 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2627 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2628 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2629 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2637 get_ia64_section_type_name (unsigned int sh_type
)
2639 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2640 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2641 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2645 case SHT_IA_64_EXT
: return "IA_64_EXT";
2646 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2647 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2648 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2649 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2650 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2651 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2652 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2653 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2654 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2662 get_x86_64_section_type_name (unsigned int sh_type
)
2666 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2674 get_arm_section_type_name (unsigned int sh_type
)
2680 case SHT_ARM_PREEMPTMAP
:
2681 return "ARM_PREEMPTMAP";
2682 case SHT_ARM_ATTRIBUTES
:
2683 return "ARM_ATTRIBUTES";
2691 get_section_type_name (unsigned int sh_type
)
2693 static char buff
[32];
2697 case SHT_NULL
: return "NULL";
2698 case SHT_PROGBITS
: return "PROGBITS";
2699 case SHT_SYMTAB
: return "SYMTAB";
2700 case SHT_STRTAB
: return "STRTAB";
2701 case SHT_RELA
: return "RELA";
2702 case SHT_HASH
: return "HASH";
2703 case SHT_DYNAMIC
: return "DYNAMIC";
2704 case SHT_NOTE
: return "NOTE";
2705 case SHT_NOBITS
: return "NOBITS";
2706 case SHT_REL
: return "REL";
2707 case SHT_SHLIB
: return "SHLIB";
2708 case SHT_DYNSYM
: return "DYNSYM";
2709 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2710 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2711 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2712 case SHT_GNU_HASH
: return "GNU_HASH";
2713 case SHT_GROUP
: return "GROUP";
2714 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2715 case SHT_GNU_verdef
: return "VERDEF";
2716 case SHT_GNU_verneed
: return "VERNEED";
2717 case SHT_GNU_versym
: return "VERSYM";
2718 case 0x6ffffff0: return "VERSYM";
2719 case 0x6ffffffc: return "VERDEF";
2720 case 0x7ffffffd: return "AUXILIARY";
2721 case 0x7fffffff: return "FILTER";
2722 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2725 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2729 switch (elf_header
.e_machine
)
2732 case EM_MIPS_RS3_LE
:
2733 result
= get_mips_section_type_name (sh_type
);
2736 result
= get_parisc_section_type_name (sh_type
);
2739 result
= get_ia64_section_type_name (sh_type
);
2742 result
= get_x86_64_section_type_name (sh_type
);
2745 result
= get_arm_section_type_name (sh_type
);
2755 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2757 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2761 switch (elf_header
.e_machine
)
2764 result
= get_ia64_section_type_name (sh_type
);
2774 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2776 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2777 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2779 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2785 #define OPTION_DEBUG_DUMP 512
2787 static struct option options
[] =
2789 {"all", no_argument
, 0, 'a'},
2790 {"file-header", no_argument
, 0, 'h'},
2791 {"program-headers", no_argument
, 0, 'l'},
2792 {"headers", no_argument
, 0, 'e'},
2793 {"histogram", no_argument
, 0, 'I'},
2794 {"segments", no_argument
, 0, 'l'},
2795 {"sections", no_argument
, 0, 'S'},
2796 {"section-headers", no_argument
, 0, 'S'},
2797 {"section-groups", no_argument
, 0, 'g'},
2798 {"section-details", no_argument
, 0, 't'},
2799 {"full-section-name",no_argument
, 0, 'N'},
2800 {"symbols", no_argument
, 0, 's'},
2801 {"syms", no_argument
, 0, 's'},
2802 {"relocs", no_argument
, 0, 'r'},
2803 {"notes", no_argument
, 0, 'n'},
2804 {"dynamic", no_argument
, 0, 'd'},
2805 {"arch-specific", no_argument
, 0, 'A'},
2806 {"version-info", no_argument
, 0, 'V'},
2807 {"use-dynamic", no_argument
, 0, 'D'},
2808 {"unwind", no_argument
, 0, 'u'},
2809 {"archive-index", no_argument
, 0, 'c'},
2810 {"hex-dump", required_argument
, 0, 'x'},
2811 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2812 {"string-dump", required_argument
, 0, 'p'},
2813 #ifdef SUPPORT_DISASSEMBLY
2814 {"instruction-dump", required_argument
, 0, 'i'},
2817 {"version", no_argument
, 0, 'v'},
2818 {"wide", no_argument
, 0, 'W'},
2819 {"help", no_argument
, 0, 'H'},
2820 {0, no_argument
, 0, 0}
2824 usage (FILE *stream
)
2826 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2827 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2828 fprintf (stream
, _(" Options are:\n\
2829 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2830 -h --file-header Display the ELF file header\n\
2831 -l --program-headers Display the program headers\n\
2832 --segments An alias for --program-headers\n\
2833 -S --section-headers Display the sections' header\n\
2834 --sections An alias for --section-headers\n\
2835 -g --section-groups Display the section groups\n\
2836 -t --section-details Display the section details\n\
2837 -e --headers Equivalent to: -h -l -S\n\
2838 -s --syms Display the symbol table\n\
2839 --symbols An alias for --syms\n\
2840 -n --notes Display the core notes (if present)\n\
2841 -r --relocs Display the relocations (if present)\n\
2842 -u --unwind Display the unwind info (if present)\n\
2843 -d --dynamic Display the dynamic section (if present)\n\
2844 -V --version-info Display the version sections (if present)\n\
2845 -A --arch-specific Display architecture specific information (if any).\n\
2846 -c --archive-index Display the symbol/file index in an archive\n\
2847 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2848 -x --hex-dump=<number|name>\n\
2849 Dump the contents of section <number|name> as bytes\n\
2850 -p --string-dump=<number|name>\n\
2851 Dump the contents of section <number|name> as strings\n\
2852 -w[lLiaprmfFsoR] or\n\
2853 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2854 Display the contents of DWARF2 debug sections\n"));
2855 #ifdef SUPPORT_DISASSEMBLY
2856 fprintf (stream
, _("\
2857 -i --instruction-dump=<number|name>\n\
2858 Disassemble the contents of section <number|name>\n"));
2860 fprintf (stream
, _("\
2861 -I --histogram Display histogram of bucket list lengths\n\
2862 -W --wide Allow output width to exceed 80 characters\n\
2863 @<file> Read options from <file>\n\
2864 -H --help Display this information\n\
2865 -v --version Display the version number of readelf\n"));
2867 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2868 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2870 exit (stream
== stdout
? 0 : 1);
2873 /* Record the fact that the user wants the contents of section number
2874 SECTION to be displayed using the method(s) encoded as flags bits
2875 in TYPE. Note, TYPE can be zero if we are creating the array for
2879 request_dump_bynumber (unsigned int section
, dump_type type
)
2881 if (section
>= num_dump_sects
)
2883 dump_type
*new_dump_sects
;
2885 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2887 if (new_dump_sects
== NULL
)
2888 error (_("Out of memory allocating dump request table.\n"));
2891 /* Copy current flag settings. */
2892 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2896 dump_sects
= new_dump_sects
;
2897 num_dump_sects
= section
+ 1;
2902 dump_sects
[section
] |= type
;
2907 /* Request a dump by section name. */
2910 request_dump_byname (const char *section
, dump_type type
)
2912 struct dump_list_entry
*new_request
;
2914 new_request
= malloc (sizeof (struct dump_list_entry
));
2916 error (_("Out of memory allocating dump request table.\n"));
2918 new_request
->name
= strdup (section
);
2919 if (!new_request
->name
)
2920 error (_("Out of memory allocating dump request table.\n"));
2922 new_request
->type
= type
;
2924 new_request
->next
= dump_sects_byname
;
2925 dump_sects_byname
= new_request
;
2929 parse_args (int argc
, char **argv
)
2936 while ((c
= getopt_long
2937 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
2958 do_section_groups
++;
2966 do_section_groups
++;
2971 do_section_details
++;
3016 section
= strtoul (optarg
, & cp
, 0);
3017 if (! *cp
&& section
>= 0)
3018 request_dump_bynumber (section
, HEX_DUMP
);
3020 request_dump_byname (optarg
, HEX_DUMP
);
3024 section
= strtoul (optarg
, & cp
, 0);
3025 if (! *cp
&& section
>= 0)
3026 request_dump_bynumber (section
, STRING_DUMP
);
3028 request_dump_byname (optarg
, STRING_DUMP
);
3036 unsigned int index
= 0;
3040 while (optarg
[index
])
3041 switch (optarg
[index
++])
3048 do_debug_abbrevs
= 1;
3056 do_debug_lines_decoded
= 1;
3060 do_debug_pubnames
= 1;
3064 do_debug_aranges
= 1;
3068 do_debug_ranges
= 1;
3072 do_debug_frames_interp
= 1;
3074 do_debug_frames
= 1;
3078 do_debug_macinfo
= 1;
3090 warn (_("Unrecognized debug option '%s'\n"), optarg
);
3095 case OPTION_DEBUG_DUMP
:
3103 const char * option
;
3106 debug_dump_long_opts
;
3108 debug_dump_long_opts opts_table
[] =
3110 /* Please keep this table alpha- sorted. */
3111 { "Ranges", & do_debug_ranges
},
3112 { "abbrev", & do_debug_abbrevs
},
3113 { "aranges", & do_debug_aranges
},
3114 { "frames", & do_debug_frames
},
3115 { "frames-interp", & do_debug_frames_interp
},
3116 { "info", & do_debug_info
},
3117 { "line", & do_debug_lines
}, /* For backwards compatibility. */
3118 { "rawline", & do_debug_lines
},
3119 { "decodedline", & do_debug_lines_decoded
},
3120 { "loc", & do_debug_loc
},
3121 { "macro", & do_debug_macinfo
},
3122 { "pubnames", & do_debug_pubnames
},
3123 /* This entry is for compatability
3124 with earlier versions of readelf. */
3125 { "ranges", & do_debug_aranges
},
3126 { "str", & do_debug_str
},
3137 debug_dump_long_opts
* entry
;
3139 for (entry
= opts_table
; entry
->option
; entry
++)
3141 size_t len
= strlen (entry
->option
);
3143 if (strneq (p
, entry
->option
, len
)
3144 && (p
[len
] == ',' || p
[len
] == '\0'))
3146 * entry
->variable
= 1;
3148 /* The --debug-dump=frames-interp option also
3149 enables the --debug-dump=frames option. */
3150 if (do_debug_frames_interp
)
3151 do_debug_frames
= 1;
3158 if (entry
->option
== NULL
)
3160 warn (_("Unrecognized debug option '%s'\n"), p
);
3161 p
= strchr (p
, ',');
3171 #ifdef SUPPORT_DISASSEMBLY
3174 section
= strtoul (optarg
, & cp
, 0);
3175 if (! *cp
&& section
>= 0)
3176 request_dump_bynumber (section
, DISASS_DUMP
);
3178 request_dump_byname (optarg
, DISASS_DUMP
);
3181 print_version (program_name
);
3190 /* xgettext:c-format */
3191 error (_("Invalid option '-%c'\n"), c
);
3198 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3199 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3200 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3201 && !do_section_groups
&& !do_archive_index
)
3205 warn (_("Nothing to do.\n"));
3211 get_elf_class (unsigned int elf_class
)
3213 static char buff
[32];
3217 case ELFCLASSNONE
: return _("none");
3218 case ELFCLASS32
: return "ELF32";
3219 case ELFCLASS64
: return "ELF64";
3221 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3227 get_data_encoding (unsigned int encoding
)
3229 static char buff
[32];
3233 case ELFDATANONE
: return _("none");
3234 case ELFDATA2LSB
: return _("2's complement, little endian");
3235 case ELFDATA2MSB
: return _("2's complement, big endian");
3237 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3242 /* Decode the data held in 'elf_header'. */
3245 process_file_header (void)
3247 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3248 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3249 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3250 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3253 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3257 init_dwarf_regnames (elf_header
.e_machine
);
3263 printf (_("ELF Header:\n"));
3264 printf (_(" Magic: "));
3265 for (i
= 0; i
< EI_NIDENT
; i
++)
3266 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3268 printf (_(" Class: %s\n"),
3269 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3270 printf (_(" Data: %s\n"),
3271 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3272 printf (_(" Version: %d %s\n"),
3273 elf_header
.e_ident
[EI_VERSION
],
3274 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3276 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3279 printf (_(" OS/ABI: %s\n"),
3280 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3281 printf (_(" ABI Version: %d\n"),
3282 elf_header
.e_ident
[EI_ABIVERSION
]);
3283 printf (_(" Type: %s\n"),
3284 get_file_type (elf_header
.e_type
));
3285 printf (_(" Machine: %s\n"),
3286 get_machine_name (elf_header
.e_machine
));
3287 printf (_(" Version: 0x%lx\n"),
3288 (unsigned long) elf_header
.e_version
);
3290 printf (_(" Entry point address: "));
3291 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3292 printf (_("\n Start of program headers: "));
3293 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3294 printf (_(" (bytes into file)\n Start of section headers: "));
3295 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3296 printf (_(" (bytes into file)\n"));
3298 printf (_(" Flags: 0x%lx%s\n"),
3299 (unsigned long) elf_header
.e_flags
,
3300 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3301 printf (_(" Size of this header: %ld (bytes)\n"),
3302 (long) elf_header
.e_ehsize
);
3303 printf (_(" Size of program headers: %ld (bytes)\n"),
3304 (long) elf_header
.e_phentsize
);
3305 printf (_(" Number of program headers: %ld\n"),
3306 (long) elf_header
.e_phnum
);
3307 printf (_(" Size of section headers: %ld (bytes)\n"),
3308 (long) elf_header
.e_shentsize
);
3309 printf (_(" Number of section headers: %ld"),
3310 (long) elf_header
.e_shnum
);
3311 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3312 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3313 putc ('\n', stdout
);
3314 printf (_(" Section header string table index: %ld"),
3315 (long) elf_header
.e_shstrndx
);
3316 if (section_headers
!= NULL
3317 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3318 printf (" (%u)", section_headers
[0].sh_link
);
3319 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3320 printf (" <corrupt: out of range>");
3321 putc ('\n', stdout
);
3324 if (section_headers
!= NULL
)
3326 if (elf_header
.e_shnum
== SHN_UNDEF
)
3327 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3328 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3329 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3330 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3331 elf_header
.e_shstrndx
= SHN_UNDEF
;
3332 free (section_headers
);
3333 section_headers
= NULL
;
3341 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3343 Elf32_External_Phdr
*phdrs
;
3344 Elf32_External_Phdr
*external
;
3345 Elf_Internal_Phdr
*internal
;
3348 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3349 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3350 _("program headers"));
3354 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3355 i
< elf_header
.e_phnum
;
3356 i
++, internal
++, external
++)
3358 internal
->p_type
= BYTE_GET (external
->p_type
);
3359 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3360 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3361 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3362 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3363 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3364 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3365 internal
->p_align
= BYTE_GET (external
->p_align
);
3374 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3376 Elf64_External_Phdr
*phdrs
;
3377 Elf64_External_Phdr
*external
;
3378 Elf_Internal_Phdr
*internal
;
3381 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3382 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3383 _("program headers"));
3387 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3388 i
< elf_header
.e_phnum
;
3389 i
++, internal
++, external
++)
3391 internal
->p_type
= BYTE_GET (external
->p_type
);
3392 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3393 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3394 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3395 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3396 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3397 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3398 internal
->p_align
= BYTE_GET (external
->p_align
);
3406 /* Returns 1 if the program headers were read into `program_headers'. */
3409 get_program_headers (FILE *file
)
3411 Elf_Internal_Phdr
*phdrs
;
3413 /* Check cache of prior read. */
3414 if (program_headers
!= NULL
)
3417 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3421 error (_("Out of memory\n"));
3426 ? get_32bit_program_headers (file
, phdrs
)
3427 : get_64bit_program_headers (file
, phdrs
))
3429 program_headers
= phdrs
;
3437 /* Returns 1 if the program headers were loaded. */
3440 process_program_headers (FILE *file
)
3442 Elf_Internal_Phdr
*segment
;
3445 if (elf_header
.e_phnum
== 0)
3448 printf (_("\nThere are no program headers in this file.\n"));
3452 if (do_segments
&& !do_header
)
3454 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3455 printf (_("Entry point "));
3456 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3457 printf (_("\nThere are %d program headers, starting at offset "),
3458 elf_header
.e_phnum
);
3459 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3463 if (! get_program_headers (file
))
3468 if (elf_header
.e_phnum
> 1)
3469 printf (_("\nProgram Headers:\n"));
3471 printf (_("\nProgram Headers:\n"));
3475 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3478 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3482 (_(" Type Offset VirtAddr PhysAddr\n"));
3484 (_(" FileSiz MemSiz Flags Align\n"));
3491 for (i
= 0, segment
= program_headers
;
3492 i
< elf_header
.e_phnum
;
3497 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3501 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3502 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3503 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3504 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3505 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3507 (segment
->p_flags
& PF_R
? 'R' : ' '),
3508 (segment
->p_flags
& PF_W
? 'W' : ' '),
3509 (segment
->p_flags
& PF_X
? 'E' : ' '));
3510 printf ("%#lx", (unsigned long) segment
->p_align
);
3514 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3515 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3518 print_vma (segment
->p_offset
, FULL_HEX
);
3522 print_vma (segment
->p_vaddr
, FULL_HEX
);
3524 print_vma (segment
->p_paddr
, FULL_HEX
);
3527 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3528 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3531 print_vma (segment
->p_filesz
, FULL_HEX
);
3535 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3536 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3539 print_vma (segment
->p_offset
, FULL_HEX
);
3543 (segment
->p_flags
& PF_R
? 'R' : ' '),
3544 (segment
->p_flags
& PF_W
? 'W' : ' '),
3545 (segment
->p_flags
& PF_X
? 'E' : ' '));
3547 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3548 printf ("%#lx", (unsigned long) segment
->p_align
);
3551 print_vma (segment
->p_align
, PREFIX_HEX
);
3556 print_vma (segment
->p_offset
, FULL_HEX
);
3558 print_vma (segment
->p_vaddr
, FULL_HEX
);
3560 print_vma (segment
->p_paddr
, FULL_HEX
);
3562 print_vma (segment
->p_filesz
, FULL_HEX
);
3564 print_vma (segment
->p_memsz
, FULL_HEX
);
3566 (segment
->p_flags
& PF_R
? 'R' : ' '),
3567 (segment
->p_flags
& PF_W
? 'W' : ' '),
3568 (segment
->p_flags
& PF_X
? 'E' : ' '));
3569 print_vma (segment
->p_align
, HEX
);
3573 switch (segment
->p_type
)
3577 error (_("more than one dynamic segment\n"));
3579 /* By default, assume that the .dynamic section is the first
3580 section in the DYNAMIC segment. */
3581 dynamic_addr
= segment
->p_offset
;
3582 dynamic_size
= segment
->p_filesz
;
3584 /* Try to locate the .dynamic section. If there is
3585 a section header table, we can easily locate it. */
3586 if (section_headers
!= NULL
)
3588 Elf_Internal_Shdr
*sec
;
3590 sec
= find_section (".dynamic");
3591 if (sec
== NULL
|| sec
->sh_size
== 0)
3593 error (_("no .dynamic section in the dynamic segment\n"));
3597 if (sec
->sh_type
== SHT_NOBITS
)
3603 dynamic_addr
= sec
->sh_offset
;
3604 dynamic_size
= sec
->sh_size
;
3606 if (dynamic_addr
< segment
->p_offset
3607 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3608 warn (_("the .dynamic section is not contained"
3609 " within the dynamic segment\n"));
3610 else if (dynamic_addr
> segment
->p_offset
)
3611 warn (_("the .dynamic section is not the first section"
3612 " in the dynamic segment.\n"));
3617 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3619 error (_("Unable to find program interpreter name\n"));
3623 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3625 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3626 error (_("Internal error: failed to create format string to display program interpreter\n"));
3628 program_interpreter
[0] = 0;
3629 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3630 error (_("Unable to read program interpreter name\n"));
3633 printf (_("\n [Requesting program interpreter: %s]"),
3634 program_interpreter
);
3640 putc ('\n', stdout
);
3643 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3645 printf (_("\n Section to Segment mapping:\n"));
3646 printf (_(" Segment Sections...\n"));
3648 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3651 Elf_Internal_Shdr
*section
;
3653 segment
= program_headers
+ i
;
3654 section
= section_headers
+ 1;
3656 printf (" %2.2d ", i
);
3658 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3660 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3661 printf ("%s ", SECTION_NAME (section
));
3672 /* Find the file offset corresponding to VMA by using the program headers. */
3675 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3677 Elf_Internal_Phdr
*seg
;
3679 if (! get_program_headers (file
))
3681 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3685 for (seg
= program_headers
;
3686 seg
< program_headers
+ elf_header
.e_phnum
;
3689 if (seg
->p_type
!= PT_LOAD
)
3692 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3693 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3694 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3697 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3698 (unsigned long) vma
);
3704 get_32bit_section_headers (FILE *file
, unsigned int num
)
3706 Elf32_External_Shdr
*shdrs
;
3707 Elf_Internal_Shdr
*internal
;
3710 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3711 elf_header
.e_shentsize
, num
, _("section headers"));
3715 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3717 if (section_headers
== NULL
)
3719 error (_("Out of memory\n"));
3723 for (i
= 0, internal
= section_headers
;
3727 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3728 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3729 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3730 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3731 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3732 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3733 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3734 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3735 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3736 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3745 get_64bit_section_headers (FILE *file
, unsigned int num
)
3747 Elf64_External_Shdr
*shdrs
;
3748 Elf_Internal_Shdr
*internal
;
3751 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3752 elf_header
.e_shentsize
, num
, _("section headers"));
3756 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3758 if (section_headers
== NULL
)
3760 error (_("Out of memory\n"));
3764 for (i
= 0, internal
= section_headers
;
3768 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3769 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3770 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3771 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3772 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3773 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3774 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3775 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3776 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3777 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3785 static Elf_Internal_Sym
*
3786 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3788 unsigned long number
;
3789 Elf32_External_Sym
*esyms
;
3790 Elf_External_Sym_Shndx
*shndx
;
3791 Elf_Internal_Sym
*isyms
;
3792 Elf_Internal_Sym
*psym
;
3795 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3801 if (symtab_shndx_hdr
!= NULL
3802 && (symtab_shndx_hdr
->sh_link
3803 == (unsigned long) (section
- section_headers
)))
3805 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3806 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3814 number
= section
->sh_size
/ section
->sh_entsize
;
3815 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3819 error (_("Out of memory\n"));
3826 for (j
= 0, psym
= isyms
;
3830 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3831 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3832 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3833 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3834 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3836 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3837 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3838 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3839 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3840 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3850 static Elf_Internal_Sym
*
3851 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3853 unsigned long number
;
3854 Elf64_External_Sym
*esyms
;
3855 Elf_External_Sym_Shndx
*shndx
;
3856 Elf_Internal_Sym
*isyms
;
3857 Elf_Internal_Sym
*psym
;
3860 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3866 if (symtab_shndx_hdr
!= NULL
3867 && (symtab_shndx_hdr
->sh_link
3868 == (unsigned long) (section
- section_headers
)))
3870 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3871 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3879 number
= section
->sh_size
/ section
->sh_entsize
;
3880 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3884 error (_("Out of memory\n"));
3891 for (j
= 0, psym
= isyms
;
3895 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3896 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3897 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3898 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3899 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3901 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3902 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3903 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3904 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3905 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3916 get_elf_section_flags (bfd_vma sh_flags
)
3918 static char buff
[1024];
3920 int field_size
= is_32bit_elf
? 8 : 16;
3921 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3922 bfd_vma os_flags
= 0;
3923 bfd_vma proc_flags
= 0;
3924 bfd_vma unknown_flags
= 0;
3938 { "LINK ORDER", 10 },
3939 { "OS NONCONF", 10 },
3942 /* IA-64 specific. */
3945 /* IA-64 OpenVMS specific. */
3946 { "VMS_GLOBAL", 10 },
3947 { "VMS_OVERLAID", 12 },
3948 { "VMS_SHARED", 10 },
3949 { "VMS_VECTOR", 10 },
3950 { "VMS_ALLOC_64BIT", 15 },
3951 { "VMS_PROTECTED", 13}
3954 if (do_section_details
)
3956 sprintf (buff
, "[%*.*lx]: ",
3957 field_size
, field_size
, (unsigned long) sh_flags
);
3958 p
+= field_size
+ 4;
3965 flag
= sh_flags
& - sh_flags
;
3968 if (do_section_details
)
3972 case SHF_WRITE
: index
= 0; break;
3973 case SHF_ALLOC
: index
= 1; break;
3974 case SHF_EXECINSTR
: index
= 2; break;
3975 case SHF_MERGE
: index
= 3; break;
3976 case SHF_STRINGS
: index
= 4; break;
3977 case SHF_INFO_LINK
: index
= 5; break;
3978 case SHF_LINK_ORDER
: index
= 6; break;
3979 case SHF_OS_NONCONFORMING
: index
= 7; break;
3980 case SHF_GROUP
: index
= 8; break;
3981 case SHF_TLS
: index
= 9; break;
3985 if (elf_header
.e_machine
== EM_IA_64
)
3987 if (flag
== SHF_IA_64_SHORT
)
3989 else if (flag
== SHF_IA_64_NORECOV
)
3992 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3995 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3996 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3997 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3998 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3999 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
4000 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
4010 if (p
!= buff
+ field_size
+ 4)
4012 if (size
< (10 + 2))
4019 size
-= flags
[index
].len
;
4020 p
= stpcpy (p
, flags
[index
].str
);
4022 else if (flag
& SHF_MASKOS
)
4024 else if (flag
& SHF_MASKPROC
)
4027 unknown_flags
|= flag
;
4033 case SHF_WRITE
: *p
= 'W'; break;
4034 case SHF_ALLOC
: *p
= 'A'; break;
4035 case SHF_EXECINSTR
: *p
= 'X'; break;
4036 case SHF_MERGE
: *p
= 'M'; break;
4037 case SHF_STRINGS
: *p
= 'S'; break;
4038 case SHF_INFO_LINK
: *p
= 'I'; break;
4039 case SHF_LINK_ORDER
: *p
= 'L'; break;
4040 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4041 case SHF_GROUP
: *p
= 'G'; break;
4042 case SHF_TLS
: *p
= 'T'; break;
4045 if (elf_header
.e_machine
== EM_X86_64
4046 && flag
== SHF_X86_64_LARGE
)
4048 else if (flag
& SHF_MASKOS
)
4051 sh_flags
&= ~ SHF_MASKOS
;
4053 else if (flag
& SHF_MASKPROC
)
4056 sh_flags
&= ~ SHF_MASKPROC
;
4066 if (do_section_details
)
4070 size
-= 5 + field_size
;
4071 if (p
!= buff
+ field_size
+ 4)
4079 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4080 (unsigned long) os_flags
);
4081 p
+= 5 + field_size
;
4085 size
-= 7 + field_size
;
4086 if (p
!= buff
+ field_size
+ 4)
4094 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4095 (unsigned long) proc_flags
);
4096 p
+= 7 + field_size
;
4100 size
-= 10 + field_size
;
4101 if (p
!= buff
+ field_size
+ 4)
4109 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4110 (unsigned long) unknown_flags
);
4111 p
+= 10 + field_size
;
4120 process_section_headers (FILE *file
)
4122 Elf_Internal_Shdr
*section
;
4125 section_headers
= NULL
;
4127 if (elf_header
.e_shnum
== 0)
4130 printf (_("\nThere are no sections in this file.\n"));
4135 if (do_sections
&& !do_header
)
4136 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4137 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4141 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4144 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4147 /* Read in the string table, so that we have names to display. */
4148 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4149 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4151 section
= section_headers
+ elf_header
.e_shstrndx
;
4153 if (section
->sh_size
!= 0)
4155 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4156 1, section
->sh_size
, _("string table"));
4158 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4162 /* Scan the sections for the dynamic symbol table
4163 and dynamic string table and debug sections. */
4164 dynamic_symbols
= NULL
;
4165 dynamic_strings
= NULL
;
4166 dynamic_syminfo
= NULL
;
4167 symtab_shndx_hdr
= NULL
;
4169 eh_addr_size
= is_32bit_elf
? 4 : 8;
4170 switch (elf_header
.e_machine
)
4173 case EM_MIPS_RS3_LE
:
4174 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4175 FDE addresses. However, the ABI also has a semi-official ILP32
4176 variant for which the normal FDE address size rules apply.
4178 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4179 section, where XX is the size of longs in bits. Unfortunately,
4180 earlier compilers provided no way of distinguishing ILP32 objects
4181 from LP64 objects, so if there's any doubt, we should assume that
4182 the official LP64 form is being used. */
4183 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4184 && find_section (".gcc_compiled_long32") == NULL
)
4190 switch (elf_header
.e_flags
& EF_H8_MACH
)
4192 case E_H8_MACH_H8300
:
4193 case E_H8_MACH_H8300HN
:
4194 case E_H8_MACH_H8300SN
:
4195 case E_H8_MACH_H8300SXN
:
4198 case E_H8_MACH_H8300H
:
4199 case E_H8_MACH_H8300S
:
4200 case E_H8_MACH_H8300SX
:
4208 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4210 case EF_M32C_CPU_M16C
:
4217 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4220 size_t expected_entsize \
4221 = is_32bit_elf ? size32 : size64; \
4222 if (section->sh_entsize != expected_entsize) \
4223 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4224 i, (unsigned long int) section->sh_entsize, \
4225 (unsigned long int) expected_entsize); \
4226 section->sh_entsize = expected_entsize; \
4229 #define CHECK_ENTSIZE(section, i, type) \
4230 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4231 sizeof (Elf64_External_##type))
4233 for (i
= 0, section
= section_headers
;
4234 i
< elf_header
.e_shnum
;
4237 char *name
= SECTION_NAME (section
);
4239 if (section
->sh_type
== SHT_DYNSYM
)
4241 if (dynamic_symbols
!= NULL
)
4243 error (_("File contains multiple dynamic symbol tables\n"));
4247 CHECK_ENTSIZE (section
, i
, Sym
);
4248 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4249 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4251 else if (section
->sh_type
== SHT_STRTAB
4252 && streq (name
, ".dynstr"))
4254 if (dynamic_strings
!= NULL
)
4256 error (_("File contains multiple dynamic string tables\n"));
4260 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4261 1, section
->sh_size
, _("dynamic strings"));
4262 dynamic_strings_length
= section
->sh_size
;
4264 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4266 if (symtab_shndx_hdr
!= NULL
)
4268 error (_("File contains multiple symtab shndx tables\n"));
4271 symtab_shndx_hdr
= section
;
4273 else if (section
->sh_type
== SHT_SYMTAB
)
4274 CHECK_ENTSIZE (section
, i
, Sym
);
4275 else if (section
->sh_type
== SHT_GROUP
)
4276 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4277 else if (section
->sh_type
== SHT_REL
)
4278 CHECK_ENTSIZE (section
, i
, Rel
);
4279 else if (section
->sh_type
== SHT_RELA
)
4280 CHECK_ENTSIZE (section
, i
, Rela
);
4281 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4282 || do_debug_lines
|| do_debug_lines_decoded
|| do_debug_pubnames
4283 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4284 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4285 && (const_strneq (name
, ".debug_")
4286 || const_strneq (name
, ".zdebug_")))
4289 name
+= sizeof (".zdebug_") - 1;
4291 name
+= sizeof (".debug_") - 1;
4294 || (do_debug_info
&& streq (name
, "info"))
4295 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4296 || ((do_debug_lines
|| do_debug_lines_decoded
)
4297 && streq (name
, "line"))
4298 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4299 || (do_debug_aranges
&& streq (name
, "aranges"))
4300 || (do_debug_ranges
&& streq (name
, "ranges"))
4301 || (do_debug_frames
&& streq (name
, "frame"))
4302 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4303 || (do_debug_str
&& streq (name
, "str"))
4304 || (do_debug_loc
&& streq (name
, "loc"))
4306 request_dump_bynumber (i
, DEBUG_DUMP
);
4308 /* Linkonce section to be combined with .debug_info at link time. */
4309 else if ((do_debugging
|| do_debug_info
)
4310 && const_strneq (name
, ".gnu.linkonce.wi."))
4311 request_dump_bynumber (i
, DEBUG_DUMP
);
4312 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4313 request_dump_bynumber (i
, DEBUG_DUMP
);
4319 if (elf_header
.e_shnum
> 1)
4320 printf (_("\nSection Headers:\n"));
4322 printf (_("\nSection Header:\n"));
4326 if (do_section_details
)
4328 printf (_(" [Nr] Name\n"));
4329 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4333 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4337 if (do_section_details
)
4339 printf (_(" [Nr] Name\n"));
4340 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4344 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4348 if (do_section_details
)
4350 printf (_(" [Nr] Name\n"));
4351 printf (_(" Type Address Offset Link\n"));
4352 printf (_(" Size EntSize Info Align\n"));
4356 printf (_(" [Nr] Name Type Address Offset\n"));
4357 printf (_(" Size EntSize Flags Link Info Align\n"));
4361 if (do_section_details
)
4362 printf (_(" Flags\n"));
4364 for (i
= 0, section
= section_headers
;
4365 i
< elf_header
.e_shnum
;
4368 if (do_section_details
)
4370 printf (" [%2u] %s\n",
4372 SECTION_NAME (section
));
4373 if (is_32bit_elf
|| do_wide
)
4374 printf (" %-15.15s ",
4375 get_section_type_name (section
->sh_type
));
4378 printf (" [%2u] %-17.17s %-15.15s ",
4380 SECTION_NAME (section
),
4381 get_section_type_name (section
->sh_type
));
4385 print_vma (section
->sh_addr
, LONG_HEX
);
4387 printf ( " %6.6lx %6.6lx %2.2lx",
4388 (unsigned long) section
->sh_offset
,
4389 (unsigned long) section
->sh_size
,
4390 (unsigned long) section
->sh_entsize
);
4392 if (do_section_details
)
4393 fputs (" ", stdout
);
4395 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4397 printf ("%2u %3u %2lu\n",
4400 (unsigned long) section
->sh_addralign
);
4404 print_vma (section
->sh_addr
, LONG_HEX
);
4406 if ((long) section
->sh_offset
== section
->sh_offset
)
4407 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4411 print_vma (section
->sh_offset
, LONG_HEX
);
4414 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4415 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4419 print_vma (section
->sh_size
, LONG_HEX
);
4422 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4423 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4427 print_vma (section
->sh_entsize
, LONG_HEX
);
4430 if (do_section_details
)
4431 fputs (" ", stdout
);
4433 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4435 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4437 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4438 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4441 print_vma (section
->sh_addralign
, DEC
);
4445 else if (do_section_details
)
4447 printf (" %-15.15s ",
4448 get_section_type_name (section
->sh_type
));
4449 print_vma (section
->sh_addr
, LONG_HEX
);
4450 if ((long) section
->sh_offset
== section
->sh_offset
)
4451 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4455 print_vma (section
->sh_offset
, LONG_HEX
);
4457 printf (" %u\n ", section
->sh_link
);
4458 print_vma (section
->sh_size
, LONG_HEX
);
4460 print_vma (section
->sh_entsize
, LONG_HEX
);
4462 printf (" %-16u %lu\n",
4464 (unsigned long) section
->sh_addralign
);
4469 print_vma (section
->sh_addr
, LONG_HEX
);
4470 if ((long) section
->sh_offset
== section
->sh_offset
)
4471 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4475 print_vma (section
->sh_offset
, LONG_HEX
);
4478 print_vma (section
->sh_size
, LONG_HEX
);
4480 print_vma (section
->sh_entsize
, LONG_HEX
);
4482 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4484 printf (" %2u %3u %lu\n",
4487 (unsigned long) section
->sh_addralign
);
4490 if (do_section_details
)
4491 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4494 if (!do_section_details
)
4495 printf (_("Key to Flags:\n\
4496 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4497 I (info), L (link order), G (group), x (unknown)\n\
4498 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4504 get_group_flags (unsigned int flags
)
4506 static char buff
[32];
4513 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4520 process_section_groups (FILE *file
)
4522 Elf_Internal_Shdr
*section
;
4524 struct group
*group
;
4525 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4526 Elf_Internal_Sym
*symtab
;
4530 /* Don't process section groups unless needed. */
4531 if (!do_unwind
&& !do_section_groups
)
4534 if (elf_header
.e_shnum
== 0)
4536 if (do_section_groups
)
4537 printf (_("\nThere are no sections in this file.\n"));
4542 if (section_headers
== NULL
)
4544 error (_("Section headers are not available!\n"));
4548 section_headers_groups
= calloc (elf_header
.e_shnum
,
4549 sizeof (struct group
*));
4551 if (section_headers_groups
== NULL
)
4553 error (_("Out of memory\n"));
4557 /* Scan the sections for the group section. */
4559 for (i
= 0, section
= section_headers
;
4560 i
< elf_header
.e_shnum
;
4562 if (section
->sh_type
== SHT_GROUP
)
4565 if (group_count
== 0)
4567 if (do_section_groups
)
4568 printf (_("\nThere are no section groups in this file.\n"));
4573 section_groups
= calloc (group_count
, sizeof (struct group
));
4575 if (section_groups
== NULL
)
4577 error (_("Out of memory\n"));
4586 for (i
= 0, section
= section_headers
, group
= section_groups
;
4587 i
< elf_header
.e_shnum
;
4590 if (section
->sh_type
== SHT_GROUP
)
4592 char *name
= SECTION_NAME (section
);
4594 unsigned char *start
, *indices
;
4595 unsigned int entry
, j
, size
;
4596 Elf_Internal_Shdr
*sec
;
4597 Elf_Internal_Sym
*sym
;
4599 /* Get the symbol table. */
4600 if (section
->sh_link
>= elf_header
.e_shnum
4601 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4604 error (_("Bad sh_link in group section `%s'\n"), name
);
4608 if (symtab_sec
!= sec
)
4613 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4616 sym
= symtab
+ section
->sh_info
;
4618 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4620 if (sym
->st_shndx
== 0
4621 || sym
->st_shndx
>= elf_header
.e_shnum
)
4623 error (_("Bad sh_info in group section `%s'\n"), name
);
4627 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4636 /* Get the string table. */
4637 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4646 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4651 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4652 1, strtab_sec
->sh_size
,
4654 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4656 group_name
= sym
->st_name
< strtab_size
4657 ? strtab
+ sym
->st_name
: "<corrupt>";
4660 start
= get_data (NULL
, file
, section
->sh_offset
,
4661 1, section
->sh_size
, _("section data"));
4664 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4665 entry
= byte_get (indices
, 4);
4668 if (do_section_groups
)
4670 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4671 get_group_flags (entry
), i
, name
, group_name
, size
);
4673 printf (_(" [Index] Name\n"));
4676 group
->group_index
= i
;
4678 for (j
= 0; j
< size
; j
++)
4680 struct group_list
*g
;
4682 entry
= byte_get (indices
, 4);
4685 if (entry
>= elf_header
.e_shnum
)
4687 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4688 entry
, i
, elf_header
.e_shnum
- 1);
4692 if (section_headers_groups
[entry
] != NULL
)
4696 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4698 section_headers_groups
[entry
]->group_index
);
4703 /* Intel C/C++ compiler may put section 0 in a
4704 section group. We just warn it the first time
4705 and ignore it afterwards. */
4706 static int warned
= 0;
4709 error (_("section 0 in group section [%5u]\n"),
4710 section_headers_groups
[entry
]->group_index
);
4716 section_headers_groups
[entry
] = group
;
4718 if (do_section_groups
)
4720 sec
= section_headers
+ entry
;
4721 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4724 g
= xmalloc (sizeof (struct group_list
));
4725 g
->section_index
= entry
;
4726 g
->next
= group
->root
;
4750 } dynamic_relocations
[] =
4752 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4753 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4754 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4757 /* Process the reloc section. */
4760 process_relocs (FILE *file
)
4762 unsigned long rel_size
;
4763 unsigned long rel_offset
;
4769 if (do_using_dynamic
)
4773 int has_dynamic_reloc
;
4776 has_dynamic_reloc
= 0;
4778 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4780 is_rela
= dynamic_relocations
[i
].rela
;
4781 name
= dynamic_relocations
[i
].name
;
4782 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4783 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4785 has_dynamic_reloc
|= rel_size
;
4787 if (is_rela
== UNKNOWN
)
4789 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4790 switch (dynamic_info
[DT_PLTREL
])
4804 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4805 name
, rel_offset
, rel_size
);
4807 dump_relocations (file
,
4808 offset_from_vma (file
, rel_offset
, rel_size
),
4810 dynamic_symbols
, num_dynamic_syms
,
4811 dynamic_strings
, dynamic_strings_length
, is_rela
);
4815 if (! has_dynamic_reloc
)
4816 printf (_("\nThere are no dynamic relocations in this file.\n"));
4820 Elf_Internal_Shdr
*section
;
4824 for (i
= 0, section
= section_headers
;
4825 i
< elf_header
.e_shnum
;
4828 if ( section
->sh_type
!= SHT_RELA
4829 && section
->sh_type
!= SHT_REL
)
4832 rel_offset
= section
->sh_offset
;
4833 rel_size
= section
->sh_size
;
4837 Elf_Internal_Shdr
*strsec
;
4840 printf (_("\nRelocation section "));
4842 if (string_table
== NULL
)
4843 printf ("%d", section
->sh_name
);
4845 printf (_("'%s'"), SECTION_NAME (section
));
4847 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4848 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4850 is_rela
= section
->sh_type
== SHT_RELA
;
4852 if (section
->sh_link
!= 0
4853 && section
->sh_link
< elf_header
.e_shnum
)
4855 Elf_Internal_Shdr
*symsec
;
4856 Elf_Internal_Sym
*symtab
;
4857 unsigned long nsyms
;
4858 unsigned long strtablen
= 0;
4859 char *strtab
= NULL
;
4861 symsec
= section_headers
+ section
->sh_link
;
4862 if (symsec
->sh_type
!= SHT_SYMTAB
4863 && symsec
->sh_type
!= SHT_DYNSYM
)
4866 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4867 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4872 if (symsec
->sh_link
!= 0
4873 && symsec
->sh_link
< elf_header
.e_shnum
)
4875 strsec
= section_headers
+ symsec
->sh_link
;
4877 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4880 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4883 dump_relocations (file
, rel_offset
, rel_size
,
4884 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4890 dump_relocations (file
, rel_offset
, rel_size
,
4891 NULL
, 0, NULL
, 0, is_rela
);
4898 printf (_("\nThere are no relocations in this file.\n"));
4904 /* Process the unwind section. */
4906 #include "unwind-ia64.h"
4908 /* An absolute address consists of a section and an offset. If the
4909 section is NULL, the offset itself is the address, otherwise, the
4910 address equals to LOAD_ADDRESS(section) + offset. */
4914 unsigned short section
;
4918 #define ABSADDR(a) \
4920 ? section_headers [(a).section].sh_addr + (a).offset \
4923 struct ia64_unw_aux_info
4925 struct ia64_unw_table_entry
4927 struct absaddr start
;
4929 struct absaddr info
;
4931 *table
; /* Unwind table. */
4932 unsigned long table_len
; /* Length of unwind table. */
4933 unsigned char *info
; /* Unwind info. */
4934 unsigned long info_size
; /* Size of unwind info. */
4935 bfd_vma info_addr
; /* starting address of unwind info. */
4936 bfd_vma seg_base
; /* Starting address of segment. */
4937 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4938 unsigned long nsyms
; /* Number of symbols. */
4939 char *strtab
; /* The string table. */
4940 unsigned long strtab_size
; /* Size of string table. */
4944 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4945 unsigned long nsyms
,
4947 unsigned long strtab_size
,
4948 struct absaddr addr
,
4949 const char **symname
,
4952 bfd_vma dist
= 0x100000;
4953 Elf_Internal_Sym
*sym
, *best
= NULL
;
4956 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4958 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4959 && sym
->st_name
!= 0
4960 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4961 && addr
.offset
>= sym
->st_value
4962 && addr
.offset
- sym
->st_value
< dist
)
4965 dist
= addr
.offset
- sym
->st_value
;
4972 *symname
= (best
->st_name
>= strtab_size
4973 ? "<corrupt>" : strtab
+ best
->st_name
);
4978 *offset
= addr
.offset
;
4982 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4984 struct ia64_unw_table_entry
*tp
;
4987 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4991 const unsigned char *dp
;
4992 const unsigned char *head
;
4993 const char *procname
;
4995 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4996 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4998 fputs ("\n<", stdout
);
5002 fputs (procname
, stdout
);
5005 printf ("+%lx", (unsigned long) offset
);
5008 fputs (">: [", stdout
);
5009 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5010 fputc ('-', stdout
);
5011 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5012 printf ("], info at +0x%lx\n",
5013 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5015 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5016 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5018 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5019 (unsigned) UNW_VER (stamp
),
5020 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5021 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5022 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5023 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5025 if (UNW_VER (stamp
) != 1)
5027 printf ("\tUnknown version.\n");
5032 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5033 dp
= unw_decode (dp
, in_body
, & in_body
);
5038 slurp_ia64_unwind_table (FILE *file
,
5039 struct ia64_unw_aux_info
*aux
,
5040 Elf_Internal_Shdr
*sec
)
5042 unsigned long size
, nrelas
, i
;
5043 Elf_Internal_Phdr
*seg
;
5044 struct ia64_unw_table_entry
*tep
;
5045 Elf_Internal_Shdr
*relsec
;
5046 Elf_Internal_Rela
*rela
, *rp
;
5047 unsigned char *table
, *tp
;
5048 Elf_Internal_Sym
*sym
;
5049 const char *relname
;
5051 /* First, find the starting address of the segment that includes
5054 if (elf_header
.e_phnum
)
5056 if (! get_program_headers (file
))
5059 for (seg
= program_headers
;
5060 seg
< program_headers
+ elf_header
.e_phnum
;
5063 if (seg
->p_type
!= PT_LOAD
)
5066 if (sec
->sh_addr
>= seg
->p_vaddr
5067 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5069 aux
->seg_base
= seg
->p_vaddr
;
5075 /* Second, build the unwind table from the contents of the unwind section: */
5076 size
= sec
->sh_size
;
5077 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5081 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5083 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
5085 tep
->start
.section
= SHN_UNDEF
;
5086 tep
->end
.section
= SHN_UNDEF
;
5087 tep
->info
.section
= SHN_UNDEF
;
5090 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5091 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5092 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5096 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5097 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5098 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5100 tep
->start
.offset
+= aux
->seg_base
;
5101 tep
->end
.offset
+= aux
->seg_base
;
5102 tep
->info
.offset
+= aux
->seg_base
;
5106 /* Third, apply any relocations to the unwind table: */
5107 for (relsec
= section_headers
;
5108 relsec
< section_headers
+ elf_header
.e_shnum
;
5111 if (relsec
->sh_type
!= SHT_RELA
5112 || relsec
->sh_info
>= elf_header
.e_shnum
5113 || section_headers
+ relsec
->sh_info
!= sec
)
5116 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5120 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5122 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5123 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5125 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5127 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5131 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5133 switch (rp
->r_offset
/eh_addr_size
% 3)
5136 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5137 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5140 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5141 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5144 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5145 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5155 aux
->table_len
= size
/ (3 * eh_addr_size
);
5160 ia64_process_unwind (FILE *file
)
5162 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5163 unsigned long i
, unwcount
= 0, unwstart
= 0;
5164 struct ia64_unw_aux_info aux
;
5166 memset (& aux
, 0, sizeof (aux
));
5168 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5170 if (sec
->sh_type
== SHT_SYMTAB
5171 && sec
->sh_link
< elf_header
.e_shnum
)
5173 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5174 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5176 strsec
= section_headers
+ sec
->sh_link
;
5177 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5178 1, strsec
->sh_size
, _("string table"));
5179 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5181 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5186 printf (_("\nThere are no unwind sections in this file.\n"));
5188 while (unwcount
-- > 0)
5193 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5194 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5195 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5202 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5204 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5206 /* We need to find which section group it is in. */
5207 struct group_list
*g
= section_headers_groups
[i
]->root
;
5209 for (; g
!= NULL
; g
= g
->next
)
5211 sec
= section_headers
+ g
->section_index
;
5213 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5218 i
= elf_header
.e_shnum
;
5220 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5222 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5223 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5224 suffix
= SECTION_NAME (unwsec
) + len
;
5225 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5227 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5228 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5233 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5234 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5235 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5236 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5238 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5239 suffix
= SECTION_NAME (unwsec
) + len
;
5240 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5242 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5243 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5247 if (i
== elf_header
.e_shnum
)
5249 printf (_("\nCould not find unwind info section for "));
5251 if (string_table
== NULL
)
5252 printf ("%d", unwsec
->sh_name
);
5254 printf (_("'%s'"), SECTION_NAME (unwsec
));
5258 aux
.info_size
= sec
->sh_size
;
5259 aux
.info_addr
= sec
->sh_addr
;
5260 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5263 printf (_("\nUnwind section "));
5265 if (string_table
== NULL
)
5266 printf ("%d", unwsec
->sh_name
);
5268 printf (_("'%s'"), SECTION_NAME (unwsec
));
5270 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5271 (unsigned long) unwsec
->sh_offset
,
5272 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5274 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5276 if (aux
.table_len
> 0)
5277 dump_ia64_unwind (& aux
);
5280 free ((char *) aux
.table
);
5282 free ((char *) aux
.info
);
5291 free ((char *) aux
.strtab
);
5296 struct hppa_unw_aux_info
5298 struct hppa_unw_table_entry
5300 struct absaddr start
;
5302 unsigned int Cannot_unwind
:1; /* 0 */
5303 unsigned int Millicode
:1; /* 1 */
5304 unsigned int Millicode_save_sr0
:1; /* 2 */
5305 unsigned int Region_description
:2; /* 3..4 */
5306 unsigned int reserved1
:1; /* 5 */
5307 unsigned int Entry_SR
:1; /* 6 */
5308 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5309 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5310 unsigned int Args_stored
:1; /* 16 */
5311 unsigned int Variable_Frame
:1; /* 17 */
5312 unsigned int Separate_Package_Body
:1; /* 18 */
5313 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5314 unsigned int Stack_Overflow_Check
:1; /* 20 */
5315 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5316 unsigned int Ada_Region
:1; /* 22 */
5317 unsigned int cxx_info
:1; /* 23 */
5318 unsigned int cxx_try_catch
:1; /* 24 */
5319 unsigned int sched_entry_seq
:1; /* 25 */
5320 unsigned int reserved2
:1; /* 26 */
5321 unsigned int Save_SP
:1; /* 27 */
5322 unsigned int Save_RP
:1; /* 28 */
5323 unsigned int Save_MRP_in_frame
:1; /* 29 */
5324 unsigned int extn_ptr_defined
:1; /* 30 */
5325 unsigned int Cleanup_defined
:1; /* 31 */
5327 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5328 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5329 unsigned int Large_frame
:1; /* 2 */
5330 unsigned int Pseudo_SP_Set
:1; /* 3 */
5331 unsigned int reserved4
:1; /* 4 */
5332 unsigned int Total_frame_size
:27; /* 5..31 */
5334 *table
; /* Unwind table. */
5335 unsigned long table_len
; /* Length of unwind table. */
5336 bfd_vma seg_base
; /* Starting address of segment. */
5337 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5338 unsigned long nsyms
; /* Number of symbols. */
5339 char *strtab
; /* The string table. */
5340 unsigned long strtab_size
; /* Size of string table. */
5344 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5346 struct hppa_unw_table_entry
*tp
;
5348 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5351 const char *procname
;
5353 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5354 aux
->strtab_size
, tp
->start
, &procname
,
5357 fputs ("\n<", stdout
);
5361 fputs (procname
, stdout
);
5364 printf ("+%lx", (unsigned long) offset
);
5367 fputs (">: [", stdout
);
5368 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5369 fputc ('-', stdout
);
5370 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5373 #define PF(_m) if (tp->_m) printf (#_m " ");
5374 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5377 PF(Millicode_save_sr0
);
5378 /* PV(Region_description); */
5384 PF(Separate_Package_Body
);
5385 PF(Frame_Extension_Millicode
);
5386 PF(Stack_Overflow_Check
);
5387 PF(Two_Instruction_SP_Increment
);
5391 PF(sched_entry_seq
);
5394 PF(Save_MRP_in_frame
);
5395 PF(extn_ptr_defined
);
5396 PF(Cleanup_defined
);
5397 PF(MPE_XL_interrupt_marker
);
5398 PF(HP_UX_interrupt_marker
);
5401 PV(Total_frame_size
);
5410 slurp_hppa_unwind_table (FILE *file
,
5411 struct hppa_unw_aux_info
*aux
,
5412 Elf_Internal_Shdr
*sec
)
5414 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5415 Elf_Internal_Phdr
*seg
;
5416 struct hppa_unw_table_entry
*tep
;
5417 Elf_Internal_Shdr
*relsec
;
5418 Elf_Internal_Rela
*rela
, *rp
;
5419 unsigned char *table
, *tp
;
5420 Elf_Internal_Sym
*sym
;
5421 const char *relname
;
5423 /* First, find the starting address of the segment that includes
5426 if (elf_header
.e_phnum
)
5428 if (! get_program_headers (file
))
5431 for (seg
= program_headers
;
5432 seg
< program_headers
+ elf_header
.e_phnum
;
5435 if (seg
->p_type
!= PT_LOAD
)
5438 if (sec
->sh_addr
>= seg
->p_vaddr
5439 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5441 aux
->seg_base
= seg
->p_vaddr
;
5447 /* Second, build the unwind table from the contents of the unwind
5449 size
= sec
->sh_size
;
5450 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5455 nentries
= size
/ unw_ent_size
;
5456 size
= unw_ent_size
* nentries
;
5458 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5460 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5462 unsigned int tmp1
, tmp2
;
5464 tep
->start
.section
= SHN_UNDEF
;
5465 tep
->end
.section
= SHN_UNDEF
;
5467 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5468 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5469 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5470 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5472 tep
->start
.offset
+= aux
->seg_base
;
5473 tep
->end
.offset
+= aux
->seg_base
;
5475 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5476 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5477 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5478 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5479 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5480 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5481 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5482 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5483 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5484 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5485 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5486 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5487 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5488 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5489 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5490 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5491 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5492 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5493 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5494 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5495 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5496 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5497 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5498 tep
->Cleanup_defined
= tmp1
& 0x1;
5500 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5501 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5502 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5503 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5504 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5505 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5509 /* Third, apply any relocations to the unwind table. */
5510 for (relsec
= section_headers
;
5511 relsec
< section_headers
+ elf_header
.e_shnum
;
5514 if (relsec
->sh_type
!= SHT_RELA
5515 || relsec
->sh_info
>= elf_header
.e_shnum
5516 || section_headers
+ relsec
->sh_info
!= sec
)
5519 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5523 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5525 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5526 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5528 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5529 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5531 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5535 i
= rp
->r_offset
/ unw_ent_size
;
5537 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5540 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5541 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5544 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5545 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5555 aux
->table_len
= nentries
;
5561 hppa_process_unwind (FILE *file
)
5563 struct hppa_unw_aux_info aux
;
5564 Elf_Internal_Shdr
*unwsec
= NULL
;
5565 Elf_Internal_Shdr
*strsec
;
5566 Elf_Internal_Shdr
*sec
;
5569 memset (& aux
, 0, sizeof (aux
));
5571 if (string_table
== NULL
)
5574 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5576 if (sec
->sh_type
== SHT_SYMTAB
5577 && sec
->sh_link
< elf_header
.e_shnum
)
5579 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5580 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5582 strsec
= section_headers
+ sec
->sh_link
;
5583 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5584 1, strsec
->sh_size
, _("string table"));
5585 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5587 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5592 printf (_("\nThere are no unwind sections in this file.\n"));
5594 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5596 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5598 printf (_("\nUnwind section "));
5599 printf (_("'%s'"), SECTION_NAME (sec
));
5601 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5602 (unsigned long) sec
->sh_offset
,
5603 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5605 slurp_hppa_unwind_table (file
, &aux
, sec
);
5606 if (aux
.table_len
> 0)
5607 dump_hppa_unwind (&aux
);
5610 free ((char *) aux
.table
);
5618 free ((char *) aux
.strtab
);
5624 process_unwind (FILE *file
)
5626 struct unwind_handler
{
5628 int (*handler
)(FILE *file
);
5630 { EM_IA_64
, ia64_process_unwind
},
5631 { EM_PARISC
, hppa_process_unwind
},
5639 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5640 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5641 return handlers
[i
].handler (file
);
5643 printf (_("\nThere are no unwind sections in this file.\n"));
5648 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5650 switch (entry
->d_tag
)
5653 if (entry
->d_un
.d_val
== 0)
5657 static const char * opts
[] =
5659 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5660 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5661 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5662 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5667 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5668 if (entry
->d_un
.d_val
& (1 << cnt
))
5670 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5677 case DT_MIPS_IVERSION
:
5678 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5679 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5681 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5684 case DT_MIPS_TIME_STAMP
:
5689 time_t time
= entry
->d_un
.d_val
;
5690 tmp
= gmtime (&time
);
5691 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5692 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5693 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5694 printf ("Time Stamp: %s\n", timebuf
);
5698 case DT_MIPS_RLD_VERSION
:
5699 case DT_MIPS_LOCAL_GOTNO
:
5700 case DT_MIPS_CONFLICTNO
:
5701 case DT_MIPS_LIBLISTNO
:
5702 case DT_MIPS_SYMTABNO
:
5703 case DT_MIPS_UNREFEXTNO
:
5704 case DT_MIPS_HIPAGENO
:
5705 case DT_MIPS_DELTA_CLASS_NO
:
5706 case DT_MIPS_DELTA_INSTANCE_NO
:
5707 case DT_MIPS_DELTA_RELOC_NO
:
5708 case DT_MIPS_DELTA_SYM_NO
:
5709 case DT_MIPS_DELTA_CLASSSYM_NO
:
5710 case DT_MIPS_COMPACT_SIZE
:
5711 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5715 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5721 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5723 switch (entry
->d_tag
)
5725 case DT_HP_DLD_FLAGS
:
5734 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5735 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5736 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5737 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5738 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5739 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5740 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5741 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5742 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5743 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5744 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5745 { DT_HP_GST
, "HP_GST" },
5746 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5747 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5748 { DT_HP_NODELETE
, "HP_NODELETE" },
5749 { DT_HP_GROUP
, "HP_GROUP" },
5750 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5754 bfd_vma val
= entry
->d_un
.d_val
;
5756 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5757 if (val
& flags
[cnt
].bit
)
5761 fputs (flags
[cnt
].str
, stdout
);
5763 val
^= flags
[cnt
].bit
;
5766 if (val
!= 0 || first
)
5770 print_vma (val
, HEX
);
5776 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5783 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5785 switch (entry
->d_tag
)
5787 case DT_IA_64_PLT_RESERVE
:
5788 /* First 3 slots reserved. */
5789 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5791 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5795 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5802 get_32bit_dynamic_section (FILE *file
)
5804 Elf32_External_Dyn
*edyn
, *ext
;
5805 Elf_Internal_Dyn
*entry
;
5807 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5808 _("dynamic section"));
5812 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5813 might not have the luxury of section headers. Look for the DT_NULL
5814 terminator to determine the number of entries. */
5815 for (ext
= edyn
, dynamic_nent
= 0;
5816 (char *) ext
< (char *) edyn
+ dynamic_size
;
5820 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5824 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5825 if (dynamic_section
== NULL
)
5827 error (_("Out of memory\n"));
5832 for (ext
= edyn
, entry
= dynamic_section
;
5833 entry
< dynamic_section
+ dynamic_nent
;
5836 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5837 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5846 get_64bit_dynamic_section (FILE *file
)
5848 Elf64_External_Dyn
*edyn
, *ext
;
5849 Elf_Internal_Dyn
*entry
;
5851 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5852 _("dynamic section"));
5856 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5857 might not have the luxury of section headers. Look for the DT_NULL
5858 terminator to determine the number of entries. */
5859 for (ext
= edyn
, dynamic_nent
= 0;
5860 (char *) ext
< (char *) edyn
+ dynamic_size
;
5864 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5868 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5869 if (dynamic_section
== NULL
)
5871 error (_("Out of memory\n"));
5876 for (ext
= edyn
, entry
= dynamic_section
;
5877 entry
< dynamic_section
+ dynamic_nent
;
5880 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5881 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5890 print_dynamic_flags (bfd_vma flags
)
5898 flag
= flags
& - flags
;
5908 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5909 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5910 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5911 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5912 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5913 default: fputs ("unknown", stdout
); break;
5919 /* Parse and display the contents of the dynamic section. */
5922 process_dynamic_section (FILE *file
)
5924 Elf_Internal_Dyn
*entry
;
5926 if (dynamic_size
== 0)
5929 printf (_("\nThere is no dynamic section in this file.\n"));
5936 if (! get_32bit_dynamic_section (file
))
5939 else if (! get_64bit_dynamic_section (file
))
5942 /* Find the appropriate symbol table. */
5943 if (dynamic_symbols
== NULL
)
5945 for (entry
= dynamic_section
;
5946 entry
< dynamic_section
+ dynamic_nent
;
5949 Elf_Internal_Shdr section
;
5951 if (entry
->d_tag
!= DT_SYMTAB
)
5954 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5956 /* Since we do not know how big the symbol table is,
5957 we default to reading in the entire file (!) and
5958 processing that. This is overkill, I know, but it
5960 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5962 if (archive_file_offset
!= 0)
5963 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5966 if (fseek (file
, 0, SEEK_END
))
5967 error (_("Unable to seek to end of file!\n"));
5969 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5973 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5975 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5977 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5978 if (num_dynamic_syms
< 1)
5980 error (_("Unable to determine the number of symbols to load\n"));
5984 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5988 /* Similarly find a string table. */
5989 if (dynamic_strings
== NULL
)
5991 for (entry
= dynamic_section
;
5992 entry
< dynamic_section
+ dynamic_nent
;
5995 unsigned long offset
;
5998 if (entry
->d_tag
!= DT_STRTAB
)
6001 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6003 /* Since we do not know how big the string table is,
6004 we default to reading in the entire file (!) and
6005 processing that. This is overkill, I know, but it
6008 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6010 if (archive_file_offset
!= 0)
6011 str_tab_len
= archive_file_size
- offset
;
6014 if (fseek (file
, 0, SEEK_END
))
6015 error (_("Unable to seek to end of file\n"));
6016 str_tab_len
= ftell (file
) - offset
;
6019 if (str_tab_len
< 1)
6022 (_("Unable to determine the length of the dynamic string table\n"));
6026 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
6027 _("dynamic string table"));
6028 dynamic_strings_length
= str_tab_len
;
6033 /* And find the syminfo section if available. */
6034 if (dynamic_syminfo
== NULL
)
6036 unsigned long syminsz
= 0;
6038 for (entry
= dynamic_section
;
6039 entry
< dynamic_section
+ dynamic_nent
;
6042 if (entry
->d_tag
== DT_SYMINENT
)
6044 /* Note: these braces are necessary to avoid a syntax
6045 error from the SunOS4 C compiler. */
6046 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6048 else if (entry
->d_tag
== DT_SYMINSZ
)
6049 syminsz
= entry
->d_un
.d_val
;
6050 else if (entry
->d_tag
== DT_SYMINFO
)
6051 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6055 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6057 Elf_External_Syminfo
*extsyminfo
, *extsym
;
6058 Elf_Internal_Syminfo
*syminfo
;
6060 /* There is a syminfo section. Read the data. */
6061 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
6062 syminsz
, _("symbol information"));
6066 dynamic_syminfo
= malloc (syminsz
);
6067 if (dynamic_syminfo
== NULL
)
6069 error (_("Out of memory\n"));
6073 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6074 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6075 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6076 ++syminfo
, ++extsym
)
6078 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6079 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6086 if (do_dynamic
&& dynamic_addr
)
6087 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6088 dynamic_addr
, dynamic_nent
);
6090 printf (_(" Tag Type Name/Value\n"));
6092 for (entry
= dynamic_section
;
6093 entry
< dynamic_section
+ dynamic_nent
;
6101 print_vma (entry
->d_tag
, FULL_HEX
);
6102 dtype
= get_dynamic_type (entry
->d_tag
);
6103 printf (" (%s)%*s", dtype
,
6104 ((is_32bit_elf
? 27 : 19)
6105 - (int) strlen (dtype
)),
6109 switch (entry
->d_tag
)
6113 print_dynamic_flags (entry
->d_un
.d_val
);
6123 switch (entry
->d_tag
)
6126 printf (_("Auxiliary library"));
6130 printf (_("Filter library"));
6134 printf (_("Configuration file"));
6138 printf (_("Dependency audit library"));
6142 printf (_("Audit library"));
6146 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6147 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6151 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6160 printf (_("Flags:"));
6162 if (entry
->d_un
.d_val
== 0)
6163 printf (_(" None\n"));
6166 unsigned long int val
= entry
->d_un
.d_val
;
6168 if (val
& DTF_1_PARINIT
)
6170 printf (" PARINIT");
6171 val
^= DTF_1_PARINIT
;
6173 if (val
& DTF_1_CONFEXP
)
6175 printf (" CONFEXP");
6176 val
^= DTF_1_CONFEXP
;
6179 printf (" %lx", val
);
6188 printf (_("Flags:"));
6190 if (entry
->d_un
.d_val
== 0)
6191 printf (_(" None\n"));
6194 unsigned long int val
= entry
->d_un
.d_val
;
6196 if (val
& DF_P1_LAZYLOAD
)
6198 printf (" LAZYLOAD");
6199 val
^= DF_P1_LAZYLOAD
;
6201 if (val
& DF_P1_GROUPPERM
)
6203 printf (" GROUPPERM");
6204 val
^= DF_P1_GROUPPERM
;
6207 printf (" %lx", val
);
6216 printf (_("Flags:"));
6217 if (entry
->d_un
.d_val
== 0)
6218 printf (_(" None\n"));
6221 unsigned long int val
= entry
->d_un
.d_val
;
6228 if (val
& DF_1_GLOBAL
)
6233 if (val
& DF_1_GROUP
)
6238 if (val
& DF_1_NODELETE
)
6240 printf (" NODELETE");
6241 val
^= DF_1_NODELETE
;
6243 if (val
& DF_1_LOADFLTR
)
6245 printf (" LOADFLTR");
6246 val
^= DF_1_LOADFLTR
;
6248 if (val
& DF_1_INITFIRST
)
6250 printf (" INITFIRST");
6251 val
^= DF_1_INITFIRST
;
6253 if (val
& DF_1_NOOPEN
)
6258 if (val
& DF_1_ORIGIN
)
6263 if (val
& DF_1_DIRECT
)
6268 if (val
& DF_1_TRANS
)
6273 if (val
& DF_1_INTERPOSE
)
6275 printf (" INTERPOSE");
6276 val
^= DF_1_INTERPOSE
;
6278 if (val
& DF_1_NODEFLIB
)
6280 printf (" NODEFLIB");
6281 val
^= DF_1_NODEFLIB
;
6283 if (val
& DF_1_NODUMP
)
6288 if (val
& DF_1_CONLFAT
)
6290 printf (" CONLFAT");
6291 val
^= DF_1_CONLFAT
;
6294 printf (" %lx", val
);
6301 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6303 puts (get_dynamic_type (entry
->d_un
.d_val
));
6323 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6329 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6330 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6336 switch (entry
->d_tag
)
6339 printf (_("Shared library: [%s]"), name
);
6341 if (streq (name
, program_interpreter
))
6342 printf (_(" program interpreter"));
6346 printf (_("Library soname: [%s]"), name
);
6350 printf (_("Library rpath: [%s]"), name
);
6354 printf (_("Library runpath: [%s]"), name
);
6358 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6363 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6376 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6380 case DT_INIT_ARRAYSZ
:
6381 case DT_FINI_ARRAYSZ
:
6382 case DT_GNU_CONFLICTSZ
:
6383 case DT_GNU_LIBLISTSZ
:
6386 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6387 printf (" (bytes)\n");
6397 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6410 if (entry
->d_tag
== DT_USED
6411 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6413 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6417 printf (_("Not needed object: [%s]\n"), name
);
6422 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6428 /* The value of this entry is ignored. */
6433 case DT_GNU_PRELINKED
:
6437 time_t time
= entry
->d_un
.d_val
;
6439 tmp
= gmtime (&time
);
6440 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6441 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6442 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6448 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6451 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6457 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6458 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6463 switch (elf_header
.e_machine
)
6466 case EM_MIPS_RS3_LE
:
6467 dynamic_section_mips_val (entry
);
6470 dynamic_section_parisc_val (entry
);
6473 dynamic_section_ia64_val (entry
);
6476 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6488 get_ver_flags (unsigned int flags
)
6490 static char buff
[32];
6497 if (flags
& VER_FLG_BASE
)
6498 strcat (buff
, "BASE ");
6500 if (flags
& VER_FLG_WEAK
)
6502 if (flags
& VER_FLG_BASE
)
6503 strcat (buff
, "| ");
6505 strcat (buff
, "WEAK ");
6508 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6509 strcat (buff
, "| <unknown>");
6514 /* Display the contents of the version sections. */
6516 process_version_sections (FILE *file
)
6518 Elf_Internal_Shdr
*section
;
6525 for (i
= 0, section
= section_headers
;
6526 i
< elf_header
.e_shnum
;
6529 switch (section
->sh_type
)
6531 case SHT_GNU_verdef
:
6533 Elf_External_Verdef
*edefs
;
6541 (_("\nVersion definition section '%s' contains %u entries:\n"),
6542 SECTION_NAME (section
), section
->sh_info
);
6544 printf (_(" Addr: 0x"));
6545 printf_vma (section
->sh_addr
);
6546 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6547 (unsigned long) section
->sh_offset
, section
->sh_link
,
6548 section
->sh_link
< elf_header
.e_shnum
6549 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6552 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6554 _("version definition section"));
6555 endbuf
= (char *) edefs
+ section
->sh_size
;
6559 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6562 Elf_External_Verdef
*edef
;
6563 Elf_Internal_Verdef ent
;
6564 Elf_External_Verdaux
*eaux
;
6565 Elf_Internal_Verdaux aux
;
6569 vstart
= ((char *) edefs
) + idx
;
6570 if (vstart
+ sizeof (*edef
) > endbuf
)
6573 edef
= (Elf_External_Verdef
*) vstart
;
6575 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6576 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6577 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6578 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6579 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6580 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6581 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6583 printf (_(" %#06x: Rev: %d Flags: %s"),
6584 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6586 printf (_(" Index: %d Cnt: %d "),
6587 ent
.vd_ndx
, ent
.vd_cnt
);
6589 vstart
+= ent
.vd_aux
;
6591 eaux
= (Elf_External_Verdaux
*) vstart
;
6593 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6594 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6596 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6597 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6599 printf (_("Name index: %ld\n"), aux
.vda_name
);
6601 isum
= idx
+ ent
.vd_aux
;
6603 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6605 isum
+= aux
.vda_next
;
6606 vstart
+= aux
.vda_next
;
6608 eaux
= (Elf_External_Verdaux
*) vstart
;
6609 if (vstart
+ sizeof (*eaux
) > endbuf
)
6612 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6613 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6615 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6616 printf (_(" %#06x: Parent %d: %s\n"),
6617 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6619 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6620 isum
, j
, aux
.vda_name
);
6623 printf (_(" Version def aux past end of section\n"));
6627 if (cnt
< section
->sh_info
)
6628 printf (_(" Version definition past end of section\n"));
6634 case SHT_GNU_verneed
:
6636 Elf_External_Verneed
*eneed
;
6643 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6644 SECTION_NAME (section
), section
->sh_info
);
6646 printf (_(" Addr: 0x"));
6647 printf_vma (section
->sh_addr
);
6648 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6649 (unsigned long) section
->sh_offset
, section
->sh_link
,
6650 section
->sh_link
< elf_header
.e_shnum
6651 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6654 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6656 _("version need section"));
6657 endbuf
= (char *) eneed
+ section
->sh_size
;
6661 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6663 Elf_External_Verneed
*entry
;
6664 Elf_Internal_Verneed ent
;
6669 vstart
= ((char *) eneed
) + idx
;
6670 if (vstart
+ sizeof (*entry
) > endbuf
)
6673 entry
= (Elf_External_Verneed
*) vstart
;
6675 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6676 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6677 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6678 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6679 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6681 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6683 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6684 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6686 printf (_(" File: %lx"), ent
.vn_file
);
6688 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6690 vstart
+= ent
.vn_aux
;
6692 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6694 Elf_External_Vernaux
*eaux
;
6695 Elf_Internal_Vernaux aux
;
6697 if (vstart
+ sizeof (*eaux
) > endbuf
)
6699 eaux
= (Elf_External_Vernaux
*) vstart
;
6701 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6702 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6703 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6704 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6705 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6707 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6708 printf (_(" %#06x: Name: %s"),
6709 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6711 printf (_(" %#06x: Name index: %lx"),
6712 isum
, aux
.vna_name
);
6714 printf (_(" Flags: %s Version: %d\n"),
6715 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6717 isum
+= aux
.vna_next
;
6718 vstart
+= aux
.vna_next
;
6721 printf (_(" Version need aux past end of section\n"));
6725 if (cnt
< section
->sh_info
)
6726 printf (_(" Version need past end of section\n"));
6732 case SHT_GNU_versym
:
6734 Elf_Internal_Shdr
*link_section
;
6737 unsigned char *edata
;
6738 unsigned short *data
;
6740 Elf_Internal_Sym
*symbols
;
6741 Elf_Internal_Shdr
*string_sec
;
6744 if (section
->sh_link
>= elf_header
.e_shnum
)
6747 link_section
= section_headers
+ section
->sh_link
;
6748 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6750 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6755 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6757 string_sec
= section_headers
+ link_section
->sh_link
;
6759 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6760 string_sec
->sh_size
, _("version string table"));
6764 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6765 SECTION_NAME (section
), total
);
6767 printf (_(" Addr: "));
6768 printf_vma (section
->sh_addr
);
6769 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6770 (unsigned long) section
->sh_offset
, section
->sh_link
,
6771 SECTION_NAME (link_section
));
6773 off
= offset_from_vma (file
,
6774 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6775 total
* sizeof (short));
6776 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6777 _("version symbol data"));
6784 data
= cmalloc (total
, sizeof (short));
6786 for (cnt
= total
; cnt
--;)
6787 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6792 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6795 int check_def
, check_need
;
6798 printf (" %03x:", cnt
);
6800 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6801 switch (data
[cnt
+ j
])
6804 fputs (_(" 0 (*local*) "), stdout
);
6808 fputs (_(" 1 (*global*) "), stdout
);
6812 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6813 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6817 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6818 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6821 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6828 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6830 Elf_Internal_Verneed ivn
;
6831 unsigned long offset
;
6833 offset
= offset_from_vma
6834 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6835 sizeof (Elf_External_Verneed
));
6839 Elf_Internal_Vernaux ivna
;
6840 Elf_External_Verneed evn
;
6841 Elf_External_Vernaux evna
;
6842 unsigned long a_off
;
6844 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6847 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6848 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6850 a_off
= offset
+ ivn
.vn_aux
;
6854 get_data (&evna
, file
, a_off
, sizeof (evna
),
6855 1, _("version need aux (2)"));
6857 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6858 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6860 a_off
+= ivna
.vna_next
;
6862 while (ivna
.vna_other
!= data
[cnt
+ j
]
6863 && ivna
.vna_next
!= 0);
6865 if (ivna
.vna_other
== data
[cnt
+ j
])
6867 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6869 if (ivna
.vna_name
>= string_sec
->sh_size
)
6870 name
= _("*invalid*");
6872 name
= strtab
+ ivna
.vna_name
;
6873 nn
+= printf ("(%s%-*s",
6875 12 - (int) strlen (name
),
6881 offset
+= ivn
.vn_next
;
6883 while (ivn
.vn_next
);
6886 if (check_def
&& data
[cnt
+ j
] != 0x8001
6887 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6889 Elf_Internal_Verdef ivd
;
6890 Elf_External_Verdef evd
;
6891 unsigned long offset
;
6893 offset
= offset_from_vma
6894 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6899 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6902 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6903 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6905 offset
+= ivd
.vd_next
;
6907 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6908 && ivd
.vd_next
!= 0);
6910 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6912 Elf_External_Verdaux evda
;
6913 Elf_Internal_Verdaux ivda
;
6915 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6917 get_data (&evda
, file
,
6918 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6920 _("version def aux"));
6922 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6924 if (ivda
.vda_name
>= string_sec
->sh_size
)
6925 name
= _("*invalid*");
6927 name
= strtab
+ ivda
.vda_name
;
6928 nn
+= printf ("(%s%-*s",
6930 12 - (int) strlen (name
),
6936 printf ("%*c", 18 - nn
, ' ');
6954 printf (_("\nNo version information found in this file.\n"));
6960 get_symbol_binding (unsigned int binding
)
6962 static char buff
[32];
6966 case STB_LOCAL
: return "LOCAL";
6967 case STB_GLOBAL
: return "GLOBAL";
6968 case STB_WEAK
: return "WEAK";
6970 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6971 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6973 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6974 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6976 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6982 get_symbol_type (unsigned int type
)
6984 static char buff
[32];
6988 case STT_NOTYPE
: return "NOTYPE";
6989 case STT_OBJECT
: return "OBJECT";
6990 case STT_FUNC
: return "FUNC";
6991 case STT_SECTION
: return "SECTION";
6992 case STT_FILE
: return "FILE";
6993 case STT_COMMON
: return "COMMON";
6994 case STT_TLS
: return "TLS";
6995 case STT_RELC
: return "RELC";
6996 case STT_SRELC
: return "SRELC";
6998 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7000 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7001 return "THUMB_FUNC";
7003 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7006 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7007 return "PARISC_MILLI";
7009 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7011 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7013 if (elf_header
.e_machine
== EM_PARISC
)
7015 if (type
== STT_HP_OPAQUE
)
7017 if (type
== STT_HP_STUB
)
7021 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7024 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7030 get_symbol_visibility (unsigned int visibility
)
7034 case STV_DEFAULT
: return "DEFAULT";
7035 case STV_INTERNAL
: return "INTERNAL";
7036 case STV_HIDDEN
: return "HIDDEN";
7037 case STV_PROTECTED
: return "PROTECTED";
7043 get_mips_symbol_other (unsigned int other
)
7047 case STO_OPTIONAL
: return "OPTIONAL";
7048 case STO_MIPS16
: return "MIPS16";
7049 case STO_MIPS_PLT
: return "MIPS PLT";
7050 case STO_MIPS_PIC
: return "MIPS PIC";
7051 default: return NULL
;
7056 get_symbol_other (unsigned int other
)
7058 const char * result
= NULL
;
7059 static char buff
[32];
7064 switch (elf_header
.e_machine
)
7067 result
= get_mips_symbol_other (other
);
7075 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7080 get_symbol_index_type (unsigned int type
)
7082 static char buff
[32];
7086 case SHN_UNDEF
: return "UND";
7087 case SHN_ABS
: return "ABS";
7088 case SHN_COMMON
: return "COM";
7090 if (type
== SHN_IA_64_ANSI_COMMON
7091 && elf_header
.e_machine
== EM_IA_64
7092 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7094 else if (elf_header
.e_machine
== EM_X86_64
7095 && type
== SHN_X86_64_LCOMMON
)
7097 else if (type
== SHN_MIPS_SCOMMON
7098 && elf_header
.e_machine
== EM_MIPS
)
7100 else if (type
== SHN_MIPS_SUNDEFINED
7101 && elf_header
.e_machine
== EM_MIPS
)
7103 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7104 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7105 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7106 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7107 else if (type
>= SHN_LORESERVE
)
7108 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7110 sprintf (buff
, "%3d", type
);
7118 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7120 unsigned char *e_data
;
7123 e_data
= cmalloc (number
, ent_size
);
7127 error (_("Out of memory\n"));
7131 if (fread (e_data
, ent_size
, number
, file
) != number
)
7133 error (_("Unable to read in dynamic data\n"));
7137 i_data
= cmalloc (number
, sizeof (*i_data
));
7141 error (_("Out of memory\n"));
7147 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7155 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7157 Elf_Internal_Sym
*psym
;
7160 psym
= dynamic_symbols
+ si
;
7162 n
= print_vma (si
, DEC_5
);
7164 fputs (" " + n
, stdout
);
7165 printf (" %3lu: ", hn
);
7166 print_vma (psym
->st_value
, LONG_HEX
);
7168 print_vma (psym
->st_size
, DEC_5
);
7170 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7171 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7172 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7173 /* Check to see if any other bits in the st_other field are set.
7174 Note - displaying this information disrupts the layout of the
7175 table being generated, but for the moment this case is very
7177 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7178 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7179 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7180 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7181 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7183 printf (" <corrupt: %14ld>", psym
->st_name
);
7187 /* Dump the symbol table. */
7189 process_symbol_table (FILE *file
)
7191 Elf_Internal_Shdr
*section
;
7192 bfd_vma nbuckets
= 0;
7193 bfd_vma nchains
= 0;
7194 bfd_vma
*buckets
= NULL
;
7195 bfd_vma
*chains
= NULL
;
7196 bfd_vma ngnubuckets
= 0;
7197 bfd_vma
*gnubuckets
= NULL
;
7198 bfd_vma
*gnuchains
= NULL
;
7199 bfd_vma gnusymidx
= 0;
7201 if (! do_syms
&& !do_histogram
)
7204 if (dynamic_info
[DT_HASH
]
7206 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7208 unsigned char nb
[8];
7209 unsigned char nc
[8];
7210 int hash_ent_size
= 4;
7212 if ((elf_header
.e_machine
== EM_ALPHA
7213 || elf_header
.e_machine
== EM_S390
7214 || elf_header
.e_machine
== EM_S390_OLD
)
7215 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7219 (archive_file_offset
7220 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7221 sizeof nb
+ sizeof nc
)),
7224 error (_("Unable to seek to start of dynamic information\n"));
7228 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7230 error (_("Failed to read in number of buckets\n"));
7234 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7236 error (_("Failed to read in number of chains\n"));
7240 nbuckets
= byte_get (nb
, hash_ent_size
);
7241 nchains
= byte_get (nc
, hash_ent_size
);
7243 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7244 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7246 if (buckets
== NULL
|| chains
== NULL
)
7250 if (dynamic_info_DT_GNU_HASH
7252 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7254 unsigned char nb
[16];
7255 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7256 bfd_vma buckets_vma
;
7259 (archive_file_offset
7260 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7264 error (_("Unable to seek to start of dynamic information\n"));
7268 if (fread (nb
, 16, 1, file
) != 1)
7270 error (_("Failed to read in number of buckets\n"));
7274 ngnubuckets
= byte_get (nb
, 4);
7275 gnusymidx
= byte_get (nb
+ 4, 4);
7276 bitmaskwords
= byte_get (nb
+ 8, 4);
7277 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7279 buckets_vma
+= bitmaskwords
* 4;
7281 buckets_vma
+= bitmaskwords
* 8;
7284 (archive_file_offset
7285 + offset_from_vma (file
, buckets_vma
, 4)),
7288 error (_("Unable to seek to start of dynamic information\n"));
7292 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7294 if (gnubuckets
== NULL
)
7297 for (i
= 0; i
< ngnubuckets
; i
++)
7298 if (gnubuckets
[i
] != 0)
7300 if (gnubuckets
[i
] < gnusymidx
)
7303 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7304 maxchain
= gnubuckets
[i
];
7307 if (maxchain
== 0xffffffff)
7310 maxchain
-= gnusymidx
;
7313 (archive_file_offset
7314 + offset_from_vma (file
, buckets_vma
7315 + 4 * (ngnubuckets
+ maxchain
), 4)),
7318 error (_("Unable to seek to start of dynamic information\n"));
7324 if (fread (nb
, 4, 1, file
) != 1)
7326 error (_("Failed to determine last chain length\n"));
7330 if (maxchain
+ 1 == 0)
7335 while ((byte_get (nb
, 4) & 1) == 0);
7338 (archive_file_offset
7339 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7342 error (_("Unable to seek to start of dynamic information\n"));
7346 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7348 if (gnuchains
== NULL
)
7352 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7355 && dynamic_strings
!= NULL
)
7359 if (dynamic_info
[DT_HASH
])
7363 printf (_("\nSymbol table for image:\n"));
7365 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7367 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7369 for (hn
= 0; hn
< nbuckets
; hn
++)
7374 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7375 print_dynamic_symbol (si
, hn
);
7379 if (dynamic_info_DT_GNU_HASH
)
7381 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7383 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7385 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7387 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7388 if (gnubuckets
[hn
] != 0)
7390 bfd_vma si
= gnubuckets
[hn
];
7391 bfd_vma off
= si
- gnusymidx
;
7395 print_dynamic_symbol (si
, hn
);
7398 while ((gnuchains
[off
++] & 1) == 0);
7402 else if (do_syms
&& !do_using_dynamic
)
7406 for (i
= 0, section
= section_headers
;
7407 i
< elf_header
.e_shnum
;
7411 char *strtab
= NULL
;
7412 unsigned long int strtab_size
= 0;
7413 Elf_Internal_Sym
*symtab
;
7414 Elf_Internal_Sym
*psym
;
7417 if ( section
->sh_type
!= SHT_SYMTAB
7418 && section
->sh_type
!= SHT_DYNSYM
)
7421 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7422 SECTION_NAME (section
),
7423 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7425 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7427 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7429 symtab
= GET_ELF_SYMBOLS (file
, section
);
7433 if (section
->sh_link
== elf_header
.e_shstrndx
)
7435 strtab
= string_table
;
7436 strtab_size
= string_table_length
;
7438 else if (section
->sh_link
< elf_header
.e_shnum
)
7440 Elf_Internal_Shdr
*string_sec
;
7442 string_sec
= section_headers
+ section
->sh_link
;
7444 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7445 1, string_sec
->sh_size
, _("string table"));
7446 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7449 for (si
= 0, psym
= symtab
;
7450 si
< section
->sh_size
/ section
->sh_entsize
;
7453 printf ("%6d: ", si
);
7454 print_vma (psym
->st_value
, LONG_HEX
);
7456 print_vma (psym
->st_size
, DEC_5
);
7457 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7458 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7459 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7460 /* Check to see if any other bits in the st_other field are set.
7461 Note - displaying this information disrupts the layout of the
7462 table being generated, but for the moment this case is very rare. */
7463 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7464 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7465 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7466 print_symbol (25, psym
->st_name
< strtab_size
7467 ? strtab
+ psym
->st_name
: "<corrupt>");
7469 if (section
->sh_type
== SHT_DYNSYM
&&
7470 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7472 unsigned char data
[2];
7473 unsigned short vers_data
;
7474 unsigned long offset
;
7478 offset
= offset_from_vma
7479 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7480 sizeof data
+ si
* sizeof (vers_data
));
7482 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7483 sizeof (data
), 1, _("version data"));
7485 vers_data
= byte_get (data
, 2);
7487 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7488 && section_headers
[psym
->st_shndx
].sh_type
7491 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7493 if ((vers_data
& 0x8000) || vers_data
> 1)
7495 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7496 && (is_nobits
|| ! check_def
))
7498 Elf_External_Verneed evn
;
7499 Elf_Internal_Verneed ivn
;
7500 Elf_Internal_Vernaux ivna
;
7502 /* We must test both. */
7503 offset
= offset_from_vma
7504 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7509 unsigned long vna_off
;
7511 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7514 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7515 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7517 vna_off
= offset
+ ivn
.vn_aux
;
7521 Elf_External_Vernaux evna
;
7523 get_data (&evna
, file
, vna_off
,
7525 _("version need aux (3)"));
7527 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7528 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7529 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7531 vna_off
+= ivna
.vna_next
;
7533 while (ivna
.vna_other
!= vers_data
7534 && ivna
.vna_next
!= 0);
7536 if (ivna
.vna_other
== vers_data
)
7539 offset
+= ivn
.vn_next
;
7541 while (ivn
.vn_next
!= 0);
7543 if (ivna
.vna_other
== vers_data
)
7546 ivna
.vna_name
< strtab_size
7547 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7551 else if (! is_nobits
)
7552 error (_("bad dynamic symbol\n"));
7559 if (vers_data
!= 0x8001
7560 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7562 Elf_Internal_Verdef ivd
;
7563 Elf_Internal_Verdaux ivda
;
7564 Elf_External_Verdaux evda
;
7565 unsigned long offset
;
7567 offset
= offset_from_vma
7569 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7570 sizeof (Elf_External_Verdef
));
7574 Elf_External_Verdef evd
;
7576 get_data (&evd
, file
, offset
, sizeof (evd
),
7577 1, _("version def"));
7579 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7580 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7581 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7583 offset
+= ivd
.vd_next
;
7585 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7586 && ivd
.vd_next
!= 0);
7588 offset
-= ivd
.vd_next
;
7589 offset
+= ivd
.vd_aux
;
7591 get_data (&evda
, file
, offset
, sizeof (evda
),
7592 1, _("version def aux"));
7594 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7596 if (psym
->st_name
!= ivda
.vda_name
)
7597 printf ((vers_data
& 0x8000)
7599 ivda
.vda_name
< strtab_size
7600 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7610 if (strtab
!= string_table
)
7616 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7618 if (do_histogram
&& buckets
!= NULL
)
7620 unsigned long *lengths
;
7621 unsigned long *counts
;
7624 unsigned long maxlength
= 0;
7625 unsigned long nzero_counts
= 0;
7626 unsigned long nsyms
= 0;
7628 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7629 (unsigned long) nbuckets
);
7630 printf (_(" Length Number %% of total Coverage\n"));
7632 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7633 if (lengths
== NULL
)
7635 error (_("Out of memory\n"));
7638 for (hn
= 0; hn
< nbuckets
; ++hn
)
7640 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7643 if (maxlength
< ++lengths
[hn
])
7648 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7651 error (_("Out of memory\n"));
7655 for (hn
= 0; hn
< nbuckets
; ++hn
)
7656 ++counts
[lengths
[hn
]];
7661 printf (" 0 %-10lu (%5.1f%%)\n",
7662 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7663 for (i
= 1; i
<= maxlength
; ++i
)
7665 nzero_counts
+= counts
[i
] * i
;
7666 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7667 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7668 (nzero_counts
* 100.0) / nsyms
);
7676 if (buckets
!= NULL
)
7682 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7684 unsigned long *lengths
;
7685 unsigned long *counts
;
7687 unsigned long maxlength
= 0;
7688 unsigned long nzero_counts
= 0;
7689 unsigned long nsyms
= 0;
7691 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7692 if (lengths
== NULL
)
7694 error (_("Out of memory\n"));
7698 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7699 (unsigned long) ngnubuckets
);
7700 printf (_(" Length Number %% of total Coverage\n"));
7702 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7703 if (gnubuckets
[hn
] != 0)
7705 bfd_vma off
, length
= 1;
7707 for (off
= gnubuckets
[hn
] - gnusymidx
;
7708 (gnuchains
[off
] & 1) == 0; ++off
)
7710 lengths
[hn
] = length
;
7711 if (length
> maxlength
)
7716 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7719 error (_("Out of memory\n"));
7723 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7724 ++counts
[lengths
[hn
]];
7726 if (ngnubuckets
> 0)
7729 printf (" 0 %-10lu (%5.1f%%)\n",
7730 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7731 for (j
= 1; j
<= maxlength
; ++j
)
7733 nzero_counts
+= counts
[j
] * j
;
7734 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7735 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7736 (nzero_counts
* 100.0) / nsyms
);
7750 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7754 if (dynamic_syminfo
== NULL
7756 /* No syminfo, this is ok. */
7759 /* There better should be a dynamic symbol section. */
7760 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7764 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7765 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7767 printf (_(" Num: Name BoundTo Flags\n"));
7768 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7770 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7772 printf ("%4d: ", i
);
7773 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7774 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7776 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7779 switch (dynamic_syminfo
[i
].si_boundto
)
7781 case SYMINFO_BT_SELF
:
7782 fputs ("SELF ", stdout
);
7784 case SYMINFO_BT_PARENT
:
7785 fputs ("PARENT ", stdout
);
7788 if (dynamic_syminfo
[i
].si_boundto
> 0
7789 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7790 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7792 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7796 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7800 if (flags
& SYMINFO_FLG_DIRECT
)
7802 if (flags
& SYMINFO_FLG_PASSTHRU
)
7803 printf (" PASSTHRU");
7804 if (flags
& SYMINFO_FLG_COPY
)
7806 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7807 printf (" LAZYLOAD");
7815 #ifdef SUPPORT_DISASSEMBLY
7817 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7819 printf (_("\nAssembly dump of section %s\n"),
7820 SECTION_NAME (section
));
7822 /* XXX -- to be done --- XXX */
7829 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7831 Elf_Internal_Shdr
*relsec
;
7832 bfd_size_type num_bytes
;
7837 char *name
= SECTION_NAME (section
);
7838 bfd_boolean some_strings_shown
;
7840 num_bytes
= section
->sh_size
;
7842 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7844 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7848 addr
= section
->sh_addr
;
7850 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7855 printf (_("\nString dump of section '%s':\n"), name
);
7857 /* If the section being dumped has relocations against it the user might
7858 be expecting these relocations to have been applied. Check for this
7859 case and issue a warning message in order to avoid confusion.
7860 FIXME: Maybe we ought to have an option that dumps a section with
7862 for (relsec
= section_headers
;
7863 relsec
< section_headers
+ elf_header
.e_shnum
;
7866 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7867 || relsec
->sh_info
>= elf_header
.e_shnum
7868 || section_headers
+ relsec
->sh_info
!= section
7869 || relsec
->sh_size
== 0
7870 || relsec
->sh_link
>= elf_header
.e_shnum
)
7873 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7878 end
= start
+ num_bytes
;
7879 some_strings_shown
= FALSE
;
7883 while (!ISPRINT (* data
))
7890 printf (" [%6tx] %s\n", data
- start
, data
);
7892 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7894 data
+= strlen (data
);
7895 some_strings_shown
= TRUE
;
7899 if (! some_strings_shown
)
7900 printf (_(" No strings found in this section."));
7910 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
7912 Elf_Internal_Shdr
*relsec
;
7913 bfd_size_type bytes
;
7915 unsigned char *data
;
7916 unsigned char *start
;
7918 bytes
= section
->sh_size
;
7920 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7922 printf (_("\nSection '%s' has no data to dump.\n"),
7923 SECTION_NAME (section
));
7927 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7929 addr
= section
->sh_addr
;
7931 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7936 /* If the section being dumped has relocations against it the user might
7937 be expecting these relocations to have been applied. Check for this
7938 case and issue a warning message in order to avoid confusion.
7939 FIXME: Maybe we ought to have an option that dumps a section with
7941 for (relsec
= section_headers
;
7942 relsec
< section_headers
+ elf_header
.e_shnum
;
7945 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7946 || relsec
->sh_info
>= elf_header
.e_shnum
7947 || section_headers
+ relsec
->sh_info
!= section
7948 || relsec
->sh_size
== 0
7949 || relsec
->sh_link
>= elf_header
.e_shnum
)
7952 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7964 lbytes
= (bytes
> 16 ? 16 : bytes
);
7966 printf (" 0x%8.8lx ", (unsigned long) addr
);
7968 for (j
= 0; j
< 16; j
++)
7971 printf ("%2.2x", data
[j
]);
7979 for (j
= 0; j
< lbytes
; j
++)
7982 if (k
>= ' ' && k
< 0x7f)
8001 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8002 DWARF debug sections. This is a target specific test. Note - we do not
8003 go through the whole including-target-headers-multiple-times route, (as
8004 we have already done with <elf/h8.h>) because this would become very
8005 messy and even then this function would have to contain target specific
8006 information (the names of the relocs instead of their numeric values).
8007 FIXME: This is not the correct way to solve this problem. The proper way
8008 is to have target specific reloc sizing and typing functions created by
8009 the reloc-macros.h header, in the same way that it already creates the
8010 reloc naming functions. */
8013 is_32bit_abs_reloc (unsigned int reloc_type
)
8015 switch (elf_header
.e_machine
)
8019 return reloc_type
== 1; /* R_386_32. */
8021 return reloc_type
== 1; /* R_68K_32. */
8023 return reloc_type
== 1; /* R_860_32. */
8025 return reloc_type
== 1; /* XXX Is this right ? */
8027 return reloc_type
== 1; /* R_ARC_32. */
8029 return reloc_type
== 2; /* R_ARM_ABS32 */
8032 return reloc_type
== 1;
8034 return reloc_type
== 0x12; /* R_byte4_data. */
8036 return reloc_type
== 3; /* R_CRIS_32. */
8039 return reloc_type
== 3; /* R_CR16_NUM32. */
8041 return reloc_type
== 15; /* R_CRX_NUM32. */
8043 return reloc_type
== 1;
8044 case EM_CYGNUS_D10V
:
8046 return reloc_type
== 6; /* R_D10V_32. */
8047 case EM_CYGNUS_D30V
:
8049 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8051 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8052 case EM_CYGNUS_FR30
:
8054 return reloc_type
== 3; /* R_FR30_32. */
8058 return reloc_type
== 1; /* R_H8_DIR32. */
8060 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8063 return reloc_type
== 2; /* R_IP2K_32. */
8065 return reloc_type
== 2; /* R_IQ2000_32. */
8068 return reloc_type
== 3; /* R_M32C_32. */
8070 return reloc_type
== 34; /* R_M32R_32_RELA. */
8072 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8074 return reloc_type
== 4; /* R_MEP_32. */
8076 return reloc_type
== 2; /* R_MIPS_32. */
8078 return reloc_type
== 4; /* R_MMIX_32. */
8079 case EM_CYGNUS_MN10200
:
8081 return reloc_type
== 1; /* R_MN10200_32. */
8082 case EM_CYGNUS_MN10300
:
8084 return reloc_type
== 1; /* R_MN10300_32. */
8087 return reloc_type
== 1; /* R_MSP43_32. */
8089 return reloc_type
== 2; /* R_MT_32. */
8090 case EM_ALTERA_NIOS2
:
8092 return reloc_type
== 1; /* R_NIOS_32. */
8095 return reloc_type
== 1; /* R_OR32_32. */
8097 return reloc_type
== 1; /* R_PARISC_DIR32. */
8100 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8102 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8104 return reloc_type
== 1; /* R_PPC_ADDR32. */
8106 return reloc_type
== 1; /* R_I370_ADDR31. */
8109 return reloc_type
== 4; /* R_S390_32. */
8111 return reloc_type
== 8; /* R_SCORE_ABS32. */
8113 return reloc_type
== 1; /* R_SH_DIR32. */
8114 case EM_SPARC32PLUS
:
8117 return reloc_type
== 3 /* R_SPARC_32. */
8118 || reloc_type
== 23; /* R_SPARC_UA32. */
8120 return reloc_type
== 6; /* R_SPU_ADDR32 */
8121 case EM_CYGNUS_V850
:
8123 return reloc_type
== 6; /* R_V850_ABS32. */
8125 return reloc_type
== 1; /* R_VAX_32. */
8127 return reloc_type
== 10; /* R_X86_64_32. */
8129 return reloc_type
== 1; /* R_XSTROMY16_32. */
8132 return reloc_type
== 1; /* R_XTENSA_32. */
8135 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8136 elf_header
.e_machine
);
8141 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8142 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8145 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8147 switch (elf_header
.e_machine
)
8151 return reloc_type
== 2; /* R_386_PC32. */
8153 return reloc_type
== 4; /* R_68K_PC32. */
8155 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8157 return reloc_type
== 3; /* R_ARM_REL32 */
8159 return reloc_type
== 0; /* R_PARISC_NONE. *//* FIXME: This reloc is generated, but it may be a bug. */
8161 return reloc_type
== 26; /* R_PPC_REL32. */
8163 return reloc_type
== 26; /* R_PPC64_REL32. */
8166 return reloc_type
== 5; /* R_390_PC32. */
8168 return reloc_type
== 2; /* R_SH_REL32. */
8169 case EM_SPARC32PLUS
:
8172 return reloc_type
== 6; /* R_SPARC_DISP32. */
8174 return reloc_type
== 13; /* R_SPU_REL32. */
8176 return reloc_type
== 2; /* R_X86_64_PC32. */
8179 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8181 /* Do not abort or issue an error message here. Not all targets use
8182 pc-relative 32-bit relocs in their DWARF debug information and we
8183 have already tested for target coverage in is_32bit_abs_reloc. A
8184 more helpful warning message will be generated by
8185 debug_apply_relocations anyway, so just return. */
8190 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8191 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8194 is_64bit_abs_reloc (unsigned int reloc_type
)
8196 switch (elf_header
.e_machine
)
8199 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8201 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8203 return reloc_type
== 80; /* R_PARISC_DIR64. */
8205 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8206 case EM_SPARC32PLUS
:
8209 return reloc_type
== 54; /* R_SPARC_UA64. */
8211 return reloc_type
== 1; /* R_X86_64_64. */
8214 return reloc_type
== 22; /* R_S390_64 */
8216 return reloc_type
== 18; /* R_MIPS_64 */
8222 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8223 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8226 is_16bit_abs_reloc (unsigned int reloc_type
)
8228 switch (elf_header
.e_machine
)
8232 return reloc_type
== 4; /* R_AVR_16. */
8233 case EM_CYGNUS_D10V
:
8235 return reloc_type
== 3; /* R_D10V_16. */
8239 return reloc_type
== R_H8_DIR16
;
8242 return reloc_type
== 1; /* R_IP2K_16. */
8245 return reloc_type
== 1; /* R_M32C_16 */
8248 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8249 case EM_ALTERA_NIOS2
:
8251 return reloc_type
== 9; /* R_NIOS_16. */
8257 /* Uncompresses a section that was compressed using zlib, in place.
8258 * This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8261 uncompress_section_contents (unsigned char **buffer
, dwarf_size_type
*size
)
8264 /* These are just to quiet gcc. */
8269 dwarf_size_type compressed_size
= *size
;
8270 unsigned char* compressed_buffer
= *buffer
;
8271 dwarf_size_type uncompressed_size
;
8272 unsigned char* uncompressed_buffer
;
8275 dwarf_size_type header_size
= 12;
8277 /* Read the zlib header. In this case, it should be "ZLIB" followed
8278 by the uncompressed section size, 8 bytes in big-endian order. */
8279 if (compressed_size
< header_size
8280 || ! streq ((char*) compressed_buffer
, "ZLIB"))
8282 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8283 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8284 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8285 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8286 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8287 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8288 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8289 uncompressed_size
+= compressed_buffer
[11];
8291 /* It is possible the section consists of several compressed
8292 buffers concatenated together, so we uncompress in a loop. */
8296 strm
.avail_in
= compressed_size
- header_size
;
8297 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8298 strm
.avail_out
= uncompressed_size
;
8299 uncompressed_buffer
= xmalloc (uncompressed_size
);
8301 rc
= inflateInit (&strm
);
8302 while (strm
.avail_in
> 0)
8306 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8307 + (uncompressed_size
- strm
.avail_out
));
8308 rc
= inflate (&strm
, Z_FINISH
);
8309 if (rc
!= Z_STREAM_END
)
8311 rc
= inflateReset (&strm
);
8313 rc
= inflateEnd (&strm
);
8315 || strm
.avail_out
!= 0)
8318 free (compressed_buffer
);
8319 *buffer
= uncompressed_buffer
;
8320 *size
= uncompressed_size
;
8324 free (uncompressed_buffer
);
8326 #endif /* HAVE_ZLIB_H */
8329 /* Apply relocations to a debug section. */
8332 debug_apply_relocations (void *file
,
8333 Elf_Internal_Shdr
*section
,
8334 unsigned char *start
)
8336 Elf_Internal_Shdr
*relsec
;
8337 unsigned char *end
= start
+ section
->sh_size
;
8339 if (elf_header
.e_type
!= ET_REL
)
8342 /* Find the reloc section associated with the debug section. */
8343 for (relsec
= section_headers
;
8344 relsec
< section_headers
+ elf_header
.e_shnum
;
8347 bfd_boolean is_rela
;
8348 unsigned long num_relocs
;
8349 Elf_Internal_Rela
*relocs
, *rp
;
8350 Elf_Internal_Shdr
*symsec
;
8351 Elf_Internal_Sym
*symtab
;
8352 Elf_Internal_Sym
*sym
;
8354 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8355 || relsec
->sh_info
>= elf_header
.e_shnum
8356 || section_headers
+ relsec
->sh_info
!= section
8357 || relsec
->sh_size
== 0
8358 || relsec
->sh_link
>= elf_header
.e_shnum
)
8361 is_rela
= relsec
->sh_type
== SHT_RELA
;
8365 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8366 & relocs
, & num_relocs
))
8371 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8372 & relocs
, & num_relocs
))
8376 /* SH uses RELA but uses in place value instead of the addend field. */
8377 if (elf_header
.e_machine
== EM_SH
)
8380 symsec
= section_headers
+ relsec
->sh_link
;
8381 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8383 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8386 unsigned int reloc_type
;
8387 unsigned int reloc_size
;
8388 unsigned char * loc
;
8390 reloc_type
= get_reloc_type (rp
->r_info
);
8392 if (is_32bit_abs_reloc (reloc_type
)
8393 || is_32bit_pcrel_reloc (reloc_type
))
8395 else if (is_64bit_abs_reloc (reloc_type
))
8397 else if (is_16bit_abs_reloc (reloc_type
))
8401 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8402 reloc_type
, SECTION_NAME (section
));
8406 loc
= start
+ rp
->r_offset
;
8407 if ((loc
+ reloc_size
) > end
)
8409 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8410 (unsigned long) rp
->r_offset
,
8411 SECTION_NAME (section
));
8415 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8417 /* If the reloc has a symbol associated with it,
8418 make sure that it is of an appropriate type. */
8420 && ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
8421 /* Relocations against symbols without type can happen.
8422 Gcc -feliminate-dwarf2-dups may generate symbols
8423 without type for debug info. */
8424 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8425 /* Relocations against object symbols can happen,
8426 eg when referencing a global array. For an
8427 example of this see the _clz.o binary in libgcc.a. */
8428 && ELF_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8430 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8431 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8432 (long int)(rp
- relocs
),
8433 SECTION_NAME (relsec
));
8437 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8439 if (is_32bit_pcrel_reloc (reloc_type
))
8440 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8443 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8453 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8455 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8456 Elf_Internal_Shdr
*sec
;
8458 int section_is_compressed
;
8460 /* If it is already loaded, do nothing. */
8461 if (section
->start
!= NULL
)
8464 /* Locate the debug section. */
8465 sec
= find_section (section
->uncompressed_name
);
8467 section
->name
= section
->uncompressed_name
;
8470 sec
= find_section (section
->compressed_name
);
8472 section
->name
= section
->compressed_name
;
8476 section_is_compressed
= section
->name
== section
->compressed_name
;
8478 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8479 section
->address
= sec
->sh_addr
;
8480 section
->size
= sec
->sh_size
;
8481 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8483 if (section
->start
== NULL
)
8486 if (section_is_compressed
)
8487 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8490 if (debug_displays
[debug
].relocate
)
8491 debug_apply_relocations (file
, sec
, section
->start
);
8497 free_debug_section (enum dwarf_section_display_enum debug
)
8499 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8501 if (section
->start
== NULL
)
8504 free ((char *) section
->start
);
8505 section
->start
= NULL
;
8506 section
->address
= 0;
8511 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8513 char *name
= SECTION_NAME (section
);
8514 bfd_size_type length
;
8516 enum dwarf_section_display_enum i
;
8518 length
= section
->sh_size
;
8521 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8525 if (const_strneq (name
, ".gnu.linkonce.wi."))
8526 name
= ".debug_info";
8528 /* See if we know how to display the contents of this section. */
8529 for (i
= 0; i
< max
; i
++)
8530 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8531 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8533 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8535 if (load_debug_section (i
, file
))
8537 result
&= debug_displays
[i
].display (sec
, file
);
8539 if (i
!= info
&& i
!= abbrev
)
8540 free_debug_section (i
);
8548 printf (_("Unrecognized debug section: %s\n"), name
);
8555 /* Set DUMP_SECTS for all sections where dumps were requested
8556 based on section name. */
8559 initialise_dumps_byname (void)
8561 struct dump_list_entry
*cur
;
8563 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8568 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8569 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8571 request_dump_bynumber (i
, cur
->type
);
8576 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8582 process_section_contents (FILE *file
)
8584 Elf_Internal_Shdr
*section
;
8590 initialise_dumps_byname ();
8592 for (i
= 0, section
= section_headers
;
8593 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8596 #ifdef SUPPORT_DISASSEMBLY
8597 if (dump_sects
[i
] & DISASS_DUMP
)
8598 disassemble_section (section
, file
);
8600 if (dump_sects
[i
] & HEX_DUMP
)
8601 dump_section_as_bytes (section
, file
);
8603 if (dump_sects
[i
] & DEBUG_DUMP
)
8604 display_debug_section (section
, file
);
8606 if (dump_sects
[i
] & STRING_DUMP
)
8607 dump_section_as_strings (section
, file
);
8610 /* Check to see if the user requested a
8611 dump of a section that does not exist. */
8612 while (i
++ < num_dump_sects
)
8614 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8618 process_mips_fpe_exception (int mask
)
8623 if (mask
& OEX_FPU_INEX
)
8624 fputs ("INEX", stdout
), first
= 0;
8625 if (mask
& OEX_FPU_UFLO
)
8626 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8627 if (mask
& OEX_FPU_OFLO
)
8628 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8629 if (mask
& OEX_FPU_DIV0
)
8630 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8631 if (mask
& OEX_FPU_INVAL
)
8632 printf ("%sINVAL", first
? "" : "|");
8635 fputs ("0", stdout
);
8638 /* ARM EABI attributes section. */
8643 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8646 } arm_attr_public_tag
;
8648 static const char *arm_attr_tag_CPU_arch
[] =
8649 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8651 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8652 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8653 {"No", "Thumb-1", "Thumb-2"};
8654 static const char *arm_attr_tag_VFP_arch
[] =
8655 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8656 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8657 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8658 static const char *arm_attr_tag_ABI_PCS_config
[] =
8659 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8660 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8661 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8662 {"V6", "SB", "TLS", "Unused"};
8663 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8664 {"Absolute", "PC-relative", "SB-relative", "None"};
8665 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8666 {"Absolute", "PC-relative", "None"};
8667 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8668 {"None", "direct", "GOT-indirect"};
8669 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8670 {"None", "??? 1", "2", "??? 3", "4"};
8671 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8672 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8673 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8674 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8675 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8676 {"Unused", "Finite", "RTABI", "IEEE 754"};
8677 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8678 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8679 {"No", "Yes, except leaf SP", "Yes"};
8680 static const char *arm_attr_tag_ABI_enum_size
[] =
8681 {"Unused", "small", "int", "forced to int"};
8682 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8683 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8684 static const char *arm_attr_tag_ABI_VFP_args
[] =
8685 {"AAPCS", "VFP registers", "custom"};
8686 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8687 {"AAPCS", "WMMX registers", "custom"};
8688 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8689 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8690 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8691 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8692 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8693 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8695 #define LOOKUP(id, name) \
8696 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8697 static arm_attr_public_tag arm_attr_public_tags
[] =
8699 {4, "CPU_raw_name", 1, NULL
},
8700 {5, "CPU_name", 1, NULL
},
8701 LOOKUP(6, CPU_arch
),
8702 {7, "CPU_arch_profile", 0, NULL
},
8703 LOOKUP(8, ARM_ISA_use
),
8704 LOOKUP(9, THUMB_ISA_use
),
8705 LOOKUP(10, VFP_arch
),
8706 LOOKUP(11, WMMX_arch
),
8707 LOOKUP(12, NEON_arch
),
8708 LOOKUP(13, ABI_PCS_config
),
8709 LOOKUP(14, ABI_PCS_R9_use
),
8710 LOOKUP(15, ABI_PCS_RW_data
),
8711 LOOKUP(16, ABI_PCS_RO_DATA
),
8712 LOOKUP(17, ABI_PCS_GOT_use
),
8713 LOOKUP(18, ABI_PCS_wchar_t
),
8714 LOOKUP(19, ABI_FP_rounding
),
8715 LOOKUP(20, ABI_FP_denormal
),
8716 LOOKUP(21, ABI_FP_exceptions
),
8717 LOOKUP(22, ABI_FP_user_exceptions
),
8718 LOOKUP(23, ABI_FP_number_model
),
8719 LOOKUP(24, ABI_align8_needed
),
8720 LOOKUP(25, ABI_align8_preserved
),
8721 LOOKUP(26, ABI_enum_size
),
8722 LOOKUP(27, ABI_HardFP_use
),
8723 LOOKUP(28, ABI_VFP_args
),
8724 LOOKUP(29, ABI_WMMX_args
),
8725 LOOKUP(30, ABI_optimization_goals
),
8726 LOOKUP(31, ABI_FP_optimization_goals
),
8727 {32, "compatibility", 0, NULL
}
8731 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8734 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8748 val
|= ((unsigned int)c
& 0x7f) << shift
;
8757 static unsigned char *
8758 display_arm_attribute (unsigned char *p
)
8763 arm_attr_public_tag
*attr
;
8767 tag
= read_uleb128 (p
, &len
);
8770 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8772 if (arm_attr_public_tags
[i
].tag
== tag
)
8774 attr
= &arm_attr_public_tags
[i
];
8781 printf (" Tag_%s: ", attr
->name
);
8787 case 7: /* Tag_CPU_arch_profile. */
8788 val
= read_uleb128 (p
, &len
);
8792 case 0: printf ("None\n"); break;
8793 case 'A': printf ("Application\n"); break;
8794 case 'R': printf ("Realtime\n"); break;
8795 case 'M': printf ("Microcontroller\n"); break;
8796 default: printf ("??? (%d)\n", val
); break;
8800 case 32: /* Tag_compatibility. */
8801 val
= read_uleb128 (p
, &len
);
8803 printf ("flag = %d, vendor = %s\n", val
, p
);
8804 p
+= strlen((char *)p
) + 1;
8818 assert (attr
->type
& 0x80);
8819 val
= read_uleb128 (p
, &len
);
8821 type
= attr
->type
& 0x7f;
8823 printf ("??? (%d)\n", val
);
8825 printf ("%s\n", attr
->table
[val
]);
8832 type
= 1; /* String. */
8834 type
= 2; /* uleb128. */
8835 printf (" Tag_unknown_%d: ", tag
);
8840 printf ("\"%s\"\n", p
);
8841 p
+= strlen((char *)p
) + 1;
8845 val
= read_uleb128 (p
, &len
);
8847 printf ("%d (0x%x)\n", val
, val
);
8853 static unsigned char *
8854 display_gnu_attribute (unsigned char * p
,
8855 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8862 tag
= read_uleb128 (p
, &len
);
8865 /* Tag_compatibility is the only generic GNU attribute defined at
8869 val
= read_uleb128 (p
, &len
);
8871 printf ("flag = %d, vendor = %s\n", val
, p
);
8872 p
+= strlen ((char *) p
) + 1;
8876 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8877 return display_proc_gnu_attribute (p
, tag
);
8880 type
= 1; /* String. */
8882 type
= 2; /* uleb128. */
8883 printf (" Tag_unknown_%d: ", tag
);
8887 printf ("\"%s\"\n", p
);
8888 p
+= strlen ((char *) p
) + 1;
8892 val
= read_uleb128 (p
, &len
);
8894 printf ("%d (0x%x)\n", val
, val
);
8900 static unsigned char *
8901 display_power_gnu_attribute (unsigned char *p
, int tag
)
8907 if (tag
== Tag_GNU_Power_ABI_FP
)
8909 val
= read_uleb128 (p
, &len
);
8911 printf (" Tag_GNU_Power_ABI_FP: ");
8916 printf ("Hard or soft float\n");
8919 printf ("Hard float\n");
8922 printf ("Soft float\n");
8925 printf ("Single-precision hard float\n");
8928 printf ("??? (%d)\n", val
);
8934 if (tag
== Tag_GNU_Power_ABI_Vector
)
8936 val
= read_uleb128 (p
, &len
);
8938 printf (" Tag_GNU_Power_ABI_Vector: ");
8945 printf ("Generic\n");
8948 printf ("AltiVec\n");
8954 printf ("??? (%d)\n", val
);
8961 type
= 1; /* String. */
8963 type
= 2; /* uleb128. */
8964 printf (" Tag_unknown_%d: ", tag
);
8968 printf ("\"%s\"\n", p
);
8969 p
+= strlen ((char *) p
) + 1;
8973 val
= read_uleb128 (p
, &len
);
8975 printf ("%d (0x%x)\n", val
, val
);
8981 static unsigned char *
8982 display_mips_gnu_attribute (unsigned char *p
, int tag
)
8988 if (tag
== Tag_GNU_MIPS_ABI_FP
)
8990 val
= read_uleb128 (p
, &len
);
8992 printf (" Tag_GNU_MIPS_ABI_FP: ");
8997 printf ("Hard or soft float\n");
9000 printf ("Hard float (-mdouble-float)\n");
9003 printf ("Hard float (-msingle-float)\n");
9006 printf ("Soft float\n");
9009 printf ("64-bit float (-mips32r2 -mfp64)\n");
9012 printf ("??? (%d)\n", val
);
9019 type
= 1; /* String. */
9021 type
= 2; /* uleb128. */
9022 printf (" Tag_unknown_%d: ", tag
);
9026 printf ("\"%s\"\n", p
);
9027 p
+= strlen ((char *) p
) + 1;
9031 val
= read_uleb128 (p
, &len
);
9033 printf ("%d (0x%x)\n", val
, val
);
9040 process_attributes (FILE * file
,
9041 const char * public_name
,
9042 unsigned int proc_type
,
9043 unsigned char * (* display_pub_attribute
) (unsigned char *),
9044 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9046 Elf_Internal_Shdr
*sect
;
9047 unsigned char *contents
;
9050 bfd_vma section_len
;
9054 /* Find the section header so that we get the size. */
9055 for (i
= 0, sect
= section_headers
;
9056 i
< elf_header
.e_shnum
;
9059 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9062 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9064 if (contents
== NULL
)
9070 len
= sect
->sh_size
- 1;
9076 bfd_boolean public_section
;
9077 bfd_boolean gnu_section
;
9079 section_len
= byte_get (p
, 4);
9082 if (section_len
> len
)
9084 printf (_("ERROR: Bad section length (%d > %d)\n"),
9085 (int) section_len
, (int) len
);
9090 printf ("Attribute Section: %s\n", p
);
9092 if (public_name
&& streq ((char *) p
, public_name
))
9093 public_section
= TRUE
;
9095 public_section
= FALSE
;
9097 if (streq ((char *) p
, "gnu"))
9100 gnu_section
= FALSE
;
9102 namelen
= strlen ((char *) p
) + 1;
9104 section_len
-= namelen
+ 4;
9106 while (section_len
> 0)
9112 size
= byte_get (p
, 4);
9113 if (size
> section_len
)
9115 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9116 (int) size
, (int) section_len
);
9120 section_len
-= size
;
9127 printf ("File Attributes\n");
9130 printf ("Section Attributes:");
9133 printf ("Symbol Attributes:");
9139 val
= read_uleb128 (p
, &i
);
9143 printf (" %d", val
);
9148 printf ("Unknown tag: %d\n", tag
);
9149 public_section
= FALSE
;
9156 p
= display_pub_attribute (p
);
9158 else if (gnu_section
)
9161 p
= display_gnu_attribute (p
,
9162 display_proc_gnu_attribute
);
9166 /* ??? Do something sensible, like dump hex. */
9167 printf (" Unknown section contexts\n");
9174 printf (_("Unknown format '%c'\n"), *p
);
9182 process_arm_specific (FILE *file
)
9184 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9185 display_arm_attribute
, NULL
);
9189 process_power_specific (FILE *file
)
9191 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9192 display_power_gnu_attribute
);
9195 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9196 Print the Address, Access and Initial fields of an entry at VMA ADDR
9197 and return the VMA of the next entry. */
9200 print_mips_got_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9203 print_vma (addr
, LONG_HEX
);
9205 if (addr
< pltgot
+ 0xfff0)
9206 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9208 printf ("%10s", "");
9211 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9216 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9217 print_vma (entry
, LONG_HEX
);
9219 return addr
+ (is_32bit_elf
? 4 : 8);
9222 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9223 PLTGOT. Print the Address and Initial fields of an entry at VMA
9224 ADDR and return the VMA of the next entry. */
9227 print_mips_pltgot_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9230 print_vma (addr
, LONG_HEX
);
9233 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9238 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9239 print_vma (entry
, LONG_HEX
);
9241 return addr
+ (is_32bit_elf
? 4 : 8);
9245 process_mips_specific (FILE *file
)
9247 Elf_Internal_Dyn
*entry
;
9248 size_t liblist_offset
= 0;
9249 size_t liblistno
= 0;
9250 size_t conflictsno
= 0;
9251 size_t options_offset
= 0;
9252 size_t conflicts_offset
= 0;
9253 size_t pltrelsz
= 0;
9256 bfd_vma mips_pltgot
= 0;
9258 bfd_vma local_gotno
= 0;
9260 bfd_vma symtabno
= 0;
9262 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9263 display_mips_gnu_attribute
);
9265 /* We have a lot of special sections. Thanks SGI! */
9266 if (dynamic_section
== NULL
)
9267 /* No information available. */
9270 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9271 switch (entry
->d_tag
)
9273 case DT_MIPS_LIBLIST
:
9275 = offset_from_vma (file
, entry
->d_un
.d_val
,
9276 liblistno
* sizeof (Elf32_External_Lib
));
9278 case DT_MIPS_LIBLISTNO
:
9279 liblistno
= entry
->d_un
.d_val
;
9281 case DT_MIPS_OPTIONS
:
9282 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9284 case DT_MIPS_CONFLICT
:
9286 = offset_from_vma (file
, entry
->d_un
.d_val
,
9287 conflictsno
* sizeof (Elf32_External_Conflict
));
9289 case DT_MIPS_CONFLICTNO
:
9290 conflictsno
= entry
->d_un
.d_val
;
9293 pltgot
= entry
->d_un
.d_ptr
;
9295 case DT_MIPS_LOCAL_GOTNO
:
9296 local_gotno
= entry
->d_un
.d_val
;
9298 case DT_MIPS_GOTSYM
:
9299 gotsym
= entry
->d_un
.d_val
;
9301 case DT_MIPS_SYMTABNO
:
9302 symtabno
= entry
->d_un
.d_val
;
9304 case DT_MIPS_PLTGOT
:
9305 mips_pltgot
= entry
->d_un
.d_ptr
;
9308 pltrel
= entry
->d_un
.d_val
;
9311 pltrelsz
= entry
->d_un
.d_val
;
9314 jmprel
= entry
->d_un
.d_ptr
;
9320 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9322 Elf32_External_Lib
*elib
;
9325 elib
= get_data (NULL
, file
, liblist_offset
,
9326 liblistno
, sizeof (Elf32_External_Lib
),
9330 printf ("\nSection '.liblist' contains %lu entries:\n",
9331 (unsigned long) liblistno
);
9332 fputs (" Library Time Stamp Checksum Version Flags\n",
9335 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9342 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9343 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9344 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9345 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9346 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9348 tmp
= gmtime (&time
);
9349 snprintf (timebuf
, sizeof (timebuf
),
9350 "%04u-%02u-%02uT%02u:%02u:%02u",
9351 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9352 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9354 printf ("%3lu: ", (unsigned long) cnt
);
9355 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9356 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9358 printf ("<corrupt: %9ld>", liblist
.l_name
);
9359 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9362 if (liblist
.l_flags
== 0)
9373 { " EXACT_MATCH", LL_EXACT_MATCH
},
9374 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9375 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9376 { " EXPORTS", LL_EXPORTS
},
9377 { " DELAY_LOAD", LL_DELAY_LOAD
},
9378 { " DELTA", LL_DELTA
}
9380 int flags
= liblist
.l_flags
;
9383 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9384 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9386 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9387 flags
^= l_flags_vals
[fcnt
].bit
;
9390 printf (" %#x", (unsigned int) flags
);
9400 if (options_offset
!= 0)
9402 Elf_External_Options
*eopt
;
9403 Elf_Internal_Shdr
*sect
= section_headers
;
9404 Elf_Internal_Options
*iopt
;
9405 Elf_Internal_Options
*option
;
9409 /* Find the section header so that we get the size. */
9410 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9413 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9417 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
9420 error (_("Out of memory\n"));
9427 while (offset
< sect
->sh_size
)
9429 Elf_External_Options
*eoption
;
9431 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9433 option
->kind
= BYTE_GET (eoption
->kind
);
9434 option
->size
= BYTE_GET (eoption
->size
);
9435 option
->section
= BYTE_GET (eoption
->section
);
9436 option
->info
= BYTE_GET (eoption
->info
);
9438 offset
+= option
->size
;
9444 printf (_("\nSection '%s' contains %d entries:\n"),
9445 SECTION_NAME (sect
), cnt
);
9453 switch (option
->kind
)
9456 /* This shouldn't happen. */
9457 printf (" NULL %d %lx", option
->section
, option
->info
);
9460 printf (" REGINFO ");
9461 if (elf_header
.e_machine
== EM_MIPS
)
9464 Elf32_External_RegInfo
*ereg
;
9465 Elf32_RegInfo reginfo
;
9467 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9468 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9469 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9470 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9471 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9472 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9473 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9475 printf ("GPR %08lx GP 0x%lx\n",
9477 (unsigned long) reginfo
.ri_gp_value
);
9478 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9479 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9480 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9485 Elf64_External_RegInfo
*ereg
;
9486 Elf64_Internal_RegInfo reginfo
;
9488 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9489 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9490 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9491 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9492 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9493 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9494 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9496 printf ("GPR %08lx GP 0x",
9497 reginfo
.ri_gprmask
);
9498 printf_vma (reginfo
.ri_gp_value
);
9501 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9502 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9503 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9507 case ODK_EXCEPTIONS
:
9508 fputs (" EXCEPTIONS fpe_min(", stdout
);
9509 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9510 fputs (") fpe_max(", stdout
);
9511 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9512 fputs (")", stdout
);
9514 if (option
->info
& OEX_PAGE0
)
9515 fputs (" PAGE0", stdout
);
9516 if (option
->info
& OEX_SMM
)
9517 fputs (" SMM", stdout
);
9518 if (option
->info
& OEX_FPDBUG
)
9519 fputs (" FPDBUG", stdout
);
9520 if (option
->info
& OEX_DISMISS
)
9521 fputs (" DISMISS", stdout
);
9524 fputs (" PAD ", stdout
);
9525 if (option
->info
& OPAD_PREFIX
)
9526 fputs (" PREFIX", stdout
);
9527 if (option
->info
& OPAD_POSTFIX
)
9528 fputs (" POSTFIX", stdout
);
9529 if (option
->info
& OPAD_SYMBOL
)
9530 fputs (" SYMBOL", stdout
);
9533 fputs (" HWPATCH ", stdout
);
9534 if (option
->info
& OHW_R4KEOP
)
9535 fputs (" R4KEOP", stdout
);
9536 if (option
->info
& OHW_R8KPFETCH
)
9537 fputs (" R8KPFETCH", stdout
);
9538 if (option
->info
& OHW_R5KEOP
)
9539 fputs (" R5KEOP", stdout
);
9540 if (option
->info
& OHW_R5KCVTL
)
9541 fputs (" R5KCVTL", stdout
);
9544 fputs (" FILL ", stdout
);
9545 /* XXX Print content of info word? */
9548 fputs (" TAGS ", stdout
);
9549 /* XXX Print content of info word? */
9552 fputs (" HWAND ", stdout
);
9553 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9554 fputs (" R4KEOP_CHECKED", stdout
);
9555 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9556 fputs (" R4KEOP_CLEAN", stdout
);
9559 fputs (" HWOR ", stdout
);
9560 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9561 fputs (" R4KEOP_CHECKED", stdout
);
9562 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9563 fputs (" R4KEOP_CLEAN", stdout
);
9566 printf (" GP_GROUP %#06lx self-contained %#06lx",
9567 option
->info
& OGP_GROUP
,
9568 (option
->info
& OGP_SELF
) >> 16);
9571 printf (" IDENT %#06lx self-contained %#06lx",
9572 option
->info
& OGP_GROUP
,
9573 (option
->info
& OGP_SELF
) >> 16);
9576 /* This shouldn't happen. */
9577 printf (" %3d ??? %d %lx",
9578 option
->kind
, option
->section
, option
->info
);
9582 len
= sizeof (*eopt
);
9583 while (len
< option
->size
)
9584 if (((char *) option
)[len
] >= ' '
9585 && ((char *) option
)[len
] < 0x7f)
9586 printf ("%c", ((char *) option
)[len
++]);
9588 printf ("\\%03o", ((char *) option
)[len
++]);
9590 fputs ("\n", stdout
);
9598 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9600 Elf32_Conflict
*iconf
;
9603 if (dynamic_symbols
== NULL
)
9605 error (_("conflict list found without a dynamic symbol table\n"));
9609 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9612 error (_("Out of memory\n"));
9618 Elf32_External_Conflict
*econf32
;
9620 econf32
= get_data (NULL
, file
, conflicts_offset
,
9621 conflictsno
, sizeof (*econf32
), _("conflict"));
9625 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9626 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9632 Elf64_External_Conflict
*econf64
;
9634 econf64
= get_data (NULL
, file
, conflicts_offset
,
9635 conflictsno
, sizeof (*econf64
), _("conflict"));
9639 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9640 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9645 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9646 (unsigned long) conflictsno
);
9647 puts (_(" Num: Index Value Name"));
9649 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9651 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9653 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9654 print_vma (psym
->st_value
, FULL_HEX
);
9656 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9657 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9659 printf ("<corrupt: %14ld>", psym
->st_name
);
9666 if (pltgot
!= 0 && local_gotno
!= 0)
9668 bfd_vma entry
, local_end
, global_end
;
9670 unsigned char *data
;
9674 addr_size
= (is_32bit_elf
? 4 : 8);
9675 local_end
= pltgot
+ local_gotno
* addr_size
;
9676 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9678 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9679 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9680 printf (_("\nPrimary GOT:\n"));
9681 printf (_(" Canonical gp value: "));
9682 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9685 printf (_(" Reserved entries:\n"));
9686 printf (_(" %*s %10s %*s Purpose\n"),
9687 addr_size
* 2, "Address", "Access",
9688 addr_size
* 2, "Initial");
9689 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9690 printf (" Lazy resolver\n");
9692 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9693 >> (addr_size
* 8 - 1)) != 0)
9695 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9696 printf (" Module pointer (GNU extension)\n");
9700 if (entry
< local_end
)
9702 printf (_(" Local entries:\n"));
9703 printf (_(" %*s %10s %*s\n"),
9704 addr_size
* 2, "Address", "Access",
9705 addr_size
* 2, "Initial");
9706 while (entry
< local_end
)
9708 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9714 if (gotsym
< symtabno
)
9718 printf (_(" Global entries:\n"));
9719 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9720 addr_size
* 2, "Address", "Access",
9721 addr_size
* 2, "Initial",
9722 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9723 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9724 for (i
= gotsym
; i
< symtabno
; i
++)
9726 Elf_Internal_Sym
*psym
;
9728 psym
= dynamic_symbols
+ i
;
9729 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9731 print_vma (psym
->st_value
, LONG_HEX
);
9732 printf (" %-7s %3s ",
9733 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9734 get_symbol_index_type (psym
->st_shndx
));
9735 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9736 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9738 printf ("<corrupt: %14ld>", psym
->st_name
);
9748 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9751 size_t offset
, rel_offset
;
9752 unsigned long count
, i
;
9753 unsigned char *data
;
9754 int addr_size
, sym_width
;
9755 Elf_Internal_Rela
*rels
;
9757 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9758 if (pltrel
== DT_RELA
)
9760 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9765 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9769 entry
= mips_pltgot
;
9770 addr_size
= (is_32bit_elf
? 4 : 8);
9771 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9773 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9774 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9775 printf (_("\nPLT GOT:\n\n"));
9776 printf (_(" Reserved entries:\n"));
9777 printf (_(" %*s %*s Purpose\n"),
9778 addr_size
* 2, "Address", addr_size
* 2, "Initial");
9779 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9780 printf (" PLT lazy resolver\n");
9781 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9782 printf (" Module pointer\n");
9785 printf (_(" Entries:\n"));
9786 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9787 addr_size
* 2, "Address",
9788 addr_size
* 2, "Initial",
9789 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9790 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
9791 for (i
= 0; i
< count
; i
++)
9793 Elf_Internal_Sym
*psym
;
9795 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
9796 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9798 print_vma (psym
->st_value
, LONG_HEX
);
9799 printf (" %-7s %3s ",
9800 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9801 get_symbol_index_type (psym
->st_shndx
));
9802 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9803 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9805 printf ("<corrupt: %14ld>", psym
->st_name
);
9819 process_gnu_liblist (FILE *file
)
9821 Elf_Internal_Shdr
*section
, *string_sec
;
9822 Elf32_External_Lib
*elib
;
9831 for (i
= 0, section
= section_headers
;
9832 i
< elf_header
.e_shnum
;
9835 switch (section
->sh_type
)
9837 case SHT_GNU_LIBLIST
:
9838 if (section
->sh_link
>= elf_header
.e_shnum
)
9841 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9846 string_sec
= section_headers
+ section
->sh_link
;
9848 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9849 string_sec
->sh_size
, _("liblist string table"));
9850 strtab_size
= string_sec
->sh_size
;
9853 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9859 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9860 SECTION_NAME (section
),
9861 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9863 puts (" Library Time Stamp Checksum Version Flags");
9865 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9873 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9874 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9875 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9876 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9877 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9879 tmp
= gmtime (&time
);
9880 snprintf (timebuf
, sizeof (timebuf
),
9881 "%04u-%02u-%02uT%02u:%02u:%02u",
9882 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9883 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9885 printf ("%3lu: ", (unsigned long) cnt
);
9887 printf ("%-20s", liblist
.l_name
< strtab_size
9888 ? strtab
+ liblist
.l_name
: "<corrupt>");
9890 printf ("%-20.20s", liblist
.l_name
< strtab_size
9891 ? strtab
+ liblist
.l_name
: "<corrupt>");
9892 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9893 liblist
.l_version
, liblist
.l_flags
);
9904 get_note_type (unsigned e_type
)
9906 static char buff
[64];
9908 if (elf_header
.e_type
== ET_CORE
)
9912 return _("NT_AUXV (auxiliary vector)");
9914 return _("NT_PRSTATUS (prstatus structure)");
9916 return _("NT_FPREGSET (floating point registers)");
9918 return _("NT_PRPSINFO (prpsinfo structure)");
9920 return _("NT_TASKSTRUCT (task structure)");
9922 return _("NT_PRXFPREG (user_xfpregs structure)");
9924 return _("NT_PPC_VMX (ppc Altivec registers)");
9926 return _("NT_PPC_VSX (ppc VSX registers)");
9928 return _("NT_PSTATUS (pstatus structure)");
9930 return _("NT_FPREGS (floating point registers)");
9932 return _("NT_PSINFO (psinfo structure)");
9934 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9936 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9937 case NT_WIN32PSTATUS
:
9938 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9946 return _("NT_VERSION (version)");
9948 return _("NT_ARCH (architecture)");
9953 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9958 get_gnu_elf_note_type (unsigned e_type
)
9960 static char buff
[64];
9964 case NT_GNU_ABI_TAG
:
9965 return _("NT_GNU_ABI_TAG (ABI version tag)");
9967 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9968 case NT_GNU_BUILD_ID
:
9969 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9970 case NT_GNU_GOLD_VERSION
:
9971 return _("NT_GNU_GOLD_VERSION (gold version)");
9976 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9981 get_netbsd_elfcore_note_type (unsigned e_type
)
9983 static char buff
[64];
9985 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9987 /* NetBSD core "procinfo" structure. */
9988 return _("NetBSD procinfo structure");
9991 /* As of Jan 2002 there are no other machine-independent notes
9992 defined for NetBSD core files. If the note type is less
9993 than the start of the machine-dependent note types, we don't
9996 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9998 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10002 switch (elf_header
.e_machine
)
10004 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10005 and PT_GETFPREGS == mach+2. */
10010 case EM_SPARC32PLUS
:
10014 case NT_NETBSDCORE_FIRSTMACH
+0:
10015 return _("PT_GETREGS (reg structure)");
10016 case NT_NETBSDCORE_FIRSTMACH
+2:
10017 return _("PT_GETFPREGS (fpreg structure)");
10023 /* On all other arch's, PT_GETREGS == mach+1 and
10024 PT_GETFPREGS == mach+3. */
10028 case NT_NETBSDCORE_FIRSTMACH
+1:
10029 return _("PT_GETREGS (reg structure)");
10030 case NT_NETBSDCORE_FIRSTMACH
+3:
10031 return _("PT_GETFPREGS (fpreg structure)");
10037 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10038 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10042 /* Note that by the ELF standard, the name field is already null byte
10043 terminated, and namesz includes the terminating null byte.
10044 I.E. the value of namesz for the name "FSF" is 4.
10046 If the value of namesz is zero, there is no name present. */
10048 process_note (Elf_Internal_Note
*pnote
)
10050 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10053 if (pnote
->namesz
== 0)
10054 /* If there is no note name, then use the default set of
10055 note type strings. */
10056 nt
= get_note_type (pnote
->type
);
10058 else if (const_strneq (pnote
->namedata
, "GNU"))
10059 /* GNU-specific object file notes. */
10060 nt
= get_gnu_elf_note_type (pnote
->type
);
10062 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10063 /* NetBSD-specific core file notes. */
10064 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10066 else if (strneq (pnote
->namedata
, "SPU/", 4))
10068 /* SPU-specific core file notes. */
10069 nt
= pnote
->namedata
+ 4;
10074 /* Don't recognize this note name; just use the default set of
10075 note type strings. */
10076 nt
= get_note_type (pnote
->type
);
10078 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10084 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10086 Elf_External_Note
*pnotes
;
10087 Elf_External_Note
*external
;
10093 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10099 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10100 (unsigned long) offset
, (unsigned long) length
);
10101 printf (_(" Owner\t\tData size\tDescription\n"));
10103 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10105 Elf_External_Note
*next
;
10106 Elf_Internal_Note inote
;
10109 inote
.type
= BYTE_GET (external
->type
);
10110 inote
.namesz
= BYTE_GET (external
->namesz
);
10111 inote
.namedata
= external
->name
;
10112 inote
.descsz
= BYTE_GET (external
->descsz
);
10113 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10114 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10116 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10118 if (((char *) next
) > (((char *) pnotes
) + length
))
10120 warn (_("corrupt note found at offset %lx into core notes\n"),
10121 (unsigned long) ((char *) external
- (char *) pnotes
));
10122 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10123 inote
.type
, inote
.namesz
, inote
.descsz
);
10129 /* Verify that name is null terminated. It appears that at least
10130 one version of Linux (RedHat 6.0) generates corefiles that don't
10131 comply with the ELF spec by failing to include the null byte in
10133 if (inote
.namedata
[inote
.namesz
] != '\0')
10135 temp
= malloc (inote
.namesz
+ 1);
10139 error (_("Out of memory\n"));
10144 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10145 temp
[inote
.namesz
] = 0;
10147 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10148 inote
.namedata
= temp
;
10151 res
&= process_note (& inote
);
10166 process_corefile_note_segments (FILE *file
)
10168 Elf_Internal_Phdr
*segment
;
10172 if (! get_program_headers (file
))
10175 for (i
= 0, segment
= program_headers
;
10176 i
< elf_header
.e_phnum
;
10179 if (segment
->p_type
== PT_NOTE
)
10180 res
&= process_corefile_note_segment (file
,
10181 (bfd_vma
) segment
->p_offset
,
10182 (bfd_vma
) segment
->p_filesz
);
10189 process_note_sections (FILE *file
)
10191 Elf_Internal_Shdr
*section
;
10195 for (i
= 0, section
= section_headers
;
10196 i
< elf_header
.e_shnum
;
10198 if (section
->sh_type
== SHT_NOTE
)
10199 res
&= process_corefile_note_segment (file
,
10200 (bfd_vma
) section
->sh_offset
,
10201 (bfd_vma
) section
->sh_size
);
10207 process_notes (FILE *file
)
10209 /* If we have not been asked to display the notes then do nothing. */
10213 if (elf_header
.e_type
!= ET_CORE
)
10214 return process_note_sections (file
);
10216 /* No program headers means no NOTE segment. */
10217 if (elf_header
.e_phnum
> 0)
10218 return process_corefile_note_segments (file
);
10220 printf (_("No note segments present in the core file.\n"));
10225 process_arch_specific (FILE *file
)
10230 switch (elf_header
.e_machine
)
10233 return process_arm_specific (file
);
10235 case EM_MIPS_RS3_LE
:
10236 return process_mips_specific (file
);
10239 return process_power_specific (file
);
10248 get_file_header (FILE *file
)
10250 /* Read in the identity array. */
10251 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10254 /* Determine how to read the rest of the header. */
10255 switch (elf_header
.e_ident
[EI_DATA
])
10257 default: /* fall through */
10258 case ELFDATANONE
: /* fall through */
10260 byte_get
= byte_get_little_endian
;
10261 byte_put
= byte_put_little_endian
;
10264 byte_get
= byte_get_big_endian
;
10265 byte_put
= byte_put_big_endian
;
10269 /* For now we only support 32 bit and 64 bit ELF files. */
10270 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10272 /* Read in the rest of the header. */
10275 Elf32_External_Ehdr ehdr32
;
10277 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10280 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10281 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10282 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10283 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10284 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10285 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10286 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10287 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10288 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10289 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10290 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10291 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10292 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10296 Elf64_External_Ehdr ehdr64
;
10298 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10299 we will not be able to cope with the 64bit data found in
10300 64 ELF files. Detect this now and abort before we start
10301 overwriting things. */
10302 if (sizeof (bfd_vma
) < 8)
10304 error (_("This instance of readelf has been built without support for a\n\
10305 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10309 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10312 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10313 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10314 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10315 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10316 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10317 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10318 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10319 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10320 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10321 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10322 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10323 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10324 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10327 if (elf_header
.e_shoff
)
10329 /* There may be some extensions in the first section header. Don't
10330 bomb if we can't read it. */
10332 get_32bit_section_headers (file
, 1);
10334 get_64bit_section_headers (file
, 1);
10340 /* Process one ELF object file according to the command line options.
10341 This file may actually be stored in an archive. The file is
10342 positioned at the start of the ELF object. */
10345 process_object (char *file_name
, FILE *file
)
10349 if (! get_file_header (file
))
10351 error (_("%s: Failed to read file header\n"), file_name
);
10355 /* Initialise per file variables. */
10356 for (i
= ARRAY_SIZE (version_info
); i
--;)
10357 version_info
[i
] = 0;
10359 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10360 dynamic_info
[i
] = 0;
10362 /* Process the file. */
10364 printf (_("\nFile: %s\n"), file_name
);
10366 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10367 Note we do this even if cmdline_dump_sects is empty because we
10368 must make sure that the dump_sets array is zeroed out before each
10369 object file is processed. */
10370 if (num_dump_sects
> num_cmdline_dump_sects
)
10371 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10373 if (num_cmdline_dump_sects
> 0)
10375 if (num_dump_sects
== 0)
10376 /* A sneaky way of allocating the dump_sects array. */
10377 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10379 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10380 memcpy (dump_sects
, cmdline_dump_sects
,
10381 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10384 if (! process_file_header ())
10387 if (! process_section_headers (file
))
10389 /* Without loaded section headers we cannot process lots of
10391 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10393 if (! do_using_dynamic
)
10394 do_syms
= do_reloc
= 0;
10397 if (! process_section_groups (file
))
10399 /* Without loaded section groups we cannot process unwind. */
10403 if (process_program_headers (file
))
10404 process_dynamic_section (file
);
10406 process_relocs (file
);
10408 process_unwind (file
);
10410 process_symbol_table (file
);
10412 process_syminfo (file
);
10414 process_version_sections (file
);
10416 process_section_contents (file
);
10418 process_notes (file
);
10420 process_gnu_liblist (file
);
10422 process_arch_specific (file
);
10424 if (program_headers
)
10426 free (program_headers
);
10427 program_headers
= NULL
;
10430 if (section_headers
)
10432 free (section_headers
);
10433 section_headers
= NULL
;
10438 free (string_table
);
10439 string_table
= NULL
;
10440 string_table_length
= 0;
10443 if (dynamic_strings
)
10445 free (dynamic_strings
);
10446 dynamic_strings
= NULL
;
10447 dynamic_strings_length
= 0;
10450 if (dynamic_symbols
)
10452 free (dynamic_symbols
);
10453 dynamic_symbols
= NULL
;
10454 num_dynamic_syms
= 0;
10457 if (dynamic_syminfo
)
10459 free (dynamic_syminfo
);
10460 dynamic_syminfo
= NULL
;
10463 if (section_headers_groups
)
10465 free (section_headers_groups
);
10466 section_headers_groups
= NULL
;
10469 if (section_groups
)
10471 struct group_list
*g
, *next
;
10473 for (i
= 0; i
< group_count
; i
++)
10475 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10482 free (section_groups
);
10483 section_groups
= NULL
;
10486 free_debug_memory ();
10491 /* Process an ELF archive.
10492 On entry the file is positioned just after the ARMAG string. */
10495 process_archive (char *file_name
, FILE *file
)
10497 struct ar_hdr arhdr
;
10499 unsigned long size
;
10500 unsigned long index_num
= 0;
10501 unsigned long *index_array
= NULL
;
10502 char *sym_table
= NULL
;
10503 unsigned long sym_size
= 0;
10504 char *longnames
= NULL
;
10505 unsigned long longnames_size
= 0;
10506 size_t file_name_size
;
10511 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10512 if (got
!= sizeof arhdr
)
10517 error (_("%s: failed to read archive header\n"), file_name
);
10521 /* See if this is the archive symbol table. */
10522 if (const_strneq (arhdr
.ar_name
, "/ ")
10523 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
10525 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10526 size
= size
+ (size
& 1);
10528 if (do_archive_index
)
10531 /* A buffer used to hold numbers read in from an archive index.
10532 These are always 4 bytes long and stored in big-endian format. */
10533 #define SIZEOF_AR_INDEX_NUMBERS 4
10534 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10535 unsigned char * index_buffer
;
10537 /* Check the size of the archive index. */
10538 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10540 error (_("%s: the archive index is empty\n"), file_name
);
10544 /* Read the numer of entries in the archive index. */
10545 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10546 if (got
!= sizeof (integer_buffer
))
10548 error (_("%s: failed to read archive index\n"), file_name
);
10551 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10552 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10554 /* Read in the archive index. */
10555 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10557 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10558 file_name
, index_num
);
10561 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10562 if (index_buffer
== NULL
)
10564 error (_("Out of memory whilst trying to read archive symbol index\n"));
10567 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
10568 if (got
!= index_num
)
10570 free (index_buffer
);
10571 error (_("%s: failed to read archive index\n"), file_name
);
10575 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10577 /* Convert the index numbers into the host's numeric format. */
10578 index_array
= malloc (index_num
* sizeof (* index_array
));
10579 if (index_array
== NULL
)
10581 free (index_buffer
);
10582 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10586 for (i
= 0; i
< index_num
; i
++)
10587 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10588 SIZEOF_AR_INDEX_NUMBERS
);
10589 free (index_buffer
);
10591 /* The remaining space in the header is taken up by the symbol table. */
10594 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10598 sym_table
= malloc (size
);
10600 if (sym_table
== NULL
)
10602 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10606 got
= fread (sym_table
, 1, size
, file
);
10609 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10616 if (fseek (file
, size
, SEEK_CUR
) != 0)
10618 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10623 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10624 if (got
!= sizeof arhdr
)
10632 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10637 else if (do_archive_index
)
10638 printf (_("%s has no archive index\n"), file_name
);
10640 if (const_strneq (arhdr
.ar_name
, "// "))
10642 /* This is the archive string table holding long member
10645 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10646 longnames
= malloc (longnames_size
);
10647 if (longnames
== NULL
)
10649 error (_("Out of memory reading long symbol names in archive\n"));
10654 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10657 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10662 if ((longnames_size
& 1) != 0)
10665 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10666 if (got
!= sizeof arhdr
)
10672 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10679 if (do_archive_index
)
10681 if (sym_table
== NULL
)
10682 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10685 unsigned int i
, j
, k
, l
;
10687 unsigned long current_pos
;
10689 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10690 file_name
, index_num
, sym_size
);
10691 current_pos
= ftell (file
);
10693 for (i
= l
= 0; i
< index_num
; i
++)
10695 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10697 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10699 error (_("%s: failed to seek to next file name\n"), file_name
);
10703 got
= fread (elf_name
, 1, 16, file
);
10706 error (_("%s: failed to read file name\n"), file_name
);
10711 if (elf_name
[0] == '/')
10713 /* We have a long name. */
10714 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10715 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10717 longnames
[j
] = '\0';
10718 printf (_("Binary %s contains:\n"), longnames
+ k
);
10719 longnames
[j
] = '/';
10724 while ((elf_name
[j
] != '/') && (j
< 16))
10726 elf_name
[j
] = '\0';
10727 printf(_("Binary %s contains:\n"), elf_name
);
10732 error (_("%s: end of the symbol table reached before the end of the index\n"),
10736 printf ("\t%s\n", sym_table
+ l
);
10737 l
+= strlen (sym_table
+ l
) + 1;
10741 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10744 free (index_array
);
10745 index_array
= NULL
;
10748 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10750 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10755 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10756 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10757 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10758 && !do_section_groups
)
10759 return 0; /* Archive index only. */
10762 file_name_size
= strlen (file_name
);
10771 if (arhdr
.ar_name
[0] == '/')
10775 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10776 if (off
>= longnames_size
)
10778 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10783 name
= longnames
+ off
;
10784 nameend
= memchr (name
, '/', longnames_size
- off
);
10788 name
= arhdr
.ar_name
;
10789 nameend
= memchr (name
, '/', 16);
10792 if (nameend
== NULL
)
10794 error (_("%s: bad archive file name\n"), file_name
);
10799 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10800 if (namealc
== NULL
)
10802 error (_("Out of memory\n"));
10807 memcpy (namealc
, file_name
, file_name_size
);
10808 namealc
[file_name_size
] = '(';
10809 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10810 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10811 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10813 archive_file_offset
= ftell (file
);
10814 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10816 ret
|= process_object (namealc
, file
);
10821 (archive_file_offset
10822 + archive_file_size
10823 + (archive_file_size
& 1)),
10826 error (_("%s: failed to seek to next archive header\n"), file_name
);
10831 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10832 if (got
!= sizeof arhdr
)
10837 error (_("%s: failed to read archive header\n"), file_name
);
10844 if (index_array
!= NULL
)
10845 free (index_array
);
10846 if (sym_table
!= NULL
)
10848 if (longnames
!= NULL
)
10855 process_file (char *file_name
)
10858 struct stat statbuf
;
10859 char armag
[SARMAG
];
10862 if (stat (file_name
, &statbuf
) < 0)
10864 if (errno
== ENOENT
)
10865 error (_("'%s': No such file\n"), file_name
);
10867 error (_("Could not locate '%s'. System error message: %s\n"),
10868 file_name
, strerror (errno
));
10872 if (! S_ISREG (statbuf
.st_mode
))
10874 error (_("'%s' is not an ordinary file\n"), file_name
);
10878 file
= fopen (file_name
, "rb");
10881 error (_("Input file '%s' is not readable.\n"), file_name
);
10885 if (fread (armag
, SARMAG
, 1, file
) != 1)
10887 error (_("%s: Failed to read file's magic number\n"), file_name
);
10892 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10893 ret
= process_archive (file_name
, file
);
10896 if (do_archive_index
)
10897 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10901 archive_file_size
= archive_file_offset
= 0;
10902 ret
= process_object (file_name
, file
);
10910 #ifdef SUPPORT_DISASSEMBLY
10911 /* Needed by the i386 disassembler. For extra credit, someone could
10912 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10916 print_address (unsigned int addr
, FILE *outfile
)
10918 fprintf (outfile
,"0x%8.8x", addr
);
10921 /* Needed by the i386 disassembler. */
10923 db_task_printsym (unsigned int addr
)
10925 print_address (addr
, stderr
);
10930 main (int argc
, char **argv
)
10934 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10935 setlocale (LC_MESSAGES
, "");
10937 #if defined (HAVE_SETLOCALE)
10938 setlocale (LC_CTYPE
, "");
10940 bindtextdomain (PACKAGE
, LOCALEDIR
);
10941 textdomain (PACKAGE
);
10943 expandargv (&argc
, &argv
);
10945 parse_args (argc
, argv
);
10947 if (num_dump_sects
> 0)
10949 /* Make a copy of the dump_sects array. */
10950 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10951 if (cmdline_dump_sects
== NULL
)
10952 error (_("Out of memory allocating dump request table.\n"));
10955 memcpy (cmdline_dump_sects
, dump_sects
,
10956 num_dump_sects
* sizeof (* dump_sects
));
10957 num_cmdline_dump_sects
= num_dump_sects
;
10961 if (optind
< (argc
- 1))
10965 while (optind
< argc
)
10966 err
|= process_file (argv
[optind
++]);
10968 if (dump_sects
!= NULL
)
10970 if (cmdline_dump_sects
!= NULL
)
10971 free (cmdline_dump_sects
);