1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 Free Software Foundation, Inc.
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
9 This file is part of GNU Binutils.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
26 /* The difference between readelf and objdump:
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56 as this will allow us to read in and parse 64bit and 32bit ELF files.
57 Only do this if we believe that the compiler can support a 64 bit
58 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
105 #include "elf/fr30.h"
108 #include "elf/hppa.h"
109 #include "elf/i386.h"
110 #include "elf/i370.h"
111 #include "elf/i860.h"
112 #include "elf/i960.h"
113 #include "elf/ia64.h"
114 #include "elf/ip2k.h"
115 #include "elf/lm32.h"
116 #include "elf/iq2000.h"
117 #include "elf/m32c.h"
118 #include "elf/m32r.h"
119 #include "elf/m68k.h"
120 #include "elf/m68hc11.h"
121 #include "elf/mcore.h"
123 #include "elf/microblaze.h"
124 #include "elf/mips.h"
125 #include "elf/mmix.h"
126 #include "elf/mn10200.h"
127 #include "elf/mn10300.h"
129 #include "elf/msp430.h"
130 #include "elf/or32.h"
133 #include "elf/ppc64.h"
135 #include "elf/s390.h"
136 #include "elf/score.h"
138 #include "elf/sparc.h"
140 #include "elf/v850.h"
142 #include "elf/x86-64.h"
143 #include "elf/xc16x.h"
144 #include "elf/xstormy16.h"
145 #include "elf/xtensa.h"
150 #include "libiberty.h"
151 #include "safe-ctype.h"
152 #include "filenames.h"
154 char * program_name
= "readelf";
155 static long archive_file_offset
;
156 static unsigned long archive_file_size
;
157 static unsigned long dynamic_addr
;
158 static bfd_size_type dynamic_size
;
159 static unsigned int dynamic_nent
;
160 static char * dynamic_strings
;
161 static unsigned long dynamic_strings_length
;
162 static char * string_table
;
163 static unsigned long string_table_length
;
164 static unsigned long num_dynamic_syms
;
165 static Elf_Internal_Sym
* dynamic_symbols
;
166 static Elf_Internal_Syminfo
* dynamic_syminfo
;
167 static unsigned long dynamic_syminfo_offset
;
168 static unsigned int dynamic_syminfo_nent
;
169 static char program_interpreter
[PATH_MAX
];
170 static bfd_vma dynamic_info
[DT_ENCODING
];
171 static bfd_vma dynamic_info_DT_GNU_HASH
;
172 static bfd_vma version_info
[16];
173 static Elf_Internal_Ehdr elf_header
;
174 static Elf_Internal_Shdr
* section_headers
;
175 static Elf_Internal_Phdr
* program_headers
;
176 static Elf_Internal_Dyn
* dynamic_section
;
177 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
178 static int show_name
;
179 static int do_dynamic
;
181 static int do_dyn_syms
;
183 static int do_sections
;
184 static int do_section_groups
;
185 static int do_section_details
;
186 static int do_segments
;
187 static int do_unwind
;
188 static int do_using_dynamic
;
189 static int do_header
;
191 static int do_version
;
192 static int do_histogram
;
193 static int do_debugging
;
196 static int do_archive_index
;
197 static int is_32bit_elf
;
201 struct group_list
* next
;
202 unsigned int section_index
;
207 struct group_list
* root
;
208 unsigned int group_index
;
211 static size_t group_count
;
212 static struct group
* section_groups
;
213 static struct group
** section_headers_groups
;
216 /* Flag bits indicating particular types of dump. */
217 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
218 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
219 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
220 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
221 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
223 typedef unsigned char dump_type
;
225 /* A linked list of the section names for which dumps were requested. */
226 struct dump_list_entry
230 struct dump_list_entry
* next
;
232 static struct dump_list_entry
* dump_sects_byname
;
234 /* A dynamic array of flags indicating for which sections a dump
235 has been requested via command line switches. */
236 static dump_type
* cmdline_dump_sects
= NULL
;
237 static unsigned int num_cmdline_dump_sects
= 0;
239 /* A dynamic array of flags indicating for which sections a dump of
240 some kind has been requested. It is reset on a per-object file
241 basis and then initialised from the cmdline_dump_sects array,
242 the results of interpreting the -w switch, and the
243 dump_sects_byname list. */
244 static dump_type
* dump_sects
= NULL
;
245 static unsigned int num_dump_sects
= 0;
248 /* How to print a vma value. */
249 typedef enum print_mode
261 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
265 #define SECTION_NAME(X) \
266 ((X) == NULL ? "<none>" \
267 : string_table == NULL ? "<no-name>" \
268 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
269 : string_table + (X)->sh_name))
271 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
273 #define BYTE_GET(field) byte_get (field, sizeof (field))
275 #define GET_ELF_SYMBOLS(file, section) \
276 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
277 : get_64bit_elf_symbols (file, section))
279 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
280 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
281 already been called and verified that the string exists. */
282 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
284 /* This is just a bit of syntatic sugar. */
285 #define streq(a,b) (strcmp ((a), (b)) == 0)
286 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
287 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
290 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
295 if (size
== 0 || nmemb
== 0)
298 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
300 error (_("Unable to seek to 0x%lx for %s\n"),
301 (unsigned long) archive_file_offset
+ offset
, reason
);
308 /* Check for overflow. */
309 if (nmemb
< (~(size_t) 0 - 1) / size
)
310 /* + 1 so that we can '\0' terminate invalid string table sections. */
311 mvar
= malloc (size
* nmemb
+ 1);
315 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
316 (unsigned long)(size
* nmemb
), reason
);
320 ((char *) mvar
)[size
* nmemb
] = '\0';
323 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
325 error (_("Unable to read in 0x%lx bytes of %s\n"),
326 (unsigned long)(size
* nmemb
), reason
);
336 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
341 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
342 field
[6] = ((value
>> 24) >> 24) & 0xff;
343 field
[5] = ((value
>> 24) >> 16) & 0xff;
344 field
[4] = ((value
>> 24) >> 8) & 0xff;
347 field
[3] = (value
>> 24) & 0xff;
350 field
[2] = (value
>> 16) & 0xff;
353 field
[1] = (value
>> 8) & 0xff;
356 field
[0] = value
& 0xff;
360 error (_("Unhandled data length: %d\n"), size
);
365 /* Print a VMA value. */
368 print_vma (bfd_vma vma
, print_mode mode
)
381 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
388 return printf ("%5" BFD_VMA_FMT
"d", vma
);
396 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
399 return printf ("%" BFD_VMA_FMT
"d", vma
);
402 return printf ("%" BFD_VMA_FMT
"u", vma
);
407 /* Display a symbol on stdout. Handles the display of non-printing characters.
409 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
410 truncating as necessary. If WIDTH is negative then format the string to be
411 exactly - WIDTH characters, truncating or padding as necessary.
413 Returns the number of emitted characters. */
416 print_symbol (int width
, const char * symbol
)
419 bfd_boolean extra_padding
= FALSE
;
420 unsigned int num_printed
= 0;
424 /* Set the width to a very large value. This simplifies the code below. */
429 /* Keep the width positive. This also helps. */
431 extra_padding
= TRUE
;
440 /* Look for non-printing symbols inside the symbol's name.
441 This test is triggered in particular by the names generated
442 by the assembler for local labels. */
443 while (ISPRINT (* c
))
453 printf ("%.*s", len
, symbol
);
459 if (* c
== 0 || width
== 0)
462 /* Now display the non-printing character, if
463 there is room left in which to dipslay it. */
469 printf ("^%c", *c
+ 0x40);
479 printf ("<0x%.2x>", *c
);
488 if (extra_padding
&& width
> 0)
490 /* Fill in the remaining spaces. */
491 printf ("%-*s", width
, " ");
499 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
504 field
[7] = value
& 0xff;
505 field
[6] = (value
>> 8) & 0xff;
506 field
[5] = (value
>> 16) & 0xff;
507 field
[4] = (value
>> 24) & 0xff;
512 field
[3] = value
& 0xff;
516 field
[2] = value
& 0xff;
520 field
[1] = value
& 0xff;
524 field
[0] = value
& 0xff;
528 error (_("Unhandled data length: %d\n"), size
);
533 /* Return a pointer to section NAME, or NULL if no such section exists. */
535 static Elf_Internal_Shdr
*
536 find_section (const char * name
)
540 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
541 if (streq (SECTION_NAME (section_headers
+ i
), name
))
542 return section_headers
+ i
;
547 /* Guess the relocation size commonly used by the specific machines. */
550 guess_is_rela (unsigned int e_machine
)
554 /* Targets that use REL relocations. */
570 /* Targets that use RELA relocations. */
574 case EM_ALTERA_NIOS2
:
594 case EM_LATTICEMICO32
:
602 case EM_CYGNUS_MN10200
:
604 case EM_CYGNUS_MN10300
:
628 case EM_MICROBLAZE_OLD
:
649 warn (_("Don't know about relocations on this machine architecture\n"));
655 slurp_rela_relocs (FILE * file
,
656 unsigned long rel_offset
,
657 unsigned long rel_size
,
658 Elf_Internal_Rela
** relasp
,
659 unsigned long * nrelasp
)
661 Elf_Internal_Rela
* relas
;
662 unsigned long nrelas
;
667 Elf32_External_Rela
* erelas
;
669 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
670 rel_size
, _("relocs"));
674 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
676 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
677 sizeof (Elf_Internal_Rela
));
682 error (_("out of memory parsing relocs\n"));
686 for (i
= 0; i
< nrelas
; i
++)
688 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
689 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
690 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
697 Elf64_External_Rela
* erelas
;
699 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
700 rel_size
, _("relocs"));
704 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
706 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
707 sizeof (Elf_Internal_Rela
));
712 error (_("out of memory parsing relocs\n"));
716 for (i
= 0; i
< nrelas
; i
++)
718 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
719 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
720 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
722 /* The #ifdef BFD64 below is to prevent a compile time
723 warning. We know that if we do not have a 64 bit data
724 type that we will never execute this code anyway. */
726 if (elf_header
.e_machine
== EM_MIPS
727 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
729 /* In little-endian objects, r_info isn't really a
730 64-bit little-endian value: it has a 32-bit
731 little-endian symbol index followed by four
732 individual byte fields. Reorder INFO
734 bfd_vma inf
= relas
[i
].r_info
;
735 inf
= (((inf
& 0xffffffff) << 32)
736 | ((inf
>> 56) & 0xff)
737 | ((inf
>> 40) & 0xff00)
738 | ((inf
>> 24) & 0xff0000)
739 | ((inf
>> 8) & 0xff000000));
740 relas
[i
].r_info
= inf
;
753 slurp_rel_relocs (FILE * file
,
754 unsigned long rel_offset
,
755 unsigned long rel_size
,
756 Elf_Internal_Rela
** relsp
,
757 unsigned long * nrelsp
)
759 Elf_Internal_Rela
* rels
;
765 Elf32_External_Rel
* erels
;
767 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
768 rel_size
, _("relocs"));
772 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
774 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
779 error (_("out of memory parsing relocs\n"));
783 for (i
= 0; i
< nrels
; i
++)
785 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
786 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
787 rels
[i
].r_addend
= 0;
794 Elf64_External_Rel
* erels
;
796 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
797 rel_size
, _("relocs"));
801 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
803 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
808 error (_("out of memory parsing relocs\n"));
812 for (i
= 0; i
< nrels
; i
++)
814 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
815 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
816 rels
[i
].r_addend
= 0;
818 /* The #ifdef BFD64 below is to prevent a compile time
819 warning. We know that if we do not have a 64 bit data
820 type that we will never execute this code anyway. */
822 if (elf_header
.e_machine
== EM_MIPS
823 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
825 /* In little-endian objects, r_info isn't really a
826 64-bit little-endian value: it has a 32-bit
827 little-endian symbol index followed by four
828 individual byte fields. Reorder INFO
830 bfd_vma inf
= rels
[i
].r_info
;
831 inf
= (((inf
& 0xffffffff) << 32)
832 | ((inf
>> 56) & 0xff)
833 | ((inf
>> 40) & 0xff00)
834 | ((inf
>> 24) & 0xff0000)
835 | ((inf
>> 8) & 0xff000000));
836 rels
[i
].r_info
= inf
;
848 /* Returns the reloc type extracted from the reloc info field. */
851 get_reloc_type (bfd_vma reloc_info
)
854 return ELF32_R_TYPE (reloc_info
);
856 switch (elf_header
.e_machine
)
859 /* Note: We assume that reloc_info has already been adjusted for us. */
860 return ELF64_MIPS_R_TYPE (reloc_info
);
863 return ELF64_R_TYPE_ID (reloc_info
);
866 return ELF64_R_TYPE (reloc_info
);
870 /* Return the symbol index extracted from the reloc info field. */
873 get_reloc_symindex (bfd_vma reloc_info
)
875 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
878 /* Display the contents of the relocation data found at the specified
882 dump_relocations (FILE * file
,
883 unsigned long rel_offset
,
884 unsigned long rel_size
,
885 Elf_Internal_Sym
* symtab
,
888 unsigned long strtablen
,
892 Elf_Internal_Rela
* rels
;
894 if (is_rela
== UNKNOWN
)
895 is_rela
= guess_is_rela (elf_header
.e_machine
);
899 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
904 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
913 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
915 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
920 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
922 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
930 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
932 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
937 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
939 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
943 for (i
= 0; i
< rel_size
; i
++)
948 bfd_vma symtab_index
;
951 offset
= rels
[i
].r_offset
;
952 inf
= rels
[i
].r_info
;
954 type
= get_reloc_type (inf
);
955 symtab_index
= get_reloc_symindex (inf
);
959 printf ("%8.8lx %8.8lx ",
960 (unsigned long) offset
& 0xffffffff,
961 (unsigned long) inf
& 0xffffffff);
965 #if BFD_HOST_64BIT_LONG
967 ? "%16.16lx %16.16lx "
968 : "%12.12lx %12.12lx ",
970 #elif BFD_HOST_64BIT_LONG_LONG
973 ? "%16.16llx %16.16llx "
974 : "%12.12llx %12.12llx ",
978 ? "%16.16I64x %16.16I64x "
979 : "%12.12I64x %12.12I64x ",
984 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
985 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
986 _bfd_int64_high (offset
),
987 _bfd_int64_low (offset
),
988 _bfd_int64_high (inf
),
989 _bfd_int64_low (inf
));
993 switch (elf_header
.e_machine
)
1000 case EM_CYGNUS_M32R
:
1001 rtype
= elf_m32r_reloc_type (type
);
1006 rtype
= elf_i386_reloc_type (type
);
1011 rtype
= elf_m68hc11_reloc_type (type
);
1015 rtype
= elf_m68k_reloc_type (type
);
1019 rtype
= elf_i960_reloc_type (type
);
1024 rtype
= elf_avr_reloc_type (type
);
1027 case EM_OLD_SPARCV9
:
1028 case EM_SPARC32PLUS
:
1031 rtype
= elf_sparc_reloc_type (type
);
1035 rtype
= elf_spu_reloc_type (type
);
1039 case EM_CYGNUS_V850
:
1040 rtype
= v850_reloc_type (type
);
1044 case EM_CYGNUS_D10V
:
1045 rtype
= elf_d10v_reloc_type (type
);
1049 case EM_CYGNUS_D30V
:
1050 rtype
= elf_d30v_reloc_type (type
);
1054 rtype
= elf_dlx_reloc_type (type
);
1058 rtype
= elf_sh_reloc_type (type
);
1062 case EM_CYGNUS_MN10300
:
1063 rtype
= elf_mn10300_reloc_type (type
);
1067 case EM_CYGNUS_MN10200
:
1068 rtype
= elf_mn10200_reloc_type (type
);
1072 case EM_CYGNUS_FR30
:
1073 rtype
= elf_fr30_reloc_type (type
);
1077 rtype
= elf_frv_reloc_type (type
);
1081 rtype
= elf_mcore_reloc_type (type
);
1085 rtype
= elf_mmix_reloc_type (type
);
1090 rtype
= elf_msp430_reloc_type (type
);
1094 rtype
= elf_ppc_reloc_type (type
);
1098 rtype
= elf_ppc64_reloc_type (type
);
1102 case EM_MIPS_RS3_LE
:
1103 rtype
= elf_mips_reloc_type (type
);
1107 rtype
= elf_alpha_reloc_type (type
);
1111 rtype
= elf_arm_reloc_type (type
);
1115 rtype
= elf_arc_reloc_type (type
);
1119 rtype
= elf_hppa_reloc_type (type
);
1125 rtype
= elf_h8_reloc_type (type
);
1130 rtype
= elf_or32_reloc_type (type
);
1135 rtype
= elf_pj_reloc_type (type
);
1138 rtype
= elf_ia64_reloc_type (type
);
1142 rtype
= elf_cris_reloc_type (type
);
1146 rtype
= elf_i860_reloc_type (type
);
1151 rtype
= elf_x86_64_reloc_type (type
);
1155 rtype
= i370_reloc_type (type
);
1160 rtype
= elf_s390_reloc_type (type
);
1164 rtype
= elf_score_reloc_type (type
);
1168 rtype
= elf_xstormy16_reloc_type (type
);
1172 rtype
= elf_crx_reloc_type (type
);
1176 rtype
= elf_vax_reloc_type (type
);
1181 rtype
= elf_ip2k_reloc_type (type
);
1185 rtype
= elf_iq2000_reloc_type (type
);
1190 rtype
= elf_xtensa_reloc_type (type
);
1193 case EM_LATTICEMICO32
:
1194 rtype
= elf_lm32_reloc_type (type
);
1199 rtype
= elf_m32c_reloc_type (type
);
1203 rtype
= elf_mt_reloc_type (type
);
1207 rtype
= elf_bfin_reloc_type (type
);
1211 rtype
= elf_mep_reloc_type (type
);
1216 rtype
= elf_cr16_reloc_type (type
);
1220 case EM_MICROBLAZE_OLD
:
1221 rtype
= elf_microblaze_reloc_type (type
);
1225 rtype
= elf_rx_reloc_type (type
);
1230 rtype
= elf_xc16x_reloc_type (type
);
1235 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1237 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1239 if (elf_header
.e_machine
== EM_ALPHA
1241 && streq (rtype
, "R_ALPHA_LITUSE")
1244 switch (rels
[i
].r_addend
)
1246 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1247 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1248 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1249 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1250 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1251 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1252 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1253 default: rtype
= NULL
;
1256 printf (" (%s)", rtype
);
1260 printf (_("<unknown addend: %lx>"),
1261 (unsigned long) rels
[i
].r_addend
);
1264 else if (symtab_index
)
1266 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1267 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1270 Elf_Internal_Sym
* psym
;
1272 psym
= symtab
+ symtab_index
;
1276 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1280 unsigned int width
= is_32bit_elf
? 8 : 14;
1282 /* Relocations against GNU_IFUNC symbols do not use the value
1283 of the symbol as the address to relocate against. Instead
1284 they invoke the function named by the symbol and use its
1285 result as the address for relocation.
1287 To indicate this to the user, do not display the value of
1288 the symbol in the "Symbols's Value" field. Instead show
1289 its name followed by () as a hint that the symbol is
1293 || psym
->st_name
== 0
1294 || psym
->st_name
>= strtablen
)
1297 name
= strtab
+ psym
->st_name
;
1299 len
= print_symbol (width
, name
);
1300 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1304 print_vma (psym
->st_value
, LONG_HEX
);
1306 printf (is_32bit_elf
? " " : " ");
1309 if (psym
->st_name
== 0)
1311 const char * sec_name
= "<null>";
1314 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1316 if (psym
->st_shndx
< elf_header
.e_shnum
)
1318 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1319 else if (psym
->st_shndx
== SHN_ABS
)
1321 else if (psym
->st_shndx
== SHN_COMMON
)
1322 sec_name
= "COMMON";
1323 else if (elf_header
.e_machine
== EM_MIPS
1324 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1325 sec_name
= "SCOMMON";
1326 else if (elf_header
.e_machine
== EM_MIPS
1327 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1328 sec_name
= "SUNDEF";
1329 else if ((elf_header
.e_machine
== EM_X86_64
1330 || elf_header
.e_machine
== EM_L1OM
)
1331 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1332 sec_name
= "LARGE_COMMON";
1333 else if (elf_header
.e_machine
== EM_IA_64
1334 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1335 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1336 sec_name
= "ANSI_COM";
1337 else if (elf_header
.e_machine
== EM_IA_64
1338 && (elf_header
.e_ident
[EI_OSABI
]
1339 == ELFOSABI_OPENVMS
)
1340 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1341 sec_name
= "VMS_SYMVEC";
1344 sprintf (name_buf
, "<section 0x%x>",
1345 (unsigned int) psym
->st_shndx
);
1346 sec_name
= name_buf
;
1349 print_symbol (22, sec_name
);
1351 else if (strtab
== NULL
)
1352 printf (_("<string table index: %3ld>"), psym
->st_name
);
1353 else if (psym
->st_name
>= strtablen
)
1354 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1356 print_symbol (22, strtab
+ psym
->st_name
);
1360 long off
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1363 printf (" - %lx", - off
);
1365 printf (" + %lx", off
);
1371 printf ("%*c", is_32bit_elf
?
1372 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1373 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1376 if (elf_header
.e_machine
== EM_SPARCV9
1378 && streq (rtype
, "R_SPARC_OLO10"))
1379 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1384 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1386 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1387 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1388 const char * rtype2
= elf_mips_reloc_type (type2
);
1389 const char * rtype3
= elf_mips_reloc_type (type3
);
1391 printf (" Type2: ");
1394 printf (_("unrecognized: %-7lx"),
1395 (unsigned long) type2
& 0xffffffff);
1397 printf ("%-17.17s", rtype2
);
1399 printf ("\n Type3: ");
1402 printf (_("unrecognized: %-7lx"),
1403 (unsigned long) type3
& 0xffffffff);
1405 printf ("%-17.17s", rtype3
);
1416 get_mips_dynamic_type (unsigned long type
)
1420 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1421 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1422 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1423 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1424 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1425 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1426 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1427 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1428 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1429 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1430 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1431 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1432 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1433 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1434 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1435 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1436 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1437 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1438 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1439 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1440 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1441 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1442 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1443 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1444 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1445 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1446 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1447 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1448 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1449 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1450 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1451 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1452 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1453 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1454 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1455 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1456 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1457 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1458 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1459 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1460 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1461 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1462 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1463 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1464 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1471 get_sparc64_dynamic_type (unsigned long type
)
1475 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1482 get_ppc_dynamic_type (unsigned long type
)
1486 case DT_PPC_GOT
: return "PPC_GOT";
1487 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1494 get_ppc64_dynamic_type (unsigned long type
)
1498 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1499 case DT_PPC64_OPD
: return "PPC64_OPD";
1500 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1501 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1508 get_parisc_dynamic_type (unsigned long type
)
1512 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1513 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1514 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1515 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1516 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1517 case DT_HP_PREINIT
: return "HP_PREINIT";
1518 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1519 case DT_HP_NEEDED
: return "HP_NEEDED";
1520 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1521 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1522 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1523 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1524 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1525 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1526 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1527 case DT_HP_FILTERED
: return "HP_FILTERED";
1528 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1529 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1530 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1531 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1532 case DT_PLT
: return "PLT";
1533 case DT_PLT_SIZE
: return "PLT_SIZE";
1534 case DT_DLT
: return "DLT";
1535 case DT_DLT_SIZE
: return "DLT_SIZE";
1542 get_ia64_dynamic_type (unsigned long type
)
1546 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1547 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1548 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1549 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1550 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1551 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1552 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1553 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1554 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1555 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1556 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1557 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1558 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1559 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1560 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1561 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1562 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1563 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1564 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1565 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1566 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1567 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1568 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1569 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1570 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1571 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1572 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1573 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1574 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1575 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1576 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1583 get_alpha_dynamic_type (unsigned long type
)
1587 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1594 get_score_dynamic_type (unsigned long type
)
1598 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1599 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1600 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1601 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1602 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1603 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1611 get_dynamic_type (unsigned long type
)
1613 static char buff
[64];
1617 case DT_NULL
: return "NULL";
1618 case DT_NEEDED
: return "NEEDED";
1619 case DT_PLTRELSZ
: return "PLTRELSZ";
1620 case DT_PLTGOT
: return "PLTGOT";
1621 case DT_HASH
: return "HASH";
1622 case DT_STRTAB
: return "STRTAB";
1623 case DT_SYMTAB
: return "SYMTAB";
1624 case DT_RELA
: return "RELA";
1625 case DT_RELASZ
: return "RELASZ";
1626 case DT_RELAENT
: return "RELAENT";
1627 case DT_STRSZ
: return "STRSZ";
1628 case DT_SYMENT
: return "SYMENT";
1629 case DT_INIT
: return "INIT";
1630 case DT_FINI
: return "FINI";
1631 case DT_SONAME
: return "SONAME";
1632 case DT_RPATH
: return "RPATH";
1633 case DT_SYMBOLIC
: return "SYMBOLIC";
1634 case DT_REL
: return "REL";
1635 case DT_RELSZ
: return "RELSZ";
1636 case DT_RELENT
: return "RELENT";
1637 case DT_PLTREL
: return "PLTREL";
1638 case DT_DEBUG
: return "DEBUG";
1639 case DT_TEXTREL
: return "TEXTREL";
1640 case DT_JMPREL
: return "JMPREL";
1641 case DT_BIND_NOW
: return "BIND_NOW";
1642 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1643 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1644 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1645 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1646 case DT_RUNPATH
: return "RUNPATH";
1647 case DT_FLAGS
: return "FLAGS";
1649 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1650 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1652 case DT_CHECKSUM
: return "CHECKSUM";
1653 case DT_PLTPADSZ
: return "PLTPADSZ";
1654 case DT_MOVEENT
: return "MOVEENT";
1655 case DT_MOVESZ
: return "MOVESZ";
1656 case DT_FEATURE
: return "FEATURE";
1657 case DT_POSFLAG_1
: return "POSFLAG_1";
1658 case DT_SYMINSZ
: return "SYMINSZ";
1659 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1661 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1662 case DT_CONFIG
: return "CONFIG";
1663 case DT_DEPAUDIT
: return "DEPAUDIT";
1664 case DT_AUDIT
: return "AUDIT";
1665 case DT_PLTPAD
: return "PLTPAD";
1666 case DT_MOVETAB
: return "MOVETAB";
1667 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1669 case DT_VERSYM
: return "VERSYM";
1671 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1672 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1673 case DT_RELACOUNT
: return "RELACOUNT";
1674 case DT_RELCOUNT
: return "RELCOUNT";
1675 case DT_FLAGS_1
: return "FLAGS_1";
1676 case DT_VERDEF
: return "VERDEF";
1677 case DT_VERDEFNUM
: return "VERDEFNUM";
1678 case DT_VERNEED
: return "VERNEED";
1679 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1681 case DT_AUXILIARY
: return "AUXILIARY";
1682 case DT_USED
: return "USED";
1683 case DT_FILTER
: return "FILTER";
1685 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1686 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1687 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1688 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1689 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1690 case DT_GNU_HASH
: return "GNU_HASH";
1693 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1695 const char * result
;
1697 switch (elf_header
.e_machine
)
1700 case EM_MIPS_RS3_LE
:
1701 result
= get_mips_dynamic_type (type
);
1704 result
= get_sparc64_dynamic_type (type
);
1707 result
= get_ppc_dynamic_type (type
);
1710 result
= get_ppc64_dynamic_type (type
);
1713 result
= get_ia64_dynamic_type (type
);
1716 result
= get_alpha_dynamic_type (type
);
1719 result
= get_score_dynamic_type (type
);
1729 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1731 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1732 || (elf_header
.e_machine
== EM_PARISC
1733 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1735 const char * result
;
1737 switch (elf_header
.e_machine
)
1740 result
= get_parisc_dynamic_type (type
);
1743 result
= get_ia64_dynamic_type (type
);
1753 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1757 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1764 get_file_type (unsigned e_type
)
1766 static char buff
[32];
1770 case ET_NONE
: return _("NONE (None)");
1771 case ET_REL
: return _("REL (Relocatable file)");
1772 case ET_EXEC
: return _("EXEC (Executable file)");
1773 case ET_DYN
: return _("DYN (Shared object file)");
1774 case ET_CORE
: return _("CORE (Core file)");
1777 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1778 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1779 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1780 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1782 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1788 get_machine_name (unsigned e_machine
)
1790 static char buff
[64]; /* XXX */
1794 case EM_NONE
: return _("None");
1795 case EM_M32
: return "WE32100";
1796 case EM_SPARC
: return "Sparc";
1797 case EM_SPU
: return "SPU";
1798 case EM_386
: return "Intel 80386";
1799 case EM_68K
: return "MC68000";
1800 case EM_88K
: return "MC88000";
1801 case EM_486
: return "Intel 80486";
1802 case EM_860
: return "Intel 80860";
1803 case EM_MIPS
: return "MIPS R3000";
1804 case EM_S370
: return "IBM System/370";
1805 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1806 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1807 case EM_PARISC
: return "HPPA";
1808 case EM_PPC_OLD
: return "Power PC (old)";
1809 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1810 case EM_960
: return "Intel 90860";
1811 case EM_PPC
: return "PowerPC";
1812 case EM_PPC64
: return "PowerPC64";
1813 case EM_V800
: return "NEC V800";
1814 case EM_FR20
: return "Fujitsu FR20";
1815 case EM_RH32
: return "TRW RH32";
1816 case EM_MCORE
: return "MCORE";
1817 case EM_ARM
: return "ARM";
1818 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1819 case EM_SH
: return "Renesas / SuperH SH";
1820 case EM_SPARCV9
: return "Sparc v9";
1821 case EM_TRICORE
: return "Siemens Tricore";
1822 case EM_ARC
: return "ARC";
1823 case EM_H8_300
: return "Renesas H8/300";
1824 case EM_H8_300H
: return "Renesas H8/300H";
1825 case EM_H8S
: return "Renesas H8S";
1826 case EM_H8_500
: return "Renesas H8/500";
1827 case EM_IA_64
: return "Intel IA-64";
1828 case EM_MIPS_X
: return "Stanford MIPS-X";
1829 case EM_COLDFIRE
: return "Motorola Coldfire";
1830 case EM_68HC12
: return "Motorola M68HC12";
1831 case EM_ALPHA
: return "Alpha";
1832 case EM_CYGNUS_D10V
:
1833 case EM_D10V
: return "d10v";
1834 case EM_CYGNUS_D30V
:
1835 case EM_D30V
: return "d30v";
1836 case EM_CYGNUS_M32R
:
1837 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1838 case EM_CYGNUS_V850
:
1839 case EM_V850
: return "NEC v850";
1840 case EM_CYGNUS_MN10300
:
1841 case EM_MN10300
: return "mn10300";
1842 case EM_CYGNUS_MN10200
:
1843 case EM_MN10200
: return "mn10200";
1844 case EM_CYGNUS_FR30
:
1845 case EM_FR30
: return "Fujitsu FR30";
1846 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1848 case EM_PJ
: return "picoJava";
1849 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1850 case EM_PCP
: return "Siemens PCP";
1851 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1852 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1853 case EM_STARCORE
: return "Motorola Star*Core processor";
1854 case EM_ME16
: return "Toyota ME16 processor";
1855 case EM_ST100
: return "STMicroelectronics ST100 processor";
1856 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1857 case EM_PDSP
: return "Sony DSP processor";
1858 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1859 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1860 case EM_FX66
: return "Siemens FX66 microcontroller";
1861 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1862 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1863 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1864 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1865 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1866 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1867 case EM_SVX
: return "Silicon Graphics SVx";
1868 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1869 case EM_VAX
: return "Digital VAX";
1871 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1872 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1873 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1874 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1875 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1876 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1877 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1878 case EM_PRISM
: return "Vitesse Prism";
1879 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1880 case EM_L1OM
: return "Intel L1OM";
1882 case EM_S390
: return "IBM S/390";
1883 case EM_SCORE
: return "SUNPLUS S+Core";
1884 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1886 case EM_OR32
: return "OpenRISC";
1887 case EM_ARC_A5
: return "ARC International ARCompact processor";
1888 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1889 case EM_DLX
: return "OpenDLX";
1891 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1892 case EM_IQ2000
: return "Vitesse IQ2000";
1894 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1895 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1896 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1897 case EM_NS32K
: return "National Semiconductor 32000 series";
1898 case EM_TPC
: return "Tenor Network TPC processor";
1899 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1900 case EM_MAX
: return "MAX Processor";
1901 case EM_CR
: return "National Semiconductor CompactRISC";
1902 case EM_F2MC16
: return "Fujitsu F2MC16";
1903 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1904 case EM_LATTICEMICO32
: return "Lattice Mico32";
1906 case EM_M32C
: return "Renesas M32c";
1907 case EM_MT
: return "Morpho Techologies MT processor";
1908 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1909 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1910 case EM_SEP
: return "Sharp embedded microprocessor";
1911 case EM_ARCA
: return "Arca RISC microprocessor";
1912 case EM_UNICORE
: return "Unicore";
1913 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1914 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1915 case EM_NIOS32
: return "Altera Nios";
1916 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1918 case EM_XC16X
: return "Infineon Technologies xc16x";
1919 case EM_M16C
: return "Renesas M16C series microprocessors";
1920 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1921 case EM_CE
: return "Freescale Communication Engine RISC core";
1922 case EM_TSK3000
: return "Altium TSK3000 core";
1923 case EM_RS08
: return "Freescale RS08 embedded processor";
1924 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1925 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1926 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1927 case EM_SE_C17
: return "Seiko Epson C17 family";
1928 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
1929 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
1930 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
1931 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1932 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
1933 case EM_R32C
: return "Renesas R32C series microprocessors";
1934 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
1935 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
1936 case EM_8051
: return "Intel 8051 and variants";
1937 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
1938 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
1939 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
1940 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1941 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
1942 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
1943 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
1944 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1946 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1947 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1948 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1949 case EM_RX
: return "Renesas RX";
1950 case EM_METAG
: return "Imagination Technologies META processor architecture";
1951 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
1952 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
1953 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
1954 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
1955 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
1956 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
1957 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
1958 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
1959 case EM_CUDA
: return "NVIDIA CUDA architecture";
1961 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1967 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1972 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1973 e_flags
&= ~ EF_ARM_EABIMASK
;
1975 /* Handle "generic" ARM flags. */
1976 if (e_flags
& EF_ARM_RELEXEC
)
1978 strcat (buf
, ", relocatable executable");
1979 e_flags
&= ~ EF_ARM_RELEXEC
;
1982 if (e_flags
& EF_ARM_HASENTRY
)
1984 strcat (buf
, ", has entry point");
1985 e_flags
&= ~ EF_ARM_HASENTRY
;
1988 /* Now handle EABI specific flags. */
1992 strcat (buf
, ", <unrecognized EABI>");
1997 case EF_ARM_EABI_VER1
:
1998 strcat (buf
, ", Version1 EABI");
2003 /* Process flags one bit at a time. */
2004 flag
= e_flags
& - e_flags
;
2009 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2010 strcat (buf
, ", sorted symbol tables");
2020 case EF_ARM_EABI_VER2
:
2021 strcat (buf
, ", Version2 EABI");
2026 /* Process flags one bit at a time. */
2027 flag
= e_flags
& - e_flags
;
2032 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2033 strcat (buf
, ", sorted symbol tables");
2036 case EF_ARM_DYNSYMSUSESEGIDX
:
2037 strcat (buf
, ", dynamic symbols use segment index");
2040 case EF_ARM_MAPSYMSFIRST
:
2041 strcat (buf
, ", mapping symbols precede others");
2051 case EF_ARM_EABI_VER3
:
2052 strcat (buf
, ", Version3 EABI");
2055 case EF_ARM_EABI_VER4
:
2056 strcat (buf
, ", Version4 EABI");
2059 case EF_ARM_EABI_VER5
:
2060 strcat (buf
, ", Version5 EABI");
2066 /* Process flags one bit at a time. */
2067 flag
= e_flags
& - e_flags
;
2073 strcat (buf
, ", BE8");
2077 strcat (buf
, ", LE8");
2087 case EF_ARM_EABI_UNKNOWN
:
2088 strcat (buf
, ", GNU EABI");
2093 /* Process flags one bit at a time. */
2094 flag
= e_flags
& - e_flags
;
2099 case EF_ARM_INTERWORK
:
2100 strcat (buf
, ", interworking enabled");
2103 case EF_ARM_APCS_26
:
2104 strcat (buf
, ", uses APCS/26");
2107 case EF_ARM_APCS_FLOAT
:
2108 strcat (buf
, ", uses APCS/float");
2112 strcat (buf
, ", position independent");
2116 strcat (buf
, ", 8 bit structure alignment");
2119 case EF_ARM_NEW_ABI
:
2120 strcat (buf
, ", uses new ABI");
2123 case EF_ARM_OLD_ABI
:
2124 strcat (buf
, ", uses old ABI");
2127 case EF_ARM_SOFT_FLOAT
:
2128 strcat (buf
, ", software FP");
2131 case EF_ARM_VFP_FLOAT
:
2132 strcat (buf
, ", VFP");
2135 case EF_ARM_MAVERICK_FLOAT
:
2136 strcat (buf
, ", Maverick FP");
2147 strcat (buf
,", <unknown>");
2151 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2153 static char buf
[1024];
2165 decode_ARM_machine_flags (e_flags
, buf
);
2169 switch (e_flags
& EF_FRV_CPU_MASK
)
2171 case EF_FRV_CPU_GENERIC
:
2175 strcat (buf
, ", fr???");
2178 case EF_FRV_CPU_FR300
:
2179 strcat (buf
, ", fr300");
2182 case EF_FRV_CPU_FR400
:
2183 strcat (buf
, ", fr400");
2185 case EF_FRV_CPU_FR405
:
2186 strcat (buf
, ", fr405");
2189 case EF_FRV_CPU_FR450
:
2190 strcat (buf
, ", fr450");
2193 case EF_FRV_CPU_FR500
:
2194 strcat (buf
, ", fr500");
2196 case EF_FRV_CPU_FR550
:
2197 strcat (buf
, ", fr550");
2200 case EF_FRV_CPU_SIMPLE
:
2201 strcat (buf
, ", simple");
2203 case EF_FRV_CPU_TOMCAT
:
2204 strcat (buf
, ", tomcat");
2210 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2211 strcat (buf
, ", m68000");
2212 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2213 strcat (buf
, ", cpu32");
2214 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2215 strcat (buf
, ", fido_a");
2218 char const * isa
= _("unknown");
2219 char const * mac
= _("unknown mac");
2220 char const * additional
= NULL
;
2222 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2224 case EF_M68K_CF_ISA_A_NODIV
:
2226 additional
= ", nodiv";
2228 case EF_M68K_CF_ISA_A
:
2231 case EF_M68K_CF_ISA_A_PLUS
:
2234 case EF_M68K_CF_ISA_B_NOUSP
:
2236 additional
= ", nousp";
2238 case EF_M68K_CF_ISA_B
:
2242 strcat (buf
, ", cf, isa ");
2245 strcat (buf
, additional
);
2246 if (e_flags
& EF_M68K_CF_FLOAT
)
2247 strcat (buf
, ", float");
2248 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2253 case EF_M68K_CF_MAC
:
2256 case EF_M68K_CF_EMAC
:
2269 if (e_flags
& EF_PPC_EMB
)
2270 strcat (buf
, ", emb");
2272 if (e_flags
& EF_PPC_RELOCATABLE
)
2273 strcat (buf
, ", relocatable");
2275 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2276 strcat (buf
, ", relocatable-lib");
2280 case EM_CYGNUS_V850
:
2281 switch (e_flags
& EF_V850_ARCH
)
2284 strcat (buf
, ", v850e1");
2287 strcat (buf
, ", v850e");
2290 strcat (buf
, ", v850");
2293 strcat (buf
, ", unknown v850 architecture variant");
2299 case EM_CYGNUS_M32R
:
2300 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2301 strcat (buf
, ", m32r");
2305 case EM_MIPS_RS3_LE
:
2306 if (e_flags
& EF_MIPS_NOREORDER
)
2307 strcat (buf
, ", noreorder");
2309 if (e_flags
& EF_MIPS_PIC
)
2310 strcat (buf
, ", pic");
2312 if (e_flags
& EF_MIPS_CPIC
)
2313 strcat (buf
, ", cpic");
2315 if (e_flags
& EF_MIPS_UCODE
)
2316 strcat (buf
, ", ugen_reserved");
2318 if (e_flags
& EF_MIPS_ABI2
)
2319 strcat (buf
, ", abi2");
2321 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2322 strcat (buf
, ", odk first");
2324 if (e_flags
& EF_MIPS_32BITMODE
)
2325 strcat (buf
, ", 32bitmode");
2327 switch ((e_flags
& EF_MIPS_MACH
))
2329 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2330 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2331 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2332 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2333 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2334 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2335 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2336 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2337 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2338 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2339 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2340 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2341 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2342 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2343 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2345 /* We simply ignore the field in this case to avoid confusion:
2346 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2349 default: strcat (buf
, ", unknown CPU"); break;
2352 switch ((e_flags
& EF_MIPS_ABI
))
2354 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2355 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2356 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2357 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2359 /* We simply ignore the field in this case to avoid confusion:
2360 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2361 This means it is likely to be an o32 file, but not for
2364 default: strcat (buf
, ", unknown ABI"); break;
2367 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2368 strcat (buf
, ", mdmx");
2370 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2371 strcat (buf
, ", mips16");
2373 switch ((e_flags
& EF_MIPS_ARCH
))
2375 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2376 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2377 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2378 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2379 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2380 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2381 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2382 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2383 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2384 default: strcat (buf
, ", unknown ISA"); break;
2390 switch ((e_flags
& EF_SH_MACH_MASK
))
2392 case EF_SH1
: strcat (buf
, ", sh1"); break;
2393 case EF_SH2
: strcat (buf
, ", sh2"); break;
2394 case EF_SH3
: strcat (buf
, ", sh3"); break;
2395 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2396 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2397 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2398 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2399 case EF_SH4
: strcat (buf
, ", sh4"); break;
2400 case EF_SH5
: strcat (buf
, ", sh5"); break;
2401 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2402 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2403 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2404 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2405 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2406 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2407 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2408 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2409 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2410 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2411 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2412 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2413 default: strcat (buf
, ", unknown ISA"); break;
2419 if (e_flags
& EF_SPARC_32PLUS
)
2420 strcat (buf
, ", v8+");
2422 if (e_flags
& EF_SPARC_SUN_US1
)
2423 strcat (buf
, ", ultrasparcI");
2425 if (e_flags
& EF_SPARC_SUN_US3
)
2426 strcat (buf
, ", ultrasparcIII");
2428 if (e_flags
& EF_SPARC_HAL_R1
)
2429 strcat (buf
, ", halr1");
2431 if (e_flags
& EF_SPARC_LEDATA
)
2432 strcat (buf
, ", ledata");
2434 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2435 strcat (buf
, ", tso");
2437 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2438 strcat (buf
, ", pso");
2440 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2441 strcat (buf
, ", rmo");
2445 switch (e_flags
& EF_PARISC_ARCH
)
2447 case EFA_PARISC_1_0
:
2448 strcpy (buf
, ", PA-RISC 1.0");
2450 case EFA_PARISC_1_1
:
2451 strcpy (buf
, ", PA-RISC 1.1");
2453 case EFA_PARISC_2_0
:
2454 strcpy (buf
, ", PA-RISC 2.0");
2459 if (e_flags
& EF_PARISC_TRAPNIL
)
2460 strcat (buf
, ", trapnil");
2461 if (e_flags
& EF_PARISC_EXT
)
2462 strcat (buf
, ", ext");
2463 if (e_flags
& EF_PARISC_LSB
)
2464 strcat (buf
, ", lsb");
2465 if (e_flags
& EF_PARISC_WIDE
)
2466 strcat (buf
, ", wide");
2467 if (e_flags
& EF_PARISC_NO_KABP
)
2468 strcat (buf
, ", no kabp");
2469 if (e_flags
& EF_PARISC_LAZYSWAP
)
2470 strcat (buf
, ", lazyswap");
2475 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2476 strcat (buf
, ", new calling convention");
2478 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2479 strcat (buf
, ", gnu calling convention");
2483 if ((e_flags
& EF_IA_64_ABI64
))
2484 strcat (buf
, ", 64-bit");
2486 strcat (buf
, ", 32-bit");
2487 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2488 strcat (buf
, ", reduced fp model");
2489 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2490 strcat (buf
, ", no function descriptors, constant gp");
2491 else if ((e_flags
& EF_IA_64_CONS_GP
))
2492 strcat (buf
, ", constant gp");
2493 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2494 strcat (buf
, ", absolute");
2498 if ((e_flags
& EF_VAX_NONPIC
))
2499 strcat (buf
, ", non-PIC");
2500 if ((e_flags
& EF_VAX_DFLOAT
))
2501 strcat (buf
, ", D-Float");
2502 if ((e_flags
& EF_VAX_GFLOAT
))
2503 strcat (buf
, ", G-Float");
2507 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2508 strcat (buf
, ", 64-bit doubles");
2509 if (e_flags
& E_FLAG_RX_DSP
)
2510 strcat (buf
, ", dsp");
2518 get_osabi_name (unsigned int osabi
)
2520 static char buff
[32];
2524 case ELFOSABI_NONE
: return "UNIX - System V";
2525 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2526 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2527 case ELFOSABI_LINUX
: return "UNIX - Linux";
2528 case ELFOSABI_HURD
: return "GNU/Hurd";
2529 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2530 case ELFOSABI_AIX
: return "UNIX - AIX";
2531 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2532 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2533 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2534 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2535 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2536 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2537 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2538 case ELFOSABI_AROS
: return "AROS";
2539 case ELFOSABI_FENIXOS
: return "FenixOS";
2540 case ELFOSABI_STANDALONE
: return _("Standalone App");
2541 case ELFOSABI_ARM
: return "ARM";
2543 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2549 get_arm_segment_type (unsigned long type
)
2563 get_mips_segment_type (unsigned long type
)
2567 case PT_MIPS_REGINFO
:
2569 case PT_MIPS_RTPROC
:
2571 case PT_MIPS_OPTIONS
:
2581 get_parisc_segment_type (unsigned long type
)
2585 case PT_HP_TLS
: return "HP_TLS";
2586 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2587 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2588 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2589 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2590 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2591 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2592 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2593 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2594 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2595 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2596 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2597 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2598 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2599 case PT_HP_STACK
: return "HP_STACK";
2600 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2601 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2602 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2603 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2612 get_ia64_segment_type (unsigned long type
)
2616 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2617 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2618 case PT_HP_TLS
: return "HP_TLS";
2619 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2620 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2621 case PT_IA_64_HP_STACK
: return "HP_STACK";
2630 get_segment_type (unsigned long p_type
)
2632 static char buff
[32];
2636 case PT_NULL
: return "NULL";
2637 case PT_LOAD
: return "LOAD";
2638 case PT_DYNAMIC
: return "DYNAMIC";
2639 case PT_INTERP
: return "INTERP";
2640 case PT_NOTE
: return "NOTE";
2641 case PT_SHLIB
: return "SHLIB";
2642 case PT_PHDR
: return "PHDR";
2643 case PT_TLS
: return "TLS";
2645 case PT_GNU_EH_FRAME
:
2646 return "GNU_EH_FRAME";
2647 case PT_GNU_STACK
: return "GNU_STACK";
2648 case PT_GNU_RELRO
: return "GNU_RELRO";
2651 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2653 const char * result
;
2655 switch (elf_header
.e_machine
)
2658 result
= get_arm_segment_type (p_type
);
2661 case EM_MIPS_RS3_LE
:
2662 result
= get_mips_segment_type (p_type
);
2665 result
= get_parisc_segment_type (p_type
);
2668 result
= get_ia64_segment_type (p_type
);
2678 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2680 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2682 const char * result
;
2684 switch (elf_header
.e_machine
)
2687 result
= get_parisc_segment_type (p_type
);
2690 result
= get_ia64_segment_type (p_type
);
2700 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2703 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2710 get_mips_section_type_name (unsigned int sh_type
)
2714 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2715 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2716 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2717 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2718 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2719 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2720 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2721 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2722 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2723 case SHT_MIPS_RELD
: return "MIPS_RELD";
2724 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2725 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2726 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2727 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2728 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2729 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2730 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2731 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2732 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2733 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2734 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2735 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2736 case SHT_MIPS_LINE
: return "MIPS_LINE";
2737 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2738 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2739 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2740 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2741 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2742 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2743 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2744 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2745 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2746 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2747 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2748 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2749 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2750 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2751 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2752 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2760 get_parisc_section_type_name (unsigned int sh_type
)
2764 case SHT_PARISC_EXT
: return "PARISC_EXT";
2765 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2766 case SHT_PARISC_DOC
: return "PARISC_DOC";
2767 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2768 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2769 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2770 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2778 get_ia64_section_type_name (unsigned int sh_type
)
2780 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2781 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2782 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2786 case SHT_IA_64_EXT
: return "IA_64_EXT";
2787 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2788 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2789 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2790 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2791 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2792 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2793 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2794 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2795 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2803 get_x86_64_section_type_name (unsigned int sh_type
)
2807 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2815 get_arm_section_type_name (unsigned int sh_type
)
2819 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2820 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2821 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2822 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2823 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2831 get_section_type_name (unsigned int sh_type
)
2833 static char buff
[32];
2837 case SHT_NULL
: return "NULL";
2838 case SHT_PROGBITS
: return "PROGBITS";
2839 case SHT_SYMTAB
: return "SYMTAB";
2840 case SHT_STRTAB
: return "STRTAB";
2841 case SHT_RELA
: return "RELA";
2842 case SHT_HASH
: return "HASH";
2843 case SHT_DYNAMIC
: return "DYNAMIC";
2844 case SHT_NOTE
: return "NOTE";
2845 case SHT_NOBITS
: return "NOBITS";
2846 case SHT_REL
: return "REL";
2847 case SHT_SHLIB
: return "SHLIB";
2848 case SHT_DYNSYM
: return "DYNSYM";
2849 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2850 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2851 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2852 case SHT_GNU_HASH
: return "GNU_HASH";
2853 case SHT_GROUP
: return "GROUP";
2854 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2855 case SHT_GNU_verdef
: return "VERDEF";
2856 case SHT_GNU_verneed
: return "VERNEED";
2857 case SHT_GNU_versym
: return "VERSYM";
2858 case 0x6ffffff0: return "VERSYM";
2859 case 0x6ffffffc: return "VERDEF";
2860 case 0x7ffffffd: return "AUXILIARY";
2861 case 0x7fffffff: return "FILTER";
2862 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2865 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2867 const char * result
;
2869 switch (elf_header
.e_machine
)
2872 case EM_MIPS_RS3_LE
:
2873 result
= get_mips_section_type_name (sh_type
);
2876 result
= get_parisc_section_type_name (sh_type
);
2879 result
= get_ia64_section_type_name (sh_type
);
2883 result
= get_x86_64_section_type_name (sh_type
);
2886 result
= get_arm_section_type_name (sh_type
);
2896 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2898 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2900 const char * result
;
2902 switch (elf_header
.e_machine
)
2905 result
= get_ia64_section_type_name (sh_type
);
2915 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2917 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2918 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2920 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2926 #define OPTION_DEBUG_DUMP 512
2927 #define OPTION_DYN_SYMS 513
2929 static struct option options
[] =
2931 {"all", no_argument
, 0, 'a'},
2932 {"file-header", no_argument
, 0, 'h'},
2933 {"program-headers", no_argument
, 0, 'l'},
2934 {"headers", no_argument
, 0, 'e'},
2935 {"histogram", no_argument
, 0, 'I'},
2936 {"segments", no_argument
, 0, 'l'},
2937 {"sections", no_argument
, 0, 'S'},
2938 {"section-headers", no_argument
, 0, 'S'},
2939 {"section-groups", no_argument
, 0, 'g'},
2940 {"section-details", no_argument
, 0, 't'},
2941 {"full-section-name",no_argument
, 0, 'N'},
2942 {"symbols", no_argument
, 0, 's'},
2943 {"syms", no_argument
, 0, 's'},
2944 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
2945 {"relocs", no_argument
, 0, 'r'},
2946 {"notes", no_argument
, 0, 'n'},
2947 {"dynamic", no_argument
, 0, 'd'},
2948 {"arch-specific", no_argument
, 0, 'A'},
2949 {"version-info", no_argument
, 0, 'V'},
2950 {"use-dynamic", no_argument
, 0, 'D'},
2951 {"unwind", no_argument
, 0, 'u'},
2952 {"archive-index", no_argument
, 0, 'c'},
2953 {"hex-dump", required_argument
, 0, 'x'},
2954 {"relocated-dump", required_argument
, 0, 'R'},
2955 {"string-dump", required_argument
, 0, 'p'},
2956 #ifdef SUPPORT_DISASSEMBLY
2957 {"instruction-dump", required_argument
, 0, 'i'},
2959 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2961 {"version", no_argument
, 0, 'v'},
2962 {"wide", no_argument
, 0, 'W'},
2963 {"help", no_argument
, 0, 'H'},
2964 {0, no_argument
, 0, 0}
2968 usage (FILE * stream
)
2970 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2971 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2972 fprintf (stream
, _(" Options are:\n\
2973 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2974 -h --file-header Display the ELF file header\n\
2975 -l --program-headers Display the program headers\n\
2976 --segments An alias for --program-headers\n\
2977 -S --section-headers Display the sections' header\n\
2978 --sections An alias for --section-headers\n\
2979 -g --section-groups Display the section groups\n\
2980 -t --section-details Display the section details\n\
2981 -e --headers Equivalent to: -h -l -S\n\
2982 -s --syms Display the symbol table\n\
2983 --symbols An alias for --syms\n\
2984 --dyn-syms Display the dynamic symbol table\n\
2985 -n --notes Display the core notes (if present)\n\
2986 -r --relocs Display the relocations (if present)\n\
2987 -u --unwind Display the unwind info (if present)\n\
2988 -d --dynamic Display the dynamic section (if present)\n\
2989 -V --version-info Display the version sections (if present)\n\
2990 -A --arch-specific Display architecture specific information (if any).\n\
2991 -c --archive-index Display the symbol/file index in an archive\n\
2992 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2993 -x --hex-dump=<number|name>\n\
2994 Dump the contents of section <number|name> as bytes\n\
2995 -p --string-dump=<number|name>\n\
2996 Dump the contents of section <number|name> as strings\n\
2997 -R --relocated-dump=<number|name>\n\
2998 Dump the contents of section <number|name> as relocated bytes\n\
2999 -w[lLiaprmfFsoRt] or\n\
3000 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3001 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
3002 Display the contents of DWARF2 debug sections\n"));
3003 #ifdef SUPPORT_DISASSEMBLY
3004 fprintf (stream
, _("\
3005 -i --instruction-dump=<number|name>\n\
3006 Disassemble the contents of section <number|name>\n"));
3008 fprintf (stream
, _("\
3009 -I --histogram Display histogram of bucket list lengths\n\
3010 -W --wide Allow output width to exceed 80 characters\n\
3011 @<file> Read options from <file>\n\
3012 -H --help Display this information\n\
3013 -v --version Display the version number of readelf\n"));
3015 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3016 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3018 exit (stream
== stdout
? 0 : 1);
3021 /* Record the fact that the user wants the contents of section number
3022 SECTION to be displayed using the method(s) encoded as flags bits
3023 in TYPE. Note, TYPE can be zero if we are creating the array for
3027 request_dump_bynumber (unsigned int section
, dump_type type
)
3029 if (section
>= num_dump_sects
)
3031 dump_type
* new_dump_sects
;
3033 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3034 sizeof (* dump_sects
));
3036 if (new_dump_sects
== NULL
)
3037 error (_("Out of memory allocating dump request table.\n"));
3040 /* Copy current flag settings. */
3041 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3045 dump_sects
= new_dump_sects
;
3046 num_dump_sects
= section
+ 1;
3051 dump_sects
[section
] |= type
;
3056 /* Request a dump by section name. */
3059 request_dump_byname (const char * section
, dump_type type
)
3061 struct dump_list_entry
* new_request
;
3063 new_request
= (struct dump_list_entry
*)
3064 malloc (sizeof (struct dump_list_entry
));
3066 error (_("Out of memory allocating dump request table.\n"));
3068 new_request
->name
= strdup (section
);
3069 if (!new_request
->name
)
3070 error (_("Out of memory allocating dump request table.\n"));
3072 new_request
->type
= type
;
3074 new_request
->next
= dump_sects_byname
;
3075 dump_sects_byname
= new_request
;
3079 request_dump (dump_type type
)
3085 section
= strtoul (optarg
, & cp
, 0);
3087 if (! *cp
&& section
>= 0)
3088 request_dump_bynumber (section
, type
);
3090 request_dump_byname (optarg
, type
);
3095 parse_args (int argc
, char ** argv
)
3102 while ((c
= getopt_long
3103 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3121 do_section_groups
++;
3129 do_section_groups
++;
3134 do_section_details
++;
3178 request_dump (HEX_DUMP
);
3181 request_dump (STRING_DUMP
);
3184 request_dump (RELOC_DUMP
);
3191 dwarf_select_sections_all ();
3196 dwarf_select_sections_by_letters (optarg
);
3199 case OPTION_DEBUG_DUMP
:
3206 dwarf_select_sections_by_names (optarg
);
3209 case OPTION_DYN_SYMS
:
3212 #ifdef SUPPORT_DISASSEMBLY
3214 request_dump (DISASS_DUMP
);
3218 print_version (program_name
);
3227 /* xgettext:c-format */
3228 error (_("Invalid option '-%c'\n"), c
);
3235 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3236 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3237 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3238 && !do_section_groups
&& !do_archive_index
3243 warn (_("Nothing to do.\n"));
3249 get_elf_class (unsigned int elf_class
)
3251 static char buff
[32];
3255 case ELFCLASSNONE
: return _("none");
3256 case ELFCLASS32
: return "ELF32";
3257 case ELFCLASS64
: return "ELF64";
3259 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3265 get_data_encoding (unsigned int encoding
)
3267 static char buff
[32];
3271 case ELFDATANONE
: return _("none");
3272 case ELFDATA2LSB
: return _("2's complement, little endian");
3273 case ELFDATA2MSB
: return _("2's complement, big endian");
3275 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3280 /* Decode the data held in 'elf_header'. */
3283 process_file_header (void)
3285 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3286 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3287 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3288 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3291 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3295 init_dwarf_regnames (elf_header
.e_machine
);
3301 printf (_("ELF Header:\n"));
3302 printf (_(" Magic: "));
3303 for (i
= 0; i
< EI_NIDENT
; i
++)
3304 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3306 printf (_(" Class: %s\n"),
3307 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3308 printf (_(" Data: %s\n"),
3309 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3310 printf (_(" Version: %d %s\n"),
3311 elf_header
.e_ident
[EI_VERSION
],
3312 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3314 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3317 printf (_(" OS/ABI: %s\n"),
3318 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3319 printf (_(" ABI Version: %d\n"),
3320 elf_header
.e_ident
[EI_ABIVERSION
]);
3321 printf (_(" Type: %s\n"),
3322 get_file_type (elf_header
.e_type
));
3323 printf (_(" Machine: %s\n"),
3324 get_machine_name (elf_header
.e_machine
));
3325 printf (_(" Version: 0x%lx\n"),
3326 (unsigned long) elf_header
.e_version
);
3328 printf (_(" Entry point address: "));
3329 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3330 printf (_("\n Start of program headers: "));
3331 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3332 printf (_(" (bytes into file)\n Start of section headers: "));
3333 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3334 printf (_(" (bytes into file)\n"));
3336 printf (_(" Flags: 0x%lx%s\n"),
3337 (unsigned long) elf_header
.e_flags
,
3338 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3339 printf (_(" Size of this header: %ld (bytes)\n"),
3340 (long) elf_header
.e_ehsize
);
3341 printf (_(" Size of program headers: %ld (bytes)\n"),
3342 (long) elf_header
.e_phentsize
);
3343 printf (_(" Number of program headers: %ld\n"),
3344 (long) elf_header
.e_phnum
);
3345 printf (_(" Size of section headers: %ld (bytes)\n"),
3346 (long) elf_header
.e_shentsize
);
3347 printf (_(" Number of section headers: %ld"),
3348 (long) elf_header
.e_shnum
);
3349 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3350 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3351 putc ('\n', stdout
);
3352 printf (_(" Section header string table index: %ld"),
3353 (long) elf_header
.e_shstrndx
);
3354 if (section_headers
!= NULL
3355 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3356 printf (" (%u)", section_headers
[0].sh_link
);
3357 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3358 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3359 printf (" <corrupt: out of range>");
3360 putc ('\n', stdout
);
3363 if (section_headers
!= NULL
)
3365 if (elf_header
.e_shnum
== SHN_UNDEF
)
3366 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3367 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3368 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3369 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3370 elf_header
.e_shstrndx
= SHN_UNDEF
;
3371 free (section_headers
);
3372 section_headers
= NULL
;
3380 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3382 Elf32_External_Phdr
* phdrs
;
3383 Elf32_External_Phdr
* external
;
3384 Elf_Internal_Phdr
* internal
;
3387 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3388 elf_header
.e_phentsize
,
3390 _("program headers"));
3394 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3395 i
< elf_header
.e_phnum
;
3396 i
++, internal
++, external
++)
3398 internal
->p_type
= BYTE_GET (external
->p_type
);
3399 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3400 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3401 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3402 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3403 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3404 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3405 internal
->p_align
= BYTE_GET (external
->p_align
);
3414 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3416 Elf64_External_Phdr
* phdrs
;
3417 Elf64_External_Phdr
* external
;
3418 Elf_Internal_Phdr
* internal
;
3421 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3422 elf_header
.e_phentsize
,
3424 _("program headers"));
3428 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3429 i
< elf_header
.e_phnum
;
3430 i
++, internal
++, external
++)
3432 internal
->p_type
= BYTE_GET (external
->p_type
);
3433 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3434 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3435 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3436 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3437 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3438 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3439 internal
->p_align
= BYTE_GET (external
->p_align
);
3447 /* Returns 1 if the program headers were read into `program_headers'. */
3450 get_program_headers (FILE * file
)
3452 Elf_Internal_Phdr
* phdrs
;
3454 /* Check cache of prior read. */
3455 if (program_headers
!= NULL
)
3458 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3459 sizeof (Elf_Internal_Phdr
));
3463 error (_("Out of memory\n"));
3468 ? get_32bit_program_headers (file
, phdrs
)
3469 : get_64bit_program_headers (file
, phdrs
))
3471 program_headers
= phdrs
;
3479 /* Returns 1 if the program headers were loaded. */
3482 process_program_headers (FILE * file
)
3484 Elf_Internal_Phdr
* segment
;
3487 if (elf_header
.e_phnum
== 0)
3490 printf (_("\nThere are no program headers in this file.\n"));
3494 if (do_segments
&& !do_header
)
3496 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3497 printf (_("Entry point "));
3498 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3499 printf (_("\nThere are %d program headers, starting at offset "),
3500 elf_header
.e_phnum
);
3501 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3505 if (! get_program_headers (file
))
3510 if (elf_header
.e_phnum
> 1)
3511 printf (_("\nProgram Headers:\n"));
3513 printf (_("\nProgram Headers:\n"));
3517 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3520 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3524 (_(" Type Offset VirtAddr PhysAddr\n"));
3526 (_(" FileSiz MemSiz Flags Align\n"));
3533 for (i
= 0, segment
= program_headers
;
3534 i
< elf_header
.e_phnum
;
3539 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3543 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3544 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3545 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3546 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3547 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3549 (segment
->p_flags
& PF_R
? 'R' : ' '),
3550 (segment
->p_flags
& PF_W
? 'W' : ' '),
3551 (segment
->p_flags
& PF_X
? 'E' : ' '));
3552 printf ("%#lx", (unsigned long) segment
->p_align
);
3556 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3557 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3560 print_vma (segment
->p_offset
, FULL_HEX
);
3564 print_vma (segment
->p_vaddr
, FULL_HEX
);
3566 print_vma (segment
->p_paddr
, FULL_HEX
);
3569 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3570 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3573 print_vma (segment
->p_filesz
, FULL_HEX
);
3577 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3578 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3581 print_vma (segment
->p_offset
, FULL_HEX
);
3585 (segment
->p_flags
& PF_R
? 'R' : ' '),
3586 (segment
->p_flags
& PF_W
? 'W' : ' '),
3587 (segment
->p_flags
& PF_X
? 'E' : ' '));
3589 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3590 printf ("%#lx", (unsigned long) segment
->p_align
);
3593 print_vma (segment
->p_align
, PREFIX_HEX
);
3598 print_vma (segment
->p_offset
, FULL_HEX
);
3600 print_vma (segment
->p_vaddr
, FULL_HEX
);
3602 print_vma (segment
->p_paddr
, FULL_HEX
);
3604 print_vma (segment
->p_filesz
, FULL_HEX
);
3606 print_vma (segment
->p_memsz
, FULL_HEX
);
3608 (segment
->p_flags
& PF_R
? 'R' : ' '),
3609 (segment
->p_flags
& PF_W
? 'W' : ' '),
3610 (segment
->p_flags
& PF_X
? 'E' : ' '));
3611 print_vma (segment
->p_align
, HEX
);
3615 switch (segment
->p_type
)
3619 error (_("more than one dynamic segment\n"));
3621 /* By default, assume that the .dynamic section is the first
3622 section in the DYNAMIC segment. */
3623 dynamic_addr
= segment
->p_offset
;
3624 dynamic_size
= segment
->p_filesz
;
3626 /* Try to locate the .dynamic section. If there is
3627 a section header table, we can easily locate it. */
3628 if (section_headers
!= NULL
)
3630 Elf_Internal_Shdr
* sec
;
3632 sec
= find_section (".dynamic");
3633 if (sec
== NULL
|| sec
->sh_size
== 0)
3635 error (_("no .dynamic section in the dynamic segment\n"));
3639 if (sec
->sh_type
== SHT_NOBITS
)
3645 dynamic_addr
= sec
->sh_offset
;
3646 dynamic_size
= sec
->sh_size
;
3648 if (dynamic_addr
< segment
->p_offset
3649 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3650 warn (_("the .dynamic section is not contained"
3651 " within the dynamic segment\n"));
3652 else if (dynamic_addr
> segment
->p_offset
)
3653 warn (_("the .dynamic section is not the first section"
3654 " in the dynamic segment.\n"));
3659 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3661 error (_("Unable to find program interpreter name\n"));
3665 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3667 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3668 error (_("Internal error: failed to create format string to display program interpreter\n"));
3670 program_interpreter
[0] = 0;
3671 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3672 error (_("Unable to read program interpreter name\n"));
3675 printf (_("\n [Requesting program interpreter: %s]"),
3676 program_interpreter
);
3682 putc ('\n', stdout
);
3685 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3687 printf (_("\n Section to Segment mapping:\n"));
3688 printf (_(" Segment Sections...\n"));
3690 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3693 Elf_Internal_Shdr
* section
;
3695 segment
= program_headers
+ i
;
3696 section
= section_headers
+ 1;
3698 printf (" %2.2d ", i
);
3700 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3702 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3703 printf ("%s ", SECTION_NAME (section
));
3714 /* Find the file offset corresponding to VMA by using the program headers. */
3717 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3719 Elf_Internal_Phdr
* seg
;
3721 if (! get_program_headers (file
))
3723 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3727 for (seg
= program_headers
;
3728 seg
< program_headers
+ elf_header
.e_phnum
;
3731 if (seg
->p_type
!= PT_LOAD
)
3734 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3735 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3736 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3739 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3740 (unsigned long) vma
);
3746 get_32bit_section_headers (FILE * file
, unsigned int num
)
3748 Elf32_External_Shdr
* shdrs
;
3749 Elf_Internal_Shdr
* internal
;
3752 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3753 elf_header
.e_shentsize
, num
,
3754 _("section headers"));
3758 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3759 sizeof (Elf_Internal_Shdr
));
3761 if (section_headers
== NULL
)
3763 error (_("Out of memory\n"));
3767 for (i
= 0, internal
= section_headers
;
3771 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3772 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3773 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3774 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3775 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3776 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3777 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3778 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3779 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3780 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3789 get_64bit_section_headers (FILE * file
, unsigned int num
)
3791 Elf64_External_Shdr
* shdrs
;
3792 Elf_Internal_Shdr
* internal
;
3795 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3796 elf_header
.e_shentsize
, num
,
3797 _("section headers"));
3801 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3802 sizeof (Elf_Internal_Shdr
));
3804 if (section_headers
== NULL
)
3806 error (_("Out of memory\n"));
3810 for (i
= 0, internal
= section_headers
;
3814 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3815 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3816 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3817 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3818 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3819 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3820 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3821 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3822 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3823 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3831 static Elf_Internal_Sym
*
3832 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3834 unsigned long number
;
3835 Elf32_External_Sym
* esyms
;
3836 Elf_External_Sym_Shndx
* shndx
;
3837 Elf_Internal_Sym
* isyms
;
3838 Elf_Internal_Sym
* psym
;
3841 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3842 section
->sh_size
, _("symbols"));
3847 if (symtab_shndx_hdr
!= NULL
3848 && (symtab_shndx_hdr
->sh_link
3849 == (unsigned long) (section
- section_headers
)))
3851 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3852 symtab_shndx_hdr
->sh_offset
,
3853 1, symtab_shndx_hdr
->sh_size
,
3862 number
= section
->sh_size
/ section
->sh_entsize
;
3863 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3867 error (_("Out of memory\n"));
3874 for (j
= 0, psym
= isyms
;
3878 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3879 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3880 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3881 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3882 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3884 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3885 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3886 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3887 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3888 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3898 static Elf_Internal_Sym
*
3899 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3901 unsigned long number
;
3902 Elf64_External_Sym
* esyms
;
3903 Elf_External_Sym_Shndx
* shndx
;
3904 Elf_Internal_Sym
* isyms
;
3905 Elf_Internal_Sym
* psym
;
3908 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3909 section
->sh_size
, _("symbols"));
3914 if (symtab_shndx_hdr
!= NULL
3915 && (symtab_shndx_hdr
->sh_link
3916 == (unsigned long) (section
- section_headers
)))
3918 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3919 symtab_shndx_hdr
->sh_offset
,
3920 1, symtab_shndx_hdr
->sh_size
,
3929 number
= section
->sh_size
/ section
->sh_entsize
;
3930 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3934 error (_("Out of memory\n"));
3941 for (j
= 0, psym
= isyms
;
3945 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3946 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3947 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3948 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3949 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3951 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3952 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3953 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3954 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3955 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3966 get_elf_section_flags (bfd_vma sh_flags
)
3968 static char buff
[1024];
3970 int field_size
= is_32bit_elf
? 8 : 16;
3972 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
3973 bfd_vma os_flags
= 0;
3974 bfd_vma proc_flags
= 0;
3975 bfd_vma unknown_flags
= 0;
3983 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3984 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3985 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3986 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3987 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
3988 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
3989 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
3990 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
3991 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
3992 /* 9 */ { STRING_COMMA_LEN ("TLS") },
3993 /* IA-64 specific. */
3994 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
3995 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
3996 /* IA-64 OpenVMS specific. */
3997 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
3998 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
3999 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4000 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4001 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4002 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4003 /* SPARC specific. */
4004 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4005 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4008 if (do_section_details
)
4010 sprintf (buff
, "[%*.*lx]: ",
4011 field_size
, field_size
, (unsigned long) sh_flags
);
4012 p
+= field_size
+ 4;
4019 flag
= sh_flags
& - sh_flags
;
4022 if (do_section_details
)
4026 case SHF_WRITE
: sindex
= 0; break;
4027 case SHF_ALLOC
: sindex
= 1; break;
4028 case SHF_EXECINSTR
: sindex
= 2; break;
4029 case SHF_MERGE
: sindex
= 3; break;
4030 case SHF_STRINGS
: sindex
= 4; break;
4031 case SHF_INFO_LINK
: sindex
= 5; break;
4032 case SHF_LINK_ORDER
: sindex
= 6; break;
4033 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4034 case SHF_GROUP
: sindex
= 8; break;
4035 case SHF_TLS
: sindex
= 9; break;
4039 switch (elf_header
.e_machine
)
4042 if (flag
== SHF_IA_64_SHORT
)
4044 else if (flag
== SHF_IA_64_NORECOV
)
4047 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4050 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4051 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4052 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4053 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4054 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4055 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4064 case EM_OLD_SPARCV9
:
4065 case EM_SPARC32PLUS
:
4068 if (flag
== SHF_EXCLUDE
)
4070 else if (flag
== SHF_ORDERED
)
4080 if (p
!= buff
+ field_size
+ 4)
4082 if (size
< (10 + 2))
4089 size
-= flags
[sindex
].len
;
4090 p
= stpcpy (p
, flags
[sindex
].str
);
4092 else if (flag
& SHF_MASKOS
)
4094 else if (flag
& SHF_MASKPROC
)
4097 unknown_flags
|= flag
;
4103 case SHF_WRITE
: *p
= 'W'; break;
4104 case SHF_ALLOC
: *p
= 'A'; break;
4105 case SHF_EXECINSTR
: *p
= 'X'; break;
4106 case SHF_MERGE
: *p
= 'M'; break;
4107 case SHF_STRINGS
: *p
= 'S'; break;
4108 case SHF_INFO_LINK
: *p
= 'I'; break;
4109 case SHF_LINK_ORDER
: *p
= 'L'; break;
4110 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4111 case SHF_GROUP
: *p
= 'G'; break;
4112 case SHF_TLS
: *p
= 'T'; break;
4115 if ((elf_header
.e_machine
== EM_X86_64
4116 || elf_header
.e_machine
== EM_L1OM
)
4117 && flag
== SHF_X86_64_LARGE
)
4119 else if (flag
& SHF_MASKOS
)
4122 sh_flags
&= ~ SHF_MASKOS
;
4124 else if (flag
& SHF_MASKPROC
)
4127 sh_flags
&= ~ SHF_MASKPROC
;
4137 if (do_section_details
)
4141 size
-= 5 + field_size
;
4142 if (p
!= buff
+ field_size
+ 4)
4150 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4151 (unsigned long) os_flags
);
4152 p
+= 5 + field_size
;
4156 size
-= 7 + field_size
;
4157 if (p
!= buff
+ field_size
+ 4)
4165 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4166 (unsigned long) proc_flags
);
4167 p
+= 7 + field_size
;
4171 size
-= 10 + field_size
;
4172 if (p
!= buff
+ field_size
+ 4)
4180 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4181 (unsigned long) unknown_flags
);
4182 p
+= 10 + field_size
;
4191 process_section_headers (FILE * file
)
4193 Elf_Internal_Shdr
* section
;
4196 section_headers
= NULL
;
4198 if (elf_header
.e_shnum
== 0)
4201 printf (_("\nThere are no sections in this file.\n"));
4206 if (do_sections
&& !do_header
)
4207 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4208 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4212 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4215 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4218 /* Read in the string table, so that we have names to display. */
4219 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4220 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4222 section
= section_headers
+ elf_header
.e_shstrndx
;
4224 if (section
->sh_size
!= 0)
4226 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4227 1, section
->sh_size
,
4230 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4234 /* Scan the sections for the dynamic symbol table
4235 and dynamic string table and debug sections. */
4236 dynamic_symbols
= NULL
;
4237 dynamic_strings
= NULL
;
4238 dynamic_syminfo
= NULL
;
4239 symtab_shndx_hdr
= NULL
;
4241 eh_addr_size
= is_32bit_elf
? 4 : 8;
4242 switch (elf_header
.e_machine
)
4245 case EM_MIPS_RS3_LE
:
4246 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4247 FDE addresses. However, the ABI also has a semi-official ILP32
4248 variant for which the normal FDE address size rules apply.
4250 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4251 section, where XX is the size of longs in bits. Unfortunately,
4252 earlier compilers provided no way of distinguishing ILP32 objects
4253 from LP64 objects, so if there's any doubt, we should assume that
4254 the official LP64 form is being used. */
4255 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4256 && find_section (".gcc_compiled_long32") == NULL
)
4262 switch (elf_header
.e_flags
& EF_H8_MACH
)
4264 case E_H8_MACH_H8300
:
4265 case E_H8_MACH_H8300HN
:
4266 case E_H8_MACH_H8300SN
:
4267 case E_H8_MACH_H8300SXN
:
4270 case E_H8_MACH_H8300H
:
4271 case E_H8_MACH_H8300S
:
4272 case E_H8_MACH_H8300SX
:
4280 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4282 case EF_M32C_CPU_M16C
:
4289 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4292 size_t expected_entsize \
4293 = is_32bit_elf ? size32 : size64; \
4294 if (section->sh_entsize != expected_entsize) \
4295 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4296 i, (unsigned long int) section->sh_entsize, \
4297 (unsigned long int) expected_entsize); \
4298 section->sh_entsize = expected_entsize; \
4301 #define CHECK_ENTSIZE(section, i, type) \
4302 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4303 sizeof (Elf64_External_##type))
4305 for (i
= 0, section
= section_headers
;
4306 i
< elf_header
.e_shnum
;
4309 char * name
= SECTION_NAME (section
);
4311 if (section
->sh_type
== SHT_DYNSYM
)
4313 if (dynamic_symbols
!= NULL
)
4315 error (_("File contains multiple dynamic symbol tables\n"));
4319 CHECK_ENTSIZE (section
, i
, Sym
);
4320 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4321 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4323 else if (section
->sh_type
== SHT_STRTAB
4324 && streq (name
, ".dynstr"))
4326 if (dynamic_strings
!= NULL
)
4328 error (_("File contains multiple dynamic string tables\n"));
4332 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4333 1, section
->sh_size
,
4334 _("dynamic strings"));
4335 dynamic_strings_length
= section
->sh_size
;
4337 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4339 if (symtab_shndx_hdr
!= NULL
)
4341 error (_("File contains multiple symtab shndx tables\n"));
4344 symtab_shndx_hdr
= section
;
4346 else if (section
->sh_type
== SHT_SYMTAB
)
4347 CHECK_ENTSIZE (section
, i
, Sym
);
4348 else if (section
->sh_type
== SHT_GROUP
)
4349 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4350 else if (section
->sh_type
== SHT_REL
)
4351 CHECK_ENTSIZE (section
, i
, Rel
);
4352 else if (section
->sh_type
== SHT_RELA
)
4353 CHECK_ENTSIZE (section
, i
, Rela
);
4354 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4355 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4356 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4357 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4358 && (const_strneq (name
, ".debug_")
4359 || const_strneq (name
, ".zdebug_")))
4362 name
+= sizeof (".zdebug_") - 1;
4364 name
+= sizeof (".debug_") - 1;
4367 || (do_debug_info
&& streq (name
, "info"))
4368 || (do_debug_info
&& streq (name
, "types"))
4369 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4370 || (do_debug_lines
&& streq (name
, "line"))
4371 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4372 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4373 || (do_debug_aranges
&& streq (name
, "aranges"))
4374 || (do_debug_ranges
&& streq (name
, "ranges"))
4375 || (do_debug_frames
&& streq (name
, "frame"))
4376 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4377 || (do_debug_str
&& streq (name
, "str"))
4378 || (do_debug_loc
&& streq (name
, "loc"))
4380 request_dump_bynumber (i
, DEBUG_DUMP
);
4382 /* Linkonce section to be combined with .debug_info at link time. */
4383 else if ((do_debugging
|| do_debug_info
)
4384 && const_strneq (name
, ".gnu.linkonce.wi."))
4385 request_dump_bynumber (i
, DEBUG_DUMP
);
4386 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4387 request_dump_bynumber (i
, DEBUG_DUMP
);
4393 if (elf_header
.e_shnum
> 1)
4394 printf (_("\nSection Headers:\n"));
4396 printf (_("\nSection Header:\n"));
4400 if (do_section_details
)
4402 printf (_(" [Nr] Name\n"));
4403 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4407 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4411 if (do_section_details
)
4413 printf (_(" [Nr] Name\n"));
4414 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4418 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4422 if (do_section_details
)
4424 printf (_(" [Nr] Name\n"));
4425 printf (_(" Type Address Offset Link\n"));
4426 printf (_(" Size EntSize Info Align\n"));
4430 printf (_(" [Nr] Name Type Address Offset\n"));
4431 printf (_(" Size EntSize Flags Link Info Align\n"));
4435 if (do_section_details
)
4436 printf (_(" Flags\n"));
4438 for (i
= 0, section
= section_headers
;
4439 i
< elf_header
.e_shnum
;
4442 if (do_section_details
)
4444 printf (" [%2u] %s\n",
4446 SECTION_NAME (section
));
4447 if (is_32bit_elf
|| do_wide
)
4448 printf (" %-15.15s ",
4449 get_section_type_name (section
->sh_type
));
4452 printf ((do_wide
? " [%2u] %-17s %-15s "
4453 : " [%2u] %-17.17s %-15.15s "),
4455 SECTION_NAME (section
),
4456 get_section_type_name (section
->sh_type
));
4460 const char * link_too_big
= NULL
;
4462 print_vma (section
->sh_addr
, LONG_HEX
);
4464 printf ( " %6.6lx %6.6lx %2.2lx",
4465 (unsigned long) section
->sh_offset
,
4466 (unsigned long) section
->sh_size
,
4467 (unsigned long) section
->sh_entsize
);
4469 if (do_section_details
)
4470 fputs (" ", stdout
);
4472 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4474 if (section
->sh_link
>= elf_header
.e_shnum
)
4477 /* The sh_link value is out of range. Normally this indicates
4478 an error but it can have special values in Solaris binaries. */
4479 switch (elf_header
.e_machine
)
4484 case EM_OLD_SPARCV9
:
4485 case EM_SPARC32PLUS
:
4488 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4489 link_too_big
= "BEFORE";
4490 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4491 link_too_big
= "AFTER";
4498 if (do_section_details
)
4500 if (link_too_big
!= NULL
&& * link_too_big
)
4501 printf ("<%s> ", link_too_big
);
4503 printf ("%2u ", section
->sh_link
);
4504 printf ("%3u %2lu\n", section
->sh_info
,
4505 (unsigned long) section
->sh_addralign
);
4508 printf ("%2u %3u %2lu\n",
4511 (unsigned long) section
->sh_addralign
);
4513 if (link_too_big
&& ! * link_too_big
)
4514 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4515 i
, section
->sh_link
);
4519 print_vma (section
->sh_addr
, LONG_HEX
);
4521 if ((long) section
->sh_offset
== section
->sh_offset
)
4522 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4526 print_vma (section
->sh_offset
, LONG_HEX
);
4529 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4530 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4534 print_vma (section
->sh_size
, LONG_HEX
);
4537 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4538 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4542 print_vma (section
->sh_entsize
, LONG_HEX
);
4545 if (do_section_details
)
4546 fputs (" ", stdout
);
4548 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4550 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4552 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4553 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4556 print_vma (section
->sh_addralign
, DEC
);
4560 else if (do_section_details
)
4562 printf (" %-15.15s ",
4563 get_section_type_name (section
->sh_type
));
4564 print_vma (section
->sh_addr
, LONG_HEX
);
4565 if ((long) section
->sh_offset
== section
->sh_offset
)
4566 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4570 print_vma (section
->sh_offset
, LONG_HEX
);
4572 printf (" %u\n ", section
->sh_link
);
4573 print_vma (section
->sh_size
, LONG_HEX
);
4575 print_vma (section
->sh_entsize
, LONG_HEX
);
4577 printf (" %-16u %lu\n",
4579 (unsigned long) section
->sh_addralign
);
4584 print_vma (section
->sh_addr
, LONG_HEX
);
4585 if ((long) section
->sh_offset
== section
->sh_offset
)
4586 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4590 print_vma (section
->sh_offset
, LONG_HEX
);
4593 print_vma (section
->sh_size
, LONG_HEX
);
4595 print_vma (section
->sh_entsize
, LONG_HEX
);
4597 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4599 printf (" %2u %3u %lu\n",
4602 (unsigned long) section
->sh_addralign
);
4605 if (do_section_details
)
4606 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4609 if (!do_section_details
)
4610 printf (_("Key to Flags:\n\
4611 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4612 I (info), L (link order), G (group), x (unknown)\n\
4613 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4619 get_group_flags (unsigned int flags
)
4621 static char buff
[32];
4628 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4635 process_section_groups (FILE * file
)
4637 Elf_Internal_Shdr
* section
;
4639 struct group
* group
;
4640 Elf_Internal_Shdr
* symtab_sec
;
4641 Elf_Internal_Shdr
* strtab_sec
;
4642 Elf_Internal_Sym
* symtab
;
4646 /* Don't process section groups unless needed. */
4647 if (!do_unwind
&& !do_section_groups
)
4650 if (elf_header
.e_shnum
== 0)
4652 if (do_section_groups
)
4653 printf (_("\nThere are no sections in this file.\n"));
4658 if (section_headers
== NULL
)
4660 error (_("Section headers are not available!\n"));
4664 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4665 sizeof (struct group
*));
4667 if (section_headers_groups
== NULL
)
4669 error (_("Out of memory\n"));
4673 /* Scan the sections for the group section. */
4675 for (i
= 0, section
= section_headers
;
4676 i
< elf_header
.e_shnum
;
4678 if (section
->sh_type
== SHT_GROUP
)
4681 if (group_count
== 0)
4683 if (do_section_groups
)
4684 printf (_("\nThere are no section groups in this file.\n"));
4689 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4691 if (section_groups
== NULL
)
4693 error (_("Out of memory\n"));
4702 for (i
= 0, section
= section_headers
, group
= section_groups
;
4703 i
< elf_header
.e_shnum
;
4706 if (section
->sh_type
== SHT_GROUP
)
4708 char * name
= SECTION_NAME (section
);
4710 unsigned char * start
;
4711 unsigned char * indices
;
4712 unsigned int entry
, j
, size
;
4713 Elf_Internal_Shdr
* sec
;
4714 Elf_Internal_Sym
* sym
;
4716 /* Get the symbol table. */
4717 if (section
->sh_link
>= elf_header
.e_shnum
4718 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4721 error (_("Bad sh_link in group section `%s'\n"), name
);
4725 if (symtab_sec
!= sec
)
4730 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4733 sym
= symtab
+ section
->sh_info
;
4735 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4737 if (sym
->st_shndx
== 0
4738 || sym
->st_shndx
>= elf_header
.e_shnum
)
4740 error (_("Bad sh_info in group section `%s'\n"), name
);
4744 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4753 /* Get the string table. */
4754 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4763 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4768 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4769 1, strtab_sec
->sh_size
,
4771 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4773 group_name
= sym
->st_name
< strtab_size
4774 ? strtab
+ sym
->st_name
: "<corrupt>";
4777 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4778 1, section
->sh_size
,
4782 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4783 entry
= byte_get (indices
, 4);
4786 if (do_section_groups
)
4788 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4789 get_group_flags (entry
), i
, name
, group_name
, size
);
4791 printf (_(" [Index] Name\n"));
4794 group
->group_index
= i
;
4796 for (j
= 0; j
< size
; j
++)
4798 struct group_list
* g
;
4800 entry
= byte_get (indices
, 4);
4803 if (entry
>= elf_header
.e_shnum
)
4805 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4806 entry
, i
, elf_header
.e_shnum
- 1);
4810 if (section_headers_groups
[entry
] != NULL
)
4814 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4816 section_headers_groups
[entry
]->group_index
);
4821 /* Intel C/C++ compiler may put section 0 in a
4822 section group. We just warn it the first time
4823 and ignore it afterwards. */
4824 static int warned
= 0;
4827 error (_("section 0 in group section [%5u]\n"),
4828 section_headers_groups
[entry
]->group_index
);
4834 section_headers_groups
[entry
] = group
;
4836 if (do_section_groups
)
4838 sec
= section_headers
+ entry
;
4839 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4842 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
4843 g
->section_index
= entry
;
4844 g
->next
= group
->root
;
4868 } dynamic_relocations
[] =
4870 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4871 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4872 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4875 /* Process the reloc section. */
4878 process_relocs (FILE * file
)
4880 unsigned long rel_size
;
4881 unsigned long rel_offset
;
4887 if (do_using_dynamic
)
4891 int has_dynamic_reloc
;
4894 has_dynamic_reloc
= 0;
4896 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4898 is_rela
= dynamic_relocations
[i
].rela
;
4899 name
= dynamic_relocations
[i
].name
;
4900 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4901 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4903 has_dynamic_reloc
|= rel_size
;
4905 if (is_rela
== UNKNOWN
)
4907 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4908 switch (dynamic_info
[DT_PLTREL
])
4922 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4923 name
, rel_offset
, rel_size
);
4925 dump_relocations (file
,
4926 offset_from_vma (file
, rel_offset
, rel_size
),
4928 dynamic_symbols
, num_dynamic_syms
,
4929 dynamic_strings
, dynamic_strings_length
, is_rela
);
4933 if (! has_dynamic_reloc
)
4934 printf (_("\nThere are no dynamic relocations in this file.\n"));
4938 Elf_Internal_Shdr
* section
;
4942 for (i
= 0, section
= section_headers
;
4943 i
< elf_header
.e_shnum
;
4946 if ( section
->sh_type
!= SHT_RELA
4947 && section
->sh_type
!= SHT_REL
)
4950 rel_offset
= section
->sh_offset
;
4951 rel_size
= section
->sh_size
;
4955 Elf_Internal_Shdr
* strsec
;
4958 printf (_("\nRelocation section "));
4960 if (string_table
== NULL
)
4961 printf ("%d", section
->sh_name
);
4963 printf (_("'%s'"), SECTION_NAME (section
));
4965 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4966 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4968 is_rela
= section
->sh_type
== SHT_RELA
;
4970 if (section
->sh_link
!= 0
4971 && section
->sh_link
< elf_header
.e_shnum
)
4973 Elf_Internal_Shdr
* symsec
;
4974 Elf_Internal_Sym
* symtab
;
4975 unsigned long nsyms
;
4976 unsigned long strtablen
= 0;
4977 char * strtab
= NULL
;
4979 symsec
= section_headers
+ section
->sh_link
;
4980 if (symsec
->sh_type
!= SHT_SYMTAB
4981 && symsec
->sh_type
!= SHT_DYNSYM
)
4984 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4985 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4990 if (symsec
->sh_link
!= 0
4991 && symsec
->sh_link
< elf_header
.e_shnum
)
4993 strsec
= section_headers
+ symsec
->sh_link
;
4995 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4998 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5001 dump_relocations (file
, rel_offset
, rel_size
,
5002 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5008 dump_relocations (file
, rel_offset
, rel_size
,
5009 NULL
, 0, NULL
, 0, is_rela
);
5016 printf (_("\nThere are no relocations in this file.\n"));
5022 /* Process the unwind section. */
5024 #include "unwind-ia64.h"
5026 /* An absolute address consists of a section and an offset. If the
5027 section is NULL, the offset itself is the address, otherwise, the
5028 address equals to LOAD_ADDRESS(section) + offset. */
5032 unsigned short section
;
5036 #define ABSADDR(a) \
5038 ? section_headers [(a).section].sh_addr + (a).offset \
5041 struct ia64_unw_table_entry
5043 struct absaddr start
;
5045 struct absaddr info
;
5048 struct ia64_unw_aux_info
5051 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5052 unsigned long table_len
; /* Length of unwind table. */
5053 unsigned char * info
; /* Unwind info. */
5054 unsigned long info_size
; /* Size of unwind info. */
5055 bfd_vma info_addr
; /* starting address of unwind info. */
5056 bfd_vma seg_base
; /* Starting address of segment. */
5057 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5058 unsigned long nsyms
; /* Number of symbols. */
5059 char * strtab
; /* The string table. */
5060 unsigned long strtab_size
; /* Size of string table. */
5064 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5065 unsigned long nsyms
,
5066 const char * strtab
,
5067 unsigned long strtab_size
,
5068 struct absaddr addr
,
5069 const char ** symname
,
5072 bfd_vma dist
= 0x100000;
5073 Elf_Internal_Sym
* sym
;
5074 Elf_Internal_Sym
* best
= NULL
;
5077 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5079 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5080 && sym
->st_name
!= 0
5081 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5082 && addr
.offset
>= sym
->st_value
5083 && addr
.offset
- sym
->st_value
< dist
)
5086 dist
= addr
.offset
- sym
->st_value
;
5093 *symname
= (best
->st_name
>= strtab_size
5094 ? "<corrupt>" : strtab
+ best
->st_name
);
5099 *offset
= addr
.offset
;
5103 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5105 struct ia64_unw_table_entry
* tp
;
5108 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5112 const unsigned char * dp
;
5113 const unsigned char * head
;
5114 const char * procname
;
5116 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5117 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5119 fputs ("\n<", stdout
);
5123 fputs (procname
, stdout
);
5126 printf ("+%lx", (unsigned long) offset
);
5129 fputs (">: [", stdout
);
5130 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5131 fputc ('-', stdout
);
5132 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5133 printf ("], info at +0x%lx\n",
5134 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5136 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5137 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5139 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5140 (unsigned) UNW_VER (stamp
),
5141 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5142 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5143 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5144 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5146 if (UNW_VER (stamp
) != 1)
5148 printf ("\tUnknown version.\n");
5153 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5154 dp
= unw_decode (dp
, in_body
, & in_body
);
5159 slurp_ia64_unwind_table (FILE * file
,
5160 struct ia64_unw_aux_info
* aux
,
5161 Elf_Internal_Shdr
* sec
)
5163 unsigned long size
, nrelas
, i
;
5164 Elf_Internal_Phdr
* seg
;
5165 struct ia64_unw_table_entry
* tep
;
5166 Elf_Internal_Shdr
* relsec
;
5167 Elf_Internal_Rela
* rela
;
5168 Elf_Internal_Rela
* rp
;
5169 unsigned char * table
;
5171 Elf_Internal_Sym
* sym
;
5172 const char * relname
;
5174 /* First, find the starting address of the segment that includes
5177 if (elf_header
.e_phnum
)
5179 if (! get_program_headers (file
))
5182 for (seg
= program_headers
;
5183 seg
< program_headers
+ elf_header
.e_phnum
;
5186 if (seg
->p_type
!= PT_LOAD
)
5189 if (sec
->sh_addr
>= seg
->p_vaddr
5190 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5192 aux
->seg_base
= seg
->p_vaddr
;
5198 /* Second, build the unwind table from the contents of the unwind section: */
5199 size
= sec
->sh_size
;
5200 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5205 aux
->table
= (struct ia64_unw_table_entry
*)
5206 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5208 for (tp
= table
; tp
< table
+ size
; ++tep
)
5210 tep
->start
.section
= SHN_UNDEF
;
5211 tep
->end
.section
= SHN_UNDEF
;
5212 tep
->info
.section
= SHN_UNDEF
;
5213 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5214 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5215 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5216 tep
->start
.offset
+= aux
->seg_base
;
5217 tep
->end
.offset
+= aux
->seg_base
;
5218 tep
->info
.offset
+= aux
->seg_base
;
5222 /* Third, apply any relocations to the unwind table: */
5223 for (relsec
= section_headers
;
5224 relsec
< section_headers
+ elf_header
.e_shnum
;
5227 if (relsec
->sh_type
!= SHT_RELA
5228 || relsec
->sh_info
>= elf_header
.e_shnum
5229 || section_headers
+ relsec
->sh_info
!= sec
)
5232 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5236 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5238 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5239 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5241 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5243 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5247 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5249 switch (rp
->r_offset
/eh_addr_size
% 3)
5252 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5253 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5256 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5257 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5260 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5261 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5271 aux
->table_len
= size
/ (3 * eh_addr_size
);
5276 ia64_process_unwind (FILE * file
)
5278 Elf_Internal_Shdr
* sec
;
5279 Elf_Internal_Shdr
* unwsec
= NULL
;
5280 Elf_Internal_Shdr
* strsec
;
5281 unsigned long i
, unwcount
= 0, unwstart
= 0;
5282 struct ia64_unw_aux_info aux
;
5284 memset (& aux
, 0, sizeof (aux
));
5286 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5288 if (sec
->sh_type
== SHT_SYMTAB
5289 && sec
->sh_link
< elf_header
.e_shnum
)
5291 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5292 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5294 strsec
= section_headers
+ sec
->sh_link
;
5295 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5298 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5300 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5305 printf (_("\nThere are no unwind sections in this file.\n"));
5307 while (unwcount
-- > 0)
5312 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5313 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5314 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5321 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5323 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5325 /* We need to find which section group it is in. */
5326 struct group_list
* g
= section_headers_groups
[i
]->root
;
5328 for (; g
!= NULL
; g
= g
->next
)
5330 sec
= section_headers
+ g
->section_index
;
5332 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5337 i
= elf_header
.e_shnum
;
5339 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5341 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5342 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5343 suffix
= SECTION_NAME (unwsec
) + len
;
5344 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5346 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5347 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5352 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5353 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5354 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5355 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5357 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5358 suffix
= SECTION_NAME (unwsec
) + len
;
5359 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5361 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5362 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5366 if (i
== elf_header
.e_shnum
)
5368 printf (_("\nCould not find unwind info section for "));
5370 if (string_table
== NULL
)
5371 printf ("%d", unwsec
->sh_name
);
5373 printf (_("'%s'"), SECTION_NAME (unwsec
));
5377 aux
.info_size
= sec
->sh_size
;
5378 aux
.info_addr
= sec
->sh_addr
;
5379 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5383 printf (_("\nUnwind section "));
5385 if (string_table
== NULL
)
5386 printf ("%d", unwsec
->sh_name
);
5388 printf (_("'%s'"), SECTION_NAME (unwsec
));
5390 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5391 (unsigned long) unwsec
->sh_offset
,
5392 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5394 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5396 if (aux
.table_len
> 0)
5397 dump_ia64_unwind (& aux
);
5400 free ((char *) aux
.table
);
5402 free ((char *) aux
.info
);
5411 free ((char *) aux
.strtab
);
5416 struct hppa_unw_table_entry
5418 struct absaddr start
;
5420 unsigned int Cannot_unwind
:1; /* 0 */
5421 unsigned int Millicode
:1; /* 1 */
5422 unsigned int Millicode_save_sr0
:1; /* 2 */
5423 unsigned int Region_description
:2; /* 3..4 */
5424 unsigned int reserved1
:1; /* 5 */
5425 unsigned int Entry_SR
:1; /* 6 */
5426 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5427 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5428 unsigned int Args_stored
:1; /* 16 */
5429 unsigned int Variable_Frame
:1; /* 17 */
5430 unsigned int Separate_Package_Body
:1; /* 18 */
5431 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5432 unsigned int Stack_Overflow_Check
:1; /* 20 */
5433 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5434 unsigned int Ada_Region
:1; /* 22 */
5435 unsigned int cxx_info
:1; /* 23 */
5436 unsigned int cxx_try_catch
:1; /* 24 */
5437 unsigned int sched_entry_seq
:1; /* 25 */
5438 unsigned int reserved2
:1; /* 26 */
5439 unsigned int Save_SP
:1; /* 27 */
5440 unsigned int Save_RP
:1; /* 28 */
5441 unsigned int Save_MRP_in_frame
:1; /* 29 */
5442 unsigned int extn_ptr_defined
:1; /* 30 */
5443 unsigned int Cleanup_defined
:1; /* 31 */
5445 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5446 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5447 unsigned int Large_frame
:1; /* 2 */
5448 unsigned int Pseudo_SP_Set
:1; /* 3 */
5449 unsigned int reserved4
:1; /* 4 */
5450 unsigned int Total_frame_size
:27; /* 5..31 */
5453 struct hppa_unw_aux_info
5455 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5456 unsigned long table_len
; /* Length of unwind table. */
5457 bfd_vma seg_base
; /* Starting address of segment. */
5458 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5459 unsigned long nsyms
; /* Number of symbols. */
5460 char * strtab
; /* The string table. */
5461 unsigned long strtab_size
; /* Size of string table. */
5465 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5467 struct hppa_unw_table_entry
* tp
;
5469 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5472 const char * procname
;
5474 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5475 aux
->strtab_size
, tp
->start
, &procname
,
5478 fputs ("\n<", stdout
);
5482 fputs (procname
, stdout
);
5485 printf ("+%lx", (unsigned long) offset
);
5488 fputs (">: [", stdout
);
5489 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5490 fputc ('-', stdout
);
5491 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5494 #define PF(_m) if (tp->_m) printf (#_m " ");
5495 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5498 PF(Millicode_save_sr0
);
5499 /* PV(Region_description); */
5505 PF(Separate_Package_Body
);
5506 PF(Frame_Extension_Millicode
);
5507 PF(Stack_Overflow_Check
);
5508 PF(Two_Instruction_SP_Increment
);
5512 PF(sched_entry_seq
);
5515 PF(Save_MRP_in_frame
);
5516 PF(extn_ptr_defined
);
5517 PF(Cleanup_defined
);
5518 PF(MPE_XL_interrupt_marker
);
5519 PF(HP_UX_interrupt_marker
);
5522 PV(Total_frame_size
);
5531 slurp_hppa_unwind_table (FILE * file
,
5532 struct hppa_unw_aux_info
* aux
,
5533 Elf_Internal_Shdr
* sec
)
5535 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5536 Elf_Internal_Phdr
* seg
;
5537 struct hppa_unw_table_entry
* tep
;
5538 Elf_Internal_Shdr
* relsec
;
5539 Elf_Internal_Rela
* rela
;
5540 Elf_Internal_Rela
* rp
;
5541 unsigned char * table
;
5543 Elf_Internal_Sym
* sym
;
5544 const char * relname
;
5546 /* First, find the starting address of the segment that includes
5549 if (elf_header
.e_phnum
)
5551 if (! get_program_headers (file
))
5554 for (seg
= program_headers
;
5555 seg
< program_headers
+ elf_header
.e_phnum
;
5558 if (seg
->p_type
!= PT_LOAD
)
5561 if (sec
->sh_addr
>= seg
->p_vaddr
5562 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5564 aux
->seg_base
= seg
->p_vaddr
;
5570 /* Second, build the unwind table from the contents of the unwind
5572 size
= sec
->sh_size
;
5573 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5579 nentries
= size
/ unw_ent_size
;
5580 size
= unw_ent_size
* nentries
;
5582 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5583 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5585 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5587 unsigned int tmp1
, tmp2
;
5589 tep
->start
.section
= SHN_UNDEF
;
5590 tep
->end
.section
= SHN_UNDEF
;
5592 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5593 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5594 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5595 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5597 tep
->start
.offset
+= aux
->seg_base
;
5598 tep
->end
.offset
+= aux
->seg_base
;
5600 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5601 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5602 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5603 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5604 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5605 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5606 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5607 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5608 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5609 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5610 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5611 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5612 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5613 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5614 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5615 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5616 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5617 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5618 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5619 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5620 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5621 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5622 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5623 tep
->Cleanup_defined
= tmp1
& 0x1;
5625 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5626 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5627 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5628 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5629 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5630 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5634 /* Third, apply any relocations to the unwind table. */
5635 for (relsec
= section_headers
;
5636 relsec
< section_headers
+ elf_header
.e_shnum
;
5639 if (relsec
->sh_type
!= SHT_RELA
5640 || relsec
->sh_info
>= elf_header
.e_shnum
5641 || section_headers
+ relsec
->sh_info
!= sec
)
5644 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5648 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5650 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5651 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5653 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5654 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5656 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5660 i
= rp
->r_offset
/ unw_ent_size
;
5662 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5665 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5666 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
5669 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5670 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
5680 aux
->table_len
= nentries
;
5686 hppa_process_unwind (FILE * file
)
5688 struct hppa_unw_aux_info aux
;
5689 Elf_Internal_Shdr
* unwsec
= NULL
;
5690 Elf_Internal_Shdr
* strsec
;
5691 Elf_Internal_Shdr
* sec
;
5694 memset (& aux
, 0, sizeof (aux
));
5696 if (string_table
== NULL
)
5699 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5701 if (sec
->sh_type
== SHT_SYMTAB
5702 && sec
->sh_link
< elf_header
.e_shnum
)
5704 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5705 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5707 strsec
= section_headers
+ sec
->sh_link
;
5708 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5711 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5713 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5718 printf (_("\nThere are no unwind sections in this file.\n"));
5720 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5722 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5724 printf (_("\nUnwind section "));
5725 printf (_("'%s'"), SECTION_NAME (sec
));
5727 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5728 (unsigned long) sec
->sh_offset
,
5729 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5731 slurp_hppa_unwind_table (file
, &aux
, sec
);
5732 if (aux
.table_len
> 0)
5733 dump_hppa_unwind (&aux
);
5736 free ((char *) aux
.table
);
5744 free ((char *) aux
.strtab
);
5750 process_unwind (FILE * file
)
5752 struct unwind_handler
5755 int (* handler
)(FILE *);
5758 { EM_IA_64
, ia64_process_unwind
},
5759 { EM_PARISC
, hppa_process_unwind
},
5767 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5768 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5769 return handlers
[i
].handler (file
);
5771 printf (_("\nThere are no unwind sections in this file.\n"));
5776 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5778 switch (entry
->d_tag
)
5781 if (entry
->d_un
.d_val
== 0)
5785 static const char * opts
[] =
5787 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5788 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5789 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5790 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5795 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5796 if (entry
->d_un
.d_val
& (1 << cnt
))
5798 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5805 case DT_MIPS_IVERSION
:
5806 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5807 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5809 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5812 case DT_MIPS_TIME_STAMP
:
5817 time_t atime
= entry
->d_un
.d_val
;
5818 tmp
= gmtime (&atime
);
5819 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5820 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5821 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5822 printf ("Time Stamp: %s\n", timebuf
);
5826 case DT_MIPS_RLD_VERSION
:
5827 case DT_MIPS_LOCAL_GOTNO
:
5828 case DT_MIPS_CONFLICTNO
:
5829 case DT_MIPS_LIBLISTNO
:
5830 case DT_MIPS_SYMTABNO
:
5831 case DT_MIPS_UNREFEXTNO
:
5832 case DT_MIPS_HIPAGENO
:
5833 case DT_MIPS_DELTA_CLASS_NO
:
5834 case DT_MIPS_DELTA_INSTANCE_NO
:
5835 case DT_MIPS_DELTA_RELOC_NO
:
5836 case DT_MIPS_DELTA_SYM_NO
:
5837 case DT_MIPS_DELTA_CLASSSYM_NO
:
5838 case DT_MIPS_COMPACT_SIZE
:
5839 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5843 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5849 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5851 switch (entry
->d_tag
)
5853 case DT_HP_DLD_FLAGS
:
5862 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5863 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5864 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5865 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5866 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5867 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5868 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5869 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5870 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5871 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5872 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5873 { DT_HP_GST
, "HP_GST" },
5874 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5875 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5876 { DT_HP_NODELETE
, "HP_NODELETE" },
5877 { DT_HP_GROUP
, "HP_GROUP" },
5878 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5882 bfd_vma val
= entry
->d_un
.d_val
;
5884 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5885 if (val
& flags
[cnt
].bit
)
5889 fputs (flags
[cnt
].str
, stdout
);
5891 val
^= flags
[cnt
].bit
;
5894 if (val
!= 0 || first
)
5898 print_vma (val
, HEX
);
5904 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5911 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5913 switch (entry
->d_tag
)
5915 case DT_IA_64_PLT_RESERVE
:
5916 /* First 3 slots reserved. */
5917 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5919 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5923 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5930 get_32bit_dynamic_section (FILE * file
)
5932 Elf32_External_Dyn
* edyn
;
5933 Elf32_External_Dyn
* ext
;
5934 Elf_Internal_Dyn
* entry
;
5936 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5937 dynamic_size
, _("dynamic section"));
5941 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5942 might not have the luxury of section headers. Look for the DT_NULL
5943 terminator to determine the number of entries. */
5944 for (ext
= edyn
, dynamic_nent
= 0;
5945 (char *) ext
< (char *) edyn
+ dynamic_size
;
5949 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5953 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5955 if (dynamic_section
== NULL
)
5957 error (_("Out of memory\n"));
5962 for (ext
= edyn
, entry
= dynamic_section
;
5963 entry
< dynamic_section
+ dynamic_nent
;
5966 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5967 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5976 get_64bit_dynamic_section (FILE * file
)
5978 Elf64_External_Dyn
* edyn
;
5979 Elf64_External_Dyn
* ext
;
5980 Elf_Internal_Dyn
* entry
;
5982 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5983 dynamic_size
, _("dynamic section"));
5987 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5988 might not have the luxury of section headers. Look for the DT_NULL
5989 terminator to determine the number of entries. */
5990 for (ext
= edyn
, dynamic_nent
= 0;
5991 (char *) ext
< (char *) edyn
+ dynamic_size
;
5995 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5999 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
6001 if (dynamic_section
== NULL
)
6003 error (_("Out of memory\n"));
6008 for (ext
= edyn
, entry
= dynamic_section
;
6009 entry
< dynamic_section
+ dynamic_nent
;
6012 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6013 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6022 print_dynamic_flags (bfd_vma flags
)
6030 flag
= flags
& - flags
;
6040 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6041 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6042 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6043 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6044 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6045 default: fputs ("unknown", stdout
); break;
6051 /* Parse and display the contents of the dynamic section. */
6054 process_dynamic_section (FILE * file
)
6056 Elf_Internal_Dyn
* entry
;
6058 if (dynamic_size
== 0)
6061 printf (_("\nThere is no dynamic section in this file.\n"));
6068 if (! get_32bit_dynamic_section (file
))
6071 else if (! get_64bit_dynamic_section (file
))
6074 /* Find the appropriate symbol table. */
6075 if (dynamic_symbols
== NULL
)
6077 for (entry
= dynamic_section
;
6078 entry
< dynamic_section
+ dynamic_nent
;
6081 Elf_Internal_Shdr section
;
6083 if (entry
->d_tag
!= DT_SYMTAB
)
6086 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6088 /* Since we do not know how big the symbol table is,
6089 we default to reading in the entire file (!) and
6090 processing that. This is overkill, I know, but it
6092 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6094 if (archive_file_offset
!= 0)
6095 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6098 if (fseek (file
, 0, SEEK_END
))
6099 error (_("Unable to seek to end of file!\n"));
6101 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6105 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6107 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6109 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6110 if (num_dynamic_syms
< 1)
6112 error (_("Unable to determine the number of symbols to load\n"));
6116 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6120 /* Similarly find a string table. */
6121 if (dynamic_strings
== NULL
)
6123 for (entry
= dynamic_section
;
6124 entry
< dynamic_section
+ dynamic_nent
;
6127 unsigned long offset
;
6130 if (entry
->d_tag
!= DT_STRTAB
)
6133 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6135 /* Since we do not know how big the string table is,
6136 we default to reading in the entire file (!) and
6137 processing that. This is overkill, I know, but it
6140 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6142 if (archive_file_offset
!= 0)
6143 str_tab_len
= archive_file_size
- offset
;
6146 if (fseek (file
, 0, SEEK_END
))
6147 error (_("Unable to seek to end of file\n"));
6148 str_tab_len
= ftell (file
) - offset
;
6151 if (str_tab_len
< 1)
6154 (_("Unable to determine the length of the dynamic string table\n"));
6158 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6160 _("dynamic string table"));
6161 dynamic_strings_length
= str_tab_len
;
6166 /* And find the syminfo section if available. */
6167 if (dynamic_syminfo
== NULL
)
6169 unsigned long syminsz
= 0;
6171 for (entry
= dynamic_section
;
6172 entry
< dynamic_section
+ dynamic_nent
;
6175 if (entry
->d_tag
== DT_SYMINENT
)
6177 /* Note: these braces are necessary to avoid a syntax
6178 error from the SunOS4 C compiler. */
6179 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6181 else if (entry
->d_tag
== DT_SYMINSZ
)
6182 syminsz
= entry
->d_un
.d_val
;
6183 else if (entry
->d_tag
== DT_SYMINFO
)
6184 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6188 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6190 Elf_External_Syminfo
* extsyminfo
;
6191 Elf_External_Syminfo
* extsym
;
6192 Elf_Internal_Syminfo
* syminfo
;
6194 /* There is a syminfo section. Read the data. */
6195 extsyminfo
= (Elf_External_Syminfo
*)
6196 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6197 _("symbol information"));
6201 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6202 if (dynamic_syminfo
== NULL
)
6204 error (_("Out of memory\n"));
6208 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6209 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6210 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6211 ++syminfo
, ++extsym
)
6213 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6214 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6221 if (do_dynamic
&& dynamic_addr
)
6222 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6223 dynamic_addr
, dynamic_nent
);
6225 printf (_(" Tag Type Name/Value\n"));
6227 for (entry
= dynamic_section
;
6228 entry
< dynamic_section
+ dynamic_nent
;
6236 print_vma (entry
->d_tag
, FULL_HEX
);
6237 dtype
= get_dynamic_type (entry
->d_tag
);
6238 printf (" (%s)%*s", dtype
,
6239 ((is_32bit_elf
? 27 : 19)
6240 - (int) strlen (dtype
)),
6244 switch (entry
->d_tag
)
6248 print_dynamic_flags (entry
->d_un
.d_val
);
6258 switch (entry
->d_tag
)
6261 printf (_("Auxiliary library"));
6265 printf (_("Filter library"));
6269 printf (_("Configuration file"));
6273 printf (_("Dependency audit library"));
6277 printf (_("Audit library"));
6281 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6282 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6286 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6295 printf (_("Flags:"));
6297 if (entry
->d_un
.d_val
== 0)
6298 printf (_(" None\n"));
6301 unsigned long int val
= entry
->d_un
.d_val
;
6303 if (val
& DTF_1_PARINIT
)
6305 printf (" PARINIT");
6306 val
^= DTF_1_PARINIT
;
6308 if (val
& DTF_1_CONFEXP
)
6310 printf (" CONFEXP");
6311 val
^= DTF_1_CONFEXP
;
6314 printf (" %lx", val
);
6323 printf (_("Flags:"));
6325 if (entry
->d_un
.d_val
== 0)
6326 printf (_(" None\n"));
6329 unsigned long int val
= entry
->d_un
.d_val
;
6331 if (val
& DF_P1_LAZYLOAD
)
6333 printf (" LAZYLOAD");
6334 val
^= DF_P1_LAZYLOAD
;
6336 if (val
& DF_P1_GROUPPERM
)
6338 printf (" GROUPPERM");
6339 val
^= DF_P1_GROUPPERM
;
6342 printf (" %lx", val
);
6351 printf (_("Flags:"));
6352 if (entry
->d_un
.d_val
== 0)
6353 printf (_(" None\n"));
6356 unsigned long int val
= entry
->d_un
.d_val
;
6363 if (val
& DF_1_GLOBAL
)
6368 if (val
& DF_1_GROUP
)
6373 if (val
& DF_1_NODELETE
)
6375 printf (" NODELETE");
6376 val
^= DF_1_NODELETE
;
6378 if (val
& DF_1_LOADFLTR
)
6380 printf (" LOADFLTR");
6381 val
^= DF_1_LOADFLTR
;
6383 if (val
& DF_1_INITFIRST
)
6385 printf (" INITFIRST");
6386 val
^= DF_1_INITFIRST
;
6388 if (val
& DF_1_NOOPEN
)
6393 if (val
& DF_1_ORIGIN
)
6398 if (val
& DF_1_DIRECT
)
6403 if (val
& DF_1_TRANS
)
6408 if (val
& DF_1_INTERPOSE
)
6410 printf (" INTERPOSE");
6411 val
^= DF_1_INTERPOSE
;
6413 if (val
& DF_1_NODEFLIB
)
6415 printf (" NODEFLIB");
6416 val
^= DF_1_NODEFLIB
;
6418 if (val
& DF_1_NODUMP
)
6423 if (val
& DF_1_CONLFAT
)
6425 printf (" CONLFAT");
6426 val
^= DF_1_CONLFAT
;
6429 printf (" %lx", val
);
6436 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6438 puts (get_dynamic_type (entry
->d_un
.d_val
));
6458 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6464 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6465 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6471 switch (entry
->d_tag
)
6474 printf (_("Shared library: [%s]"), name
);
6476 if (streq (name
, program_interpreter
))
6477 printf (_(" program interpreter"));
6481 printf (_("Library soname: [%s]"), name
);
6485 printf (_("Library rpath: [%s]"), name
);
6489 printf (_("Library runpath: [%s]"), name
);
6493 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6498 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6511 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6515 case DT_INIT_ARRAYSZ
:
6516 case DT_FINI_ARRAYSZ
:
6517 case DT_GNU_CONFLICTSZ
:
6518 case DT_GNU_LIBLISTSZ
:
6521 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6522 printf (" (bytes)\n");
6532 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6545 if (entry
->d_tag
== DT_USED
6546 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6548 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6552 printf (_("Not needed object: [%s]\n"), name
);
6557 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6563 /* The value of this entry is ignored. */
6568 case DT_GNU_PRELINKED
:
6572 time_t atime
= entry
->d_un
.d_val
;
6574 tmp
= gmtime (&atime
);
6575 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6576 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6577 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6583 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6586 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6592 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6593 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6598 switch (elf_header
.e_machine
)
6601 case EM_MIPS_RS3_LE
:
6602 dynamic_section_mips_val (entry
);
6605 dynamic_section_parisc_val (entry
);
6608 dynamic_section_ia64_val (entry
);
6611 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6623 get_ver_flags (unsigned int flags
)
6625 static char buff
[32];
6632 if (flags
& VER_FLG_BASE
)
6633 strcat (buff
, "BASE ");
6635 if (flags
& VER_FLG_WEAK
)
6637 if (flags
& VER_FLG_BASE
)
6638 strcat (buff
, "| ");
6640 strcat (buff
, "WEAK ");
6643 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6644 strcat (buff
, "| <unknown>");
6649 /* Display the contents of the version sections. */
6652 process_version_sections (FILE * file
)
6654 Elf_Internal_Shdr
* section
;
6661 for (i
= 0, section
= section_headers
;
6662 i
< elf_header
.e_shnum
;
6665 switch (section
->sh_type
)
6667 case SHT_GNU_verdef
:
6669 Elf_External_Verdef
* edefs
;
6677 (_("\nVersion definition section '%s' contains %u entries:\n"),
6678 SECTION_NAME (section
), section
->sh_info
);
6680 printf (_(" Addr: 0x"));
6681 printf_vma (section
->sh_addr
);
6682 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6683 (unsigned long) section
->sh_offset
, section
->sh_link
,
6684 section
->sh_link
< elf_header
.e_shnum
6685 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6688 edefs
= (Elf_External_Verdef
*)
6689 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
6690 _("version definition section"));
6691 endbuf
= (char *) edefs
+ section
->sh_size
;
6695 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6698 Elf_External_Verdef
* edef
;
6699 Elf_Internal_Verdef ent
;
6700 Elf_External_Verdaux
* eaux
;
6701 Elf_Internal_Verdaux aux
;
6705 vstart
= ((char *) edefs
) + idx
;
6706 if (vstart
+ sizeof (*edef
) > endbuf
)
6709 edef
= (Elf_External_Verdef
*) vstart
;
6711 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6712 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6713 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6714 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6715 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6716 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6717 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6719 printf (_(" %#06x: Rev: %d Flags: %s"),
6720 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6722 printf (_(" Index: %d Cnt: %d "),
6723 ent
.vd_ndx
, ent
.vd_cnt
);
6725 vstart
+= ent
.vd_aux
;
6727 eaux
= (Elf_External_Verdaux
*) vstart
;
6729 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6730 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6732 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6733 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6735 printf (_("Name index: %ld\n"), aux
.vda_name
);
6737 isum
= idx
+ ent
.vd_aux
;
6739 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6741 isum
+= aux
.vda_next
;
6742 vstart
+= aux
.vda_next
;
6744 eaux
= (Elf_External_Verdaux
*) vstart
;
6745 if (vstart
+ sizeof (*eaux
) > endbuf
)
6748 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6749 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6751 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6752 printf (_(" %#06x: Parent %d: %s\n"),
6753 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6755 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6756 isum
, j
, aux
.vda_name
);
6759 printf (_(" Version def aux past end of section\n"));
6763 if (cnt
< section
->sh_info
)
6764 printf (_(" Version definition past end of section\n"));
6770 case SHT_GNU_verneed
:
6772 Elf_External_Verneed
* eneed
;
6779 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6780 SECTION_NAME (section
), section
->sh_info
);
6782 printf (_(" Addr: 0x"));
6783 printf_vma (section
->sh_addr
);
6784 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6785 (unsigned long) section
->sh_offset
, section
->sh_link
,
6786 section
->sh_link
< elf_header
.e_shnum
6787 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6790 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
6791 section
->sh_offset
, 1,
6793 _("version need section"));
6794 endbuf
= (char *) eneed
+ section
->sh_size
;
6798 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6800 Elf_External_Verneed
* entry
;
6801 Elf_Internal_Verneed ent
;
6806 vstart
= ((char *) eneed
) + idx
;
6807 if (vstart
+ sizeof (*entry
) > endbuf
)
6810 entry
= (Elf_External_Verneed
*) vstart
;
6812 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6813 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6814 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6815 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6816 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6818 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6820 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6821 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6823 printf (_(" File: %lx"), ent
.vn_file
);
6825 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6827 vstart
+= ent
.vn_aux
;
6829 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6831 Elf_External_Vernaux
* eaux
;
6832 Elf_Internal_Vernaux aux
;
6834 if (vstart
+ sizeof (*eaux
) > endbuf
)
6836 eaux
= (Elf_External_Vernaux
*) vstart
;
6838 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6839 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6840 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6841 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6842 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6844 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6845 printf (_(" %#06x: Name: %s"),
6846 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6848 printf (_(" %#06x: Name index: %lx"),
6849 isum
, aux
.vna_name
);
6851 printf (_(" Flags: %s Version: %d\n"),
6852 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6854 isum
+= aux
.vna_next
;
6855 vstart
+= aux
.vna_next
;
6858 printf (_(" Version need aux past end of section\n"));
6862 if (cnt
< section
->sh_info
)
6863 printf (_(" Version need past end of section\n"));
6869 case SHT_GNU_versym
:
6871 Elf_Internal_Shdr
* link_section
;
6874 unsigned char * edata
;
6875 unsigned short * data
;
6877 Elf_Internal_Sym
* symbols
;
6878 Elf_Internal_Shdr
* string_sec
;
6881 if (section
->sh_link
>= elf_header
.e_shnum
)
6884 link_section
= section_headers
+ section
->sh_link
;
6885 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6887 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6892 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6894 string_sec
= section_headers
+ link_section
->sh_link
;
6896 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6897 string_sec
->sh_size
,
6898 _("version string table"));
6902 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6903 SECTION_NAME (section
), total
);
6905 printf (_(" Addr: "));
6906 printf_vma (section
->sh_addr
);
6907 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6908 (unsigned long) section
->sh_offset
, section
->sh_link
,
6909 SECTION_NAME (link_section
));
6911 off
= offset_from_vma (file
,
6912 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6913 total
* sizeof (short));
6914 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
6916 _("version symbol data"));
6923 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
6925 for (cnt
= total
; cnt
--;)
6926 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6931 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6934 int check_def
, check_need
;
6937 printf (" %03x:", cnt
);
6939 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6940 switch (data
[cnt
+ j
])
6943 fputs (_(" 0 (*local*) "), stdout
);
6947 fputs (_(" 1 (*global*) "), stdout
);
6951 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
6952 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
6956 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6957 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6960 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6967 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6969 Elf_Internal_Verneed ivn
;
6970 unsigned long offset
;
6972 offset
= offset_from_vma
6973 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6974 sizeof (Elf_External_Verneed
));
6978 Elf_Internal_Vernaux ivna
;
6979 Elf_External_Verneed evn
;
6980 Elf_External_Vernaux evna
;
6981 unsigned long a_off
;
6983 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6986 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6987 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6989 a_off
= offset
+ ivn
.vn_aux
;
6993 get_data (&evna
, file
, a_off
, sizeof (evna
),
6994 1, _("version need aux (2)"));
6996 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6997 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6999 a_off
+= ivna
.vna_next
;
7001 while (ivna
.vna_other
!= data
[cnt
+ j
]
7002 && ivna
.vna_next
!= 0);
7004 if (ivna
.vna_other
== data
[cnt
+ j
])
7006 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7008 if (ivna
.vna_name
>= string_sec
->sh_size
)
7009 name
= _("*invalid*");
7011 name
= strtab
+ ivna
.vna_name
;
7012 nn
+= printf ("(%s%-*s",
7014 12 - (int) strlen (name
),
7020 offset
+= ivn
.vn_next
;
7022 while (ivn
.vn_next
);
7025 if (check_def
&& data
[cnt
+ j
] != 0x8001
7026 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7028 Elf_Internal_Verdef ivd
;
7029 Elf_External_Verdef evd
;
7030 unsigned long offset
;
7032 offset
= offset_from_vma
7033 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7038 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
7041 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7042 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7044 offset
+= ivd
.vd_next
;
7046 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
7047 && ivd
.vd_next
!= 0);
7049 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
7051 Elf_External_Verdaux evda
;
7052 Elf_Internal_Verdaux ivda
;
7054 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7056 get_data (&evda
, file
,
7057 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7059 _("version def aux"));
7061 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7063 if (ivda
.vda_name
>= string_sec
->sh_size
)
7064 name
= _("*invalid*");
7066 name
= strtab
+ ivda
.vda_name
;
7067 nn
+= printf ("(%s%-*s",
7069 12 - (int) strlen (name
),
7075 printf ("%*c", 18 - nn
, ' ');
7093 printf (_("\nNo version information found in this file.\n"));
7099 get_symbol_binding (unsigned int binding
)
7101 static char buff
[32];
7105 case STB_LOCAL
: return "LOCAL";
7106 case STB_GLOBAL
: return "GLOBAL";
7107 case STB_WEAK
: return "WEAK";
7109 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7110 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7112 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7114 if (binding
== STB_GNU_UNIQUE
7115 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7116 /* GNU/Linux is still using the default value 0. */
7117 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7119 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7122 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7128 get_symbol_type (unsigned int type
)
7130 static char buff
[32];
7134 case STT_NOTYPE
: return "NOTYPE";
7135 case STT_OBJECT
: return "OBJECT";
7136 case STT_FUNC
: return "FUNC";
7137 case STT_SECTION
: return "SECTION";
7138 case STT_FILE
: return "FILE";
7139 case STT_COMMON
: return "COMMON";
7140 case STT_TLS
: return "TLS";
7141 case STT_RELC
: return "RELC";
7142 case STT_SRELC
: return "SRELC";
7144 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7146 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7147 return "THUMB_FUNC";
7149 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7152 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7153 return "PARISC_MILLI";
7155 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7157 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7159 if (elf_header
.e_machine
== EM_PARISC
)
7161 if (type
== STT_HP_OPAQUE
)
7163 if (type
== STT_HP_STUB
)
7167 if (type
== STT_GNU_IFUNC
7168 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7169 /* GNU/Linux is still using the default value 0. */
7170 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7173 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7176 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7182 get_symbol_visibility (unsigned int visibility
)
7186 case STV_DEFAULT
: return "DEFAULT";
7187 case STV_INTERNAL
: return "INTERNAL";
7188 case STV_HIDDEN
: return "HIDDEN";
7189 case STV_PROTECTED
: return "PROTECTED";
7195 get_mips_symbol_other (unsigned int other
)
7199 case STO_OPTIONAL
: return "OPTIONAL";
7200 case STO_MIPS16
: return "MIPS16";
7201 case STO_MIPS_PLT
: return "MIPS PLT";
7202 case STO_MIPS_PIC
: return "MIPS PIC";
7203 default: return NULL
;
7208 get_symbol_other (unsigned int other
)
7210 const char * result
= NULL
;
7211 static char buff
[32];
7216 switch (elf_header
.e_machine
)
7219 result
= get_mips_symbol_other (other
);
7227 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7232 get_symbol_index_type (unsigned int type
)
7234 static char buff
[32];
7238 case SHN_UNDEF
: return "UND";
7239 case SHN_ABS
: return "ABS";
7240 case SHN_COMMON
: return "COM";
7242 if (type
== SHN_IA_64_ANSI_COMMON
7243 && elf_header
.e_machine
== EM_IA_64
7244 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7246 else if ((elf_header
.e_machine
== EM_X86_64
7247 || elf_header
.e_machine
== EM_L1OM
)
7248 && type
== SHN_X86_64_LCOMMON
)
7250 else if (type
== SHN_MIPS_SCOMMON
7251 && elf_header
.e_machine
== EM_MIPS
)
7253 else if (type
== SHN_MIPS_SUNDEFINED
7254 && elf_header
.e_machine
== EM_MIPS
)
7256 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7257 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7258 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7259 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7260 else if (type
>= SHN_LORESERVE
)
7261 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7263 sprintf (buff
, "%3d", type
);
7271 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7273 unsigned char * e_data
;
7276 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
7280 error (_("Out of memory\n"));
7284 if (fread (e_data
, ent_size
, number
, file
) != number
)
7286 error (_("Unable to read in dynamic data\n"));
7290 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
7294 error (_("Out of memory\n"));
7300 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7308 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7310 Elf_Internal_Sym
* psym
;
7313 psym
= dynamic_symbols
+ si
;
7315 n
= print_vma (si
, DEC_5
);
7317 fputs (" " + n
, stdout
);
7318 printf (" %3lu: ", hn
);
7319 print_vma (psym
->st_value
, LONG_HEX
);
7321 print_vma (psym
->st_size
, DEC_5
);
7323 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7324 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7325 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7326 /* Check to see if any other bits in the st_other field are set.
7327 Note - displaying this information disrupts the layout of the
7328 table being generated, but for the moment this case is very
7330 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7331 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7332 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7333 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7334 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7336 printf (" <corrupt: %14ld>", psym
->st_name
);
7340 /* Dump the symbol table. */
7342 process_symbol_table (FILE * file
)
7344 Elf_Internal_Shdr
* section
;
7345 bfd_vma nbuckets
= 0;
7346 bfd_vma nchains
= 0;
7347 bfd_vma
* buckets
= NULL
;
7348 bfd_vma
* chains
= NULL
;
7349 bfd_vma ngnubuckets
= 0;
7350 bfd_vma
* gnubuckets
= NULL
;
7351 bfd_vma
* gnuchains
= NULL
;
7352 bfd_vma gnusymidx
= 0;
7354 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
7357 if (dynamic_info
[DT_HASH
]
7359 || (do_using_dynamic
7361 && dynamic_strings
!= NULL
)))
7363 unsigned char nb
[8];
7364 unsigned char nc
[8];
7365 int hash_ent_size
= 4;
7367 if ((elf_header
.e_machine
== EM_ALPHA
7368 || elf_header
.e_machine
== EM_S390
7369 || elf_header
.e_machine
== EM_S390_OLD
)
7370 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7374 (archive_file_offset
7375 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7376 sizeof nb
+ sizeof nc
)),
7379 error (_("Unable to seek to start of dynamic information\n"));
7383 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7385 error (_("Failed to read in number of buckets\n"));
7389 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7391 error (_("Failed to read in number of chains\n"));
7395 nbuckets
= byte_get (nb
, hash_ent_size
);
7396 nchains
= byte_get (nc
, hash_ent_size
);
7398 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7399 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7402 if (buckets
== NULL
|| chains
== NULL
)
7404 if (do_using_dynamic
)
7415 if (dynamic_info_DT_GNU_HASH
7417 || (do_using_dynamic
7419 && dynamic_strings
!= NULL
)))
7421 unsigned char nb
[16];
7422 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7423 bfd_vma buckets_vma
;
7426 (archive_file_offset
7427 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7431 error (_("Unable to seek to start of dynamic information\n"));
7435 if (fread (nb
, 16, 1, file
) != 1)
7437 error (_("Failed to read in number of buckets\n"));
7441 ngnubuckets
= byte_get (nb
, 4);
7442 gnusymidx
= byte_get (nb
+ 4, 4);
7443 bitmaskwords
= byte_get (nb
+ 8, 4);
7444 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7446 buckets_vma
+= bitmaskwords
* 4;
7448 buckets_vma
+= bitmaskwords
* 8;
7451 (archive_file_offset
7452 + offset_from_vma (file
, buckets_vma
, 4)),
7455 error (_("Unable to seek to start of dynamic information\n"));
7459 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7461 if (gnubuckets
== NULL
)
7464 for (i
= 0; i
< ngnubuckets
; i
++)
7465 if (gnubuckets
[i
] != 0)
7467 if (gnubuckets
[i
] < gnusymidx
)
7470 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7471 maxchain
= gnubuckets
[i
];
7474 if (maxchain
== 0xffffffff)
7477 maxchain
-= gnusymidx
;
7480 (archive_file_offset
7481 + offset_from_vma (file
, buckets_vma
7482 + 4 * (ngnubuckets
+ maxchain
), 4)),
7485 error (_("Unable to seek to start of dynamic information\n"));
7491 if (fread (nb
, 4, 1, file
) != 1)
7493 error (_("Failed to determine last chain length\n"));
7497 if (maxchain
+ 1 == 0)
7502 while ((byte_get (nb
, 4) & 1) == 0);
7505 (archive_file_offset
7506 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7509 error (_("Unable to seek to start of dynamic information\n"));
7513 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7516 if (gnuchains
== NULL
)
7521 if (do_using_dynamic
)
7526 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7529 && dynamic_strings
!= NULL
)
7533 if (dynamic_info
[DT_HASH
])
7537 printf (_("\nSymbol table for image:\n"));
7539 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7541 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7543 for (hn
= 0; hn
< nbuckets
; hn
++)
7548 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7549 print_dynamic_symbol (si
, hn
);
7553 if (dynamic_info_DT_GNU_HASH
)
7555 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7557 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7559 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7561 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7562 if (gnubuckets
[hn
] != 0)
7564 bfd_vma si
= gnubuckets
[hn
];
7565 bfd_vma off
= si
- gnusymidx
;
7569 print_dynamic_symbol (si
, hn
);
7572 while ((gnuchains
[off
++] & 1) == 0);
7576 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
7580 for (i
= 0, section
= section_headers
;
7581 i
< elf_header
.e_shnum
;
7585 char * strtab
= NULL
;
7586 unsigned long int strtab_size
= 0;
7587 Elf_Internal_Sym
* symtab
;
7588 Elf_Internal_Sym
* psym
;
7590 if ((section
->sh_type
!= SHT_SYMTAB
7591 && section
->sh_type
!= SHT_DYNSYM
)
7593 && section
->sh_type
== SHT_SYMTAB
))
7596 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7597 SECTION_NAME (section
),
7598 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7600 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7602 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7604 symtab
= GET_ELF_SYMBOLS (file
, section
);
7608 if (section
->sh_link
== elf_header
.e_shstrndx
)
7610 strtab
= string_table
;
7611 strtab_size
= string_table_length
;
7613 else if (section
->sh_link
< elf_header
.e_shnum
)
7615 Elf_Internal_Shdr
* string_sec
;
7617 string_sec
= section_headers
+ section
->sh_link
;
7619 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
7620 1, string_sec
->sh_size
,
7622 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7625 for (si
= 0, psym
= symtab
;
7626 si
< section
->sh_size
/ section
->sh_entsize
;
7629 printf ("%6d: ", si
);
7630 print_vma (psym
->st_value
, LONG_HEX
);
7632 print_vma (psym
->st_size
, DEC_5
);
7633 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7634 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7635 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7636 /* Check to see if any other bits in the st_other field are set.
7637 Note - displaying this information disrupts the layout of the
7638 table being generated, but for the moment this case is very rare. */
7639 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7640 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7641 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7642 print_symbol (25, psym
->st_name
< strtab_size
7643 ? strtab
+ psym
->st_name
: "<corrupt>");
7645 if (section
->sh_type
== SHT_DYNSYM
&&
7646 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7648 unsigned char data
[2];
7649 unsigned short vers_data
;
7650 unsigned long offset
;
7654 offset
= offset_from_vma
7655 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7656 sizeof data
+ si
* sizeof (vers_data
));
7658 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7659 sizeof (data
), 1, _("version data"));
7661 vers_data
= byte_get (data
, 2);
7663 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7664 && section_headers
[psym
->st_shndx
].sh_type
7667 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7669 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
7671 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7672 && (is_nobits
|| ! check_def
))
7674 Elf_External_Verneed evn
;
7675 Elf_Internal_Verneed ivn
;
7676 Elf_Internal_Vernaux ivna
;
7678 /* We must test both. */
7679 offset
= offset_from_vma
7680 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7685 unsigned long vna_off
;
7687 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7690 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7691 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7693 vna_off
= offset
+ ivn
.vn_aux
;
7697 Elf_External_Vernaux evna
;
7699 get_data (&evna
, file
, vna_off
,
7701 _("version need aux (3)"));
7703 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7704 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7705 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7707 vna_off
+= ivna
.vna_next
;
7709 while (ivna
.vna_other
!= vers_data
7710 && ivna
.vna_next
!= 0);
7712 if (ivna
.vna_other
== vers_data
)
7715 offset
+= ivn
.vn_next
;
7717 while (ivn
.vn_next
!= 0);
7719 if (ivna
.vna_other
== vers_data
)
7722 ivna
.vna_name
< strtab_size
7723 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7727 else if (! is_nobits
)
7728 error (_("bad dynamic symbol\n"));
7735 if (vers_data
!= 0x8001
7736 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7738 Elf_Internal_Verdef ivd
;
7739 Elf_Internal_Verdaux ivda
;
7740 Elf_External_Verdaux evda
;
7743 off
= offset_from_vma
7745 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7746 sizeof (Elf_External_Verdef
));
7750 Elf_External_Verdef evd
;
7752 get_data (&evd
, file
, off
, sizeof (evd
),
7753 1, _("version def"));
7755 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7756 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7757 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7761 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
7762 && ivd
.vd_next
!= 0);
7767 get_data (&evda
, file
, off
, sizeof (evda
),
7768 1, _("version def aux"));
7770 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7772 if (psym
->st_name
!= ivda
.vda_name
)
7773 printf ((vers_data
& VERSYM_HIDDEN
)
7775 ivda
.vda_name
< strtab_size
7776 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7786 if (strtab
!= string_table
)
7792 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7794 if (do_histogram
&& buckets
!= NULL
)
7796 unsigned long * lengths
;
7797 unsigned long * counts
;
7800 unsigned long maxlength
= 0;
7801 unsigned long nzero_counts
= 0;
7802 unsigned long nsyms
= 0;
7804 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7805 (unsigned long) nbuckets
);
7806 printf (_(" Length Number %% of total Coverage\n"));
7808 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
7809 if (lengths
== NULL
)
7811 error (_("Out of memory\n"));
7814 for (hn
= 0; hn
< nbuckets
; ++hn
)
7816 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7819 if (maxlength
< ++lengths
[hn
])
7824 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7827 error (_("Out of memory\n"));
7831 for (hn
= 0; hn
< nbuckets
; ++hn
)
7832 ++counts
[lengths
[hn
]];
7837 printf (" 0 %-10lu (%5.1f%%)\n",
7838 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7839 for (i
= 1; i
<= maxlength
; ++i
)
7841 nzero_counts
+= counts
[i
] * i
;
7842 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7843 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7844 (nzero_counts
* 100.0) / nsyms
);
7852 if (buckets
!= NULL
)
7858 if (do_histogram
&& gnubuckets
!= NULL
)
7860 unsigned long * lengths
;
7861 unsigned long * counts
;
7863 unsigned long maxlength
= 0;
7864 unsigned long nzero_counts
= 0;
7865 unsigned long nsyms
= 0;
7867 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
7868 if (lengths
== NULL
)
7870 error (_("Out of memory\n"));
7874 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7875 (unsigned long) ngnubuckets
);
7876 printf (_(" Length Number %% of total Coverage\n"));
7878 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7879 if (gnubuckets
[hn
] != 0)
7881 bfd_vma off
, length
= 1;
7883 for (off
= gnubuckets
[hn
] - gnusymidx
;
7884 (gnuchains
[off
] & 1) == 0; ++off
)
7886 lengths
[hn
] = length
;
7887 if (length
> maxlength
)
7892 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7895 error (_("Out of memory\n"));
7899 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7900 ++counts
[lengths
[hn
]];
7902 if (ngnubuckets
> 0)
7905 printf (" 0 %-10lu (%5.1f%%)\n",
7906 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7907 for (j
= 1; j
<= maxlength
; ++j
)
7909 nzero_counts
+= counts
[j
] * j
;
7910 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7911 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7912 (nzero_counts
* 100.0) / nsyms
);
7926 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7930 if (dynamic_syminfo
== NULL
7932 /* No syminfo, this is ok. */
7935 /* There better should be a dynamic symbol section. */
7936 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7940 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7941 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7943 printf (_(" Num: Name BoundTo Flags\n"));
7944 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7946 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7948 printf ("%4d: ", i
);
7949 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7950 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7952 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7955 switch (dynamic_syminfo
[i
].si_boundto
)
7957 case SYMINFO_BT_SELF
:
7958 fputs ("SELF ", stdout
);
7960 case SYMINFO_BT_PARENT
:
7961 fputs ("PARENT ", stdout
);
7964 if (dynamic_syminfo
[i
].si_boundto
> 0
7965 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7966 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7968 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7972 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7976 if (flags
& SYMINFO_FLG_DIRECT
)
7978 if (flags
& SYMINFO_FLG_PASSTHRU
)
7979 printf (" PASSTHRU");
7980 if (flags
& SYMINFO_FLG_COPY
)
7982 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7983 printf (" LAZYLOAD");
7991 /* Check to see if the given reloc needs to be handled in a target specific
7992 manner. If so then process the reloc and return TRUE otherwise return
7996 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
7997 unsigned char * start
,
7998 Elf_Internal_Sym
* symtab
)
8000 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
8002 switch (elf_header
.e_machine
)
8005 case EM_CYGNUS_MN10300
:
8007 static Elf_Internal_Sym
* saved_sym
= NULL
;
8011 case 34: /* R_MN10300_ALIGN */
8013 case 33: /* R_MN10300_SYM_DIFF */
8014 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
8016 case 1: /* R_MN10300_32 */
8017 case 2: /* R_MN10300_16 */
8018 if (saved_sym
!= NULL
)
8022 value
= reloc
->r_addend
8023 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
8024 - saved_sym
->st_value
);
8026 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
8033 if (saved_sym
!= NULL
)
8034 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8044 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8045 DWARF debug sections. This is a target specific test. Note - we do not
8046 go through the whole including-target-headers-multiple-times route, (as
8047 we have already done with <elf/h8.h>) because this would become very
8048 messy and even then this function would have to contain target specific
8049 information (the names of the relocs instead of their numeric values).
8050 FIXME: This is not the correct way to solve this problem. The proper way
8051 is to have target specific reloc sizing and typing functions created by
8052 the reloc-macros.h header, in the same way that it already creates the
8053 reloc naming functions. */
8056 is_32bit_abs_reloc (unsigned int reloc_type
)
8058 switch (elf_header
.e_machine
)
8062 return reloc_type
== 1; /* R_386_32. */
8064 return reloc_type
== 1; /* R_68K_32. */
8066 return reloc_type
== 1; /* R_860_32. */
8068 return reloc_type
== 1; /* XXX Is this right ? */
8070 return reloc_type
== 1; /* R_ARC_32. */
8072 return reloc_type
== 2; /* R_ARM_ABS32 */
8075 return reloc_type
== 1;
8077 return reloc_type
== 0x12; /* R_byte4_data. */
8079 return reloc_type
== 3; /* R_CRIS_32. */
8082 return reloc_type
== 3; /* R_CR16_NUM32. */
8084 return reloc_type
== 15; /* R_CRX_NUM32. */
8086 return reloc_type
== 1;
8087 case EM_CYGNUS_D10V
:
8089 return reloc_type
== 6; /* R_D10V_32. */
8090 case EM_CYGNUS_D30V
:
8092 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8094 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8095 case EM_CYGNUS_FR30
:
8097 return reloc_type
== 3; /* R_FR30_32. */
8101 return reloc_type
== 1; /* R_H8_DIR32. */
8103 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8106 return reloc_type
== 2; /* R_IP2K_32. */
8108 return reloc_type
== 2; /* R_IQ2000_32. */
8109 case EM_LATTICEMICO32
:
8110 return reloc_type
== 3; /* R_LM32_32. */
8113 return reloc_type
== 3; /* R_M32C_32. */
8115 return reloc_type
== 34; /* R_M32R_32_RELA. */
8117 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8119 return reloc_type
== 4; /* R_MEP_32. */
8121 return reloc_type
== 2; /* R_MIPS_32. */
8123 return reloc_type
== 4; /* R_MMIX_32. */
8124 case EM_CYGNUS_MN10200
:
8126 return reloc_type
== 1; /* R_MN10200_32. */
8127 case EM_CYGNUS_MN10300
:
8129 return reloc_type
== 1; /* R_MN10300_32. */
8132 return reloc_type
== 1; /* R_MSP43_32. */
8134 return reloc_type
== 2; /* R_MT_32. */
8135 case EM_ALTERA_NIOS2
:
8137 return reloc_type
== 1; /* R_NIOS_32. */
8140 return reloc_type
== 1; /* R_OR32_32. */
8142 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8143 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8146 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8148 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8150 return reloc_type
== 1; /* R_PPC_ADDR32. */
8152 return reloc_type
== 1; /* R_RX_DIR32. */
8154 return reloc_type
== 1; /* R_I370_ADDR31. */
8157 return reloc_type
== 4; /* R_S390_32. */
8159 return reloc_type
== 8; /* R_SCORE_ABS32. */
8161 return reloc_type
== 1; /* R_SH_DIR32. */
8162 case EM_SPARC32PLUS
:
8165 return reloc_type
== 3 /* R_SPARC_32. */
8166 || reloc_type
== 23; /* R_SPARC_UA32. */
8168 return reloc_type
== 6; /* R_SPU_ADDR32 */
8169 case EM_CYGNUS_V850
:
8171 return reloc_type
== 6; /* R_V850_ABS32. */
8173 return reloc_type
== 1; /* R_VAX_32. */
8176 return reloc_type
== 10; /* R_X86_64_32. */
8179 return reloc_type
== 3; /* R_XC16C_ABS_32. */
8181 return reloc_type
== 1; /* R_XSTROMY16_32. */
8184 return reloc_type
== 1; /* R_XTENSA_32. */
8186 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8187 elf_header
.e_machine
);
8192 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8193 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8196 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8198 switch (elf_header
.e_machine
)
8202 return reloc_type
== 2; /* R_386_PC32. */
8204 return reloc_type
== 4; /* R_68K_PC32. */
8206 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8208 return reloc_type
== 3; /* R_ARM_REL32 */
8210 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8212 return reloc_type
== 26; /* R_PPC_REL32. */
8214 return reloc_type
== 26; /* R_PPC64_REL32. */
8217 return reloc_type
== 5; /* R_390_PC32. */
8219 return reloc_type
== 2; /* R_SH_REL32. */
8220 case EM_SPARC32PLUS
:
8223 return reloc_type
== 6; /* R_SPARC_DISP32. */
8225 return reloc_type
== 13; /* R_SPU_REL32. */
8228 return reloc_type
== 2; /* R_X86_64_PC32. */
8231 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8233 /* Do not abort or issue an error message here. Not all targets use
8234 pc-relative 32-bit relocs in their DWARF debug information and we
8235 have already tested for target coverage in is_32bit_abs_reloc. A
8236 more helpful warning message will be generated by apply_relocations
8237 anyway, so just return. */
8242 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8243 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8246 is_64bit_abs_reloc (unsigned int reloc_type
)
8248 switch (elf_header
.e_machine
)
8251 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8253 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8255 return reloc_type
== 80; /* R_PARISC_DIR64. */
8257 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8258 case EM_SPARC32PLUS
:
8261 return reloc_type
== 54; /* R_SPARC_UA64. */
8264 return reloc_type
== 1; /* R_X86_64_64. */
8267 return reloc_type
== 22; /* R_S390_64 */
8269 return reloc_type
== 18; /* R_MIPS_64 */
8275 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8276 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8279 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8281 switch (elf_header
.e_machine
)
8284 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8286 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8288 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8290 return reloc_type
== 44; /* R_PPC64_REL64 */
8291 case EM_SPARC32PLUS
:
8294 return reloc_type
== 46; /* R_SPARC_DISP64 */
8297 return reloc_type
== 24; /* R_X86_64_PC64 */
8300 return reloc_type
== 23; /* R_S390_PC64 */
8306 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8307 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8310 is_24bit_abs_reloc (unsigned int reloc_type
)
8312 switch (elf_header
.e_machine
)
8314 case EM_CYGNUS_MN10200
:
8316 return reloc_type
== 4; /* R_MN10200_24. */
8322 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8323 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8326 is_16bit_abs_reloc (unsigned int reloc_type
)
8328 switch (elf_header
.e_machine
)
8332 return reloc_type
== 4; /* R_AVR_16. */
8333 case EM_CYGNUS_D10V
:
8335 return reloc_type
== 3; /* R_D10V_16. */
8339 return reloc_type
== R_H8_DIR16
;
8342 return reloc_type
== 1; /* R_IP2K_16. */
8345 return reloc_type
== 1; /* R_M32C_16 */
8348 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8349 case EM_ALTERA_NIOS2
:
8351 return reloc_type
== 9; /* R_NIOS_16. */
8354 return reloc_type
== 2; /* R_XC16C_ABS_16. */
8360 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8361 relocation entries (possibly formerly used for SHT_GROUP sections). */
8364 is_none_reloc (unsigned int reloc_type
)
8366 switch (elf_header
.e_machine
)
8368 case EM_68K
: /* R_68K_NONE. */
8369 case EM_386
: /* R_386_NONE. */
8370 case EM_SPARC32PLUS
:
8372 case EM_SPARC
: /* R_SPARC_NONE. */
8373 case EM_MIPS
: /* R_MIPS_NONE. */
8374 case EM_PARISC
: /* R_PARISC_NONE. */
8375 case EM_ALPHA
: /* R_ALPHA_NONE. */
8376 case EM_PPC
: /* R_PPC_NONE. */
8377 case EM_PPC64
: /* R_PPC64_NONE. */
8378 case EM_ARM
: /* R_ARM_NONE. */
8379 case EM_IA_64
: /* R_IA64_NONE. */
8380 case EM_SH
: /* R_SH_NONE. */
8382 case EM_S390
: /* R_390_NONE. */
8383 case EM_CRIS
: /* R_CRIS_NONE. */
8384 case EM_X86_64
: /* R_X86_64_NONE. */
8385 case EM_L1OM
: /* R_X86_64_NONE. */
8386 case EM_MN10300
: /* R_MN10300_NONE. */
8387 case EM_M32R
: /* R_M32R_NONE. */
8389 case EM_C166
: /* R_XC16X_NONE. */
8390 return reloc_type
== 0;
8393 return (reloc_type
== 0 /* R_XTENSA_NONE. */
8394 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
8395 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
8396 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
8401 /* Apply relocations to a section.
8402 Note: So far support has been added only for those relocations
8403 which can be found in debug sections.
8404 FIXME: Add support for more relocations ? */
8407 apply_relocations (void * file
,
8408 Elf_Internal_Shdr
* section
,
8409 unsigned char * start
)
8411 Elf_Internal_Shdr
* relsec
;
8412 unsigned char * end
= start
+ section
->sh_size
;
8414 if (elf_header
.e_type
!= ET_REL
)
8417 /* Find the reloc section associated with the section. */
8418 for (relsec
= section_headers
;
8419 relsec
< section_headers
+ elf_header
.e_shnum
;
8422 bfd_boolean is_rela
;
8423 unsigned long num_relocs
;
8424 Elf_Internal_Rela
* relocs
;
8425 Elf_Internal_Rela
* rp
;
8426 Elf_Internal_Shdr
* symsec
;
8427 Elf_Internal_Sym
* symtab
;
8428 Elf_Internal_Sym
* sym
;
8430 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8431 || relsec
->sh_info
>= elf_header
.e_shnum
8432 || section_headers
+ relsec
->sh_info
!= section
8433 || relsec
->sh_size
== 0
8434 || relsec
->sh_link
>= elf_header
.e_shnum
)
8437 is_rela
= relsec
->sh_type
== SHT_RELA
;
8441 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
8442 relsec
->sh_size
, & relocs
, & num_relocs
))
8447 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
8448 relsec
->sh_size
, & relocs
, & num_relocs
))
8452 /* SH uses RELA but uses in place value instead of the addend field. */
8453 if (elf_header
.e_machine
== EM_SH
)
8456 symsec
= section_headers
+ relsec
->sh_link
;
8457 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
8459 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8462 unsigned int reloc_type
;
8463 unsigned int reloc_size
;
8464 unsigned char * rloc
;
8466 reloc_type
= get_reloc_type (rp
->r_info
);
8468 if (target_specific_reloc_handling (rp
, start
, symtab
))
8470 else if (is_none_reloc (reloc_type
))
8472 else if (is_32bit_abs_reloc (reloc_type
)
8473 || is_32bit_pcrel_reloc (reloc_type
))
8475 else if (is_64bit_abs_reloc (reloc_type
)
8476 || is_64bit_pcrel_reloc (reloc_type
))
8478 else if (is_24bit_abs_reloc (reloc_type
))
8480 else if (is_16bit_abs_reloc (reloc_type
))
8484 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8485 reloc_type
, SECTION_NAME (section
));
8489 rloc
= start
+ rp
->r_offset
;
8490 if ((rloc
+ reloc_size
) > end
)
8492 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8493 (unsigned long) rp
->r_offset
,
8494 SECTION_NAME (section
));
8498 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8500 /* If the reloc has a symbol associated with it,
8501 make sure that it is of an appropriate type.
8503 Relocations against symbols without type can happen.
8504 Gcc -feliminate-dwarf2-dups may generate symbols
8505 without type for debug info.
8507 Icc generates relocations against function symbols
8508 instead of local labels.
8510 Relocations against object symbols can happen, eg when
8511 referencing a global array. For an example of this see
8512 the _clz.o binary in libgcc.a. */
8514 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8516 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8517 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8518 (long int)(rp
- relocs
),
8519 SECTION_NAME (relsec
));
8525 addend
+= rp
->r_addend
;
8526 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8528 || (elf_header
.e_machine
== EM_XTENSA
8530 || ((elf_header
.e_machine
== EM_PJ
8531 || elf_header
.e_machine
== EM_PJ_OLD
)
8532 && reloc_type
== 1))
8533 addend
+= byte_get (rloc
, reloc_size
);
8535 if (is_32bit_pcrel_reloc (reloc_type
)
8536 || is_64bit_pcrel_reloc (reloc_type
))
8538 /* On HPPA, all pc-relative relocations are biased by 8. */
8539 if (elf_header
.e_machine
== EM_PARISC
)
8541 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8545 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
8554 #ifdef SUPPORT_DISASSEMBLY
8556 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8558 printf (_("\nAssembly dump of section %s\n"),
8559 SECTION_NAME (section
));
8561 /* XXX -- to be done --- XXX */
8567 /* Reads in the contents of SECTION from FILE, returning a pointer
8568 to a malloc'ed buffer or NULL if something went wrong. */
8571 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8573 bfd_size_type num_bytes
;
8575 num_bytes
= section
->sh_size
;
8577 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8579 printf (_("\nSection '%s' has no data to dump.\n"),
8580 SECTION_NAME (section
));
8584 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8585 _("section contents"));
8590 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8592 Elf_Internal_Shdr
* relsec
;
8593 bfd_size_type num_bytes
;
8598 char * name
= SECTION_NAME (section
);
8599 bfd_boolean some_strings_shown
;
8601 start
= get_section_contents (section
, file
);
8605 printf (_("\nString dump of section '%s':\n"), name
);
8607 /* If the section being dumped has relocations against it the user might
8608 be expecting these relocations to have been applied. Check for this
8609 case and issue a warning message in order to avoid confusion.
8610 FIXME: Maybe we ought to have an option that dumps a section with
8612 for (relsec
= section_headers
;
8613 relsec
< section_headers
+ elf_header
.e_shnum
;
8616 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8617 || relsec
->sh_info
>= elf_header
.e_shnum
8618 || section_headers
+ relsec
->sh_info
!= section
8619 || relsec
->sh_size
== 0
8620 || relsec
->sh_link
>= elf_header
.e_shnum
)
8623 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8627 num_bytes
= section
->sh_size
;
8628 addr
= section
->sh_addr
;
8630 end
= start
+ num_bytes
;
8631 some_strings_shown
= FALSE
;
8635 while (!ISPRINT (* data
))
8642 /* PR 11128: Use two separate invocations in order to work
8643 around bugs in the Solaris 8 implementation of printf. */
8644 printf (" [%6tx] ", data
- start
);
8645 printf ("%s\n", data
);
8647 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8649 data
+= strlen (data
);
8650 some_strings_shown
= TRUE
;
8654 if (! some_strings_shown
)
8655 printf (_(" No strings found in this section."));
8663 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8665 bfd_boolean relocate
)
8667 Elf_Internal_Shdr
* relsec
;
8668 bfd_size_type bytes
;
8670 unsigned char * data
;
8671 unsigned char * start
;
8673 start
= (unsigned char *) get_section_contents (section
, file
);
8677 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8681 apply_relocations (file
, section
, start
);
8685 /* If the section being dumped has relocations against it the user might
8686 be expecting these relocations to have been applied. Check for this
8687 case and issue a warning message in order to avoid confusion.
8688 FIXME: Maybe we ought to have an option that dumps a section with
8690 for (relsec
= section_headers
;
8691 relsec
< section_headers
+ elf_header
.e_shnum
;
8694 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8695 || relsec
->sh_info
>= elf_header
.e_shnum
8696 || section_headers
+ relsec
->sh_info
!= section
8697 || relsec
->sh_size
== 0
8698 || relsec
->sh_link
>= elf_header
.e_shnum
)
8701 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8706 addr
= section
->sh_addr
;
8707 bytes
= section
->sh_size
;
8716 lbytes
= (bytes
> 16 ? 16 : bytes
);
8718 printf (" 0x%8.8lx ", (unsigned long) addr
);
8720 for (j
= 0; j
< 16; j
++)
8723 printf ("%2.2x", data
[j
]);
8731 for (j
= 0; j
< lbytes
; j
++)
8734 if (k
>= ' ' && k
< 0x7f)
8752 /* Uncompresses a section that was compressed using zlib, in place.
8753 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8756 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8759 /* These are just to quiet gcc. */
8764 dwarf_size_type compressed_size
= *size
;
8765 unsigned char * compressed_buffer
= *buffer
;
8766 dwarf_size_type uncompressed_size
;
8767 unsigned char * uncompressed_buffer
;
8770 dwarf_size_type header_size
= 12;
8772 /* Read the zlib header. In this case, it should be "ZLIB" followed
8773 by the uncompressed section size, 8 bytes in big-endian order. */
8774 if (compressed_size
< header_size
8775 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8778 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8779 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8780 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8781 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8782 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8783 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8784 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8785 uncompressed_size
+= compressed_buffer
[11];
8787 /* It is possible the section consists of several compressed
8788 buffers concatenated together, so we uncompress in a loop. */
8792 strm
.avail_in
= compressed_size
- header_size
;
8793 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8794 strm
.avail_out
= uncompressed_size
;
8795 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
8797 rc
= inflateInit (& strm
);
8798 while (strm
.avail_in
> 0)
8802 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8803 + (uncompressed_size
- strm
.avail_out
));
8804 rc
= inflate (&strm
, Z_FINISH
);
8805 if (rc
!= Z_STREAM_END
)
8807 rc
= inflateReset (& strm
);
8809 rc
= inflateEnd (& strm
);
8811 || strm
.avail_out
!= 0)
8814 free (compressed_buffer
);
8815 *buffer
= uncompressed_buffer
;
8816 *size
= uncompressed_size
;
8820 free (uncompressed_buffer
);
8822 #endif /* HAVE_ZLIB_H */
8826 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8827 Elf_Internal_Shdr
* sec
, void * file
)
8829 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8831 int section_is_compressed
;
8833 /* If it is already loaded, do nothing. */
8834 if (section
->start
!= NULL
)
8837 section_is_compressed
= section
->name
== section
->compressed_name
;
8839 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8840 section
->address
= sec
->sh_addr
;
8841 section
->size
= sec
->sh_size
;
8842 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
8845 if (section
->start
== NULL
)
8848 if (section_is_compressed
)
8849 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8852 if (debug_displays
[debug
].relocate
)
8853 apply_relocations ((FILE *) file
, sec
, section
->start
);
8859 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8861 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8862 Elf_Internal_Shdr
* sec
;
8864 /* Locate the debug section. */
8865 sec
= find_section (section
->uncompressed_name
);
8867 section
->name
= section
->uncompressed_name
;
8870 sec
= find_section (section
->compressed_name
);
8872 section
->name
= section
->compressed_name
;
8877 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
8881 free_debug_section (enum dwarf_section_display_enum debug
)
8883 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8885 if (section
->start
== NULL
)
8888 free ((char *) section
->start
);
8889 section
->start
= NULL
;
8890 section
->address
= 0;
8895 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8897 char * name
= SECTION_NAME (section
);
8898 bfd_size_type length
;
8902 length
= section
->sh_size
;
8905 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8908 if (section
->sh_type
== SHT_NOBITS
)
8910 /* There is no point in dumping the contents of a debugging section
8911 which has the NOBITS type - the bits in the file will be random.
8912 This can happen when a file containing a .eh_frame section is
8913 stripped with the --only-keep-debug command line option. */
8914 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8918 if (const_strneq (name
, ".gnu.linkonce.wi."))
8919 name
= ".debug_info";
8921 /* See if we know how to display the contents of this section. */
8922 for (i
= 0; i
< max
; i
++)
8923 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8924 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8926 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8927 int secondary
= (section
!= find_section (name
));
8930 free_debug_section ((enum dwarf_section_display_enum
) i
);
8932 if (streq (sec
->uncompressed_name
, name
))
8933 sec
->name
= sec
->uncompressed_name
;
8935 sec
->name
= sec
->compressed_name
;
8936 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
8939 result
&= debug_displays
[i
].display (sec
, file
);
8941 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8942 free_debug_section ((enum dwarf_section_display_enum
) i
);
8950 printf (_("Unrecognized debug section: %s\n"), name
);
8957 /* Set DUMP_SECTS for all sections where dumps were requested
8958 based on section name. */
8961 initialise_dumps_byname (void)
8963 struct dump_list_entry
* cur
;
8965 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8970 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8971 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8973 request_dump_bynumber (i
, cur
->type
);
8978 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8984 process_section_contents (FILE * file
)
8986 Elf_Internal_Shdr
* section
;
8992 initialise_dumps_byname ();
8994 for (i
= 0, section
= section_headers
;
8995 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8998 #ifdef SUPPORT_DISASSEMBLY
8999 if (dump_sects
[i
] & DISASS_DUMP
)
9000 disassemble_section (section
, file
);
9002 if (dump_sects
[i
] & HEX_DUMP
)
9003 dump_section_as_bytes (section
, file
, FALSE
);
9005 if (dump_sects
[i
] & RELOC_DUMP
)
9006 dump_section_as_bytes (section
, file
, TRUE
);
9008 if (dump_sects
[i
] & STRING_DUMP
)
9009 dump_section_as_strings (section
, file
);
9011 if (dump_sects
[i
] & DEBUG_DUMP
)
9012 display_debug_section (section
, file
);
9015 /* Check to see if the user requested a
9016 dump of a section that does not exist. */
9017 while (i
++ < num_dump_sects
)
9019 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
9023 process_mips_fpe_exception (int mask
)
9028 if (mask
& OEX_FPU_INEX
)
9029 fputs ("INEX", stdout
), first
= 0;
9030 if (mask
& OEX_FPU_UFLO
)
9031 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9032 if (mask
& OEX_FPU_OFLO
)
9033 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9034 if (mask
& OEX_FPU_DIV0
)
9035 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9036 if (mask
& OEX_FPU_INVAL
)
9037 printf ("%sINVAL", first
? "" : "|");
9040 fputs ("0", stdout
);
9043 /* ARM EABI attributes section. */
9048 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9050 const char ** table
;
9051 } arm_attr_public_tag
;
9053 static const char * arm_attr_tag_CPU_arch
[] =
9054 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9055 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9056 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
9057 static const char * arm_attr_tag_THUMB_ISA_use
[] =
9058 {"No", "Thumb-1", "Thumb-2"};
9059 static const char * arm_attr_tag_VFP_arch
[] =
9060 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9061 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
9062 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
9063 static const char * arm_attr_tag_PCS_config
[] =
9064 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9065 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9066 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
9067 {"V6", "SB", "TLS", "Unused"};
9068 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
9069 {"Absolute", "PC-relative", "SB-relative", "None"};
9070 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
9071 {"Absolute", "PC-relative", "None"};
9072 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
9073 {"None", "direct", "GOT-indirect"};
9074 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
9075 {"None", "??? 1", "2", "??? 3", "4"};
9076 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
9077 static const char * arm_attr_tag_ABI_FP_denormal
[] =
9078 {"Unused", "Needed", "Sign only"};
9079 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
9080 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
9081 static const char * arm_attr_tag_ABI_FP_number_model
[] =
9082 {"Unused", "Finite", "RTABI", "IEEE 754"};
9083 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
9084 static const char * arm_attr_tag_ABI_align8_preserved
[] =
9085 {"No", "Yes, except leaf SP", "Yes"};
9086 static const char * arm_attr_tag_ABI_enum_size
[] =
9087 {"Unused", "small", "int", "forced to int"};
9088 static const char * arm_attr_tag_ABI_HardFP_use
[] =
9089 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9090 static const char * arm_attr_tag_ABI_VFP_args
[] =
9091 {"AAPCS", "VFP registers", "custom"};
9092 static const char * arm_attr_tag_ABI_WMMX_args
[] =
9093 {"AAPCS", "WMMX registers", "custom"};
9094 static const char * arm_attr_tag_ABI_optimization_goals
[] =
9095 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9096 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9097 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
9098 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9099 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9100 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
9101 static const char * arm_attr_tag_VFP_HP_extension
[] =
9102 {"Not Allowed", "Allowed"};
9103 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
9104 {"None", "IEEE 754", "Alternative Format"};
9105 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9106 static const char * arm_attr_tag_Virtualization_use
[] =
9107 {"Not Allowed", "Allowed"};
9108 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
9110 #define LOOKUP(id, name) \
9111 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9112 static arm_attr_public_tag arm_attr_public_tags
[] =
9114 {4, "CPU_raw_name", 1, NULL
},
9115 {5, "CPU_name", 1, NULL
},
9116 LOOKUP(6, CPU_arch
),
9117 {7, "CPU_arch_profile", 0, NULL
},
9118 LOOKUP(8, ARM_ISA_use
),
9119 LOOKUP(9, THUMB_ISA_use
),
9120 LOOKUP(10, VFP_arch
),
9121 LOOKUP(11, WMMX_arch
),
9122 LOOKUP(12, Advanced_SIMD_arch
),
9123 LOOKUP(13, PCS_config
),
9124 LOOKUP(14, ABI_PCS_R9_use
),
9125 LOOKUP(15, ABI_PCS_RW_data
),
9126 LOOKUP(16, ABI_PCS_RO_data
),
9127 LOOKUP(17, ABI_PCS_GOT_use
),
9128 LOOKUP(18, ABI_PCS_wchar_t
),
9129 LOOKUP(19, ABI_FP_rounding
),
9130 LOOKUP(20, ABI_FP_denormal
),
9131 LOOKUP(21, ABI_FP_exceptions
),
9132 LOOKUP(22, ABI_FP_user_exceptions
),
9133 LOOKUP(23, ABI_FP_number_model
),
9134 LOOKUP(24, ABI_align8_needed
),
9135 LOOKUP(25, ABI_align8_preserved
),
9136 LOOKUP(26, ABI_enum_size
),
9137 LOOKUP(27, ABI_HardFP_use
),
9138 LOOKUP(28, ABI_VFP_args
),
9139 LOOKUP(29, ABI_WMMX_args
),
9140 LOOKUP(30, ABI_optimization_goals
),
9141 LOOKUP(31, ABI_FP_optimization_goals
),
9142 {32, "compatibility", 0, NULL
},
9143 LOOKUP(34, CPU_unaligned_access
),
9144 LOOKUP(36, VFP_HP_extension
),
9145 LOOKUP(38, ABI_FP_16bit_format
),
9146 {64, "nodefaults", 0, NULL
},
9147 {65, "also_compatible_with", 0, NULL
},
9148 LOOKUP(66, T2EE_use
),
9149 {67, "conformance", 1, NULL
},
9150 LOOKUP(68, Virtualization_use
),
9151 LOOKUP(70, MPextension_use
)
9155 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9159 read_uleb128 (unsigned char * p
, unsigned int * plen
)
9173 val
|= ((unsigned int)c
& 0x7f) << shift
;
9182 static unsigned char *
9183 display_arm_attribute (unsigned char * p
)
9188 arm_attr_public_tag
* attr
;
9192 tag
= read_uleb128 (p
, &len
);
9195 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9197 if (arm_attr_public_tags
[i
].tag
== tag
)
9199 attr
= &arm_attr_public_tags
[i
];
9206 printf (" Tag_%s: ", attr
->name
);
9212 case 7: /* Tag_CPU_arch_profile. */
9213 val
= read_uleb128 (p
, &len
);
9217 case 0: printf ("None\n"); break;
9218 case 'A': printf ("Application\n"); break;
9219 case 'R': printf ("Realtime\n"); break;
9220 case 'M': printf ("Microcontroller\n"); break;
9221 default: printf ("??? (%d)\n", val
); break;
9225 case 32: /* Tag_compatibility. */
9226 val
= read_uleb128 (p
, &len
);
9228 printf ("flag = %d, vendor = %s\n", val
, p
);
9229 p
+= strlen ((char *) p
) + 1;
9232 case 64: /* Tag_nodefaults. */
9237 case 65: /* Tag_also_compatible_with. */
9238 val
= read_uleb128 (p
, &len
);
9240 if (val
== 6 /* Tag_CPU_arch. */)
9242 val
= read_uleb128 (p
, &len
);
9244 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
9245 printf ("??? (%d)\n", val
);
9247 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9251 while (*(p
++) != '\0' /* NUL terminator. */);
9265 assert (attr
->type
& 0x80);
9266 val
= read_uleb128 (p
, &len
);
9268 type
= attr
->type
& 0x7f;
9270 printf ("??? (%d)\n", val
);
9272 printf ("%s\n", attr
->table
[val
]);
9279 type
= 1; /* String. */
9281 type
= 2; /* uleb128. */
9282 printf (" Tag_unknown_%d: ", tag
);
9287 printf ("\"%s\"\n", p
);
9288 p
+= strlen ((char *) p
) + 1;
9292 val
= read_uleb128 (p
, &len
);
9294 printf ("%d (0x%x)\n", val
, val
);
9300 static unsigned char *
9301 display_gnu_attribute (unsigned char * p
,
9302 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9309 tag
= read_uleb128 (p
, &len
);
9312 /* Tag_compatibility is the only generic GNU attribute defined at
9316 val
= read_uleb128 (p
, &len
);
9318 printf ("flag = %d, vendor = %s\n", val
, p
);
9319 p
+= strlen ((char *) p
) + 1;
9323 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9324 return display_proc_gnu_attribute (p
, tag
);
9327 type
= 1; /* String. */
9329 type
= 2; /* uleb128. */
9330 printf (" Tag_unknown_%d: ", tag
);
9334 printf ("\"%s\"\n", p
);
9335 p
+= strlen ((char *) p
) + 1;
9339 val
= read_uleb128 (p
, &len
);
9341 printf ("%d (0x%x)\n", val
, val
);
9347 static unsigned char *
9348 display_power_gnu_attribute (unsigned char * p
, int tag
)
9354 if (tag
== Tag_GNU_Power_ABI_FP
)
9356 val
= read_uleb128 (p
, &len
);
9358 printf (" Tag_GNU_Power_ABI_FP: ");
9363 printf ("Hard or soft float\n");
9366 printf ("Hard float\n");
9369 printf ("Soft float\n");
9372 printf ("Single-precision hard float\n");
9375 printf ("??? (%d)\n", val
);
9381 if (tag
== Tag_GNU_Power_ABI_Vector
)
9383 val
= read_uleb128 (p
, &len
);
9385 printf (" Tag_GNU_Power_ABI_Vector: ");
9392 printf ("Generic\n");
9395 printf ("AltiVec\n");
9401 printf ("??? (%d)\n", val
);
9407 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9409 val
= read_uleb128 (p
, &len
);
9411 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9421 printf ("Memory\n");
9424 printf ("??? (%d)\n", val
);
9431 type
= 1; /* String. */
9433 type
= 2; /* uleb128. */
9434 printf (" Tag_unknown_%d: ", tag
);
9438 printf ("\"%s\"\n", p
);
9439 p
+= strlen ((char *) p
) + 1;
9443 val
= read_uleb128 (p
, &len
);
9445 printf ("%d (0x%x)\n", val
, val
);
9451 static unsigned char *
9452 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9458 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9460 val
= read_uleb128 (p
, &len
);
9462 printf (" Tag_GNU_MIPS_ABI_FP: ");
9467 printf ("Hard or soft float\n");
9470 printf ("Hard float (-mdouble-float)\n");
9473 printf ("Hard float (-msingle-float)\n");
9476 printf ("Soft float\n");
9479 printf ("64-bit float (-mips32r2 -mfp64)\n");
9482 printf ("??? (%d)\n", val
);
9489 type
= 1; /* String. */
9491 type
= 2; /* uleb128. */
9492 printf (" Tag_unknown_%d: ", tag
);
9496 printf ("\"%s\"\n", p
);
9497 p
+= strlen ((char *) p
) + 1;
9501 val
= read_uleb128 (p
, &len
);
9503 printf ("%d (0x%x)\n", val
, val
);
9510 process_attributes (FILE * file
,
9511 const char * public_name
,
9512 unsigned int proc_type
,
9513 unsigned char * (* display_pub_attribute
) (unsigned char *),
9514 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9516 Elf_Internal_Shdr
* sect
;
9517 unsigned char * contents
;
9519 unsigned char * end
;
9520 bfd_vma section_len
;
9524 /* Find the section header so that we get the size. */
9525 for (i
= 0, sect
= section_headers
;
9526 i
< elf_header
.e_shnum
;
9529 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9532 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
9533 sect
->sh_size
, _("attributes"));
9534 if (contents
== NULL
)
9540 len
= sect
->sh_size
- 1;
9546 bfd_boolean public_section
;
9547 bfd_boolean gnu_section
;
9549 section_len
= byte_get (p
, 4);
9552 if (section_len
> len
)
9554 printf (_("ERROR: Bad section length (%d > %d)\n"),
9555 (int) section_len
, (int) len
);
9560 printf ("Attribute Section: %s\n", p
);
9562 if (public_name
&& streq ((char *) p
, public_name
))
9563 public_section
= TRUE
;
9565 public_section
= FALSE
;
9567 if (streq ((char *) p
, "gnu"))
9570 gnu_section
= FALSE
;
9572 namelen
= strlen ((char *) p
) + 1;
9574 section_len
-= namelen
+ 4;
9576 while (section_len
> 0)
9582 size
= byte_get (p
, 4);
9583 if (size
> section_len
)
9585 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9586 (int) size
, (int) section_len
);
9590 section_len
-= size
;
9597 printf ("File Attributes\n");
9600 printf ("Section Attributes:");
9603 printf ("Symbol Attributes:");
9609 val
= read_uleb128 (p
, &j
);
9613 printf (" %d", val
);
9618 printf ("Unknown tag: %d\n", tag
);
9619 public_section
= FALSE
;
9626 p
= display_pub_attribute (p
);
9628 else if (gnu_section
)
9631 p
= display_gnu_attribute (p
,
9632 display_proc_gnu_attribute
);
9636 /* ??? Do something sensible, like dump hex. */
9637 printf (" Unknown section contexts\n");
9644 printf (_("Unknown format '%c'\n"), *p
);
9652 process_arm_specific (FILE * file
)
9654 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9655 display_arm_attribute
, NULL
);
9659 process_power_specific (FILE * file
)
9661 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9662 display_power_gnu_attribute
);
9665 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9666 Print the Address, Access and Initial fields of an entry at VMA ADDR
9667 and return the VMA of the next entry. */
9670 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9673 print_vma (addr
, LONG_HEX
);
9675 if (addr
< pltgot
+ 0xfff0)
9676 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9678 printf ("%10s", "");
9681 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9686 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9687 print_vma (entry
, LONG_HEX
);
9689 return addr
+ (is_32bit_elf
? 4 : 8);
9692 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9693 PLTGOT. Print the Address and Initial fields of an entry at VMA
9694 ADDR and return the VMA of the next entry. */
9697 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9700 print_vma (addr
, LONG_HEX
);
9703 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9708 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9709 print_vma (entry
, LONG_HEX
);
9711 return addr
+ (is_32bit_elf
? 4 : 8);
9715 process_mips_specific (FILE * file
)
9717 Elf_Internal_Dyn
* entry
;
9718 size_t liblist_offset
= 0;
9719 size_t liblistno
= 0;
9720 size_t conflictsno
= 0;
9721 size_t options_offset
= 0;
9722 size_t conflicts_offset
= 0;
9723 size_t pltrelsz
= 0;
9726 bfd_vma mips_pltgot
= 0;
9728 bfd_vma local_gotno
= 0;
9730 bfd_vma symtabno
= 0;
9732 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9733 display_mips_gnu_attribute
);
9735 /* We have a lot of special sections. Thanks SGI! */
9736 if (dynamic_section
== NULL
)
9737 /* No information available. */
9740 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9741 switch (entry
->d_tag
)
9743 case DT_MIPS_LIBLIST
:
9745 = offset_from_vma (file
, entry
->d_un
.d_val
,
9746 liblistno
* sizeof (Elf32_External_Lib
));
9748 case DT_MIPS_LIBLISTNO
:
9749 liblistno
= entry
->d_un
.d_val
;
9751 case DT_MIPS_OPTIONS
:
9752 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9754 case DT_MIPS_CONFLICT
:
9756 = offset_from_vma (file
, entry
->d_un
.d_val
,
9757 conflictsno
* sizeof (Elf32_External_Conflict
));
9759 case DT_MIPS_CONFLICTNO
:
9760 conflictsno
= entry
->d_un
.d_val
;
9763 pltgot
= entry
->d_un
.d_ptr
;
9765 case DT_MIPS_LOCAL_GOTNO
:
9766 local_gotno
= entry
->d_un
.d_val
;
9768 case DT_MIPS_GOTSYM
:
9769 gotsym
= entry
->d_un
.d_val
;
9771 case DT_MIPS_SYMTABNO
:
9772 symtabno
= entry
->d_un
.d_val
;
9774 case DT_MIPS_PLTGOT
:
9775 mips_pltgot
= entry
->d_un
.d_ptr
;
9778 pltrel
= entry
->d_un
.d_val
;
9781 pltrelsz
= entry
->d_un
.d_val
;
9784 jmprel
= entry
->d_un
.d_ptr
;
9790 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9792 Elf32_External_Lib
* elib
;
9795 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
9797 sizeof (Elf32_External_Lib
),
9801 printf ("\nSection '.liblist' contains %lu entries:\n",
9802 (unsigned long) liblistno
);
9803 fputs (" Library Time Stamp Checksum Version Flags\n",
9806 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9813 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9814 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9815 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9816 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9817 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9819 tmp
= gmtime (&atime
);
9820 snprintf (timebuf
, sizeof (timebuf
),
9821 "%04u-%02u-%02uT%02u:%02u:%02u",
9822 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9823 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9825 printf ("%3lu: ", (unsigned long) cnt
);
9826 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9827 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9829 printf ("<corrupt: %9ld>", liblist
.l_name
);
9830 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9833 if (liblist
.l_flags
== 0)
9844 { " EXACT_MATCH", LL_EXACT_MATCH
},
9845 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9846 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9847 { " EXPORTS", LL_EXPORTS
},
9848 { " DELAY_LOAD", LL_DELAY_LOAD
},
9849 { " DELTA", LL_DELTA
}
9851 int flags
= liblist
.l_flags
;
9854 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9855 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9857 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9858 flags
^= l_flags_vals
[fcnt
].bit
;
9861 printf (" %#x", (unsigned int) flags
);
9871 if (options_offset
!= 0)
9873 Elf_External_Options
* eopt
;
9874 Elf_Internal_Shdr
* sect
= section_headers
;
9875 Elf_Internal_Options
* iopt
;
9876 Elf_Internal_Options
* option
;
9880 /* Find the section header so that we get the size. */
9881 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9884 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
9885 sect
->sh_size
, _("options"));
9888 iopt
= (Elf_Internal_Options
*)
9889 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9892 error (_("Out of memory\n"));
9899 while (offset
< sect
->sh_size
)
9901 Elf_External_Options
* eoption
;
9903 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9905 option
->kind
= BYTE_GET (eoption
->kind
);
9906 option
->size
= BYTE_GET (eoption
->size
);
9907 option
->section
= BYTE_GET (eoption
->section
);
9908 option
->info
= BYTE_GET (eoption
->info
);
9910 offset
+= option
->size
;
9916 printf (_("\nSection '%s' contains %d entries:\n"),
9917 SECTION_NAME (sect
), cnt
);
9925 switch (option
->kind
)
9928 /* This shouldn't happen. */
9929 printf (" NULL %d %lx", option
->section
, option
->info
);
9932 printf (" REGINFO ");
9933 if (elf_header
.e_machine
== EM_MIPS
)
9936 Elf32_External_RegInfo
* ereg
;
9937 Elf32_RegInfo reginfo
;
9939 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9940 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9941 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9942 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9943 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9944 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9945 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9947 printf ("GPR %08lx GP 0x%lx\n",
9949 (unsigned long) reginfo
.ri_gp_value
);
9950 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9951 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9952 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9957 Elf64_External_RegInfo
* ereg
;
9958 Elf64_Internal_RegInfo reginfo
;
9960 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9961 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9962 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9963 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9964 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9965 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9966 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9968 printf ("GPR %08lx GP 0x",
9969 reginfo
.ri_gprmask
);
9970 printf_vma (reginfo
.ri_gp_value
);
9973 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9974 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9975 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9979 case ODK_EXCEPTIONS
:
9980 fputs (" EXCEPTIONS fpe_min(", stdout
);
9981 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9982 fputs (") fpe_max(", stdout
);
9983 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9984 fputs (")", stdout
);
9986 if (option
->info
& OEX_PAGE0
)
9987 fputs (" PAGE0", stdout
);
9988 if (option
->info
& OEX_SMM
)
9989 fputs (" SMM", stdout
);
9990 if (option
->info
& OEX_FPDBUG
)
9991 fputs (" FPDBUG", stdout
);
9992 if (option
->info
& OEX_DISMISS
)
9993 fputs (" DISMISS", stdout
);
9996 fputs (" PAD ", stdout
);
9997 if (option
->info
& OPAD_PREFIX
)
9998 fputs (" PREFIX", stdout
);
9999 if (option
->info
& OPAD_POSTFIX
)
10000 fputs (" POSTFIX", stdout
);
10001 if (option
->info
& OPAD_SYMBOL
)
10002 fputs (" SYMBOL", stdout
);
10005 fputs (" HWPATCH ", stdout
);
10006 if (option
->info
& OHW_R4KEOP
)
10007 fputs (" R4KEOP", stdout
);
10008 if (option
->info
& OHW_R8KPFETCH
)
10009 fputs (" R8KPFETCH", stdout
);
10010 if (option
->info
& OHW_R5KEOP
)
10011 fputs (" R5KEOP", stdout
);
10012 if (option
->info
& OHW_R5KCVTL
)
10013 fputs (" R5KCVTL", stdout
);
10016 fputs (" FILL ", stdout
);
10017 /* XXX Print content of info word? */
10020 fputs (" TAGS ", stdout
);
10021 /* XXX Print content of info word? */
10024 fputs (" HWAND ", stdout
);
10025 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10026 fputs (" R4KEOP_CHECKED", stdout
);
10027 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10028 fputs (" R4KEOP_CLEAN", stdout
);
10031 fputs (" HWOR ", stdout
);
10032 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10033 fputs (" R4KEOP_CHECKED", stdout
);
10034 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10035 fputs (" R4KEOP_CLEAN", stdout
);
10038 printf (" GP_GROUP %#06lx self-contained %#06lx",
10039 option
->info
& OGP_GROUP
,
10040 (option
->info
& OGP_SELF
) >> 16);
10043 printf (" IDENT %#06lx self-contained %#06lx",
10044 option
->info
& OGP_GROUP
,
10045 (option
->info
& OGP_SELF
) >> 16);
10048 /* This shouldn't happen. */
10049 printf (" %3d ??? %d %lx",
10050 option
->kind
, option
->section
, option
->info
);
10054 len
= sizeof (* eopt
);
10055 while (len
< option
->size
)
10056 if (((char *) option
)[len
] >= ' '
10057 && ((char *) option
)[len
] < 0x7f)
10058 printf ("%c", ((char *) option
)[len
++]);
10060 printf ("\\%03o", ((char *) option
)[len
++]);
10062 fputs ("\n", stdout
);
10070 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10072 Elf32_Conflict
* iconf
;
10075 if (dynamic_symbols
== NULL
)
10077 error (_("conflict list found without a dynamic symbol table\n"));
10081 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
10084 error (_("Out of memory\n"));
10090 Elf32_External_Conflict
* econf32
;
10092 econf32
= (Elf32_External_Conflict
*)
10093 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10094 sizeof (* econf32
), _("conflict"));
10098 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10099 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10105 Elf64_External_Conflict
* econf64
;
10107 econf64
= (Elf64_External_Conflict
*)
10108 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10109 sizeof (* econf64
), _("conflict"));
10113 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10114 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10119 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10120 (unsigned long) conflictsno
);
10121 puts (_(" Num: Index Value Name"));
10123 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10125 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10127 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10128 print_vma (psym
->st_value
, FULL_HEX
);
10130 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10131 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10133 printf ("<corrupt: %14ld>", psym
->st_name
);
10140 if (pltgot
!= 0 && local_gotno
!= 0)
10142 bfd_vma ent
, local_end
, global_end
;
10144 unsigned char * data
;
10148 addr_size
= (is_32bit_elf
? 4 : 8);
10149 local_end
= pltgot
+ local_gotno
* addr_size
;
10150 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10152 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10153 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10154 global_end
- pltgot
, 1, _("GOT"));
10155 printf (_("\nPrimary GOT:\n"));
10156 printf (_(" Canonical gp value: "));
10157 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10160 printf (_(" Reserved entries:\n"));
10161 printf (_(" %*s %10s %*s Purpose\n"),
10162 addr_size
* 2, "Address", "Access",
10163 addr_size
* 2, "Initial");
10164 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10165 printf (" Lazy resolver\n");
10167 && (byte_get (data
+ ent
- pltgot
, addr_size
)
10168 >> (addr_size
* 8 - 1)) != 0)
10170 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10171 printf (" Module pointer (GNU extension)\n");
10175 if (ent
< local_end
)
10177 printf (_(" Local entries:\n"));
10178 printf (_(" %*s %10s %*s\n"),
10179 addr_size
* 2, "Address", "Access",
10180 addr_size
* 2, "Initial");
10181 while (ent
< local_end
)
10183 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10189 if (gotsym
< symtabno
)
10193 printf (_(" Global entries:\n"));
10194 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10195 addr_size
* 2, "Address", "Access",
10196 addr_size
* 2, "Initial",
10197 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10198 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10199 for (i
= gotsym
; i
< symtabno
; i
++)
10201 Elf_Internal_Sym
* psym
;
10203 psym
= dynamic_symbols
+ i
;
10204 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10206 print_vma (psym
->st_value
, LONG_HEX
);
10207 printf (" %-7s %3s ",
10208 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10209 get_symbol_index_type (psym
->st_shndx
));
10210 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10211 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10213 printf ("<corrupt: %14ld>", psym
->st_name
);
10223 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10226 size_t offset
, rel_offset
;
10227 unsigned long count
, i
;
10228 unsigned char * data
;
10229 int addr_size
, sym_width
;
10230 Elf_Internal_Rela
* rels
;
10232 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10233 if (pltrel
== DT_RELA
)
10235 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10240 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10245 addr_size
= (is_32bit_elf
? 4 : 8);
10246 end
= mips_pltgot
+ (2 + count
) * addr_size
;
10248 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
10249 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
10251 printf (_("\nPLT GOT:\n\n"));
10252 printf (_(" Reserved entries:\n"));
10253 printf (_(" %*s %*s Purpose\n"),
10254 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10255 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10256 printf (" PLT lazy resolver\n");
10257 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10258 printf (" Module pointer\n");
10261 printf (_(" Entries:\n"));
10262 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10263 addr_size
* 2, "Address",
10264 addr_size
* 2, "Initial",
10265 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10266 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10267 for (i
= 0; i
< count
; i
++)
10269 Elf_Internal_Sym
* psym
;
10271 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10272 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10274 print_vma (psym
->st_value
, LONG_HEX
);
10275 printf (" %-7s %3s ",
10276 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10277 get_symbol_index_type (psym
->st_shndx
));
10278 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10279 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10281 printf ("<corrupt: %14ld>", psym
->st_name
);
10295 process_gnu_liblist (FILE * file
)
10297 Elf_Internal_Shdr
* section
;
10298 Elf_Internal_Shdr
* string_sec
;
10299 Elf32_External_Lib
* elib
;
10301 size_t strtab_size
;
10308 for (i
= 0, section
= section_headers
;
10309 i
< elf_header
.e_shnum
;
10312 switch (section
->sh_type
)
10314 case SHT_GNU_LIBLIST
:
10315 if (section
->sh_link
>= elf_header
.e_shnum
)
10318 elib
= (Elf32_External_Lib
*)
10319 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10324 string_sec
= section_headers
+ section
->sh_link
;
10326 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10327 string_sec
->sh_size
,
10328 _("liblist string table"));
10329 strtab_size
= string_sec
->sh_size
;
10332 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10338 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10339 SECTION_NAME (section
),
10340 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10342 puts (" Library Time Stamp Checksum Version Flags");
10344 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10352 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10353 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10354 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10355 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10356 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10358 tmp
= gmtime (&atime
);
10359 snprintf (timebuf
, sizeof (timebuf
),
10360 "%04u-%02u-%02uT%02u:%02u:%02u",
10361 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10362 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10364 printf ("%3lu: ", (unsigned long) cnt
);
10366 printf ("%-20s", liblist
.l_name
< strtab_size
10367 ? strtab
+ liblist
.l_name
: "<corrupt>");
10369 printf ("%-20.20s", liblist
.l_name
< strtab_size
10370 ? strtab
+ liblist
.l_name
: "<corrupt>");
10371 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10372 liblist
.l_version
, liblist
.l_flags
);
10382 static const char *
10383 get_note_type (unsigned e_type
)
10385 static char buff
[64];
10387 if (elf_header
.e_type
== ET_CORE
)
10391 return _("NT_AUXV (auxiliary vector)");
10393 return _("NT_PRSTATUS (prstatus structure)");
10395 return _("NT_FPREGSET (floating point registers)");
10397 return _("NT_PRPSINFO (prpsinfo structure)");
10398 case NT_TASKSTRUCT
:
10399 return _("NT_TASKSTRUCT (task structure)");
10401 return _("NT_PRXFPREG (user_xfpregs structure)");
10403 return _("NT_PPC_VMX (ppc Altivec registers)");
10405 return _("NT_PPC_VSX (ppc VSX registers)");
10406 case NT_S390_HIGH_GPRS
:
10407 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
10409 return _("NT_PSTATUS (pstatus structure)");
10411 return _("NT_FPREGS (floating point registers)");
10413 return _("NT_PSINFO (psinfo structure)");
10415 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10417 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10418 case NT_WIN32PSTATUS
:
10419 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10427 return _("NT_VERSION (version)");
10429 return _("NT_ARCH (architecture)");
10434 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10438 static const char *
10439 get_gnu_elf_note_type (unsigned e_type
)
10441 static char buff
[64];
10445 case NT_GNU_ABI_TAG
:
10446 return _("NT_GNU_ABI_TAG (ABI version tag)");
10448 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10449 case NT_GNU_BUILD_ID
:
10450 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10451 case NT_GNU_GOLD_VERSION
:
10452 return _("NT_GNU_GOLD_VERSION (gold version)");
10457 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10461 static const char *
10462 get_netbsd_elfcore_note_type (unsigned e_type
)
10464 static char buff
[64];
10466 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10468 /* NetBSD core "procinfo" structure. */
10469 return _("NetBSD procinfo structure");
10472 /* As of Jan 2002 there are no other machine-independent notes
10473 defined for NetBSD core files. If the note type is less
10474 than the start of the machine-dependent note types, we don't
10477 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10479 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10483 switch (elf_header
.e_machine
)
10485 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10486 and PT_GETFPREGS == mach+2. */
10491 case EM_SPARC32PLUS
:
10495 case NT_NETBSDCORE_FIRSTMACH
+0:
10496 return _("PT_GETREGS (reg structure)");
10497 case NT_NETBSDCORE_FIRSTMACH
+2:
10498 return _("PT_GETFPREGS (fpreg structure)");
10504 /* On all other arch's, PT_GETREGS == mach+1 and
10505 PT_GETFPREGS == mach+3. */
10509 case NT_NETBSDCORE_FIRSTMACH
+1:
10510 return _("PT_GETREGS (reg structure)");
10511 case NT_NETBSDCORE_FIRSTMACH
+3:
10512 return _("PT_GETFPREGS (fpreg structure)");
10518 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10519 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10523 /* Note that by the ELF standard, the name field is already null byte
10524 terminated, and namesz includes the terminating null byte.
10525 I.E. the value of namesz for the name "FSF" is 4.
10527 If the value of namesz is zero, there is no name present. */
10529 process_note (Elf_Internal_Note
* pnote
)
10531 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10534 if (pnote
->namesz
== 0)
10535 /* If there is no note name, then use the default set of
10536 note type strings. */
10537 nt
= get_note_type (pnote
->type
);
10539 else if (const_strneq (pnote
->namedata
, "GNU"))
10540 /* GNU-specific object file notes. */
10541 nt
= get_gnu_elf_note_type (pnote
->type
);
10543 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10544 /* NetBSD-specific core file notes. */
10545 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10547 else if (strneq (pnote
->namedata
, "SPU/", 4))
10549 /* SPU-specific core file notes. */
10550 nt
= pnote
->namedata
+ 4;
10555 /* Don't recognize this note name; just use the default set of
10556 note type strings. */
10557 nt
= get_note_type (pnote
->type
);
10559 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10565 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10567 Elf_External_Note
* pnotes
;
10568 Elf_External_Note
* external
;
10574 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
10581 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10582 (unsigned long) offset
, (unsigned long) length
);
10583 printf (_(" Owner\t\tData size\tDescription\n"));
10585 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10587 Elf_External_Note
* next
;
10588 Elf_Internal_Note inote
;
10589 char * temp
= NULL
;
10591 inote
.type
= BYTE_GET (external
->type
);
10592 inote
.namesz
= BYTE_GET (external
->namesz
);
10593 inote
.namedata
= external
->name
;
10594 inote
.descsz
= BYTE_GET (external
->descsz
);
10595 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10596 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10598 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10600 if (((char *) next
) > (((char *) pnotes
) + length
))
10602 warn (_("corrupt note found at offset %lx into core notes\n"),
10603 (unsigned long) ((char *) external
- (char *) pnotes
));
10604 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10605 inote
.type
, inote
.namesz
, inote
.descsz
);
10611 /* Verify that name is null terminated. It appears that at least
10612 one version of Linux (RedHat 6.0) generates corefiles that don't
10613 comply with the ELF spec by failing to include the null byte in
10615 if (inote
.namedata
[inote
.namesz
] != '\0')
10617 temp
= (char *) malloc (inote
.namesz
+ 1);
10621 error (_("Out of memory\n"));
10626 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10627 temp
[inote
.namesz
] = 0;
10629 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10630 inote
.namedata
= temp
;
10633 res
&= process_note (& inote
);
10648 process_corefile_note_segments (FILE * file
)
10650 Elf_Internal_Phdr
* segment
;
10654 if (! get_program_headers (file
))
10657 for (i
= 0, segment
= program_headers
;
10658 i
< elf_header
.e_phnum
;
10661 if (segment
->p_type
== PT_NOTE
)
10662 res
&= process_corefile_note_segment (file
,
10663 (bfd_vma
) segment
->p_offset
,
10664 (bfd_vma
) segment
->p_filesz
);
10671 process_note_sections (FILE * file
)
10673 Elf_Internal_Shdr
* section
;
10677 for (i
= 0, section
= section_headers
;
10678 i
< elf_header
.e_shnum
;
10680 if (section
->sh_type
== SHT_NOTE
)
10681 res
&= process_corefile_note_segment (file
,
10682 (bfd_vma
) section
->sh_offset
,
10683 (bfd_vma
) section
->sh_size
);
10689 process_notes (FILE * file
)
10691 /* If we have not been asked to display the notes then do nothing. */
10695 if (elf_header
.e_type
!= ET_CORE
)
10696 return process_note_sections (file
);
10698 /* No program headers means no NOTE segment. */
10699 if (elf_header
.e_phnum
> 0)
10700 return process_corefile_note_segments (file
);
10702 printf (_("No note segments present in the core file.\n"));
10707 process_arch_specific (FILE * file
)
10712 switch (elf_header
.e_machine
)
10715 return process_arm_specific (file
);
10717 case EM_MIPS_RS3_LE
:
10718 return process_mips_specific (file
);
10721 return process_power_specific (file
);
10730 get_file_header (FILE * file
)
10732 /* Read in the identity array. */
10733 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10736 /* Determine how to read the rest of the header. */
10737 switch (elf_header
.e_ident
[EI_DATA
])
10739 default: /* fall through */
10740 case ELFDATANONE
: /* fall through */
10742 byte_get
= byte_get_little_endian
;
10743 byte_put
= byte_put_little_endian
;
10746 byte_get
= byte_get_big_endian
;
10747 byte_put
= byte_put_big_endian
;
10751 /* For now we only support 32 bit and 64 bit ELF files. */
10752 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10754 /* Read in the rest of the header. */
10757 Elf32_External_Ehdr ehdr32
;
10759 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10762 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10763 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10764 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10765 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10766 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10767 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10768 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10769 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10770 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10771 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10772 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10773 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10774 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10778 Elf64_External_Ehdr ehdr64
;
10780 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10781 we will not be able to cope with the 64bit data found in
10782 64 ELF files. Detect this now and abort before we start
10783 overwriting things. */
10784 if (sizeof (bfd_vma
) < 8)
10786 error (_("This instance of readelf has been built without support for a\n\
10787 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10791 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10794 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10795 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10796 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10797 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10798 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10799 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10800 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10801 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10802 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10803 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10804 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10805 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10806 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10809 if (elf_header
.e_shoff
)
10811 /* There may be some extensions in the first section header. Don't
10812 bomb if we can't read it. */
10814 get_32bit_section_headers (file
, 1);
10816 get_64bit_section_headers (file
, 1);
10822 /* Process one ELF object file according to the command line options.
10823 This file may actually be stored in an archive. The file is
10824 positioned at the start of the ELF object. */
10827 process_object (char * file_name
, FILE * file
)
10831 if (! get_file_header (file
))
10833 error (_("%s: Failed to read file header\n"), file_name
);
10837 /* Initialise per file variables. */
10838 for (i
= ARRAY_SIZE (version_info
); i
--;)
10839 version_info
[i
] = 0;
10841 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10842 dynamic_info
[i
] = 0;
10844 /* Process the file. */
10846 printf (_("\nFile: %s\n"), file_name
);
10848 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10849 Note we do this even if cmdline_dump_sects is empty because we
10850 must make sure that the dump_sets array is zeroed out before each
10851 object file is processed. */
10852 if (num_dump_sects
> num_cmdline_dump_sects
)
10853 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10855 if (num_cmdline_dump_sects
> 0)
10857 if (num_dump_sects
== 0)
10858 /* A sneaky way of allocating the dump_sects array. */
10859 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10861 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10862 memcpy (dump_sects
, cmdline_dump_sects
,
10863 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10866 if (! process_file_header ())
10869 if (! process_section_headers (file
))
10871 /* Without loaded section headers we cannot process lots of
10873 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10875 if (! do_using_dynamic
)
10876 do_syms
= do_dyn_syms
= do_reloc
= 0;
10879 if (! process_section_groups (file
))
10881 /* Without loaded section groups we cannot process unwind. */
10885 if (process_program_headers (file
))
10886 process_dynamic_section (file
);
10888 process_relocs (file
);
10890 process_unwind (file
);
10892 process_symbol_table (file
);
10894 process_syminfo (file
);
10896 process_version_sections (file
);
10898 process_section_contents (file
);
10900 process_notes (file
);
10902 process_gnu_liblist (file
);
10904 process_arch_specific (file
);
10906 if (program_headers
)
10908 free (program_headers
);
10909 program_headers
= NULL
;
10912 if (section_headers
)
10914 free (section_headers
);
10915 section_headers
= NULL
;
10920 free (string_table
);
10921 string_table
= NULL
;
10922 string_table_length
= 0;
10925 if (dynamic_strings
)
10927 free (dynamic_strings
);
10928 dynamic_strings
= NULL
;
10929 dynamic_strings_length
= 0;
10932 if (dynamic_symbols
)
10934 free (dynamic_symbols
);
10935 dynamic_symbols
= NULL
;
10936 num_dynamic_syms
= 0;
10939 if (dynamic_syminfo
)
10941 free (dynamic_syminfo
);
10942 dynamic_syminfo
= NULL
;
10945 if (section_headers_groups
)
10947 free (section_headers_groups
);
10948 section_headers_groups
= NULL
;
10951 if (section_groups
)
10953 struct group_list
* g
;
10954 struct group_list
* next
;
10956 for (i
= 0; i
< group_count
; i
++)
10958 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10965 free (section_groups
);
10966 section_groups
= NULL
;
10969 free_debug_memory ();
10974 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10975 to the path name of the thin archive itself if necessary. Always returns
10976 a pointer to malloc'ed memory. */
10979 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10981 char * member_file_name
;
10982 const char * base_name
= lbasename (file_name
);
10984 /* This is a proxy entry for a thin archive member.
10985 If the extended name table contains an absolute path
10986 name, or if the archive is in the current directory,
10987 use the path name as given. Otherwise, we need to
10988 find the member relative to the directory where the
10989 archive is located. */
10990 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10992 member_file_name
= (char *) malloc (name_len
+ 1);
10993 if (member_file_name
== NULL
)
10995 error (_("Out of memory\n"));
10998 memcpy (member_file_name
, name
, name_len
);
10999 member_file_name
[name_len
] = '\0';
11003 /* Concatenate the path components of the archive file name
11004 to the relative path name from the extended name table. */
11005 size_t prefix_len
= base_name
- file_name
;
11006 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
11007 if (member_file_name
== NULL
)
11009 error (_("Out of memory\n"));
11012 memcpy (member_file_name
, file_name
, prefix_len
);
11013 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
11014 member_file_name
[prefix_len
+ name_len
] = '\0';
11016 return member_file_name
;
11019 /* Structure to hold information about an archive file. */
11021 struct archive_info
11023 char * file_name
; /* Archive file name. */
11024 FILE * file
; /* Open file descriptor. */
11025 unsigned long index_num
; /* Number of symbols in table. */
11026 unsigned long * index_array
; /* The array of member offsets. */
11027 char * sym_table
; /* The symbol table. */
11028 unsigned long sym_size
; /* Size of the symbol table. */
11029 char * longnames
; /* The long file names table. */
11030 unsigned long longnames_size
; /* Size of the long file names table. */
11031 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
11032 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
11033 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
11034 struct ar_hdr arhdr
; /* Current archive header. */
11037 /* Read the symbol table and long-name table from an archive. */
11040 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
11041 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
11044 unsigned long size
;
11046 arch
->file_name
= strdup (file_name
);
11048 arch
->index_num
= 0;
11049 arch
->index_array
= NULL
;
11050 arch
->sym_table
= NULL
;
11051 arch
->sym_size
= 0;
11052 arch
->longnames
= NULL
;
11053 arch
->longnames_size
= 0;
11054 arch
->nested_member_origin
= 0;
11055 arch
->is_thin_archive
= is_thin_archive
;
11056 arch
->next_arhdr_offset
= SARMAG
;
11058 /* Read the first archive member header. */
11059 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
11061 error (_("%s: failed to seek to first archive header\n"), file_name
);
11064 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11065 if (got
!= sizeof arch
->arhdr
)
11070 error (_("%s: failed to read archive header\n"), file_name
);
11074 /* See if this is the archive symbol table. */
11075 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
11076 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
11078 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11079 size
= size
+ (size
& 1);
11081 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
11086 /* A buffer used to hold numbers read in from an archive index.
11087 These are always 4 bytes long and stored in big-endian format. */
11088 #define SIZEOF_AR_INDEX_NUMBERS 4
11089 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
11090 unsigned char * index_buffer
;
11092 /* Check the size of the archive index. */
11093 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
11095 error (_("%s: the archive index is empty\n"), file_name
);
11099 /* Read the numer of entries in the archive index. */
11100 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
11101 if (got
!= sizeof (integer_buffer
))
11103 error (_("%s: failed to read archive index\n"), file_name
);
11106 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
11107 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11109 /* Read in the archive index. */
11110 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11112 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11113 file_name
, arch
->index_num
);
11116 index_buffer
= (unsigned char *)
11117 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11118 if (index_buffer
== NULL
)
11120 error (_("Out of memory whilst trying to read archive symbol index\n"));
11123 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11124 if (got
!= arch
->index_num
)
11126 free (index_buffer
);
11127 error (_("%s: failed to read archive index\n"), file_name
);
11130 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11132 /* Convert the index numbers into the host's numeric format. */
11133 arch
->index_array
= (long unsigned int *)
11134 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11135 if (arch
->index_array
== NULL
)
11137 free (index_buffer
);
11138 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11142 for (i
= 0; i
< arch
->index_num
; i
++)
11143 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11144 SIZEOF_AR_INDEX_NUMBERS
);
11145 free (index_buffer
);
11147 /* The remaining space in the header is taken up by the symbol table. */
11150 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11153 arch
->sym_table
= (char *) malloc (size
);
11154 arch
->sym_size
= size
;
11155 if (arch
->sym_table
== NULL
)
11157 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11160 got
= fread (arch
->sym_table
, 1, size
, file
);
11163 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11169 if (fseek (file
, size
, SEEK_CUR
) != 0)
11171 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11176 /* Read the next archive header. */
11177 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11178 if (got
!= sizeof arch
->arhdr
)
11182 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11186 else if (read_symbols
)
11187 printf (_("%s has no archive index\n"), file_name
);
11189 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11191 /* This is the archive string table holding long member names. */
11192 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11193 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11195 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11196 if (arch
->longnames
== NULL
)
11198 error (_("Out of memory reading long symbol names in archive\n"));
11202 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
11204 free (arch
->longnames
);
11205 arch
->longnames
= NULL
;
11206 error (_("%s: failed to read long symbol name string table\n"), file_name
);
11210 if ((arch
->longnames_size
& 1) != 0)
11217 /* Release the memory used for the archive information. */
11220 release_archive (struct archive_info
* arch
)
11222 if (arch
->file_name
!= NULL
)
11223 free (arch
->file_name
);
11224 if (arch
->index_array
!= NULL
)
11225 free (arch
->index_array
);
11226 if (arch
->sym_table
!= NULL
)
11227 free (arch
->sym_table
);
11228 if (arch
->longnames
!= NULL
)
11229 free (arch
->longnames
);
11232 /* Open and setup a nested archive, if not already open. */
11235 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
11237 FILE * member_file
;
11239 /* Have we already setup this archive? */
11240 if (nested_arch
->file_name
!= NULL
11241 && streq (nested_arch
->file_name
, member_file_name
))
11244 /* Close previous file and discard cached information. */
11245 if (nested_arch
->file
!= NULL
)
11246 fclose (nested_arch
->file
);
11247 release_archive (nested_arch
);
11249 member_file
= fopen (member_file_name
, "rb");
11250 if (member_file
== NULL
)
11252 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
11256 get_archive_member_name_at (struct archive_info
* arch
,
11257 unsigned long offset
,
11258 struct archive_info
* nested_arch
);
11260 /* Get the name of an archive member from the current archive header.
11261 For simple names, this will modify the ar_name field of the current
11262 archive header. For long names, it will return a pointer to the
11263 longnames table. For nested archives, it will open the nested archive
11264 and get the name recursively. NESTED_ARCH is a single-entry cache so
11265 we don't keep rereading the same information from a nested archive. */
11268 get_archive_member_name (struct archive_info
* arch
,
11269 struct archive_info
* nested_arch
)
11271 unsigned long j
, k
;
11273 if (arch
->arhdr
.ar_name
[0] == '/')
11275 /* We have a long name. */
11277 char * member_file_name
;
11278 char * member_name
;
11280 arch
->nested_member_origin
= 0;
11281 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11282 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11283 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11285 while ((j
< arch
->longnames_size
)
11286 && (arch
->longnames
[j
] != '\n')
11287 && (arch
->longnames
[j
] != '\0'))
11289 if (arch
->longnames
[j
-1] == '/')
11291 arch
->longnames
[j
] = '\0';
11293 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11294 return arch
->longnames
+ k
;
11296 /* This is a proxy for a member of a nested archive.
11297 Find the name of the member in that archive. */
11298 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11299 if (member_file_name
!= NULL
11300 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11301 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11303 free (member_file_name
);
11304 return member_name
;
11306 free (member_file_name
);
11308 /* Last resort: just return the name of the nested archive. */
11309 return arch
->longnames
+ k
;
11312 /* We have a normal (short) name. */
11314 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11316 arch
->arhdr
.ar_name
[j
] = '\0';
11317 return arch
->arhdr
.ar_name
;
11320 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11323 get_archive_member_name_at (struct archive_info
* arch
,
11324 unsigned long offset
,
11325 struct archive_info
* nested_arch
)
11329 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11331 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11334 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11335 if (got
!= sizeof arch
->arhdr
)
11337 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11340 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11342 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11346 return get_archive_member_name (arch
, nested_arch
);
11349 /* Construct a string showing the name of the archive member, qualified
11350 with the name of the containing archive file. For thin archives, we
11351 use square brackets to denote the indirection. For nested archives,
11352 we show the qualified name of the external member inside the square
11353 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11356 make_qualified_name (struct archive_info
* arch
,
11357 struct archive_info
* nested_arch
,
11358 char * member_name
)
11363 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11364 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11365 len
+= strlen (nested_arch
->file_name
) + 2;
11367 name
= (char *) malloc (len
);
11370 error (_("Out of memory\n"));
11374 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11375 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11376 else if (arch
->is_thin_archive
)
11377 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11379 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11384 /* Process an ELF archive.
11385 On entry the file is positioned just after the ARMAG string. */
11388 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11390 struct archive_info arch
;
11391 struct archive_info nested_arch
;
11393 size_t file_name_size
;
11398 /* The ARCH structure is used to hold information about this archive. */
11399 arch
.file_name
= NULL
;
11401 arch
.index_array
= NULL
;
11402 arch
.sym_table
= NULL
;
11403 arch
.longnames
= NULL
;
11405 /* The NESTED_ARCH structure is used as a single-item cache of information
11406 about a nested archive (when members of a thin archive reside within
11407 another regular archive file). */
11408 nested_arch
.file_name
= NULL
;
11409 nested_arch
.file
= NULL
;
11410 nested_arch
.index_array
= NULL
;
11411 nested_arch
.sym_table
= NULL
;
11412 nested_arch
.longnames
= NULL
;
11414 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11420 if (do_archive_index
)
11422 if (arch
.sym_table
== NULL
)
11423 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11427 unsigned long current_pos
;
11429 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11430 file_name
, arch
.index_num
, arch
.sym_size
);
11431 current_pos
= ftell (file
);
11433 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11435 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11437 char * member_name
;
11439 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11441 if (member_name
!= NULL
)
11443 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11445 if (qualified_name
!= NULL
)
11447 printf (_("Binary %s contains:\n"), qualified_name
);
11448 free (qualified_name
);
11453 if (l
>= arch
.sym_size
)
11455 error (_("%s: end of the symbol table reached before the end of the index\n"),
11459 printf ("\t%s\n", arch
.sym_table
+ l
);
11460 l
+= strlen (arch
.sym_table
+ l
) + 1;
11465 if (l
< arch
.sym_size
)
11466 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11469 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11471 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11477 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11478 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11479 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11480 && !do_section_groups
&& !do_dyn_syms
)
11482 ret
= 0; /* Archive index only. */
11487 file_name_size
= strlen (file_name
);
11494 char * qualified_name
;
11496 /* Read the next archive header. */
11497 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11499 error (_("%s: failed to seek to next archive header\n"), file_name
);
11502 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11503 if (got
!= sizeof arch
.arhdr
)
11507 error (_("%s: failed to read archive header\n"), file_name
);
11511 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11513 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11518 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11520 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11521 if (archive_file_size
& 01)
11522 ++archive_file_size
;
11524 name
= get_archive_member_name (&arch
, &nested_arch
);
11527 error (_("%s: bad archive file name\n"), file_name
);
11531 namelen
= strlen (name
);
11533 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11534 if (qualified_name
== NULL
)
11536 error (_("%s: bad archive file name\n"), file_name
);
11541 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11543 /* This is a proxy for an external member of a thin archive. */
11544 FILE * member_file
;
11545 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11546 if (member_file_name
== NULL
)
11552 member_file
= fopen (member_file_name
, "rb");
11553 if (member_file
== NULL
)
11555 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11556 free (member_file_name
);
11561 archive_file_offset
= arch
.nested_member_origin
;
11563 ret
|= process_object (qualified_name
, member_file
);
11565 fclose (member_file
);
11566 free (member_file_name
);
11568 else if (is_thin_archive
)
11570 /* This is a proxy for a member of a nested archive. */
11571 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11573 /* The nested archive file will have been opened and setup by
11574 get_archive_member_name. */
11575 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11577 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11582 ret
|= process_object (qualified_name
, nested_arch
.file
);
11586 archive_file_offset
= arch
.next_arhdr_offset
;
11587 arch
.next_arhdr_offset
+= archive_file_size
;
11589 ret
|= process_object (qualified_name
, file
);
11592 free (qualified_name
);
11596 if (nested_arch
.file
!= NULL
)
11597 fclose (nested_arch
.file
);
11598 release_archive (&nested_arch
);
11599 release_archive (&arch
);
11605 process_file (char * file_name
)
11608 struct stat statbuf
;
11609 char armag
[SARMAG
];
11612 if (stat (file_name
, &statbuf
) < 0)
11614 if (errno
== ENOENT
)
11615 error (_("'%s': No such file\n"), file_name
);
11617 error (_("Could not locate '%s'. System error message: %s\n"),
11618 file_name
, strerror (errno
));
11622 if (! S_ISREG (statbuf
.st_mode
))
11624 error (_("'%s' is not an ordinary file\n"), file_name
);
11628 file
= fopen (file_name
, "rb");
11631 error (_("Input file '%s' is not readable.\n"), file_name
);
11635 if (fread (armag
, SARMAG
, 1, file
) != 1)
11637 error (_("%s: Failed to read file's magic number\n"), file_name
);
11642 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11643 ret
= process_archive (file_name
, file
, FALSE
);
11644 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11645 ret
= process_archive (file_name
, file
, TRUE
);
11648 if (do_archive_index
)
11649 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11653 archive_file_size
= archive_file_offset
= 0;
11654 ret
= process_object (file_name
, file
);
11662 #ifdef SUPPORT_DISASSEMBLY
11663 /* Needed by the i386 disassembler. For extra credit, someone could
11664 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11668 print_address (unsigned int addr
, FILE * outfile
)
11670 fprintf (outfile
,"0x%8.8x", addr
);
11673 /* Needed by the i386 disassembler. */
11675 db_task_printsym (unsigned int addr
)
11677 print_address (addr
, stderr
);
11682 main (int argc
, char ** argv
)
11686 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11687 setlocale (LC_MESSAGES
, "");
11689 #if defined (HAVE_SETLOCALE)
11690 setlocale (LC_CTYPE
, "");
11692 bindtextdomain (PACKAGE
, LOCALEDIR
);
11693 textdomain (PACKAGE
);
11695 expandargv (&argc
, &argv
);
11697 parse_args (argc
, argv
);
11699 if (num_dump_sects
> 0)
11701 /* Make a copy of the dump_sects array. */
11702 cmdline_dump_sects
= (dump_type
*)
11703 malloc (num_dump_sects
* sizeof (* dump_sects
));
11704 if (cmdline_dump_sects
== NULL
)
11705 error (_("Out of memory allocating dump request table.\n"));
11708 memcpy (cmdline_dump_sects
, dump_sects
,
11709 num_dump_sects
* sizeof (* dump_sects
));
11710 num_cmdline_dump_sects
= num_dump_sects
;
11714 if (optind
< (argc
- 1))
11718 while (optind
< argc
)
11719 err
|= process_file (argv
[optind
++]);
11721 if (dump_sects
!= NULL
)
11723 if (cmdline_dump_sects
!= NULL
)
11724 free (cmdline_dump_sects
);