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
;
182 static int do_sections
;
183 static int do_section_groups
;
184 static int do_section_details
;
185 static int do_segments
;
186 static int do_unwind
;
187 static int do_using_dynamic
;
188 static int do_header
;
190 static int do_version
;
191 static int do_histogram
;
192 static int do_debugging
;
195 static int do_archive_index
;
196 static int is_32bit_elf
;
200 struct group_list
* next
;
201 unsigned int section_index
;
206 struct group_list
* root
;
207 unsigned int group_index
;
210 static size_t group_count
;
211 static struct group
* section_groups
;
212 static struct group
** section_headers_groups
;
215 /* Flag bits indicating particular types of dump. */
216 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
217 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
218 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
219 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
220 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
222 typedef unsigned char dump_type
;
224 /* A linked list of the section names for which dumps were requested. */
225 struct dump_list_entry
229 struct dump_list_entry
* next
;
231 static struct dump_list_entry
* dump_sects_byname
;
233 /* A dynamic array of flags indicating for which sections a dump
234 has been requested via command line switches. */
235 static dump_type
* cmdline_dump_sects
= NULL
;
236 static unsigned int num_cmdline_dump_sects
= 0;
238 /* A dynamic array of flags indicating for which sections a dump of
239 some kind has been requested. It is reset on a per-object file
240 basis and then initialised from the cmdline_dump_sects array,
241 the results of interpreting the -w switch, and the
242 dump_sects_byname list. */
243 static dump_type
* dump_sects
= NULL
;
244 static unsigned int num_dump_sects
= 0;
247 /* How to print a vma value. */
248 typedef enum print_mode
260 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
264 #define SECTION_NAME(X) \
265 ((X) == NULL ? "<none>" \
266 : string_table == NULL ? "<no-name>" \
267 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
268 : string_table + (X)->sh_name))
270 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
272 #define BYTE_GET(field) byte_get (field, sizeof (field))
274 #define GET_ELF_SYMBOLS(file, section) \
275 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
276 : get_64bit_elf_symbols (file, section))
278 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
279 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
280 already been called and verified that the string exists. */
281 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
283 /* This is just a bit of syntatic sugar. */
284 #define streq(a,b) (strcmp ((a), (b)) == 0)
285 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
286 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
289 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
294 if (size
== 0 || nmemb
== 0)
297 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
299 error (_("Unable to seek to 0x%lx for %s\n"),
300 (unsigned long) archive_file_offset
+ offset
, reason
);
307 /* Check for overflow. */
308 if (nmemb
< (~(size_t) 0 - 1) / size
)
309 /* + 1 so that we can '\0' terminate invalid string table sections. */
310 mvar
= malloc (size
* nmemb
+ 1);
314 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
315 (unsigned long)(size
* nmemb
), reason
);
319 ((char *) mvar
)[size
* nmemb
] = '\0';
322 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
324 error (_("Unable to read in 0x%lx bytes of %s\n"),
325 (unsigned long)(size
* nmemb
), reason
);
335 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
340 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
341 field
[6] = ((value
>> 24) >> 24) & 0xff;
342 field
[5] = ((value
>> 24) >> 16) & 0xff;
343 field
[4] = ((value
>> 24) >> 8) & 0xff;
346 field
[3] = (value
>> 24) & 0xff;
349 field
[2] = (value
>> 16) & 0xff;
352 field
[1] = (value
>> 8) & 0xff;
355 field
[0] = value
& 0xff;
359 error (_("Unhandled data length: %d\n"), size
);
364 /* Print a VMA value. */
367 print_vma (bfd_vma vma
, print_mode mode
)
380 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
387 return printf ("%5" BFD_VMA_FMT
"d", vma
);
395 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
398 return printf ("%" BFD_VMA_FMT
"d", vma
);
401 return printf ("%" BFD_VMA_FMT
"u", vma
);
406 /* Display a symbol on stdout. Handles the display of non-printing characters.
408 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
409 truncating as necessary. If WIDTH is negative then format the string to be
410 exactly - WIDTH characters, truncating or padding as necessary.
412 Returns the number of emitted characters. */
415 print_symbol (int width
, const char * symbol
)
418 bfd_boolean extra_padding
= FALSE
;
419 unsigned int num_printed
= 0;
423 /* Set the width to a very large value. This simplifies the code below. */
428 /* Keep the width positive. This also helps. */
430 extra_padding
= TRUE
;
439 /* Look for non-printing symbols inside the symbol's name.
440 This test is triggered in particular by the names generated
441 by the assembler for local labels. */
442 while (ISPRINT (* c
))
452 printf ("%.*s", len
, symbol
);
458 if (* c
== 0 || width
== 0)
461 /* Now display the non-printing character, if
462 there is room left in which to dipslay it. */
468 printf ("^%c", *c
+ 0x40);
478 printf ("<0x%.2x>", *c
);
487 if (extra_padding
&& width
> 0)
489 /* Fill in the remaining spaces. */
490 printf ("%-*s", width
, " ");
498 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
503 field
[7] = value
& 0xff;
504 field
[6] = (value
>> 8) & 0xff;
505 field
[5] = (value
>> 16) & 0xff;
506 field
[4] = (value
>> 24) & 0xff;
511 field
[3] = value
& 0xff;
515 field
[2] = value
& 0xff;
519 field
[1] = value
& 0xff;
523 field
[0] = value
& 0xff;
527 error (_("Unhandled data length: %d\n"), size
);
532 /* Return a pointer to section NAME, or NULL if no such section exists. */
534 static Elf_Internal_Shdr
*
535 find_section (const char * name
)
539 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
540 if (streq (SECTION_NAME (section_headers
+ i
), name
))
541 return section_headers
+ i
;
546 /* Guess the relocation size commonly used by the specific machines. */
549 guess_is_rela (unsigned int e_machine
)
553 /* Targets that use REL relocations. */
569 /* Targets that use RELA relocations. */
573 case EM_ALTERA_NIOS2
:
593 case EM_LATTICEMICO32
:
601 case EM_CYGNUS_MN10200
:
603 case EM_CYGNUS_MN10300
:
627 case EM_MICROBLAZE_OLD
:
648 warn (_("Don't know about relocations on this machine architecture\n"));
654 slurp_rela_relocs (FILE * file
,
655 unsigned long rel_offset
,
656 unsigned long rel_size
,
657 Elf_Internal_Rela
** relasp
,
658 unsigned long * nrelasp
)
660 Elf_Internal_Rela
* relas
;
661 unsigned long nrelas
;
666 Elf32_External_Rela
* erelas
;
668 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
669 rel_size
, _("relocs"));
673 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
675 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
676 sizeof (Elf_Internal_Rela
));
681 error (_("out of memory parsing relocs\n"));
685 for (i
= 0; i
< nrelas
; i
++)
687 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
688 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
689 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
696 Elf64_External_Rela
* erelas
;
698 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
699 rel_size
, _("relocs"));
703 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
705 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
706 sizeof (Elf_Internal_Rela
));
711 error (_("out of memory parsing relocs\n"));
715 for (i
= 0; i
< nrelas
; i
++)
717 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
718 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
719 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
721 /* The #ifdef BFD64 below is to prevent a compile time
722 warning. We know that if we do not have a 64 bit data
723 type that we will never execute this code anyway. */
725 if (elf_header
.e_machine
== EM_MIPS
726 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
728 /* In little-endian objects, r_info isn't really a
729 64-bit little-endian value: it has a 32-bit
730 little-endian symbol index followed by four
731 individual byte fields. Reorder INFO
733 bfd_vma inf
= relas
[i
].r_info
;
734 inf
= (((inf
& 0xffffffff) << 32)
735 | ((inf
>> 56) & 0xff)
736 | ((inf
>> 40) & 0xff00)
737 | ((inf
>> 24) & 0xff0000)
738 | ((inf
>> 8) & 0xff000000));
739 relas
[i
].r_info
= inf
;
752 slurp_rel_relocs (FILE * file
,
753 unsigned long rel_offset
,
754 unsigned long rel_size
,
755 Elf_Internal_Rela
** relsp
,
756 unsigned long * nrelsp
)
758 Elf_Internal_Rela
* rels
;
764 Elf32_External_Rel
* erels
;
766 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
767 rel_size
, _("relocs"));
771 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
773 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
778 error (_("out of memory parsing relocs\n"));
782 for (i
= 0; i
< nrels
; i
++)
784 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
785 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
786 rels
[i
].r_addend
= 0;
793 Elf64_External_Rel
* erels
;
795 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
796 rel_size
, _("relocs"));
800 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
802 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
807 error (_("out of memory parsing relocs\n"));
811 for (i
= 0; i
< nrels
; i
++)
813 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
814 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
815 rels
[i
].r_addend
= 0;
817 /* The #ifdef BFD64 below is to prevent a compile time
818 warning. We know that if we do not have a 64 bit data
819 type that we will never execute this code anyway. */
821 if (elf_header
.e_machine
== EM_MIPS
822 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
824 /* In little-endian objects, r_info isn't really a
825 64-bit little-endian value: it has a 32-bit
826 little-endian symbol index followed by four
827 individual byte fields. Reorder INFO
829 bfd_vma inf
= rels
[i
].r_info
;
830 inf
= (((inf
& 0xffffffff) << 32)
831 | ((inf
>> 56) & 0xff)
832 | ((inf
>> 40) & 0xff00)
833 | ((inf
>> 24) & 0xff0000)
834 | ((inf
>> 8) & 0xff000000));
835 rels
[i
].r_info
= inf
;
847 /* Returns the reloc type extracted from the reloc info field. */
850 get_reloc_type (bfd_vma reloc_info
)
853 return ELF32_R_TYPE (reloc_info
);
855 switch (elf_header
.e_machine
)
858 /* Note: We assume that reloc_info has already been adjusted for us. */
859 return ELF64_MIPS_R_TYPE (reloc_info
);
862 return ELF64_R_TYPE_ID (reloc_info
);
865 return ELF64_R_TYPE (reloc_info
);
869 /* Return the symbol index extracted from the reloc info field. */
872 get_reloc_symindex (bfd_vma reloc_info
)
874 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
877 /* Display the contents of the relocation data found at the specified
881 dump_relocations (FILE * file
,
882 unsigned long rel_offset
,
883 unsigned long rel_size
,
884 Elf_Internal_Sym
* symtab
,
887 unsigned long strtablen
,
891 Elf_Internal_Rela
* rels
;
893 if (is_rela
== UNKNOWN
)
894 is_rela
= guess_is_rela (elf_header
.e_machine
);
898 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
903 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
912 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
914 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
919 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
921 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
929 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
931 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
936 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
938 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
942 for (i
= 0; i
< rel_size
; i
++)
947 bfd_vma symtab_index
;
950 offset
= rels
[i
].r_offset
;
951 inf
= rels
[i
].r_info
;
953 type
= get_reloc_type (inf
);
954 symtab_index
= get_reloc_symindex (inf
);
958 printf ("%8.8lx %8.8lx ",
959 (unsigned long) offset
& 0xffffffff,
960 (unsigned long) inf
& 0xffffffff);
964 #if BFD_HOST_64BIT_LONG
966 ? "%16.16lx %16.16lx "
967 : "%12.12lx %12.12lx ",
969 #elif BFD_HOST_64BIT_LONG_LONG
972 ? "%16.16llx %16.16llx "
973 : "%12.12llx %12.12llx ",
977 ? "%16.16I64x %16.16I64x "
978 : "%12.12I64x %12.12I64x ",
983 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
984 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
985 _bfd_int64_high (offset
),
986 _bfd_int64_low (offset
),
987 _bfd_int64_high (inf
),
988 _bfd_int64_low (inf
));
992 switch (elf_header
.e_machine
)
1000 rtype
= elf_m32r_reloc_type (type
);
1005 rtype
= elf_i386_reloc_type (type
);
1010 rtype
= elf_m68hc11_reloc_type (type
);
1014 rtype
= elf_m68k_reloc_type (type
);
1018 rtype
= elf_i960_reloc_type (type
);
1023 rtype
= elf_avr_reloc_type (type
);
1026 case EM_OLD_SPARCV9
:
1027 case EM_SPARC32PLUS
:
1030 rtype
= elf_sparc_reloc_type (type
);
1034 rtype
= elf_spu_reloc_type (type
);
1038 case EM_CYGNUS_V850
:
1039 rtype
= v850_reloc_type (type
);
1043 case EM_CYGNUS_D10V
:
1044 rtype
= elf_d10v_reloc_type (type
);
1048 case EM_CYGNUS_D30V
:
1049 rtype
= elf_d30v_reloc_type (type
);
1053 rtype
= elf_dlx_reloc_type (type
);
1057 rtype
= elf_sh_reloc_type (type
);
1061 case EM_CYGNUS_MN10300
:
1062 rtype
= elf_mn10300_reloc_type (type
);
1066 case EM_CYGNUS_MN10200
:
1067 rtype
= elf_mn10200_reloc_type (type
);
1071 case EM_CYGNUS_FR30
:
1072 rtype
= elf_fr30_reloc_type (type
);
1076 rtype
= elf_frv_reloc_type (type
);
1080 rtype
= elf_mcore_reloc_type (type
);
1084 rtype
= elf_mmix_reloc_type (type
);
1089 rtype
= elf_msp430_reloc_type (type
);
1093 rtype
= elf_ppc_reloc_type (type
);
1097 rtype
= elf_ppc64_reloc_type (type
);
1101 case EM_MIPS_RS3_LE
:
1102 rtype
= elf_mips_reloc_type (type
);
1106 rtype
= elf_alpha_reloc_type (type
);
1110 rtype
= elf_arm_reloc_type (type
);
1114 rtype
= elf_arc_reloc_type (type
);
1118 rtype
= elf_hppa_reloc_type (type
);
1124 rtype
= elf_h8_reloc_type (type
);
1129 rtype
= elf_or32_reloc_type (type
);
1134 rtype
= elf_pj_reloc_type (type
);
1137 rtype
= elf_ia64_reloc_type (type
);
1141 rtype
= elf_cris_reloc_type (type
);
1145 rtype
= elf_i860_reloc_type (type
);
1150 rtype
= elf_x86_64_reloc_type (type
);
1154 rtype
= i370_reloc_type (type
);
1159 rtype
= elf_s390_reloc_type (type
);
1163 rtype
= elf_score_reloc_type (type
);
1167 rtype
= elf_xstormy16_reloc_type (type
);
1171 rtype
= elf_crx_reloc_type (type
);
1175 rtype
= elf_vax_reloc_type (type
);
1180 rtype
= elf_ip2k_reloc_type (type
);
1184 rtype
= elf_iq2000_reloc_type (type
);
1189 rtype
= elf_xtensa_reloc_type (type
);
1192 case EM_LATTICEMICO32
:
1193 rtype
= elf_lm32_reloc_type (type
);
1198 rtype
= elf_m32c_reloc_type (type
);
1202 rtype
= elf_mt_reloc_type (type
);
1206 rtype
= elf_bfin_reloc_type (type
);
1210 rtype
= elf_mep_reloc_type (type
);
1215 rtype
= elf_cr16_reloc_type (type
);
1219 case EM_MICROBLAZE_OLD
:
1220 rtype
= elf_microblaze_reloc_type (type
);
1224 rtype
= elf_rx_reloc_type (type
);
1229 rtype
= elf_xc16x_reloc_type (type
);
1234 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1236 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1238 if (elf_header
.e_machine
== EM_ALPHA
1240 && streq (rtype
, "R_ALPHA_LITUSE")
1243 switch (rels
[i
].r_addend
)
1245 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1246 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1247 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1248 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1249 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1250 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1251 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1252 default: rtype
= NULL
;
1255 printf (" (%s)", rtype
);
1259 printf (_("<unknown addend: %lx>"),
1260 (unsigned long) rels
[i
].r_addend
);
1263 else if (symtab_index
)
1265 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1266 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1269 Elf_Internal_Sym
* psym
;
1271 psym
= symtab
+ symtab_index
;
1275 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1279 unsigned int width
= is_32bit_elf
? 8 : 14;
1281 /* Relocations against GNU_IFUNC symbols do not use the value
1282 of the symbol as the address to relocate against. Instead
1283 they invoke the function named by the symbol and use its
1284 result as the address for relocation.
1286 To indicate this to the user, do not display the value of
1287 the symbol in the "Symbols's Value" field. Instead show
1288 its name followed by () as a hint that the symbol is
1292 || psym
->st_name
== 0
1293 || psym
->st_name
>= strtablen
)
1296 name
= strtab
+ psym
->st_name
;
1298 len
= print_symbol (width
, name
);
1299 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1303 print_vma (psym
->st_value
, LONG_HEX
);
1305 printf (is_32bit_elf
? " " : " ");
1308 if (psym
->st_name
== 0)
1310 const char * sec_name
= "<null>";
1313 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1315 if (psym
->st_shndx
< elf_header
.e_shnum
)
1317 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1318 else if (psym
->st_shndx
== SHN_ABS
)
1320 else if (psym
->st_shndx
== SHN_COMMON
)
1321 sec_name
= "COMMON";
1322 else if (elf_header
.e_machine
== EM_MIPS
1323 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1324 sec_name
= "SCOMMON";
1325 else if (elf_header
.e_machine
== EM_MIPS
1326 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1327 sec_name
= "SUNDEF";
1328 else if ((elf_header
.e_machine
== EM_X86_64
1329 || elf_header
.e_machine
== EM_L1OM
)
1330 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1331 sec_name
= "LARGE_COMMON";
1332 else if (elf_header
.e_machine
== EM_IA_64
1333 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1334 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1335 sec_name
= "ANSI_COM";
1336 else if (elf_header
.e_machine
== EM_IA_64
1337 && (elf_header
.e_ident
[EI_OSABI
]
1338 == ELFOSABI_OPENVMS
)
1339 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1340 sec_name
= "VMS_SYMVEC";
1343 sprintf (name_buf
, "<section 0x%x>",
1344 (unsigned int) psym
->st_shndx
);
1345 sec_name
= name_buf
;
1348 print_symbol (22, sec_name
);
1350 else if (strtab
== NULL
)
1351 printf (_("<string table index: %3ld>"), psym
->st_name
);
1352 else if (psym
->st_name
>= strtablen
)
1353 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1355 print_symbol (22, strtab
+ psym
->st_name
);
1359 long off
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1362 printf (" - %lx", - off
);
1364 printf (" + %lx", off
);
1370 printf ("%*c", is_32bit_elf
?
1371 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1372 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1375 if (elf_header
.e_machine
== EM_SPARCV9
1377 && streq (rtype
, "R_SPARC_OLO10"))
1378 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1383 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1385 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1386 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1387 const char * rtype2
= elf_mips_reloc_type (type2
);
1388 const char * rtype3
= elf_mips_reloc_type (type3
);
1390 printf (" Type2: ");
1393 printf (_("unrecognized: %-7lx"),
1394 (unsigned long) type2
& 0xffffffff);
1396 printf ("%-17.17s", rtype2
);
1398 printf ("\n Type3: ");
1401 printf (_("unrecognized: %-7lx"),
1402 (unsigned long) type3
& 0xffffffff);
1404 printf ("%-17.17s", rtype3
);
1415 get_mips_dynamic_type (unsigned long type
)
1419 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1420 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1421 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1422 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1423 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1424 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1425 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1426 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1427 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1428 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1429 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1430 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1431 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1432 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1433 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1434 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1435 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1436 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1437 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1438 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1439 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1440 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1441 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1442 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1443 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1444 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1445 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1446 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1447 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1448 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1449 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1450 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1451 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1452 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1453 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1454 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1455 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1456 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1457 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1458 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1459 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1460 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1461 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1462 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1463 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1470 get_sparc64_dynamic_type (unsigned long type
)
1474 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1481 get_ppc_dynamic_type (unsigned long type
)
1485 case DT_PPC_GOT
: return "PPC_GOT";
1486 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1493 get_ppc64_dynamic_type (unsigned long type
)
1497 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1498 case DT_PPC64_OPD
: return "PPC64_OPD";
1499 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1500 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1507 get_parisc_dynamic_type (unsigned long type
)
1511 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1512 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1513 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1514 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1515 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1516 case DT_HP_PREINIT
: return "HP_PREINIT";
1517 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1518 case DT_HP_NEEDED
: return "HP_NEEDED";
1519 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1520 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1521 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1522 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1523 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1524 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1525 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1526 case DT_HP_FILTERED
: return "HP_FILTERED";
1527 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1528 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1529 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1530 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1531 case DT_PLT
: return "PLT";
1532 case DT_PLT_SIZE
: return "PLT_SIZE";
1533 case DT_DLT
: return "DLT";
1534 case DT_DLT_SIZE
: return "DLT_SIZE";
1541 get_ia64_dynamic_type (unsigned long type
)
1545 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1546 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1547 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1548 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1549 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1550 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1551 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1552 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1553 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1554 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1555 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1556 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1557 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1558 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1559 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1560 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1561 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1562 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1563 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1564 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1565 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1566 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1567 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1568 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1569 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1570 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1571 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1572 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1573 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1574 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1575 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1582 get_alpha_dynamic_type (unsigned long type
)
1586 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1593 get_score_dynamic_type (unsigned long type
)
1597 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1598 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1599 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1600 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1601 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1602 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1610 get_dynamic_type (unsigned long type
)
1612 static char buff
[64];
1616 case DT_NULL
: return "NULL";
1617 case DT_NEEDED
: return "NEEDED";
1618 case DT_PLTRELSZ
: return "PLTRELSZ";
1619 case DT_PLTGOT
: return "PLTGOT";
1620 case DT_HASH
: return "HASH";
1621 case DT_STRTAB
: return "STRTAB";
1622 case DT_SYMTAB
: return "SYMTAB";
1623 case DT_RELA
: return "RELA";
1624 case DT_RELASZ
: return "RELASZ";
1625 case DT_RELAENT
: return "RELAENT";
1626 case DT_STRSZ
: return "STRSZ";
1627 case DT_SYMENT
: return "SYMENT";
1628 case DT_INIT
: return "INIT";
1629 case DT_FINI
: return "FINI";
1630 case DT_SONAME
: return "SONAME";
1631 case DT_RPATH
: return "RPATH";
1632 case DT_SYMBOLIC
: return "SYMBOLIC";
1633 case DT_REL
: return "REL";
1634 case DT_RELSZ
: return "RELSZ";
1635 case DT_RELENT
: return "RELENT";
1636 case DT_PLTREL
: return "PLTREL";
1637 case DT_DEBUG
: return "DEBUG";
1638 case DT_TEXTREL
: return "TEXTREL";
1639 case DT_JMPREL
: return "JMPREL";
1640 case DT_BIND_NOW
: return "BIND_NOW";
1641 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1642 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1643 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1644 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1645 case DT_RUNPATH
: return "RUNPATH";
1646 case DT_FLAGS
: return "FLAGS";
1648 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1649 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1651 case DT_CHECKSUM
: return "CHECKSUM";
1652 case DT_PLTPADSZ
: return "PLTPADSZ";
1653 case DT_MOVEENT
: return "MOVEENT";
1654 case DT_MOVESZ
: return "MOVESZ";
1655 case DT_FEATURE
: return "FEATURE";
1656 case DT_POSFLAG_1
: return "POSFLAG_1";
1657 case DT_SYMINSZ
: return "SYMINSZ";
1658 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1660 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1661 case DT_CONFIG
: return "CONFIG";
1662 case DT_DEPAUDIT
: return "DEPAUDIT";
1663 case DT_AUDIT
: return "AUDIT";
1664 case DT_PLTPAD
: return "PLTPAD";
1665 case DT_MOVETAB
: return "MOVETAB";
1666 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1668 case DT_VERSYM
: return "VERSYM";
1670 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1671 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1672 case DT_RELACOUNT
: return "RELACOUNT";
1673 case DT_RELCOUNT
: return "RELCOUNT";
1674 case DT_FLAGS_1
: return "FLAGS_1";
1675 case DT_VERDEF
: return "VERDEF";
1676 case DT_VERDEFNUM
: return "VERDEFNUM";
1677 case DT_VERNEED
: return "VERNEED";
1678 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1680 case DT_AUXILIARY
: return "AUXILIARY";
1681 case DT_USED
: return "USED";
1682 case DT_FILTER
: return "FILTER";
1684 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1685 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1686 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1687 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1688 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1689 case DT_GNU_HASH
: return "GNU_HASH";
1692 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1694 const char * result
;
1696 switch (elf_header
.e_machine
)
1699 case EM_MIPS_RS3_LE
:
1700 result
= get_mips_dynamic_type (type
);
1703 result
= get_sparc64_dynamic_type (type
);
1706 result
= get_ppc_dynamic_type (type
);
1709 result
= get_ppc64_dynamic_type (type
);
1712 result
= get_ia64_dynamic_type (type
);
1715 result
= get_alpha_dynamic_type (type
);
1718 result
= get_score_dynamic_type (type
);
1728 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1730 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1731 || (elf_header
.e_machine
== EM_PARISC
1732 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1734 const char * result
;
1736 switch (elf_header
.e_machine
)
1739 result
= get_parisc_dynamic_type (type
);
1742 result
= get_ia64_dynamic_type (type
);
1752 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1756 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1763 get_file_type (unsigned e_type
)
1765 static char buff
[32];
1769 case ET_NONE
: return _("NONE (None)");
1770 case ET_REL
: return _("REL (Relocatable file)");
1771 case ET_EXEC
: return _("EXEC (Executable file)");
1772 case ET_DYN
: return _("DYN (Shared object file)");
1773 case ET_CORE
: return _("CORE (Core file)");
1776 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1777 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1778 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1779 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1781 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1787 get_machine_name (unsigned e_machine
)
1789 static char buff
[64]; /* XXX */
1793 case EM_NONE
: return _("None");
1794 case EM_M32
: return "WE32100";
1795 case EM_SPARC
: return "Sparc";
1796 case EM_SPU
: return "SPU";
1797 case EM_386
: return "Intel 80386";
1798 case EM_68K
: return "MC68000";
1799 case EM_88K
: return "MC88000";
1800 case EM_486
: return "Intel 80486";
1801 case EM_860
: return "Intel 80860";
1802 case EM_MIPS
: return "MIPS R3000";
1803 case EM_S370
: return "IBM System/370";
1804 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1805 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1806 case EM_PARISC
: return "HPPA";
1807 case EM_PPC_OLD
: return "Power PC (old)";
1808 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1809 case EM_960
: return "Intel 90860";
1810 case EM_PPC
: return "PowerPC";
1811 case EM_PPC64
: return "PowerPC64";
1812 case EM_V800
: return "NEC V800";
1813 case EM_FR20
: return "Fujitsu FR20";
1814 case EM_RH32
: return "TRW RH32";
1815 case EM_MCORE
: return "MCORE";
1816 case EM_ARM
: return "ARM";
1817 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1818 case EM_SH
: return "Renesas / SuperH SH";
1819 case EM_SPARCV9
: return "Sparc v9";
1820 case EM_TRICORE
: return "Siemens Tricore";
1821 case EM_ARC
: return "ARC";
1822 case EM_H8_300
: return "Renesas H8/300";
1823 case EM_H8_300H
: return "Renesas H8/300H";
1824 case EM_H8S
: return "Renesas H8S";
1825 case EM_H8_500
: return "Renesas H8/500";
1826 case EM_IA_64
: return "Intel IA-64";
1827 case EM_MIPS_X
: return "Stanford MIPS-X";
1828 case EM_COLDFIRE
: return "Motorola Coldfire";
1829 case EM_68HC12
: return "Motorola M68HC12";
1830 case EM_ALPHA
: return "Alpha";
1831 case EM_CYGNUS_D10V
:
1832 case EM_D10V
: return "d10v";
1833 case EM_CYGNUS_D30V
:
1834 case EM_D30V
: return "d30v";
1835 case EM_CYGNUS_M32R
:
1836 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1837 case EM_CYGNUS_V850
:
1838 case EM_V850
: return "NEC v850";
1839 case EM_CYGNUS_MN10300
:
1840 case EM_MN10300
: return "mn10300";
1841 case EM_CYGNUS_MN10200
:
1842 case EM_MN10200
: return "mn10200";
1843 case EM_CYGNUS_FR30
:
1844 case EM_FR30
: return "Fujitsu FR30";
1845 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1847 case EM_PJ
: return "picoJava";
1848 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1849 case EM_PCP
: return "Siemens PCP";
1850 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1851 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1852 case EM_STARCORE
: return "Motorola Star*Core processor";
1853 case EM_ME16
: return "Toyota ME16 processor";
1854 case EM_ST100
: return "STMicroelectronics ST100 processor";
1855 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1856 case EM_PDSP
: return "Sony DSP processor";
1857 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1858 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1859 case EM_FX66
: return "Siemens FX66 microcontroller";
1860 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1861 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1862 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1863 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1864 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1865 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1866 case EM_SVX
: return "Silicon Graphics SVx";
1867 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1868 case EM_VAX
: return "Digital VAX";
1870 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1871 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1872 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1873 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1874 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1875 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1876 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1877 case EM_PRISM
: return "Vitesse Prism";
1878 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1879 case EM_L1OM
: return "Intel L1OM";
1881 case EM_S390
: return "IBM S/390";
1882 case EM_SCORE
: return "SUNPLUS S+Core";
1883 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1885 case EM_OR32
: return "OpenRISC";
1886 case EM_ARC_A5
: return "ARC International ARCompact processor";
1887 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1888 case EM_DLX
: return "OpenDLX";
1890 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1891 case EM_IQ2000
: return "Vitesse IQ2000";
1893 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1894 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1895 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1896 case EM_NS32K
: return "National Semiconductor 32000 series";
1897 case EM_TPC
: return "Tenor Network TPC processor";
1898 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1899 case EM_MAX
: return "MAX Processor";
1900 case EM_CR
: return "National Semiconductor CompactRISC";
1901 case EM_F2MC16
: return "Fujitsu F2MC16";
1902 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1903 case EM_LATTICEMICO32
: return "Lattice Mico32";
1905 case EM_M32C
: return "Renesas M32c";
1906 case EM_MT
: return "Morpho Techologies MT processor";
1907 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1908 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1909 case EM_SEP
: return "Sharp embedded microprocessor";
1910 case EM_ARCA
: return "Arca RISC microprocessor";
1911 case EM_UNICORE
: return "Unicore";
1912 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1913 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1914 case EM_NIOS32
: return "Altera Nios";
1915 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1917 case EM_XC16X
: return "Infineon Technologies xc16x";
1918 case EM_M16C
: return "Renesas M16C series microprocessors";
1919 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1920 case EM_CE
: return "Freescale Communication Engine RISC core";
1921 case EM_TSK3000
: return "Altium TSK3000 core";
1922 case EM_RS08
: return "Freescale RS08 embedded processor";
1923 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1924 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1925 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1926 case EM_SE_C17
: return "Seiko Epson C17 family";
1927 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
1928 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
1929 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
1930 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1931 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
1932 case EM_R32C
: return "Renesas R32C series microprocessors";
1933 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
1934 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
1935 case EM_8051
: return "Intel 8051 and variants";
1936 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
1937 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
1938 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
1939 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1940 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
1941 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
1942 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
1943 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1945 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1946 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1947 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1948 case EM_RX
: return "Renesas RX";
1949 case EM_METAG
: return "Imagination Technologies META processor architecture";
1950 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
1951 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
1952 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
1953 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
1954 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
1955 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
1956 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
1957 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
1958 case EM_CUDA
: return "NVIDIA CUDA architecture";
1960 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1966 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1971 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1972 e_flags
&= ~ EF_ARM_EABIMASK
;
1974 /* Handle "generic" ARM flags. */
1975 if (e_flags
& EF_ARM_RELEXEC
)
1977 strcat (buf
, ", relocatable executable");
1978 e_flags
&= ~ EF_ARM_RELEXEC
;
1981 if (e_flags
& EF_ARM_HASENTRY
)
1983 strcat (buf
, ", has entry point");
1984 e_flags
&= ~ EF_ARM_HASENTRY
;
1987 /* Now handle EABI specific flags. */
1991 strcat (buf
, ", <unrecognized EABI>");
1996 case EF_ARM_EABI_VER1
:
1997 strcat (buf
, ", Version1 EABI");
2002 /* Process flags one bit at a time. */
2003 flag
= e_flags
& - e_flags
;
2008 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2009 strcat (buf
, ", sorted symbol tables");
2019 case EF_ARM_EABI_VER2
:
2020 strcat (buf
, ", Version2 EABI");
2025 /* Process flags one bit at a time. */
2026 flag
= e_flags
& - e_flags
;
2031 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2032 strcat (buf
, ", sorted symbol tables");
2035 case EF_ARM_DYNSYMSUSESEGIDX
:
2036 strcat (buf
, ", dynamic symbols use segment index");
2039 case EF_ARM_MAPSYMSFIRST
:
2040 strcat (buf
, ", mapping symbols precede others");
2050 case EF_ARM_EABI_VER3
:
2051 strcat (buf
, ", Version3 EABI");
2054 case EF_ARM_EABI_VER4
:
2055 strcat (buf
, ", Version4 EABI");
2058 case EF_ARM_EABI_VER5
:
2059 strcat (buf
, ", Version5 EABI");
2065 /* Process flags one bit at a time. */
2066 flag
= e_flags
& - e_flags
;
2072 strcat (buf
, ", BE8");
2076 strcat (buf
, ", LE8");
2086 case EF_ARM_EABI_UNKNOWN
:
2087 strcat (buf
, ", GNU EABI");
2092 /* Process flags one bit at a time. */
2093 flag
= e_flags
& - e_flags
;
2098 case EF_ARM_INTERWORK
:
2099 strcat (buf
, ", interworking enabled");
2102 case EF_ARM_APCS_26
:
2103 strcat (buf
, ", uses APCS/26");
2106 case EF_ARM_APCS_FLOAT
:
2107 strcat (buf
, ", uses APCS/float");
2111 strcat (buf
, ", position independent");
2115 strcat (buf
, ", 8 bit structure alignment");
2118 case EF_ARM_NEW_ABI
:
2119 strcat (buf
, ", uses new ABI");
2122 case EF_ARM_OLD_ABI
:
2123 strcat (buf
, ", uses old ABI");
2126 case EF_ARM_SOFT_FLOAT
:
2127 strcat (buf
, ", software FP");
2130 case EF_ARM_VFP_FLOAT
:
2131 strcat (buf
, ", VFP");
2134 case EF_ARM_MAVERICK_FLOAT
:
2135 strcat (buf
, ", Maverick FP");
2146 strcat (buf
,", <unknown>");
2150 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2152 static char buf
[1024];
2164 decode_ARM_machine_flags (e_flags
, buf
);
2168 switch (e_flags
& EF_FRV_CPU_MASK
)
2170 case EF_FRV_CPU_GENERIC
:
2174 strcat (buf
, ", fr???");
2177 case EF_FRV_CPU_FR300
:
2178 strcat (buf
, ", fr300");
2181 case EF_FRV_CPU_FR400
:
2182 strcat (buf
, ", fr400");
2184 case EF_FRV_CPU_FR405
:
2185 strcat (buf
, ", fr405");
2188 case EF_FRV_CPU_FR450
:
2189 strcat (buf
, ", fr450");
2192 case EF_FRV_CPU_FR500
:
2193 strcat (buf
, ", fr500");
2195 case EF_FRV_CPU_FR550
:
2196 strcat (buf
, ", fr550");
2199 case EF_FRV_CPU_SIMPLE
:
2200 strcat (buf
, ", simple");
2202 case EF_FRV_CPU_TOMCAT
:
2203 strcat (buf
, ", tomcat");
2209 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2210 strcat (buf
, ", m68000");
2211 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2212 strcat (buf
, ", cpu32");
2213 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2214 strcat (buf
, ", fido_a");
2217 char const * isa
= _("unknown");
2218 char const * mac
= _("unknown mac");
2219 char const * additional
= NULL
;
2221 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2223 case EF_M68K_CF_ISA_A_NODIV
:
2225 additional
= ", nodiv";
2227 case EF_M68K_CF_ISA_A
:
2230 case EF_M68K_CF_ISA_A_PLUS
:
2233 case EF_M68K_CF_ISA_B_NOUSP
:
2235 additional
= ", nousp";
2237 case EF_M68K_CF_ISA_B
:
2241 strcat (buf
, ", cf, isa ");
2244 strcat (buf
, additional
);
2245 if (e_flags
& EF_M68K_CF_FLOAT
)
2246 strcat (buf
, ", float");
2247 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2252 case EF_M68K_CF_MAC
:
2255 case EF_M68K_CF_EMAC
:
2268 if (e_flags
& EF_PPC_EMB
)
2269 strcat (buf
, ", emb");
2271 if (e_flags
& EF_PPC_RELOCATABLE
)
2272 strcat (buf
, ", relocatable");
2274 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2275 strcat (buf
, ", relocatable-lib");
2279 case EM_CYGNUS_V850
:
2280 switch (e_flags
& EF_V850_ARCH
)
2283 strcat (buf
, ", v850e1");
2286 strcat (buf
, ", v850e");
2289 strcat (buf
, ", v850");
2292 strcat (buf
, ", unknown v850 architecture variant");
2298 case EM_CYGNUS_M32R
:
2299 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2300 strcat (buf
, ", m32r");
2304 case EM_MIPS_RS3_LE
:
2305 if (e_flags
& EF_MIPS_NOREORDER
)
2306 strcat (buf
, ", noreorder");
2308 if (e_flags
& EF_MIPS_PIC
)
2309 strcat (buf
, ", pic");
2311 if (e_flags
& EF_MIPS_CPIC
)
2312 strcat (buf
, ", cpic");
2314 if (e_flags
& EF_MIPS_UCODE
)
2315 strcat (buf
, ", ugen_reserved");
2317 if (e_flags
& EF_MIPS_ABI2
)
2318 strcat (buf
, ", abi2");
2320 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2321 strcat (buf
, ", odk first");
2323 if (e_flags
& EF_MIPS_32BITMODE
)
2324 strcat (buf
, ", 32bitmode");
2326 switch ((e_flags
& EF_MIPS_MACH
))
2328 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2329 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2330 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2331 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2332 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2333 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2334 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2335 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2336 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2337 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2338 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2339 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2340 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2341 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2342 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2344 /* We simply ignore the field in this case to avoid confusion:
2345 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2348 default: strcat (buf
, ", unknown CPU"); break;
2351 switch ((e_flags
& EF_MIPS_ABI
))
2353 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2354 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2355 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2356 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2358 /* We simply ignore the field in this case to avoid confusion:
2359 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2360 This means it is likely to be an o32 file, but not for
2363 default: strcat (buf
, ", unknown ABI"); break;
2366 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2367 strcat (buf
, ", mdmx");
2369 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2370 strcat (buf
, ", mips16");
2372 switch ((e_flags
& EF_MIPS_ARCH
))
2374 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2375 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2376 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2377 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2378 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2379 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2380 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2381 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2382 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2383 default: strcat (buf
, ", unknown ISA"); break;
2389 switch ((e_flags
& EF_SH_MACH_MASK
))
2391 case EF_SH1
: strcat (buf
, ", sh1"); break;
2392 case EF_SH2
: strcat (buf
, ", sh2"); break;
2393 case EF_SH3
: strcat (buf
, ", sh3"); break;
2394 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2395 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2396 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2397 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2398 case EF_SH4
: strcat (buf
, ", sh4"); break;
2399 case EF_SH5
: strcat (buf
, ", sh5"); break;
2400 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2401 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2402 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2403 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2404 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2405 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2406 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2407 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2408 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2409 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2410 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2411 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2412 default: strcat (buf
, ", unknown ISA"); break;
2418 if (e_flags
& EF_SPARC_32PLUS
)
2419 strcat (buf
, ", v8+");
2421 if (e_flags
& EF_SPARC_SUN_US1
)
2422 strcat (buf
, ", ultrasparcI");
2424 if (e_flags
& EF_SPARC_SUN_US3
)
2425 strcat (buf
, ", ultrasparcIII");
2427 if (e_flags
& EF_SPARC_HAL_R1
)
2428 strcat (buf
, ", halr1");
2430 if (e_flags
& EF_SPARC_LEDATA
)
2431 strcat (buf
, ", ledata");
2433 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2434 strcat (buf
, ", tso");
2436 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2437 strcat (buf
, ", pso");
2439 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2440 strcat (buf
, ", rmo");
2444 switch (e_flags
& EF_PARISC_ARCH
)
2446 case EFA_PARISC_1_0
:
2447 strcpy (buf
, ", PA-RISC 1.0");
2449 case EFA_PARISC_1_1
:
2450 strcpy (buf
, ", PA-RISC 1.1");
2452 case EFA_PARISC_2_0
:
2453 strcpy (buf
, ", PA-RISC 2.0");
2458 if (e_flags
& EF_PARISC_TRAPNIL
)
2459 strcat (buf
, ", trapnil");
2460 if (e_flags
& EF_PARISC_EXT
)
2461 strcat (buf
, ", ext");
2462 if (e_flags
& EF_PARISC_LSB
)
2463 strcat (buf
, ", lsb");
2464 if (e_flags
& EF_PARISC_WIDE
)
2465 strcat (buf
, ", wide");
2466 if (e_flags
& EF_PARISC_NO_KABP
)
2467 strcat (buf
, ", no kabp");
2468 if (e_flags
& EF_PARISC_LAZYSWAP
)
2469 strcat (buf
, ", lazyswap");
2474 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2475 strcat (buf
, ", new calling convention");
2477 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2478 strcat (buf
, ", gnu calling convention");
2482 if ((e_flags
& EF_IA_64_ABI64
))
2483 strcat (buf
, ", 64-bit");
2485 strcat (buf
, ", 32-bit");
2486 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2487 strcat (buf
, ", reduced fp model");
2488 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2489 strcat (buf
, ", no function descriptors, constant gp");
2490 else if ((e_flags
& EF_IA_64_CONS_GP
))
2491 strcat (buf
, ", constant gp");
2492 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2493 strcat (buf
, ", absolute");
2497 if ((e_flags
& EF_VAX_NONPIC
))
2498 strcat (buf
, ", non-PIC");
2499 if ((e_flags
& EF_VAX_DFLOAT
))
2500 strcat (buf
, ", D-Float");
2501 if ((e_flags
& EF_VAX_GFLOAT
))
2502 strcat (buf
, ", G-Float");
2506 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2507 strcat (buf
, ", 64-bit doubles");
2508 if (e_flags
& E_FLAG_RX_DSP
)
2509 strcat (buf
, ", dsp");
2517 get_osabi_name (unsigned int osabi
)
2519 static char buff
[32];
2523 case ELFOSABI_NONE
: return "UNIX - System V";
2524 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2525 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2526 case ELFOSABI_LINUX
: return "UNIX - Linux";
2527 case ELFOSABI_HURD
: return "GNU/Hurd";
2528 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2529 case ELFOSABI_AIX
: return "UNIX - AIX";
2530 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2531 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2532 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2533 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2534 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2535 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2536 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2537 case ELFOSABI_AROS
: return "AROS";
2538 case ELFOSABI_FENIXOS
: return "FenixOS";
2539 case ELFOSABI_STANDALONE
: return _("Standalone App");
2540 case ELFOSABI_ARM
: return "ARM";
2542 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2548 get_arm_segment_type (unsigned long type
)
2562 get_mips_segment_type (unsigned long type
)
2566 case PT_MIPS_REGINFO
:
2568 case PT_MIPS_RTPROC
:
2570 case PT_MIPS_OPTIONS
:
2580 get_parisc_segment_type (unsigned long type
)
2584 case PT_HP_TLS
: return "HP_TLS";
2585 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2586 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2587 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2588 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2589 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2590 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2591 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2592 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2593 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2594 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2595 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2596 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2597 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2598 case PT_HP_STACK
: return "HP_STACK";
2599 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2600 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2601 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2602 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2611 get_ia64_segment_type (unsigned long type
)
2615 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2616 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2617 case PT_HP_TLS
: return "HP_TLS";
2618 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2619 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2620 case PT_IA_64_HP_STACK
: return "HP_STACK";
2629 get_segment_type (unsigned long p_type
)
2631 static char buff
[32];
2635 case PT_NULL
: return "NULL";
2636 case PT_LOAD
: return "LOAD";
2637 case PT_DYNAMIC
: return "DYNAMIC";
2638 case PT_INTERP
: return "INTERP";
2639 case PT_NOTE
: return "NOTE";
2640 case PT_SHLIB
: return "SHLIB";
2641 case PT_PHDR
: return "PHDR";
2642 case PT_TLS
: return "TLS";
2644 case PT_GNU_EH_FRAME
:
2645 return "GNU_EH_FRAME";
2646 case PT_GNU_STACK
: return "GNU_STACK";
2647 case PT_GNU_RELRO
: return "GNU_RELRO";
2650 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2652 const char * result
;
2654 switch (elf_header
.e_machine
)
2657 result
= get_arm_segment_type (p_type
);
2660 case EM_MIPS_RS3_LE
:
2661 result
= get_mips_segment_type (p_type
);
2664 result
= get_parisc_segment_type (p_type
);
2667 result
= get_ia64_segment_type (p_type
);
2677 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2679 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2681 const char * result
;
2683 switch (elf_header
.e_machine
)
2686 result
= get_parisc_segment_type (p_type
);
2689 result
= get_ia64_segment_type (p_type
);
2699 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2702 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2709 get_mips_section_type_name (unsigned int sh_type
)
2713 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2714 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2715 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2716 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2717 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2718 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2719 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2720 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2721 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2722 case SHT_MIPS_RELD
: return "MIPS_RELD";
2723 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2724 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2725 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2726 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2727 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2728 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2729 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2730 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2731 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2732 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2733 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2734 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2735 case SHT_MIPS_LINE
: return "MIPS_LINE";
2736 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2737 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2738 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2739 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2740 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2741 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2742 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2743 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2744 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2745 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2746 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2747 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2748 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2749 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2750 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2751 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2759 get_parisc_section_type_name (unsigned int sh_type
)
2763 case SHT_PARISC_EXT
: return "PARISC_EXT";
2764 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2765 case SHT_PARISC_DOC
: return "PARISC_DOC";
2766 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2767 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2768 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2769 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2777 get_ia64_section_type_name (unsigned int sh_type
)
2779 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2780 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2781 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2785 case SHT_IA_64_EXT
: return "IA_64_EXT";
2786 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2787 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2788 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2789 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2790 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2791 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2792 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2793 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2794 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2802 get_x86_64_section_type_name (unsigned int sh_type
)
2806 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2814 get_arm_section_type_name (unsigned int sh_type
)
2818 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2819 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2820 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2821 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2822 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2830 get_section_type_name (unsigned int sh_type
)
2832 static char buff
[32];
2836 case SHT_NULL
: return "NULL";
2837 case SHT_PROGBITS
: return "PROGBITS";
2838 case SHT_SYMTAB
: return "SYMTAB";
2839 case SHT_STRTAB
: return "STRTAB";
2840 case SHT_RELA
: return "RELA";
2841 case SHT_HASH
: return "HASH";
2842 case SHT_DYNAMIC
: return "DYNAMIC";
2843 case SHT_NOTE
: return "NOTE";
2844 case SHT_NOBITS
: return "NOBITS";
2845 case SHT_REL
: return "REL";
2846 case SHT_SHLIB
: return "SHLIB";
2847 case SHT_DYNSYM
: return "DYNSYM";
2848 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2849 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2850 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2851 case SHT_GNU_HASH
: return "GNU_HASH";
2852 case SHT_GROUP
: return "GROUP";
2853 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2854 case SHT_GNU_verdef
: return "VERDEF";
2855 case SHT_GNU_verneed
: return "VERNEED";
2856 case SHT_GNU_versym
: return "VERSYM";
2857 case 0x6ffffff0: return "VERSYM";
2858 case 0x6ffffffc: return "VERDEF";
2859 case 0x7ffffffd: return "AUXILIARY";
2860 case 0x7fffffff: return "FILTER";
2861 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2864 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2866 const char * result
;
2868 switch (elf_header
.e_machine
)
2871 case EM_MIPS_RS3_LE
:
2872 result
= get_mips_section_type_name (sh_type
);
2875 result
= get_parisc_section_type_name (sh_type
);
2878 result
= get_ia64_section_type_name (sh_type
);
2882 result
= get_x86_64_section_type_name (sh_type
);
2885 result
= get_arm_section_type_name (sh_type
);
2895 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2897 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2899 const char * result
;
2901 switch (elf_header
.e_machine
)
2904 result
= get_ia64_section_type_name (sh_type
);
2914 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2916 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2917 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2919 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2925 #define OPTION_DEBUG_DUMP 512
2927 static struct option options
[] =
2929 {"all", no_argument
, 0, 'a'},
2930 {"file-header", no_argument
, 0, 'h'},
2931 {"program-headers", no_argument
, 0, 'l'},
2932 {"headers", no_argument
, 0, 'e'},
2933 {"histogram", no_argument
, 0, 'I'},
2934 {"segments", no_argument
, 0, 'l'},
2935 {"sections", no_argument
, 0, 'S'},
2936 {"section-headers", no_argument
, 0, 'S'},
2937 {"section-groups", no_argument
, 0, 'g'},
2938 {"section-details", no_argument
, 0, 't'},
2939 {"full-section-name",no_argument
, 0, 'N'},
2940 {"symbols", no_argument
, 0, 's'},
2941 {"syms", no_argument
, 0, 's'},
2942 {"relocs", no_argument
, 0, 'r'},
2943 {"notes", no_argument
, 0, 'n'},
2944 {"dynamic", no_argument
, 0, 'd'},
2945 {"arch-specific", no_argument
, 0, 'A'},
2946 {"version-info", no_argument
, 0, 'V'},
2947 {"use-dynamic", no_argument
, 0, 'D'},
2948 {"unwind", no_argument
, 0, 'u'},
2949 {"archive-index", no_argument
, 0, 'c'},
2950 {"hex-dump", required_argument
, 0, 'x'},
2951 {"relocated-dump", required_argument
, 0, 'R'},
2952 {"string-dump", required_argument
, 0, 'p'},
2953 #ifdef SUPPORT_DISASSEMBLY
2954 {"instruction-dump", required_argument
, 0, 'i'},
2956 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2958 {"version", no_argument
, 0, 'v'},
2959 {"wide", no_argument
, 0, 'W'},
2960 {"help", no_argument
, 0, 'H'},
2961 {0, no_argument
, 0, 0}
2965 usage (FILE * stream
)
2967 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2968 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2969 fprintf (stream
, _(" Options are:\n\
2970 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2971 -h --file-header Display the ELF file header\n\
2972 -l --program-headers Display the program headers\n\
2973 --segments An alias for --program-headers\n\
2974 -S --section-headers Display the sections' header\n\
2975 --sections An alias for --section-headers\n\
2976 -g --section-groups Display the section groups\n\
2977 -t --section-details Display the section details\n\
2978 -e --headers Equivalent to: -h -l -S\n\
2979 -s --syms Display the symbol table\n\
2980 --symbols An alias for --syms\n\
2981 -n --notes Display the core notes (if present)\n\
2982 -r --relocs Display the relocations (if present)\n\
2983 -u --unwind Display the unwind info (if present)\n\
2984 -d --dynamic Display the dynamic section (if present)\n\
2985 -V --version-info Display the version sections (if present)\n\
2986 -A --arch-specific Display architecture specific information (if any).\n\
2987 -c --archive-index Display the symbol/file index in an archive\n\
2988 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2989 -x --hex-dump=<number|name>\n\
2990 Dump the contents of section <number|name> as bytes\n\
2991 -p --string-dump=<number|name>\n\
2992 Dump the contents of section <number|name> as strings\n\
2993 -R --relocated-dump=<number|name>\n\
2994 Dump the contents of section <number|name> as relocated bytes\n\
2995 -w[lLiaprmfFsoRt] or\n\
2996 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
2997 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
2998 Display the contents of DWARF2 debug sections\n"));
2999 #ifdef SUPPORT_DISASSEMBLY
3000 fprintf (stream
, _("\
3001 -i --instruction-dump=<number|name>\n\
3002 Disassemble the contents of section <number|name>\n"));
3004 fprintf (stream
, _("\
3005 -I --histogram Display histogram of bucket list lengths\n\
3006 -W --wide Allow output width to exceed 80 characters\n\
3007 @<file> Read options from <file>\n\
3008 -H --help Display this information\n\
3009 -v --version Display the version number of readelf\n"));
3011 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3012 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3014 exit (stream
== stdout
? 0 : 1);
3017 /* Record the fact that the user wants the contents of section number
3018 SECTION to be displayed using the method(s) encoded as flags bits
3019 in TYPE. Note, TYPE can be zero if we are creating the array for
3023 request_dump_bynumber (unsigned int section
, dump_type type
)
3025 if (section
>= num_dump_sects
)
3027 dump_type
* new_dump_sects
;
3029 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3030 sizeof (* dump_sects
));
3032 if (new_dump_sects
== NULL
)
3033 error (_("Out of memory allocating dump request table.\n"));
3036 /* Copy current flag settings. */
3037 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3041 dump_sects
= new_dump_sects
;
3042 num_dump_sects
= section
+ 1;
3047 dump_sects
[section
] |= type
;
3052 /* Request a dump by section name. */
3055 request_dump_byname (const char * section
, dump_type type
)
3057 struct dump_list_entry
* new_request
;
3059 new_request
= (struct dump_list_entry
*)
3060 malloc (sizeof (struct dump_list_entry
));
3062 error (_("Out of memory allocating dump request table.\n"));
3064 new_request
->name
= strdup (section
);
3065 if (!new_request
->name
)
3066 error (_("Out of memory allocating dump request table.\n"));
3068 new_request
->type
= type
;
3070 new_request
->next
= dump_sects_byname
;
3071 dump_sects_byname
= new_request
;
3075 request_dump (dump_type type
)
3081 section
= strtoul (optarg
, & cp
, 0);
3083 if (! *cp
&& section
>= 0)
3084 request_dump_bynumber (section
, type
);
3086 request_dump_byname (optarg
, type
);
3091 parse_args (int argc
, char ** argv
)
3098 while ((c
= getopt_long
3099 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3117 do_section_groups
++;
3125 do_section_groups
++;
3130 do_section_details
++;
3174 request_dump (HEX_DUMP
);
3177 request_dump (STRING_DUMP
);
3180 request_dump (RELOC_DUMP
);
3187 dwarf_select_sections_all ();
3192 dwarf_select_sections_by_letters (optarg
);
3195 case OPTION_DEBUG_DUMP
:
3202 dwarf_select_sections_by_names (optarg
);
3205 #ifdef SUPPORT_DISASSEMBLY
3207 request_dump (DISASS_DUMP
);
3211 print_version (program_name
);
3220 /* xgettext:c-format */
3221 error (_("Invalid option '-%c'\n"), c
);
3228 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3229 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3230 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3231 && !do_section_groups
&& !do_archive_index
)
3235 warn (_("Nothing to do.\n"));
3241 get_elf_class (unsigned int elf_class
)
3243 static char buff
[32];
3247 case ELFCLASSNONE
: return _("none");
3248 case ELFCLASS32
: return "ELF32";
3249 case ELFCLASS64
: return "ELF64";
3251 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3257 get_data_encoding (unsigned int encoding
)
3259 static char buff
[32];
3263 case ELFDATANONE
: return _("none");
3264 case ELFDATA2LSB
: return _("2's complement, little endian");
3265 case ELFDATA2MSB
: return _("2's complement, big endian");
3267 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3272 /* Decode the data held in 'elf_header'. */
3275 process_file_header (void)
3277 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3278 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3279 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3280 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3283 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3287 init_dwarf_regnames (elf_header
.e_machine
);
3293 printf (_("ELF Header:\n"));
3294 printf (_(" Magic: "));
3295 for (i
= 0; i
< EI_NIDENT
; i
++)
3296 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3298 printf (_(" Class: %s\n"),
3299 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3300 printf (_(" Data: %s\n"),
3301 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3302 printf (_(" Version: %d %s\n"),
3303 elf_header
.e_ident
[EI_VERSION
],
3304 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3306 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3309 printf (_(" OS/ABI: %s\n"),
3310 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3311 printf (_(" ABI Version: %d\n"),
3312 elf_header
.e_ident
[EI_ABIVERSION
]);
3313 printf (_(" Type: %s\n"),
3314 get_file_type (elf_header
.e_type
));
3315 printf (_(" Machine: %s\n"),
3316 get_machine_name (elf_header
.e_machine
));
3317 printf (_(" Version: 0x%lx\n"),
3318 (unsigned long) elf_header
.e_version
);
3320 printf (_(" Entry point address: "));
3321 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3322 printf (_("\n Start of program headers: "));
3323 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3324 printf (_(" (bytes into file)\n Start of section headers: "));
3325 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3326 printf (_(" (bytes into file)\n"));
3328 printf (_(" Flags: 0x%lx%s\n"),
3329 (unsigned long) elf_header
.e_flags
,
3330 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3331 printf (_(" Size of this header: %ld (bytes)\n"),
3332 (long) elf_header
.e_ehsize
);
3333 printf (_(" Size of program headers: %ld (bytes)\n"),
3334 (long) elf_header
.e_phentsize
);
3335 printf (_(" Number of program headers: %ld\n"),
3336 (long) elf_header
.e_phnum
);
3337 printf (_(" Size of section headers: %ld (bytes)\n"),
3338 (long) elf_header
.e_shentsize
);
3339 printf (_(" Number of section headers: %ld"),
3340 (long) elf_header
.e_shnum
);
3341 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3342 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3343 putc ('\n', stdout
);
3344 printf (_(" Section header string table index: %ld"),
3345 (long) elf_header
.e_shstrndx
);
3346 if (section_headers
!= NULL
3347 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3348 printf (" (%u)", section_headers
[0].sh_link
);
3349 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3350 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3351 printf (" <corrupt: out of range>");
3352 putc ('\n', stdout
);
3355 if (section_headers
!= NULL
)
3357 if (elf_header
.e_shnum
== SHN_UNDEF
)
3358 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3359 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3360 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3361 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3362 elf_header
.e_shstrndx
= SHN_UNDEF
;
3363 free (section_headers
);
3364 section_headers
= NULL
;
3372 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3374 Elf32_External_Phdr
* phdrs
;
3375 Elf32_External_Phdr
* external
;
3376 Elf_Internal_Phdr
* internal
;
3379 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3380 elf_header
.e_phentsize
,
3382 _("program headers"));
3386 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3387 i
< elf_header
.e_phnum
;
3388 i
++, internal
++, external
++)
3390 internal
->p_type
= BYTE_GET (external
->p_type
);
3391 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3392 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3393 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3394 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3395 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3396 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3397 internal
->p_align
= BYTE_GET (external
->p_align
);
3406 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3408 Elf64_External_Phdr
* phdrs
;
3409 Elf64_External_Phdr
* external
;
3410 Elf_Internal_Phdr
* internal
;
3413 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3414 elf_header
.e_phentsize
,
3416 _("program headers"));
3420 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3421 i
< elf_header
.e_phnum
;
3422 i
++, internal
++, external
++)
3424 internal
->p_type
= BYTE_GET (external
->p_type
);
3425 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3426 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3427 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3428 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3429 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3430 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3431 internal
->p_align
= BYTE_GET (external
->p_align
);
3439 /* Returns 1 if the program headers were read into `program_headers'. */
3442 get_program_headers (FILE * file
)
3444 Elf_Internal_Phdr
* phdrs
;
3446 /* Check cache of prior read. */
3447 if (program_headers
!= NULL
)
3450 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3451 sizeof (Elf_Internal_Phdr
));
3455 error (_("Out of memory\n"));
3460 ? get_32bit_program_headers (file
, phdrs
)
3461 : get_64bit_program_headers (file
, phdrs
))
3463 program_headers
= phdrs
;
3471 /* Returns 1 if the program headers were loaded. */
3474 process_program_headers (FILE * file
)
3476 Elf_Internal_Phdr
* segment
;
3479 if (elf_header
.e_phnum
== 0)
3482 printf (_("\nThere are no program headers in this file.\n"));
3486 if (do_segments
&& !do_header
)
3488 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3489 printf (_("Entry point "));
3490 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3491 printf (_("\nThere are %d program headers, starting at offset "),
3492 elf_header
.e_phnum
);
3493 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3497 if (! get_program_headers (file
))
3502 if (elf_header
.e_phnum
> 1)
3503 printf (_("\nProgram Headers:\n"));
3505 printf (_("\nProgram Headers:\n"));
3509 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3512 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3516 (_(" Type Offset VirtAddr PhysAddr\n"));
3518 (_(" FileSiz MemSiz Flags Align\n"));
3525 for (i
= 0, segment
= program_headers
;
3526 i
< elf_header
.e_phnum
;
3531 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3535 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3536 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3537 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3538 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3539 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3541 (segment
->p_flags
& PF_R
? 'R' : ' '),
3542 (segment
->p_flags
& PF_W
? 'W' : ' '),
3543 (segment
->p_flags
& PF_X
? 'E' : ' '));
3544 printf ("%#lx", (unsigned long) segment
->p_align
);
3548 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3549 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3552 print_vma (segment
->p_offset
, FULL_HEX
);
3556 print_vma (segment
->p_vaddr
, FULL_HEX
);
3558 print_vma (segment
->p_paddr
, FULL_HEX
);
3561 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3562 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3565 print_vma (segment
->p_filesz
, FULL_HEX
);
3569 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3570 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3573 print_vma (segment
->p_offset
, FULL_HEX
);
3577 (segment
->p_flags
& PF_R
? 'R' : ' '),
3578 (segment
->p_flags
& PF_W
? 'W' : ' '),
3579 (segment
->p_flags
& PF_X
? 'E' : ' '));
3581 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3582 printf ("%#lx", (unsigned long) segment
->p_align
);
3585 print_vma (segment
->p_align
, PREFIX_HEX
);
3590 print_vma (segment
->p_offset
, FULL_HEX
);
3592 print_vma (segment
->p_vaddr
, FULL_HEX
);
3594 print_vma (segment
->p_paddr
, FULL_HEX
);
3596 print_vma (segment
->p_filesz
, FULL_HEX
);
3598 print_vma (segment
->p_memsz
, FULL_HEX
);
3600 (segment
->p_flags
& PF_R
? 'R' : ' '),
3601 (segment
->p_flags
& PF_W
? 'W' : ' '),
3602 (segment
->p_flags
& PF_X
? 'E' : ' '));
3603 print_vma (segment
->p_align
, HEX
);
3607 switch (segment
->p_type
)
3611 error (_("more than one dynamic segment\n"));
3613 /* By default, assume that the .dynamic section is the first
3614 section in the DYNAMIC segment. */
3615 dynamic_addr
= segment
->p_offset
;
3616 dynamic_size
= segment
->p_filesz
;
3618 /* Try to locate the .dynamic section. If there is
3619 a section header table, we can easily locate it. */
3620 if (section_headers
!= NULL
)
3622 Elf_Internal_Shdr
* sec
;
3624 sec
= find_section (".dynamic");
3625 if (sec
== NULL
|| sec
->sh_size
== 0)
3627 error (_("no .dynamic section in the dynamic segment\n"));
3631 if (sec
->sh_type
== SHT_NOBITS
)
3637 dynamic_addr
= sec
->sh_offset
;
3638 dynamic_size
= sec
->sh_size
;
3640 if (dynamic_addr
< segment
->p_offset
3641 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3642 warn (_("the .dynamic section is not contained"
3643 " within the dynamic segment\n"));
3644 else if (dynamic_addr
> segment
->p_offset
)
3645 warn (_("the .dynamic section is not the first section"
3646 " in the dynamic segment.\n"));
3651 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3653 error (_("Unable to find program interpreter name\n"));
3657 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3659 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3660 error (_("Internal error: failed to create format string to display program interpreter\n"));
3662 program_interpreter
[0] = 0;
3663 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3664 error (_("Unable to read program interpreter name\n"));
3667 printf (_("\n [Requesting program interpreter: %s]"),
3668 program_interpreter
);
3674 putc ('\n', stdout
);
3677 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3679 printf (_("\n Section to Segment mapping:\n"));
3680 printf (_(" Segment Sections...\n"));
3682 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3685 Elf_Internal_Shdr
* section
;
3687 segment
= program_headers
+ i
;
3688 section
= section_headers
+ 1;
3690 printf (" %2.2d ", i
);
3692 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3694 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3695 printf ("%s ", SECTION_NAME (section
));
3706 /* Find the file offset corresponding to VMA by using the program headers. */
3709 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3711 Elf_Internal_Phdr
* seg
;
3713 if (! get_program_headers (file
))
3715 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3719 for (seg
= program_headers
;
3720 seg
< program_headers
+ elf_header
.e_phnum
;
3723 if (seg
->p_type
!= PT_LOAD
)
3726 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3727 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3728 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3731 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3732 (unsigned long) vma
);
3738 get_32bit_section_headers (FILE * file
, unsigned int num
)
3740 Elf32_External_Shdr
* shdrs
;
3741 Elf_Internal_Shdr
* internal
;
3744 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3745 elf_header
.e_shentsize
, num
,
3746 _("section headers"));
3750 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3751 sizeof (Elf_Internal_Shdr
));
3753 if (section_headers
== NULL
)
3755 error (_("Out of memory\n"));
3759 for (i
= 0, internal
= section_headers
;
3763 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3764 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3765 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3766 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3767 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3768 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3769 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3770 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3771 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3772 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3781 get_64bit_section_headers (FILE * file
, unsigned int num
)
3783 Elf64_External_Shdr
* shdrs
;
3784 Elf_Internal_Shdr
* internal
;
3787 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3788 elf_header
.e_shentsize
, num
,
3789 _("section headers"));
3793 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3794 sizeof (Elf_Internal_Shdr
));
3796 if (section_headers
== NULL
)
3798 error (_("Out of memory\n"));
3802 for (i
= 0, internal
= section_headers
;
3806 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3807 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3808 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3809 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3810 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3811 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3812 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3813 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3814 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3815 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3823 static Elf_Internal_Sym
*
3824 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3826 unsigned long number
;
3827 Elf32_External_Sym
* esyms
;
3828 Elf_External_Sym_Shndx
* shndx
;
3829 Elf_Internal_Sym
* isyms
;
3830 Elf_Internal_Sym
* psym
;
3833 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3834 section
->sh_size
, _("symbols"));
3839 if (symtab_shndx_hdr
!= NULL
3840 && (symtab_shndx_hdr
->sh_link
3841 == (unsigned long) (section
- section_headers
)))
3843 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3844 symtab_shndx_hdr
->sh_offset
,
3845 1, symtab_shndx_hdr
->sh_size
,
3854 number
= section
->sh_size
/ section
->sh_entsize
;
3855 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3859 error (_("Out of memory\n"));
3866 for (j
= 0, psym
= isyms
;
3870 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3871 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3872 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3873 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3874 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3876 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3877 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3878 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3879 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3880 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3890 static Elf_Internal_Sym
*
3891 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3893 unsigned long number
;
3894 Elf64_External_Sym
* esyms
;
3895 Elf_External_Sym_Shndx
* shndx
;
3896 Elf_Internal_Sym
* isyms
;
3897 Elf_Internal_Sym
* psym
;
3900 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3901 section
->sh_size
, _("symbols"));
3906 if (symtab_shndx_hdr
!= NULL
3907 && (symtab_shndx_hdr
->sh_link
3908 == (unsigned long) (section
- section_headers
)))
3910 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3911 symtab_shndx_hdr
->sh_offset
,
3912 1, symtab_shndx_hdr
->sh_size
,
3921 number
= section
->sh_size
/ section
->sh_entsize
;
3922 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3926 error (_("Out of memory\n"));
3933 for (j
= 0, psym
= isyms
;
3937 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3938 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3939 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3940 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3941 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3943 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3944 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3945 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3946 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3947 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3958 get_elf_section_flags (bfd_vma sh_flags
)
3960 static char buff
[1024];
3962 int field_size
= is_32bit_elf
? 8 : 16;
3964 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
3965 bfd_vma os_flags
= 0;
3966 bfd_vma proc_flags
= 0;
3967 bfd_vma unknown_flags
= 0;
3975 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3976 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3977 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3978 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3979 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
3980 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
3981 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
3982 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
3983 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
3984 /* 9 */ { STRING_COMMA_LEN ("TLS") },
3985 /* IA-64 specific. */
3986 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
3987 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
3988 /* IA-64 OpenVMS specific. */
3989 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
3990 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
3991 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
3992 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
3993 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
3994 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
3995 /* SPARC specific. */
3996 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
3997 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4000 if (do_section_details
)
4002 sprintf (buff
, "[%*.*lx]: ",
4003 field_size
, field_size
, (unsigned long) sh_flags
);
4004 p
+= field_size
+ 4;
4011 flag
= sh_flags
& - sh_flags
;
4014 if (do_section_details
)
4018 case SHF_WRITE
: sindex
= 0; break;
4019 case SHF_ALLOC
: sindex
= 1; break;
4020 case SHF_EXECINSTR
: sindex
= 2; break;
4021 case SHF_MERGE
: sindex
= 3; break;
4022 case SHF_STRINGS
: sindex
= 4; break;
4023 case SHF_INFO_LINK
: sindex
= 5; break;
4024 case SHF_LINK_ORDER
: sindex
= 6; break;
4025 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4026 case SHF_GROUP
: sindex
= 8; break;
4027 case SHF_TLS
: sindex
= 9; break;
4031 switch (elf_header
.e_machine
)
4034 if (flag
== SHF_IA_64_SHORT
)
4036 else if (flag
== SHF_IA_64_NORECOV
)
4039 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4042 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4043 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4044 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4045 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4046 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4047 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4056 case EM_OLD_SPARCV9
:
4057 case EM_SPARC32PLUS
:
4060 if (flag
== SHF_EXCLUDE
)
4062 else if (flag
== SHF_ORDERED
)
4072 if (p
!= buff
+ field_size
+ 4)
4074 if (size
< (10 + 2))
4081 size
-= flags
[sindex
].len
;
4082 p
= stpcpy (p
, flags
[sindex
].str
);
4084 else if (flag
& SHF_MASKOS
)
4086 else if (flag
& SHF_MASKPROC
)
4089 unknown_flags
|= flag
;
4095 case SHF_WRITE
: *p
= 'W'; break;
4096 case SHF_ALLOC
: *p
= 'A'; break;
4097 case SHF_EXECINSTR
: *p
= 'X'; break;
4098 case SHF_MERGE
: *p
= 'M'; break;
4099 case SHF_STRINGS
: *p
= 'S'; break;
4100 case SHF_INFO_LINK
: *p
= 'I'; break;
4101 case SHF_LINK_ORDER
: *p
= 'L'; break;
4102 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4103 case SHF_GROUP
: *p
= 'G'; break;
4104 case SHF_TLS
: *p
= 'T'; break;
4107 if ((elf_header
.e_machine
== EM_X86_64
4108 || elf_header
.e_machine
== EM_L1OM
)
4109 && flag
== SHF_X86_64_LARGE
)
4111 else if (flag
& SHF_MASKOS
)
4114 sh_flags
&= ~ SHF_MASKOS
;
4116 else if (flag
& SHF_MASKPROC
)
4119 sh_flags
&= ~ SHF_MASKPROC
;
4129 if (do_section_details
)
4133 size
-= 5 + field_size
;
4134 if (p
!= buff
+ field_size
+ 4)
4142 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4143 (unsigned long) os_flags
);
4144 p
+= 5 + field_size
;
4148 size
-= 7 + field_size
;
4149 if (p
!= buff
+ field_size
+ 4)
4157 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4158 (unsigned long) proc_flags
);
4159 p
+= 7 + field_size
;
4163 size
-= 10 + field_size
;
4164 if (p
!= buff
+ field_size
+ 4)
4172 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4173 (unsigned long) unknown_flags
);
4174 p
+= 10 + field_size
;
4183 process_section_headers (FILE * file
)
4185 Elf_Internal_Shdr
* section
;
4188 section_headers
= NULL
;
4190 if (elf_header
.e_shnum
== 0)
4193 printf (_("\nThere are no sections in this file.\n"));
4198 if (do_sections
&& !do_header
)
4199 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4200 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4204 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4207 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4210 /* Read in the string table, so that we have names to display. */
4211 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4212 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4214 section
= section_headers
+ elf_header
.e_shstrndx
;
4216 if (section
->sh_size
!= 0)
4218 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4219 1, section
->sh_size
,
4222 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4226 /* Scan the sections for the dynamic symbol table
4227 and dynamic string table and debug sections. */
4228 dynamic_symbols
= NULL
;
4229 dynamic_strings
= NULL
;
4230 dynamic_syminfo
= NULL
;
4231 symtab_shndx_hdr
= NULL
;
4233 eh_addr_size
= is_32bit_elf
? 4 : 8;
4234 switch (elf_header
.e_machine
)
4237 case EM_MIPS_RS3_LE
:
4238 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4239 FDE addresses. However, the ABI also has a semi-official ILP32
4240 variant for which the normal FDE address size rules apply.
4242 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4243 section, where XX is the size of longs in bits. Unfortunately,
4244 earlier compilers provided no way of distinguishing ILP32 objects
4245 from LP64 objects, so if there's any doubt, we should assume that
4246 the official LP64 form is being used. */
4247 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4248 && find_section (".gcc_compiled_long32") == NULL
)
4254 switch (elf_header
.e_flags
& EF_H8_MACH
)
4256 case E_H8_MACH_H8300
:
4257 case E_H8_MACH_H8300HN
:
4258 case E_H8_MACH_H8300SN
:
4259 case E_H8_MACH_H8300SXN
:
4262 case E_H8_MACH_H8300H
:
4263 case E_H8_MACH_H8300S
:
4264 case E_H8_MACH_H8300SX
:
4272 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4274 case EF_M32C_CPU_M16C
:
4281 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4284 size_t expected_entsize \
4285 = is_32bit_elf ? size32 : size64; \
4286 if (section->sh_entsize != expected_entsize) \
4287 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4288 i, (unsigned long int) section->sh_entsize, \
4289 (unsigned long int) expected_entsize); \
4290 section->sh_entsize = expected_entsize; \
4293 #define CHECK_ENTSIZE(section, i, type) \
4294 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4295 sizeof (Elf64_External_##type))
4297 for (i
= 0, section
= section_headers
;
4298 i
< elf_header
.e_shnum
;
4301 char * name
= SECTION_NAME (section
);
4303 if (section
->sh_type
== SHT_DYNSYM
)
4305 if (dynamic_symbols
!= NULL
)
4307 error (_("File contains multiple dynamic symbol tables\n"));
4311 CHECK_ENTSIZE (section
, i
, Sym
);
4312 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4313 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4315 else if (section
->sh_type
== SHT_STRTAB
4316 && streq (name
, ".dynstr"))
4318 if (dynamic_strings
!= NULL
)
4320 error (_("File contains multiple dynamic string tables\n"));
4324 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4325 1, section
->sh_size
,
4326 _("dynamic strings"));
4327 dynamic_strings_length
= section
->sh_size
;
4329 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4331 if (symtab_shndx_hdr
!= NULL
)
4333 error (_("File contains multiple symtab shndx tables\n"));
4336 symtab_shndx_hdr
= section
;
4338 else if (section
->sh_type
== SHT_SYMTAB
)
4339 CHECK_ENTSIZE (section
, i
, Sym
);
4340 else if (section
->sh_type
== SHT_GROUP
)
4341 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4342 else if (section
->sh_type
== SHT_REL
)
4343 CHECK_ENTSIZE (section
, i
, Rel
);
4344 else if (section
->sh_type
== SHT_RELA
)
4345 CHECK_ENTSIZE (section
, i
, Rela
);
4346 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4347 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4348 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4349 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4350 && (const_strneq (name
, ".debug_")
4351 || const_strneq (name
, ".zdebug_")))
4354 name
+= sizeof (".zdebug_") - 1;
4356 name
+= sizeof (".debug_") - 1;
4359 || (do_debug_info
&& streq (name
, "info"))
4360 || (do_debug_info
&& streq (name
, "types"))
4361 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4362 || (do_debug_lines
&& streq (name
, "line"))
4363 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4364 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4365 || (do_debug_aranges
&& streq (name
, "aranges"))
4366 || (do_debug_ranges
&& streq (name
, "ranges"))
4367 || (do_debug_frames
&& streq (name
, "frame"))
4368 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4369 || (do_debug_str
&& streq (name
, "str"))
4370 || (do_debug_loc
&& streq (name
, "loc"))
4372 request_dump_bynumber (i
, DEBUG_DUMP
);
4374 /* Linkonce section to be combined with .debug_info at link time. */
4375 else if ((do_debugging
|| do_debug_info
)
4376 && const_strneq (name
, ".gnu.linkonce.wi."))
4377 request_dump_bynumber (i
, DEBUG_DUMP
);
4378 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4379 request_dump_bynumber (i
, DEBUG_DUMP
);
4385 if (elf_header
.e_shnum
> 1)
4386 printf (_("\nSection Headers:\n"));
4388 printf (_("\nSection Header:\n"));
4392 if (do_section_details
)
4394 printf (_(" [Nr] Name\n"));
4395 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4399 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4403 if (do_section_details
)
4405 printf (_(" [Nr] Name\n"));
4406 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4410 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4414 if (do_section_details
)
4416 printf (_(" [Nr] Name\n"));
4417 printf (_(" Type Address Offset Link\n"));
4418 printf (_(" Size EntSize Info Align\n"));
4422 printf (_(" [Nr] Name Type Address Offset\n"));
4423 printf (_(" Size EntSize Flags Link Info Align\n"));
4427 if (do_section_details
)
4428 printf (_(" Flags\n"));
4430 for (i
= 0, section
= section_headers
;
4431 i
< elf_header
.e_shnum
;
4434 if (do_section_details
)
4436 printf (" [%2u] %s\n",
4438 SECTION_NAME (section
));
4439 if (is_32bit_elf
|| do_wide
)
4440 printf (" %-15.15s ",
4441 get_section_type_name (section
->sh_type
));
4444 printf ((do_wide
? " [%2u] %-17s %-15s "
4445 : " [%2u] %-17.17s %-15.15s "),
4447 SECTION_NAME (section
),
4448 get_section_type_name (section
->sh_type
));
4452 const char * link_too_big
= NULL
;
4454 print_vma (section
->sh_addr
, LONG_HEX
);
4456 printf ( " %6.6lx %6.6lx %2.2lx",
4457 (unsigned long) section
->sh_offset
,
4458 (unsigned long) section
->sh_size
,
4459 (unsigned long) section
->sh_entsize
);
4461 if (do_section_details
)
4462 fputs (" ", stdout
);
4464 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4466 if (section
->sh_link
>= elf_header
.e_shnum
)
4469 /* The sh_link value is out of range. Normally this indicates
4470 an error but it can have special values in Solaris binaries. */
4471 switch (elf_header
.e_machine
)
4476 case EM_OLD_SPARCV9
:
4477 case EM_SPARC32PLUS
:
4480 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4481 link_too_big
= "BEFORE";
4482 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4483 link_too_big
= "AFTER";
4490 if (do_section_details
)
4492 if (link_too_big
!= NULL
&& * link_too_big
)
4493 printf ("<%s> ", link_too_big
);
4495 printf ("%2u ", section
->sh_link
);
4496 printf ("%3u %2lu\n", section
->sh_info
,
4497 (unsigned long) section
->sh_addralign
);
4500 printf ("%2u %3u %2lu\n",
4503 (unsigned long) section
->sh_addralign
);
4505 if (link_too_big
&& ! * link_too_big
)
4506 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4507 i
, section
->sh_link
);
4511 print_vma (section
->sh_addr
, LONG_HEX
);
4513 if ((long) section
->sh_offset
== section
->sh_offset
)
4514 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4518 print_vma (section
->sh_offset
, LONG_HEX
);
4521 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4522 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4526 print_vma (section
->sh_size
, LONG_HEX
);
4529 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4530 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4534 print_vma (section
->sh_entsize
, LONG_HEX
);
4537 if (do_section_details
)
4538 fputs (" ", stdout
);
4540 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4542 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4544 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4545 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4548 print_vma (section
->sh_addralign
, DEC
);
4552 else if (do_section_details
)
4554 printf (" %-15.15s ",
4555 get_section_type_name (section
->sh_type
));
4556 print_vma (section
->sh_addr
, LONG_HEX
);
4557 if ((long) section
->sh_offset
== section
->sh_offset
)
4558 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4562 print_vma (section
->sh_offset
, LONG_HEX
);
4564 printf (" %u\n ", section
->sh_link
);
4565 print_vma (section
->sh_size
, LONG_HEX
);
4567 print_vma (section
->sh_entsize
, LONG_HEX
);
4569 printf (" %-16u %lu\n",
4571 (unsigned long) section
->sh_addralign
);
4576 print_vma (section
->sh_addr
, LONG_HEX
);
4577 if ((long) section
->sh_offset
== section
->sh_offset
)
4578 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4582 print_vma (section
->sh_offset
, LONG_HEX
);
4585 print_vma (section
->sh_size
, LONG_HEX
);
4587 print_vma (section
->sh_entsize
, LONG_HEX
);
4589 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4591 printf (" %2u %3u %lu\n",
4594 (unsigned long) section
->sh_addralign
);
4597 if (do_section_details
)
4598 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4601 if (!do_section_details
)
4602 printf (_("Key to Flags:\n\
4603 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4604 I (info), L (link order), G (group), x (unknown)\n\
4605 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4611 get_group_flags (unsigned int flags
)
4613 static char buff
[32];
4620 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4627 process_section_groups (FILE * file
)
4629 Elf_Internal_Shdr
* section
;
4631 struct group
* group
;
4632 Elf_Internal_Shdr
* symtab_sec
;
4633 Elf_Internal_Shdr
* strtab_sec
;
4634 Elf_Internal_Sym
* symtab
;
4638 /* Don't process section groups unless needed. */
4639 if (!do_unwind
&& !do_section_groups
)
4642 if (elf_header
.e_shnum
== 0)
4644 if (do_section_groups
)
4645 printf (_("\nThere are no sections in this file.\n"));
4650 if (section_headers
== NULL
)
4652 error (_("Section headers are not available!\n"));
4656 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4657 sizeof (struct group
*));
4659 if (section_headers_groups
== NULL
)
4661 error (_("Out of memory\n"));
4665 /* Scan the sections for the group section. */
4667 for (i
= 0, section
= section_headers
;
4668 i
< elf_header
.e_shnum
;
4670 if (section
->sh_type
== SHT_GROUP
)
4673 if (group_count
== 0)
4675 if (do_section_groups
)
4676 printf (_("\nThere are no section groups in this file.\n"));
4681 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4683 if (section_groups
== NULL
)
4685 error (_("Out of memory\n"));
4694 for (i
= 0, section
= section_headers
, group
= section_groups
;
4695 i
< elf_header
.e_shnum
;
4698 if (section
->sh_type
== SHT_GROUP
)
4700 char * name
= SECTION_NAME (section
);
4702 unsigned char * start
;
4703 unsigned char * indices
;
4704 unsigned int entry
, j
, size
;
4705 Elf_Internal_Shdr
* sec
;
4706 Elf_Internal_Sym
* sym
;
4708 /* Get the symbol table. */
4709 if (section
->sh_link
>= elf_header
.e_shnum
4710 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4713 error (_("Bad sh_link in group section `%s'\n"), name
);
4717 if (symtab_sec
!= sec
)
4722 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4725 sym
= symtab
+ section
->sh_info
;
4727 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4729 if (sym
->st_shndx
== 0
4730 || sym
->st_shndx
>= elf_header
.e_shnum
)
4732 error (_("Bad sh_info in group section `%s'\n"), name
);
4736 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4745 /* Get the string table. */
4746 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4755 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4760 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4761 1, strtab_sec
->sh_size
,
4763 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4765 group_name
= sym
->st_name
< strtab_size
4766 ? strtab
+ sym
->st_name
: "<corrupt>";
4769 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4770 1, section
->sh_size
,
4774 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4775 entry
= byte_get (indices
, 4);
4778 if (do_section_groups
)
4780 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4781 get_group_flags (entry
), i
, name
, group_name
, size
);
4783 printf (_(" [Index] Name\n"));
4786 group
->group_index
= i
;
4788 for (j
= 0; j
< size
; j
++)
4790 struct group_list
* g
;
4792 entry
= byte_get (indices
, 4);
4795 if (entry
>= elf_header
.e_shnum
)
4797 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4798 entry
, i
, elf_header
.e_shnum
- 1);
4802 if (section_headers_groups
[entry
] != NULL
)
4806 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4808 section_headers_groups
[entry
]->group_index
);
4813 /* Intel C/C++ compiler may put section 0 in a
4814 section group. We just warn it the first time
4815 and ignore it afterwards. */
4816 static int warned
= 0;
4819 error (_("section 0 in group section [%5u]\n"),
4820 section_headers_groups
[entry
]->group_index
);
4826 section_headers_groups
[entry
] = group
;
4828 if (do_section_groups
)
4830 sec
= section_headers
+ entry
;
4831 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4834 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
4835 g
->section_index
= entry
;
4836 g
->next
= group
->root
;
4860 } dynamic_relocations
[] =
4862 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4863 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4864 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4867 /* Process the reloc section. */
4870 process_relocs (FILE * file
)
4872 unsigned long rel_size
;
4873 unsigned long rel_offset
;
4879 if (do_using_dynamic
)
4883 int has_dynamic_reloc
;
4886 has_dynamic_reloc
= 0;
4888 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4890 is_rela
= dynamic_relocations
[i
].rela
;
4891 name
= dynamic_relocations
[i
].name
;
4892 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4893 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4895 has_dynamic_reloc
|= rel_size
;
4897 if (is_rela
== UNKNOWN
)
4899 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4900 switch (dynamic_info
[DT_PLTREL
])
4914 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4915 name
, rel_offset
, rel_size
);
4917 dump_relocations (file
,
4918 offset_from_vma (file
, rel_offset
, rel_size
),
4920 dynamic_symbols
, num_dynamic_syms
,
4921 dynamic_strings
, dynamic_strings_length
, is_rela
);
4925 if (! has_dynamic_reloc
)
4926 printf (_("\nThere are no dynamic relocations in this file.\n"));
4930 Elf_Internal_Shdr
* section
;
4934 for (i
= 0, section
= section_headers
;
4935 i
< elf_header
.e_shnum
;
4938 if ( section
->sh_type
!= SHT_RELA
4939 && section
->sh_type
!= SHT_REL
)
4942 rel_offset
= section
->sh_offset
;
4943 rel_size
= section
->sh_size
;
4947 Elf_Internal_Shdr
* strsec
;
4950 printf (_("\nRelocation section "));
4952 if (string_table
== NULL
)
4953 printf ("%d", section
->sh_name
);
4955 printf (_("'%s'"), SECTION_NAME (section
));
4957 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4958 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4960 is_rela
= section
->sh_type
== SHT_RELA
;
4962 if (section
->sh_link
!= 0
4963 && section
->sh_link
< elf_header
.e_shnum
)
4965 Elf_Internal_Shdr
* symsec
;
4966 Elf_Internal_Sym
* symtab
;
4967 unsigned long nsyms
;
4968 unsigned long strtablen
= 0;
4969 char * strtab
= NULL
;
4971 symsec
= section_headers
+ section
->sh_link
;
4972 if (symsec
->sh_type
!= SHT_SYMTAB
4973 && symsec
->sh_type
!= SHT_DYNSYM
)
4976 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4977 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4982 if (symsec
->sh_link
!= 0
4983 && symsec
->sh_link
< elf_header
.e_shnum
)
4985 strsec
= section_headers
+ symsec
->sh_link
;
4987 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4990 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4993 dump_relocations (file
, rel_offset
, rel_size
,
4994 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5000 dump_relocations (file
, rel_offset
, rel_size
,
5001 NULL
, 0, NULL
, 0, is_rela
);
5008 printf (_("\nThere are no relocations in this file.\n"));
5014 /* Process the unwind section. */
5016 #include "unwind-ia64.h"
5018 /* An absolute address consists of a section and an offset. If the
5019 section is NULL, the offset itself is the address, otherwise, the
5020 address equals to LOAD_ADDRESS(section) + offset. */
5024 unsigned short section
;
5028 #define ABSADDR(a) \
5030 ? section_headers [(a).section].sh_addr + (a).offset \
5033 struct ia64_unw_table_entry
5035 struct absaddr start
;
5037 struct absaddr info
;
5040 struct ia64_unw_aux_info
5043 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5044 unsigned long table_len
; /* Length of unwind table. */
5045 unsigned char * info
; /* Unwind info. */
5046 unsigned long info_size
; /* Size of unwind info. */
5047 bfd_vma info_addr
; /* starting address of unwind info. */
5048 bfd_vma seg_base
; /* Starting address of segment. */
5049 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5050 unsigned long nsyms
; /* Number of symbols. */
5051 char * strtab
; /* The string table. */
5052 unsigned long strtab_size
; /* Size of string table. */
5056 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5057 unsigned long nsyms
,
5058 const char * strtab
,
5059 unsigned long strtab_size
,
5060 struct absaddr addr
,
5061 const char ** symname
,
5064 bfd_vma dist
= 0x100000;
5065 Elf_Internal_Sym
* sym
;
5066 Elf_Internal_Sym
* best
= NULL
;
5069 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5071 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5072 && sym
->st_name
!= 0
5073 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5074 && addr
.offset
>= sym
->st_value
5075 && addr
.offset
- sym
->st_value
< dist
)
5078 dist
= addr
.offset
- sym
->st_value
;
5085 *symname
= (best
->st_name
>= strtab_size
5086 ? "<corrupt>" : strtab
+ best
->st_name
);
5091 *offset
= addr
.offset
;
5095 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5097 struct ia64_unw_table_entry
* tp
;
5100 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5104 const unsigned char * dp
;
5105 const unsigned char * head
;
5106 const char * procname
;
5108 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5109 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5111 fputs ("\n<", stdout
);
5115 fputs (procname
, stdout
);
5118 printf ("+%lx", (unsigned long) offset
);
5121 fputs (">: [", stdout
);
5122 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5123 fputc ('-', stdout
);
5124 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5125 printf ("], info at +0x%lx\n",
5126 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5128 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5129 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5131 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5132 (unsigned) UNW_VER (stamp
),
5133 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5134 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5135 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5136 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5138 if (UNW_VER (stamp
) != 1)
5140 printf ("\tUnknown version.\n");
5145 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5146 dp
= unw_decode (dp
, in_body
, & in_body
);
5151 slurp_ia64_unwind_table (FILE * file
,
5152 struct ia64_unw_aux_info
* aux
,
5153 Elf_Internal_Shdr
* sec
)
5155 unsigned long size
, nrelas
, i
;
5156 Elf_Internal_Phdr
* seg
;
5157 struct ia64_unw_table_entry
* tep
;
5158 Elf_Internal_Shdr
* relsec
;
5159 Elf_Internal_Rela
* rela
;
5160 Elf_Internal_Rela
* rp
;
5161 unsigned char * table
;
5163 Elf_Internal_Sym
* sym
;
5164 const char * relname
;
5166 /* First, find the starting address of the segment that includes
5169 if (elf_header
.e_phnum
)
5171 if (! get_program_headers (file
))
5174 for (seg
= program_headers
;
5175 seg
< program_headers
+ elf_header
.e_phnum
;
5178 if (seg
->p_type
!= PT_LOAD
)
5181 if (sec
->sh_addr
>= seg
->p_vaddr
5182 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5184 aux
->seg_base
= seg
->p_vaddr
;
5190 /* Second, build the unwind table from the contents of the unwind section: */
5191 size
= sec
->sh_size
;
5192 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5197 aux
->table
= (struct ia64_unw_table_entry
*)
5198 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5200 for (tp
= table
; tp
< table
+ size
; ++tep
)
5202 tep
->start
.section
= SHN_UNDEF
;
5203 tep
->end
.section
= SHN_UNDEF
;
5204 tep
->info
.section
= SHN_UNDEF
;
5205 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5206 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5207 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5208 tep
->start
.offset
+= aux
->seg_base
;
5209 tep
->end
.offset
+= aux
->seg_base
;
5210 tep
->info
.offset
+= aux
->seg_base
;
5214 /* Third, apply any relocations to the unwind table: */
5215 for (relsec
= section_headers
;
5216 relsec
< section_headers
+ elf_header
.e_shnum
;
5219 if (relsec
->sh_type
!= SHT_RELA
5220 || relsec
->sh_info
>= elf_header
.e_shnum
5221 || section_headers
+ relsec
->sh_info
!= sec
)
5224 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5228 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5230 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5231 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5233 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5235 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5239 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5241 switch (rp
->r_offset
/eh_addr_size
% 3)
5244 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5245 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5248 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5249 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5252 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5253 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5263 aux
->table_len
= size
/ (3 * eh_addr_size
);
5268 ia64_process_unwind (FILE * file
)
5270 Elf_Internal_Shdr
* sec
;
5271 Elf_Internal_Shdr
* unwsec
= NULL
;
5272 Elf_Internal_Shdr
* strsec
;
5273 unsigned long i
, unwcount
= 0, unwstart
= 0;
5274 struct ia64_unw_aux_info aux
;
5276 memset (& aux
, 0, sizeof (aux
));
5278 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5280 if (sec
->sh_type
== SHT_SYMTAB
5281 && sec
->sh_link
< elf_header
.e_shnum
)
5283 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5284 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5286 strsec
= section_headers
+ sec
->sh_link
;
5287 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5290 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5292 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5297 printf (_("\nThere are no unwind sections in this file.\n"));
5299 while (unwcount
-- > 0)
5304 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5305 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5306 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5313 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5315 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5317 /* We need to find which section group it is in. */
5318 struct group_list
* g
= section_headers_groups
[i
]->root
;
5320 for (; g
!= NULL
; g
= g
->next
)
5322 sec
= section_headers
+ g
->section_index
;
5324 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5329 i
= elf_header
.e_shnum
;
5331 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5333 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5334 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5335 suffix
= SECTION_NAME (unwsec
) + len
;
5336 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5338 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5339 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5344 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5345 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5346 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5347 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5349 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5350 suffix
= SECTION_NAME (unwsec
) + len
;
5351 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5353 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5354 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5358 if (i
== elf_header
.e_shnum
)
5360 printf (_("\nCould not find unwind info section for "));
5362 if (string_table
== NULL
)
5363 printf ("%d", unwsec
->sh_name
);
5365 printf (_("'%s'"), SECTION_NAME (unwsec
));
5369 aux
.info_size
= sec
->sh_size
;
5370 aux
.info_addr
= sec
->sh_addr
;
5371 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5375 printf (_("\nUnwind section "));
5377 if (string_table
== NULL
)
5378 printf ("%d", unwsec
->sh_name
);
5380 printf (_("'%s'"), SECTION_NAME (unwsec
));
5382 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5383 (unsigned long) unwsec
->sh_offset
,
5384 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5386 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5388 if (aux
.table_len
> 0)
5389 dump_ia64_unwind (& aux
);
5392 free ((char *) aux
.table
);
5394 free ((char *) aux
.info
);
5403 free ((char *) aux
.strtab
);
5408 struct hppa_unw_table_entry
5410 struct absaddr start
;
5412 unsigned int Cannot_unwind
:1; /* 0 */
5413 unsigned int Millicode
:1; /* 1 */
5414 unsigned int Millicode_save_sr0
:1; /* 2 */
5415 unsigned int Region_description
:2; /* 3..4 */
5416 unsigned int reserved1
:1; /* 5 */
5417 unsigned int Entry_SR
:1; /* 6 */
5418 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5419 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5420 unsigned int Args_stored
:1; /* 16 */
5421 unsigned int Variable_Frame
:1; /* 17 */
5422 unsigned int Separate_Package_Body
:1; /* 18 */
5423 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5424 unsigned int Stack_Overflow_Check
:1; /* 20 */
5425 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5426 unsigned int Ada_Region
:1; /* 22 */
5427 unsigned int cxx_info
:1; /* 23 */
5428 unsigned int cxx_try_catch
:1; /* 24 */
5429 unsigned int sched_entry_seq
:1; /* 25 */
5430 unsigned int reserved2
:1; /* 26 */
5431 unsigned int Save_SP
:1; /* 27 */
5432 unsigned int Save_RP
:1; /* 28 */
5433 unsigned int Save_MRP_in_frame
:1; /* 29 */
5434 unsigned int extn_ptr_defined
:1; /* 30 */
5435 unsigned int Cleanup_defined
:1; /* 31 */
5437 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5438 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5439 unsigned int Large_frame
:1; /* 2 */
5440 unsigned int Pseudo_SP_Set
:1; /* 3 */
5441 unsigned int reserved4
:1; /* 4 */
5442 unsigned int Total_frame_size
:27; /* 5..31 */
5445 struct hppa_unw_aux_info
5447 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5448 unsigned long table_len
; /* Length of unwind table. */
5449 bfd_vma seg_base
; /* Starting address of segment. */
5450 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5451 unsigned long nsyms
; /* Number of symbols. */
5452 char * strtab
; /* The string table. */
5453 unsigned long strtab_size
; /* Size of string table. */
5457 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5459 struct hppa_unw_table_entry
* tp
;
5461 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5464 const char * procname
;
5466 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5467 aux
->strtab_size
, tp
->start
, &procname
,
5470 fputs ("\n<", stdout
);
5474 fputs (procname
, stdout
);
5477 printf ("+%lx", (unsigned long) offset
);
5480 fputs (">: [", stdout
);
5481 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5482 fputc ('-', stdout
);
5483 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5486 #define PF(_m) if (tp->_m) printf (#_m " ");
5487 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5490 PF(Millicode_save_sr0
);
5491 /* PV(Region_description); */
5497 PF(Separate_Package_Body
);
5498 PF(Frame_Extension_Millicode
);
5499 PF(Stack_Overflow_Check
);
5500 PF(Two_Instruction_SP_Increment
);
5504 PF(sched_entry_seq
);
5507 PF(Save_MRP_in_frame
);
5508 PF(extn_ptr_defined
);
5509 PF(Cleanup_defined
);
5510 PF(MPE_XL_interrupt_marker
);
5511 PF(HP_UX_interrupt_marker
);
5514 PV(Total_frame_size
);
5523 slurp_hppa_unwind_table (FILE * file
,
5524 struct hppa_unw_aux_info
* aux
,
5525 Elf_Internal_Shdr
* sec
)
5527 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5528 Elf_Internal_Phdr
* seg
;
5529 struct hppa_unw_table_entry
* tep
;
5530 Elf_Internal_Shdr
* relsec
;
5531 Elf_Internal_Rela
* rela
;
5532 Elf_Internal_Rela
* rp
;
5533 unsigned char * table
;
5535 Elf_Internal_Sym
* sym
;
5536 const char * relname
;
5538 /* First, find the starting address of the segment that includes
5541 if (elf_header
.e_phnum
)
5543 if (! get_program_headers (file
))
5546 for (seg
= program_headers
;
5547 seg
< program_headers
+ elf_header
.e_phnum
;
5550 if (seg
->p_type
!= PT_LOAD
)
5553 if (sec
->sh_addr
>= seg
->p_vaddr
5554 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5556 aux
->seg_base
= seg
->p_vaddr
;
5562 /* Second, build the unwind table from the contents of the unwind
5564 size
= sec
->sh_size
;
5565 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5571 nentries
= size
/ unw_ent_size
;
5572 size
= unw_ent_size
* nentries
;
5574 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5575 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5577 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5579 unsigned int tmp1
, tmp2
;
5581 tep
->start
.section
= SHN_UNDEF
;
5582 tep
->end
.section
= SHN_UNDEF
;
5584 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5585 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5586 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5587 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5589 tep
->start
.offset
+= aux
->seg_base
;
5590 tep
->end
.offset
+= aux
->seg_base
;
5592 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5593 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5594 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5595 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5596 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5597 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5598 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5599 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5600 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5601 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5602 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5603 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5604 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5605 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5606 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5607 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5608 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5609 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5610 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5611 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5612 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5613 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5614 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5615 tep
->Cleanup_defined
= tmp1
& 0x1;
5617 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5618 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5619 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5620 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5621 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5622 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5626 /* Third, apply any relocations to the unwind table. */
5627 for (relsec
= section_headers
;
5628 relsec
< section_headers
+ elf_header
.e_shnum
;
5631 if (relsec
->sh_type
!= SHT_RELA
5632 || relsec
->sh_info
>= elf_header
.e_shnum
5633 || section_headers
+ relsec
->sh_info
!= sec
)
5636 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5640 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5642 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5643 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5645 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5646 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5648 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5652 i
= rp
->r_offset
/ unw_ent_size
;
5654 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5657 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5658 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
5661 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5662 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
5672 aux
->table_len
= nentries
;
5678 hppa_process_unwind (FILE * file
)
5680 struct hppa_unw_aux_info aux
;
5681 Elf_Internal_Shdr
* unwsec
= NULL
;
5682 Elf_Internal_Shdr
* strsec
;
5683 Elf_Internal_Shdr
* sec
;
5686 memset (& aux
, 0, sizeof (aux
));
5688 if (string_table
== NULL
)
5691 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5693 if (sec
->sh_type
== SHT_SYMTAB
5694 && sec
->sh_link
< elf_header
.e_shnum
)
5696 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5697 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5699 strsec
= section_headers
+ sec
->sh_link
;
5700 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5703 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5705 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5710 printf (_("\nThere are no unwind sections in this file.\n"));
5712 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5714 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5716 printf (_("\nUnwind section "));
5717 printf (_("'%s'"), SECTION_NAME (sec
));
5719 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5720 (unsigned long) sec
->sh_offset
,
5721 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5723 slurp_hppa_unwind_table (file
, &aux
, sec
);
5724 if (aux
.table_len
> 0)
5725 dump_hppa_unwind (&aux
);
5728 free ((char *) aux
.table
);
5736 free ((char *) aux
.strtab
);
5742 process_unwind (FILE * file
)
5744 struct unwind_handler
5747 int (* handler
)(FILE *);
5750 { EM_IA_64
, ia64_process_unwind
},
5751 { EM_PARISC
, hppa_process_unwind
},
5759 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5760 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5761 return handlers
[i
].handler (file
);
5763 printf (_("\nThere are no unwind sections in this file.\n"));
5768 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5770 switch (entry
->d_tag
)
5773 if (entry
->d_un
.d_val
== 0)
5777 static const char * opts
[] =
5779 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5780 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5781 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5782 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5787 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5788 if (entry
->d_un
.d_val
& (1 << cnt
))
5790 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5797 case DT_MIPS_IVERSION
:
5798 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5799 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5801 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5804 case DT_MIPS_TIME_STAMP
:
5809 time_t atime
= entry
->d_un
.d_val
;
5810 tmp
= gmtime (&atime
);
5811 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5812 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5813 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5814 printf ("Time Stamp: %s\n", timebuf
);
5818 case DT_MIPS_RLD_VERSION
:
5819 case DT_MIPS_LOCAL_GOTNO
:
5820 case DT_MIPS_CONFLICTNO
:
5821 case DT_MIPS_LIBLISTNO
:
5822 case DT_MIPS_SYMTABNO
:
5823 case DT_MIPS_UNREFEXTNO
:
5824 case DT_MIPS_HIPAGENO
:
5825 case DT_MIPS_DELTA_CLASS_NO
:
5826 case DT_MIPS_DELTA_INSTANCE_NO
:
5827 case DT_MIPS_DELTA_RELOC_NO
:
5828 case DT_MIPS_DELTA_SYM_NO
:
5829 case DT_MIPS_DELTA_CLASSSYM_NO
:
5830 case DT_MIPS_COMPACT_SIZE
:
5831 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5835 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5841 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5843 switch (entry
->d_tag
)
5845 case DT_HP_DLD_FLAGS
:
5854 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5855 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5856 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5857 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5858 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5859 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5860 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5861 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5862 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5863 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5864 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5865 { DT_HP_GST
, "HP_GST" },
5866 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5867 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5868 { DT_HP_NODELETE
, "HP_NODELETE" },
5869 { DT_HP_GROUP
, "HP_GROUP" },
5870 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5874 bfd_vma val
= entry
->d_un
.d_val
;
5876 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5877 if (val
& flags
[cnt
].bit
)
5881 fputs (flags
[cnt
].str
, stdout
);
5883 val
^= flags
[cnt
].bit
;
5886 if (val
!= 0 || first
)
5890 print_vma (val
, HEX
);
5896 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5903 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5905 switch (entry
->d_tag
)
5907 case DT_IA_64_PLT_RESERVE
:
5908 /* First 3 slots reserved. */
5909 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5911 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5915 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5922 get_32bit_dynamic_section (FILE * file
)
5924 Elf32_External_Dyn
* edyn
;
5925 Elf32_External_Dyn
* ext
;
5926 Elf_Internal_Dyn
* entry
;
5928 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5929 dynamic_size
, _("dynamic section"));
5933 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5934 might not have the luxury of section headers. Look for the DT_NULL
5935 terminator to determine the number of entries. */
5936 for (ext
= edyn
, dynamic_nent
= 0;
5937 (char *) ext
< (char *) edyn
+ dynamic_size
;
5941 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5945 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5947 if (dynamic_section
== NULL
)
5949 error (_("Out of memory\n"));
5954 for (ext
= edyn
, entry
= dynamic_section
;
5955 entry
< dynamic_section
+ dynamic_nent
;
5958 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5959 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5968 get_64bit_dynamic_section (FILE * file
)
5970 Elf64_External_Dyn
* edyn
;
5971 Elf64_External_Dyn
* ext
;
5972 Elf_Internal_Dyn
* entry
;
5974 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5975 dynamic_size
, _("dynamic section"));
5979 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5980 might not have the luxury of section headers. Look for the DT_NULL
5981 terminator to determine the number of entries. */
5982 for (ext
= edyn
, dynamic_nent
= 0;
5983 (char *) ext
< (char *) edyn
+ dynamic_size
;
5987 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5991 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5993 if (dynamic_section
== NULL
)
5995 error (_("Out of memory\n"));
6000 for (ext
= edyn
, entry
= dynamic_section
;
6001 entry
< dynamic_section
+ dynamic_nent
;
6004 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6005 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6014 print_dynamic_flags (bfd_vma flags
)
6022 flag
= flags
& - flags
;
6032 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6033 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6034 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6035 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6036 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6037 default: fputs ("unknown", stdout
); break;
6043 /* Parse and display the contents of the dynamic section. */
6046 process_dynamic_section (FILE * file
)
6048 Elf_Internal_Dyn
* entry
;
6050 if (dynamic_size
== 0)
6053 printf (_("\nThere is no dynamic section in this file.\n"));
6060 if (! get_32bit_dynamic_section (file
))
6063 else if (! get_64bit_dynamic_section (file
))
6066 /* Find the appropriate symbol table. */
6067 if (dynamic_symbols
== NULL
)
6069 for (entry
= dynamic_section
;
6070 entry
< dynamic_section
+ dynamic_nent
;
6073 Elf_Internal_Shdr section
;
6075 if (entry
->d_tag
!= DT_SYMTAB
)
6078 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6080 /* Since we do not know how big the symbol table is,
6081 we default to reading in the entire file (!) and
6082 processing that. This is overkill, I know, but it
6084 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6086 if (archive_file_offset
!= 0)
6087 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6090 if (fseek (file
, 0, SEEK_END
))
6091 error (_("Unable to seek to end of file!\n"));
6093 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6097 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6099 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6101 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6102 if (num_dynamic_syms
< 1)
6104 error (_("Unable to determine the number of symbols to load\n"));
6108 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6112 /* Similarly find a string table. */
6113 if (dynamic_strings
== NULL
)
6115 for (entry
= dynamic_section
;
6116 entry
< dynamic_section
+ dynamic_nent
;
6119 unsigned long offset
;
6122 if (entry
->d_tag
!= DT_STRTAB
)
6125 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6127 /* Since we do not know how big the string table is,
6128 we default to reading in the entire file (!) and
6129 processing that. This is overkill, I know, but it
6132 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6134 if (archive_file_offset
!= 0)
6135 str_tab_len
= archive_file_size
- offset
;
6138 if (fseek (file
, 0, SEEK_END
))
6139 error (_("Unable to seek to end of file\n"));
6140 str_tab_len
= ftell (file
) - offset
;
6143 if (str_tab_len
< 1)
6146 (_("Unable to determine the length of the dynamic string table\n"));
6150 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6152 _("dynamic string table"));
6153 dynamic_strings_length
= str_tab_len
;
6158 /* And find the syminfo section if available. */
6159 if (dynamic_syminfo
== NULL
)
6161 unsigned long syminsz
= 0;
6163 for (entry
= dynamic_section
;
6164 entry
< dynamic_section
+ dynamic_nent
;
6167 if (entry
->d_tag
== DT_SYMINENT
)
6169 /* Note: these braces are necessary to avoid a syntax
6170 error from the SunOS4 C compiler. */
6171 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6173 else if (entry
->d_tag
== DT_SYMINSZ
)
6174 syminsz
= entry
->d_un
.d_val
;
6175 else if (entry
->d_tag
== DT_SYMINFO
)
6176 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6180 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6182 Elf_External_Syminfo
* extsyminfo
;
6183 Elf_External_Syminfo
* extsym
;
6184 Elf_Internal_Syminfo
* syminfo
;
6186 /* There is a syminfo section. Read the data. */
6187 extsyminfo
= (Elf_External_Syminfo
*)
6188 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6189 _("symbol information"));
6193 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6194 if (dynamic_syminfo
== NULL
)
6196 error (_("Out of memory\n"));
6200 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6201 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6202 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6203 ++syminfo
, ++extsym
)
6205 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6206 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6213 if (do_dynamic
&& dynamic_addr
)
6214 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6215 dynamic_addr
, dynamic_nent
);
6217 printf (_(" Tag Type Name/Value\n"));
6219 for (entry
= dynamic_section
;
6220 entry
< dynamic_section
+ dynamic_nent
;
6228 print_vma (entry
->d_tag
, FULL_HEX
);
6229 dtype
= get_dynamic_type (entry
->d_tag
);
6230 printf (" (%s)%*s", dtype
,
6231 ((is_32bit_elf
? 27 : 19)
6232 - (int) strlen (dtype
)),
6236 switch (entry
->d_tag
)
6240 print_dynamic_flags (entry
->d_un
.d_val
);
6250 switch (entry
->d_tag
)
6253 printf (_("Auxiliary library"));
6257 printf (_("Filter library"));
6261 printf (_("Configuration file"));
6265 printf (_("Dependency audit library"));
6269 printf (_("Audit library"));
6273 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6274 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6278 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6287 printf (_("Flags:"));
6289 if (entry
->d_un
.d_val
== 0)
6290 printf (_(" None\n"));
6293 unsigned long int val
= entry
->d_un
.d_val
;
6295 if (val
& DTF_1_PARINIT
)
6297 printf (" PARINIT");
6298 val
^= DTF_1_PARINIT
;
6300 if (val
& DTF_1_CONFEXP
)
6302 printf (" CONFEXP");
6303 val
^= DTF_1_CONFEXP
;
6306 printf (" %lx", val
);
6315 printf (_("Flags:"));
6317 if (entry
->d_un
.d_val
== 0)
6318 printf (_(" None\n"));
6321 unsigned long int val
= entry
->d_un
.d_val
;
6323 if (val
& DF_P1_LAZYLOAD
)
6325 printf (" LAZYLOAD");
6326 val
^= DF_P1_LAZYLOAD
;
6328 if (val
& DF_P1_GROUPPERM
)
6330 printf (" GROUPPERM");
6331 val
^= DF_P1_GROUPPERM
;
6334 printf (" %lx", val
);
6343 printf (_("Flags:"));
6344 if (entry
->d_un
.d_val
== 0)
6345 printf (_(" None\n"));
6348 unsigned long int val
= entry
->d_un
.d_val
;
6355 if (val
& DF_1_GLOBAL
)
6360 if (val
& DF_1_GROUP
)
6365 if (val
& DF_1_NODELETE
)
6367 printf (" NODELETE");
6368 val
^= DF_1_NODELETE
;
6370 if (val
& DF_1_LOADFLTR
)
6372 printf (" LOADFLTR");
6373 val
^= DF_1_LOADFLTR
;
6375 if (val
& DF_1_INITFIRST
)
6377 printf (" INITFIRST");
6378 val
^= DF_1_INITFIRST
;
6380 if (val
& DF_1_NOOPEN
)
6385 if (val
& DF_1_ORIGIN
)
6390 if (val
& DF_1_DIRECT
)
6395 if (val
& DF_1_TRANS
)
6400 if (val
& DF_1_INTERPOSE
)
6402 printf (" INTERPOSE");
6403 val
^= DF_1_INTERPOSE
;
6405 if (val
& DF_1_NODEFLIB
)
6407 printf (" NODEFLIB");
6408 val
^= DF_1_NODEFLIB
;
6410 if (val
& DF_1_NODUMP
)
6415 if (val
& DF_1_CONLFAT
)
6417 printf (" CONLFAT");
6418 val
^= DF_1_CONLFAT
;
6421 printf (" %lx", val
);
6428 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6430 puts (get_dynamic_type (entry
->d_un
.d_val
));
6450 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6456 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6457 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6463 switch (entry
->d_tag
)
6466 printf (_("Shared library: [%s]"), name
);
6468 if (streq (name
, program_interpreter
))
6469 printf (_(" program interpreter"));
6473 printf (_("Library soname: [%s]"), name
);
6477 printf (_("Library rpath: [%s]"), name
);
6481 printf (_("Library runpath: [%s]"), name
);
6485 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6490 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6503 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6507 case DT_INIT_ARRAYSZ
:
6508 case DT_FINI_ARRAYSZ
:
6509 case DT_GNU_CONFLICTSZ
:
6510 case DT_GNU_LIBLISTSZ
:
6513 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6514 printf (" (bytes)\n");
6524 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6537 if (entry
->d_tag
== DT_USED
6538 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6540 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6544 printf (_("Not needed object: [%s]\n"), name
);
6549 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6555 /* The value of this entry is ignored. */
6560 case DT_GNU_PRELINKED
:
6564 time_t atime
= entry
->d_un
.d_val
;
6566 tmp
= gmtime (&atime
);
6567 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6568 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6569 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6575 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6578 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6584 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6585 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6590 switch (elf_header
.e_machine
)
6593 case EM_MIPS_RS3_LE
:
6594 dynamic_section_mips_val (entry
);
6597 dynamic_section_parisc_val (entry
);
6600 dynamic_section_ia64_val (entry
);
6603 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6615 get_ver_flags (unsigned int flags
)
6617 static char buff
[32];
6624 if (flags
& VER_FLG_BASE
)
6625 strcat (buff
, "BASE ");
6627 if (flags
& VER_FLG_WEAK
)
6629 if (flags
& VER_FLG_BASE
)
6630 strcat (buff
, "| ");
6632 strcat (buff
, "WEAK ");
6635 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6636 strcat (buff
, "| <unknown>");
6641 /* Display the contents of the version sections. */
6644 process_version_sections (FILE * file
)
6646 Elf_Internal_Shdr
* section
;
6653 for (i
= 0, section
= section_headers
;
6654 i
< elf_header
.e_shnum
;
6657 switch (section
->sh_type
)
6659 case SHT_GNU_verdef
:
6661 Elf_External_Verdef
* edefs
;
6669 (_("\nVersion definition section '%s' contains %u entries:\n"),
6670 SECTION_NAME (section
), section
->sh_info
);
6672 printf (_(" Addr: 0x"));
6673 printf_vma (section
->sh_addr
);
6674 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6675 (unsigned long) section
->sh_offset
, section
->sh_link
,
6676 section
->sh_link
< elf_header
.e_shnum
6677 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6680 edefs
= (Elf_External_Verdef
*)
6681 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
6682 _("version definition section"));
6683 endbuf
= (char *) edefs
+ section
->sh_size
;
6687 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6690 Elf_External_Verdef
* edef
;
6691 Elf_Internal_Verdef ent
;
6692 Elf_External_Verdaux
* eaux
;
6693 Elf_Internal_Verdaux aux
;
6697 vstart
= ((char *) edefs
) + idx
;
6698 if (vstart
+ sizeof (*edef
) > endbuf
)
6701 edef
= (Elf_External_Verdef
*) vstart
;
6703 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6704 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6705 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6706 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6707 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6708 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6709 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6711 printf (_(" %#06x: Rev: %d Flags: %s"),
6712 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6714 printf (_(" Index: %d Cnt: %d "),
6715 ent
.vd_ndx
, ent
.vd_cnt
);
6717 vstart
+= ent
.vd_aux
;
6719 eaux
= (Elf_External_Verdaux
*) vstart
;
6721 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6722 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6724 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6725 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6727 printf (_("Name index: %ld\n"), aux
.vda_name
);
6729 isum
= idx
+ ent
.vd_aux
;
6731 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6733 isum
+= aux
.vda_next
;
6734 vstart
+= aux
.vda_next
;
6736 eaux
= (Elf_External_Verdaux
*) vstart
;
6737 if (vstart
+ sizeof (*eaux
) > endbuf
)
6740 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6741 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6743 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6744 printf (_(" %#06x: Parent %d: %s\n"),
6745 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6747 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6748 isum
, j
, aux
.vda_name
);
6751 printf (_(" Version def aux past end of section\n"));
6755 if (cnt
< section
->sh_info
)
6756 printf (_(" Version definition past end of section\n"));
6762 case SHT_GNU_verneed
:
6764 Elf_External_Verneed
* eneed
;
6771 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6772 SECTION_NAME (section
), section
->sh_info
);
6774 printf (_(" Addr: 0x"));
6775 printf_vma (section
->sh_addr
);
6776 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6777 (unsigned long) section
->sh_offset
, section
->sh_link
,
6778 section
->sh_link
< elf_header
.e_shnum
6779 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6782 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
6783 section
->sh_offset
, 1,
6785 _("version need section"));
6786 endbuf
= (char *) eneed
+ section
->sh_size
;
6790 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6792 Elf_External_Verneed
* entry
;
6793 Elf_Internal_Verneed ent
;
6798 vstart
= ((char *) eneed
) + idx
;
6799 if (vstart
+ sizeof (*entry
) > endbuf
)
6802 entry
= (Elf_External_Verneed
*) vstart
;
6804 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6805 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6806 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6807 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6808 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6810 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6812 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6813 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6815 printf (_(" File: %lx"), ent
.vn_file
);
6817 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6819 vstart
+= ent
.vn_aux
;
6821 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6823 Elf_External_Vernaux
* eaux
;
6824 Elf_Internal_Vernaux aux
;
6826 if (vstart
+ sizeof (*eaux
) > endbuf
)
6828 eaux
= (Elf_External_Vernaux
*) vstart
;
6830 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6831 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6832 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6833 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6834 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6836 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6837 printf (_(" %#06x: Name: %s"),
6838 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6840 printf (_(" %#06x: Name index: %lx"),
6841 isum
, aux
.vna_name
);
6843 printf (_(" Flags: %s Version: %d\n"),
6844 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6846 isum
+= aux
.vna_next
;
6847 vstart
+= aux
.vna_next
;
6850 printf (_(" Version need aux past end of section\n"));
6854 if (cnt
< section
->sh_info
)
6855 printf (_(" Version need past end of section\n"));
6861 case SHT_GNU_versym
:
6863 Elf_Internal_Shdr
* link_section
;
6866 unsigned char * edata
;
6867 unsigned short * data
;
6869 Elf_Internal_Sym
* symbols
;
6870 Elf_Internal_Shdr
* string_sec
;
6873 if (section
->sh_link
>= elf_header
.e_shnum
)
6876 link_section
= section_headers
+ section
->sh_link
;
6877 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6879 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6884 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6886 string_sec
= section_headers
+ link_section
->sh_link
;
6888 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6889 string_sec
->sh_size
,
6890 _("version string table"));
6894 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6895 SECTION_NAME (section
), total
);
6897 printf (_(" Addr: "));
6898 printf_vma (section
->sh_addr
);
6899 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6900 (unsigned long) section
->sh_offset
, section
->sh_link
,
6901 SECTION_NAME (link_section
));
6903 off
= offset_from_vma (file
,
6904 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6905 total
* sizeof (short));
6906 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
6908 _("version symbol data"));
6915 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
6917 for (cnt
= total
; cnt
--;)
6918 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6923 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6926 int check_def
, check_need
;
6929 printf (" %03x:", cnt
);
6931 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6932 switch (data
[cnt
+ j
])
6935 fputs (_(" 0 (*local*) "), stdout
);
6939 fputs (_(" 1 (*global*) "), stdout
);
6943 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
6944 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
6948 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6949 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6952 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6959 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6961 Elf_Internal_Verneed ivn
;
6962 unsigned long offset
;
6964 offset
= offset_from_vma
6965 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6966 sizeof (Elf_External_Verneed
));
6970 Elf_Internal_Vernaux ivna
;
6971 Elf_External_Verneed evn
;
6972 Elf_External_Vernaux evna
;
6973 unsigned long a_off
;
6975 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6978 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6979 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6981 a_off
= offset
+ ivn
.vn_aux
;
6985 get_data (&evna
, file
, a_off
, sizeof (evna
),
6986 1, _("version need aux (2)"));
6988 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6989 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6991 a_off
+= ivna
.vna_next
;
6993 while (ivna
.vna_other
!= data
[cnt
+ j
]
6994 && ivna
.vna_next
!= 0);
6996 if (ivna
.vna_other
== data
[cnt
+ j
])
6998 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7000 if (ivna
.vna_name
>= string_sec
->sh_size
)
7001 name
= _("*invalid*");
7003 name
= strtab
+ ivna
.vna_name
;
7004 nn
+= printf ("(%s%-*s",
7006 12 - (int) strlen (name
),
7012 offset
+= ivn
.vn_next
;
7014 while (ivn
.vn_next
);
7017 if (check_def
&& data
[cnt
+ j
] != 0x8001
7018 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7020 Elf_Internal_Verdef ivd
;
7021 Elf_External_Verdef evd
;
7022 unsigned long offset
;
7024 offset
= offset_from_vma
7025 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7030 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
7033 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7034 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7036 offset
+= ivd
.vd_next
;
7038 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
7039 && ivd
.vd_next
!= 0);
7041 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
7043 Elf_External_Verdaux evda
;
7044 Elf_Internal_Verdaux ivda
;
7046 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7048 get_data (&evda
, file
,
7049 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7051 _("version def aux"));
7053 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7055 if (ivda
.vda_name
>= string_sec
->sh_size
)
7056 name
= _("*invalid*");
7058 name
= strtab
+ ivda
.vda_name
;
7059 nn
+= printf ("(%s%-*s",
7061 12 - (int) strlen (name
),
7067 printf ("%*c", 18 - nn
, ' ');
7085 printf (_("\nNo version information found in this file.\n"));
7091 get_symbol_binding (unsigned int binding
)
7093 static char buff
[32];
7097 case STB_LOCAL
: return "LOCAL";
7098 case STB_GLOBAL
: return "GLOBAL";
7099 case STB_WEAK
: return "WEAK";
7101 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7102 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7104 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7106 if (binding
== STB_GNU_UNIQUE
7107 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7108 /* GNU/Linux is still using the default value 0. */
7109 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7111 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7114 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7120 get_symbol_type (unsigned int type
)
7122 static char buff
[32];
7126 case STT_NOTYPE
: return "NOTYPE";
7127 case STT_OBJECT
: return "OBJECT";
7128 case STT_FUNC
: return "FUNC";
7129 case STT_SECTION
: return "SECTION";
7130 case STT_FILE
: return "FILE";
7131 case STT_COMMON
: return "COMMON";
7132 case STT_TLS
: return "TLS";
7133 case STT_RELC
: return "RELC";
7134 case STT_SRELC
: return "SRELC";
7136 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7138 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7139 return "THUMB_FUNC";
7141 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7144 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7145 return "PARISC_MILLI";
7147 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7149 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7151 if (elf_header
.e_machine
== EM_PARISC
)
7153 if (type
== STT_HP_OPAQUE
)
7155 if (type
== STT_HP_STUB
)
7159 if (type
== STT_GNU_IFUNC
7160 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7161 /* GNU/Linux is still using the default value 0. */
7162 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7165 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7168 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7174 get_symbol_visibility (unsigned int visibility
)
7178 case STV_DEFAULT
: return "DEFAULT";
7179 case STV_INTERNAL
: return "INTERNAL";
7180 case STV_HIDDEN
: return "HIDDEN";
7181 case STV_PROTECTED
: return "PROTECTED";
7187 get_mips_symbol_other (unsigned int other
)
7191 case STO_OPTIONAL
: return "OPTIONAL";
7192 case STO_MIPS16
: return "MIPS16";
7193 case STO_MIPS_PLT
: return "MIPS PLT";
7194 case STO_MIPS_PIC
: return "MIPS PIC";
7195 default: return NULL
;
7200 get_symbol_other (unsigned int other
)
7202 const char * result
= NULL
;
7203 static char buff
[32];
7208 switch (elf_header
.e_machine
)
7211 result
= get_mips_symbol_other (other
);
7219 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7224 get_symbol_index_type (unsigned int type
)
7226 static char buff
[32];
7230 case SHN_UNDEF
: return "UND";
7231 case SHN_ABS
: return "ABS";
7232 case SHN_COMMON
: return "COM";
7234 if (type
== SHN_IA_64_ANSI_COMMON
7235 && elf_header
.e_machine
== EM_IA_64
7236 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7238 else if ((elf_header
.e_machine
== EM_X86_64
7239 || elf_header
.e_machine
== EM_L1OM
)
7240 && type
== SHN_X86_64_LCOMMON
)
7242 else if (type
== SHN_MIPS_SCOMMON
7243 && elf_header
.e_machine
== EM_MIPS
)
7245 else if (type
== SHN_MIPS_SUNDEFINED
7246 && elf_header
.e_machine
== EM_MIPS
)
7248 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7249 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7250 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7251 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7252 else if (type
>= SHN_LORESERVE
)
7253 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7255 sprintf (buff
, "%3d", type
);
7263 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7265 unsigned char * e_data
;
7268 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
7272 error (_("Out of memory\n"));
7276 if (fread (e_data
, ent_size
, number
, file
) != number
)
7278 error (_("Unable to read in dynamic data\n"));
7282 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
7286 error (_("Out of memory\n"));
7292 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7300 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7302 Elf_Internal_Sym
* psym
;
7305 psym
= dynamic_symbols
+ si
;
7307 n
= print_vma (si
, DEC_5
);
7309 fputs (" " + n
, stdout
);
7310 printf (" %3lu: ", hn
);
7311 print_vma (psym
->st_value
, LONG_HEX
);
7313 print_vma (psym
->st_size
, DEC_5
);
7315 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7316 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7317 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7318 /* Check to see if any other bits in the st_other field are set.
7319 Note - displaying this information disrupts the layout of the
7320 table being generated, but for the moment this case is very
7322 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7323 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7324 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7325 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7326 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7328 printf (" <corrupt: %14ld>", psym
->st_name
);
7332 /* Dump the symbol table. */
7334 process_symbol_table (FILE * file
)
7336 Elf_Internal_Shdr
* section
;
7337 bfd_vma nbuckets
= 0;
7338 bfd_vma nchains
= 0;
7339 bfd_vma
* buckets
= NULL
;
7340 bfd_vma
* chains
= NULL
;
7341 bfd_vma ngnubuckets
= 0;
7342 bfd_vma
* gnubuckets
= NULL
;
7343 bfd_vma
* gnuchains
= NULL
;
7344 bfd_vma gnusymidx
= 0;
7346 if (! do_syms
&& !do_histogram
)
7349 if (dynamic_info
[DT_HASH
]
7351 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7353 unsigned char nb
[8];
7354 unsigned char nc
[8];
7355 int hash_ent_size
= 4;
7357 if ((elf_header
.e_machine
== EM_ALPHA
7358 || elf_header
.e_machine
== EM_S390
7359 || elf_header
.e_machine
== EM_S390_OLD
)
7360 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7364 (archive_file_offset
7365 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7366 sizeof nb
+ sizeof nc
)),
7369 error (_("Unable to seek to start of dynamic information\n"));
7373 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7375 error (_("Failed to read in number of buckets\n"));
7379 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7381 error (_("Failed to read in number of chains\n"));
7385 nbuckets
= byte_get (nb
, hash_ent_size
);
7386 nchains
= byte_get (nc
, hash_ent_size
);
7388 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7389 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7392 if (buckets
== NULL
|| chains
== NULL
)
7394 if (do_using_dynamic
)
7405 if (dynamic_info_DT_GNU_HASH
7407 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7409 unsigned char nb
[16];
7410 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7411 bfd_vma buckets_vma
;
7414 (archive_file_offset
7415 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7419 error (_("Unable to seek to start of dynamic information\n"));
7423 if (fread (nb
, 16, 1, file
) != 1)
7425 error (_("Failed to read in number of buckets\n"));
7429 ngnubuckets
= byte_get (nb
, 4);
7430 gnusymidx
= byte_get (nb
+ 4, 4);
7431 bitmaskwords
= byte_get (nb
+ 8, 4);
7432 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7434 buckets_vma
+= bitmaskwords
* 4;
7436 buckets_vma
+= bitmaskwords
* 8;
7439 (archive_file_offset
7440 + offset_from_vma (file
, buckets_vma
, 4)),
7443 error (_("Unable to seek to start of dynamic information\n"));
7447 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7449 if (gnubuckets
== NULL
)
7452 for (i
= 0; i
< ngnubuckets
; i
++)
7453 if (gnubuckets
[i
] != 0)
7455 if (gnubuckets
[i
] < gnusymidx
)
7458 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7459 maxchain
= gnubuckets
[i
];
7462 if (maxchain
== 0xffffffff)
7465 maxchain
-= gnusymidx
;
7468 (archive_file_offset
7469 + offset_from_vma (file
, buckets_vma
7470 + 4 * (ngnubuckets
+ maxchain
), 4)),
7473 error (_("Unable to seek to start of dynamic information\n"));
7479 if (fread (nb
, 4, 1, file
) != 1)
7481 error (_("Failed to determine last chain length\n"));
7485 if (maxchain
+ 1 == 0)
7490 while ((byte_get (nb
, 4) & 1) == 0);
7493 (archive_file_offset
7494 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7497 error (_("Unable to seek to start of dynamic information\n"));
7501 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7504 if (gnuchains
== NULL
)
7509 if (do_using_dynamic
)
7514 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7517 && dynamic_strings
!= NULL
)
7521 if (dynamic_info
[DT_HASH
])
7525 printf (_("\nSymbol table for image:\n"));
7527 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7529 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7531 for (hn
= 0; hn
< nbuckets
; hn
++)
7536 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7537 print_dynamic_symbol (si
, hn
);
7541 if (dynamic_info_DT_GNU_HASH
)
7543 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7545 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7547 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7549 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7550 if (gnubuckets
[hn
] != 0)
7552 bfd_vma si
= gnubuckets
[hn
];
7553 bfd_vma off
= si
- gnusymidx
;
7557 print_dynamic_symbol (si
, hn
);
7560 while ((gnuchains
[off
++] & 1) == 0);
7564 else if (do_syms
&& !do_using_dynamic
)
7568 for (i
= 0, section
= section_headers
;
7569 i
< elf_header
.e_shnum
;
7573 char * strtab
= NULL
;
7574 unsigned long int strtab_size
= 0;
7575 Elf_Internal_Sym
* symtab
;
7576 Elf_Internal_Sym
* psym
;
7578 if ( section
->sh_type
!= SHT_SYMTAB
7579 && section
->sh_type
!= SHT_DYNSYM
)
7582 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7583 SECTION_NAME (section
),
7584 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7586 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7588 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7590 symtab
= GET_ELF_SYMBOLS (file
, section
);
7594 if (section
->sh_link
== elf_header
.e_shstrndx
)
7596 strtab
= string_table
;
7597 strtab_size
= string_table_length
;
7599 else if (section
->sh_link
< elf_header
.e_shnum
)
7601 Elf_Internal_Shdr
* string_sec
;
7603 string_sec
= section_headers
+ section
->sh_link
;
7605 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
7606 1, string_sec
->sh_size
,
7608 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7611 for (si
= 0, psym
= symtab
;
7612 si
< section
->sh_size
/ section
->sh_entsize
;
7615 printf ("%6d: ", si
);
7616 print_vma (psym
->st_value
, LONG_HEX
);
7618 print_vma (psym
->st_size
, DEC_5
);
7619 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7620 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7621 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7622 /* Check to see if any other bits in the st_other field are set.
7623 Note - displaying this information disrupts the layout of the
7624 table being generated, but for the moment this case is very rare. */
7625 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7626 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7627 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7628 print_symbol (25, psym
->st_name
< strtab_size
7629 ? strtab
+ psym
->st_name
: "<corrupt>");
7631 if (section
->sh_type
== SHT_DYNSYM
&&
7632 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7634 unsigned char data
[2];
7635 unsigned short vers_data
;
7636 unsigned long offset
;
7640 offset
= offset_from_vma
7641 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7642 sizeof data
+ si
* sizeof (vers_data
));
7644 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7645 sizeof (data
), 1, _("version data"));
7647 vers_data
= byte_get (data
, 2);
7649 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7650 && section_headers
[psym
->st_shndx
].sh_type
7653 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7655 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
7657 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7658 && (is_nobits
|| ! check_def
))
7660 Elf_External_Verneed evn
;
7661 Elf_Internal_Verneed ivn
;
7662 Elf_Internal_Vernaux ivna
;
7664 /* We must test both. */
7665 offset
= offset_from_vma
7666 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7671 unsigned long vna_off
;
7673 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7676 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7677 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7679 vna_off
= offset
+ ivn
.vn_aux
;
7683 Elf_External_Vernaux evna
;
7685 get_data (&evna
, file
, vna_off
,
7687 _("version need aux (3)"));
7689 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7690 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7691 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7693 vna_off
+= ivna
.vna_next
;
7695 while (ivna
.vna_other
!= vers_data
7696 && ivna
.vna_next
!= 0);
7698 if (ivna
.vna_other
== vers_data
)
7701 offset
+= ivn
.vn_next
;
7703 while (ivn
.vn_next
!= 0);
7705 if (ivna
.vna_other
== vers_data
)
7708 ivna
.vna_name
< strtab_size
7709 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7713 else if (! is_nobits
)
7714 error (_("bad dynamic symbol\n"));
7721 if (vers_data
!= 0x8001
7722 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7724 Elf_Internal_Verdef ivd
;
7725 Elf_Internal_Verdaux ivda
;
7726 Elf_External_Verdaux evda
;
7729 off
= offset_from_vma
7731 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7732 sizeof (Elf_External_Verdef
));
7736 Elf_External_Verdef evd
;
7738 get_data (&evd
, file
, off
, sizeof (evd
),
7739 1, _("version def"));
7741 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7742 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7743 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7747 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
7748 && ivd
.vd_next
!= 0);
7753 get_data (&evda
, file
, off
, sizeof (evda
),
7754 1, _("version def aux"));
7756 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7758 if (psym
->st_name
!= ivda
.vda_name
)
7759 printf ((vers_data
& VERSYM_HIDDEN
)
7761 ivda
.vda_name
< strtab_size
7762 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7772 if (strtab
!= string_table
)
7778 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7780 if (do_histogram
&& buckets
!= NULL
)
7782 unsigned long * lengths
;
7783 unsigned long * counts
;
7786 unsigned long maxlength
= 0;
7787 unsigned long nzero_counts
= 0;
7788 unsigned long nsyms
= 0;
7790 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7791 (unsigned long) nbuckets
);
7792 printf (_(" Length Number %% of total Coverage\n"));
7794 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
7795 if (lengths
== NULL
)
7797 error (_("Out of memory\n"));
7800 for (hn
= 0; hn
< nbuckets
; ++hn
)
7802 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7805 if (maxlength
< ++lengths
[hn
])
7810 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7813 error (_("Out of memory\n"));
7817 for (hn
= 0; hn
< nbuckets
; ++hn
)
7818 ++counts
[lengths
[hn
]];
7823 printf (" 0 %-10lu (%5.1f%%)\n",
7824 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7825 for (i
= 1; i
<= maxlength
; ++i
)
7827 nzero_counts
+= counts
[i
] * i
;
7828 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7829 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7830 (nzero_counts
* 100.0) / nsyms
);
7838 if (buckets
!= NULL
)
7844 if (do_histogram
&& gnubuckets
!= NULL
)
7846 unsigned long * lengths
;
7847 unsigned long * counts
;
7849 unsigned long maxlength
= 0;
7850 unsigned long nzero_counts
= 0;
7851 unsigned long nsyms
= 0;
7853 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
7854 if (lengths
== NULL
)
7856 error (_("Out of memory\n"));
7860 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7861 (unsigned long) ngnubuckets
);
7862 printf (_(" Length Number %% of total Coverage\n"));
7864 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7865 if (gnubuckets
[hn
] != 0)
7867 bfd_vma off
, length
= 1;
7869 for (off
= gnubuckets
[hn
] - gnusymidx
;
7870 (gnuchains
[off
] & 1) == 0; ++off
)
7872 lengths
[hn
] = length
;
7873 if (length
> maxlength
)
7878 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7881 error (_("Out of memory\n"));
7885 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7886 ++counts
[lengths
[hn
]];
7888 if (ngnubuckets
> 0)
7891 printf (" 0 %-10lu (%5.1f%%)\n",
7892 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7893 for (j
= 1; j
<= maxlength
; ++j
)
7895 nzero_counts
+= counts
[j
] * j
;
7896 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7897 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7898 (nzero_counts
* 100.0) / nsyms
);
7912 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7916 if (dynamic_syminfo
== NULL
7918 /* No syminfo, this is ok. */
7921 /* There better should be a dynamic symbol section. */
7922 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7926 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7927 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7929 printf (_(" Num: Name BoundTo Flags\n"));
7930 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7932 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7934 printf ("%4d: ", i
);
7935 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7936 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7938 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7941 switch (dynamic_syminfo
[i
].si_boundto
)
7943 case SYMINFO_BT_SELF
:
7944 fputs ("SELF ", stdout
);
7946 case SYMINFO_BT_PARENT
:
7947 fputs ("PARENT ", stdout
);
7950 if (dynamic_syminfo
[i
].si_boundto
> 0
7951 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7952 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7954 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7958 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7962 if (flags
& SYMINFO_FLG_DIRECT
)
7964 if (flags
& SYMINFO_FLG_PASSTHRU
)
7965 printf (" PASSTHRU");
7966 if (flags
& SYMINFO_FLG_COPY
)
7968 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7969 printf (" LAZYLOAD");
7977 /* Check to see if the given reloc needs to be handled in a target specific
7978 manner. If so then process the reloc and return TRUE otherwise return
7982 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
7983 unsigned char * start
,
7984 Elf_Internal_Sym
* symtab
)
7986 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
7988 switch (elf_header
.e_machine
)
7991 case EM_CYGNUS_MN10300
:
7993 static Elf_Internal_Sym
* saved_sym
= NULL
;
7997 case 34: /* R_MN10300_ALIGN */
7999 case 33: /* R_MN10300_SYM_DIFF */
8000 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
8002 case 1: /* R_MN10300_32 */
8003 case 2: /* R_MN10300_16 */
8004 if (saved_sym
!= NULL
)
8008 value
= reloc
->r_addend
8009 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
8010 - saved_sym
->st_value
);
8012 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
8019 if (saved_sym
!= NULL
)
8020 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8030 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8031 DWARF debug sections. This is a target specific test. Note - we do not
8032 go through the whole including-target-headers-multiple-times route, (as
8033 we have already done with <elf/h8.h>) because this would become very
8034 messy and even then this function would have to contain target specific
8035 information (the names of the relocs instead of their numeric values).
8036 FIXME: This is not the correct way to solve this problem. The proper way
8037 is to have target specific reloc sizing and typing functions created by
8038 the reloc-macros.h header, in the same way that it already creates the
8039 reloc naming functions. */
8042 is_32bit_abs_reloc (unsigned int reloc_type
)
8044 switch (elf_header
.e_machine
)
8048 return reloc_type
== 1; /* R_386_32. */
8050 return reloc_type
== 1; /* R_68K_32. */
8052 return reloc_type
== 1; /* R_860_32. */
8054 return reloc_type
== 1; /* XXX Is this right ? */
8056 return reloc_type
== 1; /* R_ARC_32. */
8058 return reloc_type
== 2; /* R_ARM_ABS32 */
8061 return reloc_type
== 1;
8063 return reloc_type
== 0x12; /* R_byte4_data. */
8065 return reloc_type
== 3; /* R_CRIS_32. */
8068 return reloc_type
== 3; /* R_CR16_NUM32. */
8070 return reloc_type
== 15; /* R_CRX_NUM32. */
8072 return reloc_type
== 1;
8073 case EM_CYGNUS_D10V
:
8075 return reloc_type
== 6; /* R_D10V_32. */
8076 case EM_CYGNUS_D30V
:
8078 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8080 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8081 case EM_CYGNUS_FR30
:
8083 return reloc_type
== 3; /* R_FR30_32. */
8087 return reloc_type
== 1; /* R_H8_DIR32. */
8089 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8092 return reloc_type
== 2; /* R_IP2K_32. */
8094 return reloc_type
== 2; /* R_IQ2000_32. */
8095 case EM_LATTICEMICO32
:
8096 return reloc_type
== 3; /* R_LM32_32. */
8099 return reloc_type
== 3; /* R_M32C_32. */
8101 return reloc_type
== 34; /* R_M32R_32_RELA. */
8103 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8105 return reloc_type
== 4; /* R_MEP_32. */
8107 return reloc_type
== 2; /* R_MIPS_32. */
8109 return reloc_type
== 4; /* R_MMIX_32. */
8110 case EM_CYGNUS_MN10200
:
8112 return reloc_type
== 1; /* R_MN10200_32. */
8113 case EM_CYGNUS_MN10300
:
8115 return reloc_type
== 1; /* R_MN10300_32. */
8118 return reloc_type
== 1; /* R_MSP43_32. */
8120 return reloc_type
== 2; /* R_MT_32. */
8121 case EM_ALTERA_NIOS2
:
8123 return reloc_type
== 1; /* R_NIOS_32. */
8126 return reloc_type
== 1; /* R_OR32_32. */
8128 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8129 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8132 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8134 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8136 return reloc_type
== 1; /* R_PPC_ADDR32. */
8138 return reloc_type
== 1; /* R_RX_DIR32. */
8140 return reloc_type
== 1; /* R_I370_ADDR31. */
8143 return reloc_type
== 4; /* R_S390_32. */
8145 return reloc_type
== 8; /* R_SCORE_ABS32. */
8147 return reloc_type
== 1; /* R_SH_DIR32. */
8148 case EM_SPARC32PLUS
:
8151 return reloc_type
== 3 /* R_SPARC_32. */
8152 || reloc_type
== 23; /* R_SPARC_UA32. */
8154 return reloc_type
== 6; /* R_SPU_ADDR32 */
8155 case EM_CYGNUS_V850
:
8157 return reloc_type
== 6; /* R_V850_ABS32. */
8159 return reloc_type
== 1; /* R_VAX_32. */
8162 return reloc_type
== 10; /* R_X86_64_32. */
8165 return reloc_type
== 3; /* R_XC16C_ABS_32. */
8167 return reloc_type
== 1; /* R_XSTROMY16_32. */
8170 return reloc_type
== 1; /* R_XTENSA_32. */
8172 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8173 elf_header
.e_machine
);
8178 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8179 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8182 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8184 switch (elf_header
.e_machine
)
8188 return reloc_type
== 2; /* R_386_PC32. */
8190 return reloc_type
== 4; /* R_68K_PC32. */
8192 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8194 return reloc_type
== 3; /* R_ARM_REL32 */
8196 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8198 return reloc_type
== 26; /* R_PPC_REL32. */
8200 return reloc_type
== 26; /* R_PPC64_REL32. */
8203 return reloc_type
== 5; /* R_390_PC32. */
8205 return reloc_type
== 2; /* R_SH_REL32. */
8206 case EM_SPARC32PLUS
:
8209 return reloc_type
== 6; /* R_SPARC_DISP32. */
8211 return reloc_type
== 13; /* R_SPU_REL32. */
8214 return reloc_type
== 2; /* R_X86_64_PC32. */
8217 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8219 /* Do not abort or issue an error message here. Not all targets use
8220 pc-relative 32-bit relocs in their DWARF debug information and we
8221 have already tested for target coverage in is_32bit_abs_reloc. A
8222 more helpful warning message will be generated by apply_relocations
8223 anyway, so just return. */
8228 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8229 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8232 is_64bit_abs_reloc (unsigned int reloc_type
)
8234 switch (elf_header
.e_machine
)
8237 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8239 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8241 return reloc_type
== 80; /* R_PARISC_DIR64. */
8243 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8244 case EM_SPARC32PLUS
:
8247 return reloc_type
== 54; /* R_SPARC_UA64. */
8250 return reloc_type
== 1; /* R_X86_64_64. */
8253 return reloc_type
== 22; /* R_S390_64 */
8255 return reloc_type
== 18; /* R_MIPS_64 */
8261 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8262 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8265 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8267 switch (elf_header
.e_machine
)
8270 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8272 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8274 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8276 return reloc_type
== 44; /* R_PPC64_REL64 */
8277 case EM_SPARC32PLUS
:
8280 return reloc_type
== 46; /* R_SPARC_DISP64 */
8283 return reloc_type
== 24; /* R_X86_64_PC64 */
8286 return reloc_type
== 23; /* R_S390_PC64 */
8292 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8293 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8296 is_24bit_abs_reloc (unsigned int reloc_type
)
8298 switch (elf_header
.e_machine
)
8300 case EM_CYGNUS_MN10200
:
8302 return reloc_type
== 4; /* R_MN10200_24. */
8308 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8309 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8312 is_16bit_abs_reloc (unsigned int reloc_type
)
8314 switch (elf_header
.e_machine
)
8318 return reloc_type
== 4; /* R_AVR_16. */
8319 case EM_CYGNUS_D10V
:
8321 return reloc_type
== 3; /* R_D10V_16. */
8325 return reloc_type
== R_H8_DIR16
;
8328 return reloc_type
== 1; /* R_IP2K_16. */
8331 return reloc_type
== 1; /* R_M32C_16 */
8334 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8335 case EM_ALTERA_NIOS2
:
8337 return reloc_type
== 9; /* R_NIOS_16. */
8340 return reloc_type
== 2; /* R_XC16C_ABS_16. */
8346 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8347 relocation entries (possibly formerly used for SHT_GROUP sections). */
8350 is_none_reloc (unsigned int reloc_type
)
8352 switch (elf_header
.e_machine
)
8354 case EM_68K
: /* R_68K_NONE. */
8355 case EM_386
: /* R_386_NONE. */
8356 case EM_SPARC32PLUS
:
8358 case EM_SPARC
: /* R_SPARC_NONE. */
8359 case EM_MIPS
: /* R_MIPS_NONE. */
8360 case EM_PARISC
: /* R_PARISC_NONE. */
8361 case EM_ALPHA
: /* R_ALPHA_NONE. */
8362 case EM_PPC
: /* R_PPC_NONE. */
8363 case EM_PPC64
: /* R_PPC64_NONE. */
8364 case EM_ARM
: /* R_ARM_NONE. */
8365 case EM_IA_64
: /* R_IA64_NONE. */
8366 case EM_SH
: /* R_SH_NONE. */
8368 case EM_S390
: /* R_390_NONE. */
8369 case EM_CRIS
: /* R_CRIS_NONE. */
8370 case EM_X86_64
: /* R_X86_64_NONE. */
8371 case EM_L1OM
: /* R_X86_64_NONE. */
8372 case EM_MN10300
: /* R_MN10300_NONE. */
8373 case EM_M32R
: /* R_M32R_NONE. */
8375 case EM_C166
: /* R_XC16X_NONE. */
8376 return reloc_type
== 0;
8379 return (reloc_type
== 0 /* R_XTENSA_NONE. */
8380 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
8381 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
8382 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
8387 /* Apply relocations to a section.
8388 Note: So far support has been added only for those relocations
8389 which can be found in debug sections.
8390 FIXME: Add support for more relocations ? */
8393 apply_relocations (void * file
,
8394 Elf_Internal_Shdr
* section
,
8395 unsigned char * start
)
8397 Elf_Internal_Shdr
* relsec
;
8398 unsigned char * end
= start
+ section
->sh_size
;
8400 if (elf_header
.e_type
!= ET_REL
)
8403 /* Find the reloc section associated with the section. */
8404 for (relsec
= section_headers
;
8405 relsec
< section_headers
+ elf_header
.e_shnum
;
8408 bfd_boolean is_rela
;
8409 unsigned long num_relocs
;
8410 Elf_Internal_Rela
* relocs
;
8411 Elf_Internal_Rela
* rp
;
8412 Elf_Internal_Shdr
* symsec
;
8413 Elf_Internal_Sym
* symtab
;
8414 Elf_Internal_Sym
* sym
;
8416 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8417 || relsec
->sh_info
>= elf_header
.e_shnum
8418 || section_headers
+ relsec
->sh_info
!= section
8419 || relsec
->sh_size
== 0
8420 || relsec
->sh_link
>= elf_header
.e_shnum
)
8423 is_rela
= relsec
->sh_type
== SHT_RELA
;
8427 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
8428 relsec
->sh_size
, & relocs
, & num_relocs
))
8433 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
8434 relsec
->sh_size
, & relocs
, & num_relocs
))
8438 /* SH uses RELA but uses in place value instead of the addend field. */
8439 if (elf_header
.e_machine
== EM_SH
)
8442 symsec
= section_headers
+ relsec
->sh_link
;
8443 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
8445 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8448 unsigned int reloc_type
;
8449 unsigned int reloc_size
;
8450 unsigned char * rloc
;
8452 reloc_type
= get_reloc_type (rp
->r_info
);
8454 if (target_specific_reloc_handling (rp
, start
, symtab
))
8456 else if (is_none_reloc (reloc_type
))
8458 else if (is_32bit_abs_reloc (reloc_type
)
8459 || is_32bit_pcrel_reloc (reloc_type
))
8461 else if (is_64bit_abs_reloc (reloc_type
)
8462 || is_64bit_pcrel_reloc (reloc_type
))
8464 else if (is_24bit_abs_reloc (reloc_type
))
8466 else if (is_16bit_abs_reloc (reloc_type
))
8470 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8471 reloc_type
, SECTION_NAME (section
));
8475 rloc
= start
+ rp
->r_offset
;
8476 if ((rloc
+ reloc_size
) > end
)
8478 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8479 (unsigned long) rp
->r_offset
,
8480 SECTION_NAME (section
));
8484 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8486 /* If the reloc has a symbol associated with it,
8487 make sure that it is of an appropriate type.
8489 Relocations against symbols without type can happen.
8490 Gcc -feliminate-dwarf2-dups may generate symbols
8491 without type for debug info.
8493 Icc generates relocations against function symbols
8494 instead of local labels.
8496 Relocations against object symbols can happen, eg when
8497 referencing a global array. For an example of this see
8498 the _clz.o binary in libgcc.a. */
8500 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8502 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8503 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8504 (long int)(rp
- relocs
),
8505 SECTION_NAME (relsec
));
8511 addend
+= rp
->r_addend
;
8512 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8514 || (elf_header
.e_machine
== EM_XTENSA
8516 || ((elf_header
.e_machine
== EM_PJ
8517 || elf_header
.e_machine
== EM_PJ_OLD
)
8518 && reloc_type
== 1))
8519 addend
+= byte_get (rloc
, reloc_size
);
8521 if (is_32bit_pcrel_reloc (reloc_type
)
8522 || is_64bit_pcrel_reloc (reloc_type
))
8524 /* On HPPA, all pc-relative relocations are biased by 8. */
8525 if (elf_header
.e_machine
== EM_PARISC
)
8527 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8531 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
8540 #ifdef SUPPORT_DISASSEMBLY
8542 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8544 printf (_("\nAssembly dump of section %s\n"),
8545 SECTION_NAME (section
));
8547 /* XXX -- to be done --- XXX */
8553 /* Reads in the contents of SECTION from FILE, returning a pointer
8554 to a malloc'ed buffer or NULL if something went wrong. */
8557 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8559 bfd_size_type num_bytes
;
8561 num_bytes
= section
->sh_size
;
8563 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8565 printf (_("\nSection '%s' has no data to dump.\n"),
8566 SECTION_NAME (section
));
8570 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8571 _("section contents"));
8576 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8578 Elf_Internal_Shdr
* relsec
;
8579 bfd_size_type num_bytes
;
8584 char * name
= SECTION_NAME (section
);
8585 bfd_boolean some_strings_shown
;
8587 start
= get_section_contents (section
, file
);
8591 printf (_("\nString dump of section '%s':\n"), name
);
8593 /* If the section being dumped has relocations against it the user might
8594 be expecting these relocations to have been applied. Check for this
8595 case and issue a warning message in order to avoid confusion.
8596 FIXME: Maybe we ought to have an option that dumps a section with
8598 for (relsec
= section_headers
;
8599 relsec
< section_headers
+ elf_header
.e_shnum
;
8602 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8603 || relsec
->sh_info
>= elf_header
.e_shnum
8604 || section_headers
+ relsec
->sh_info
!= section
8605 || relsec
->sh_size
== 0
8606 || relsec
->sh_link
>= elf_header
.e_shnum
)
8609 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8613 num_bytes
= section
->sh_size
;
8614 addr
= section
->sh_addr
;
8616 end
= start
+ num_bytes
;
8617 some_strings_shown
= FALSE
;
8621 while (!ISPRINT (* data
))
8628 /* PR 11128: Use two separate invocations in order to work
8629 around bugs in the Solaris 8 implementation of printf. */
8630 printf (" [%6tx] ", data
- start
);
8631 printf ("%s\n", data
);
8633 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8635 data
+= strlen (data
);
8636 some_strings_shown
= TRUE
;
8640 if (! some_strings_shown
)
8641 printf (_(" No strings found in this section."));
8649 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8651 bfd_boolean relocate
)
8653 Elf_Internal_Shdr
* relsec
;
8654 bfd_size_type bytes
;
8656 unsigned char * data
;
8657 unsigned char * start
;
8659 start
= (unsigned char *) get_section_contents (section
, file
);
8663 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8667 apply_relocations (file
, section
, start
);
8671 /* If the section being dumped has relocations against it the user might
8672 be expecting these relocations to have been applied. Check for this
8673 case and issue a warning message in order to avoid confusion.
8674 FIXME: Maybe we ought to have an option that dumps a section with
8676 for (relsec
= section_headers
;
8677 relsec
< section_headers
+ elf_header
.e_shnum
;
8680 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8681 || relsec
->sh_info
>= elf_header
.e_shnum
8682 || section_headers
+ relsec
->sh_info
!= section
8683 || relsec
->sh_size
== 0
8684 || relsec
->sh_link
>= elf_header
.e_shnum
)
8687 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8692 addr
= section
->sh_addr
;
8693 bytes
= section
->sh_size
;
8702 lbytes
= (bytes
> 16 ? 16 : bytes
);
8704 printf (" 0x%8.8lx ", (unsigned long) addr
);
8706 for (j
= 0; j
< 16; j
++)
8709 printf ("%2.2x", data
[j
]);
8717 for (j
= 0; j
< lbytes
; j
++)
8720 if (k
>= ' ' && k
< 0x7f)
8738 /* Uncompresses a section that was compressed using zlib, in place.
8739 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8742 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8745 /* These are just to quiet gcc. */
8750 dwarf_size_type compressed_size
= *size
;
8751 unsigned char * compressed_buffer
= *buffer
;
8752 dwarf_size_type uncompressed_size
;
8753 unsigned char * uncompressed_buffer
;
8756 dwarf_size_type header_size
= 12;
8758 /* Read the zlib header. In this case, it should be "ZLIB" followed
8759 by the uncompressed section size, 8 bytes in big-endian order. */
8760 if (compressed_size
< header_size
8761 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8764 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8765 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8766 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8767 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8768 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8769 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8770 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8771 uncompressed_size
+= compressed_buffer
[11];
8773 /* It is possible the section consists of several compressed
8774 buffers concatenated together, so we uncompress in a loop. */
8778 strm
.avail_in
= compressed_size
- header_size
;
8779 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8780 strm
.avail_out
= uncompressed_size
;
8781 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
8783 rc
= inflateInit (& strm
);
8784 while (strm
.avail_in
> 0)
8788 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8789 + (uncompressed_size
- strm
.avail_out
));
8790 rc
= inflate (&strm
, Z_FINISH
);
8791 if (rc
!= Z_STREAM_END
)
8793 rc
= inflateReset (& strm
);
8795 rc
= inflateEnd (& strm
);
8797 || strm
.avail_out
!= 0)
8800 free (compressed_buffer
);
8801 *buffer
= uncompressed_buffer
;
8802 *size
= uncompressed_size
;
8806 free (uncompressed_buffer
);
8808 #endif /* HAVE_ZLIB_H */
8812 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8813 Elf_Internal_Shdr
* sec
, void * file
)
8815 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8817 int section_is_compressed
;
8819 /* If it is already loaded, do nothing. */
8820 if (section
->start
!= NULL
)
8823 section_is_compressed
= section
->name
== section
->compressed_name
;
8825 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8826 section
->address
= sec
->sh_addr
;
8827 section
->size
= sec
->sh_size
;
8828 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
8831 if (section
->start
== NULL
)
8834 if (section_is_compressed
)
8835 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8838 if (debug_displays
[debug
].relocate
)
8839 apply_relocations ((FILE *) file
, sec
, section
->start
);
8845 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8847 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8848 Elf_Internal_Shdr
* sec
;
8850 /* Locate the debug section. */
8851 sec
= find_section (section
->uncompressed_name
);
8853 section
->name
= section
->uncompressed_name
;
8856 sec
= find_section (section
->compressed_name
);
8858 section
->name
= section
->compressed_name
;
8863 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
8867 free_debug_section (enum dwarf_section_display_enum debug
)
8869 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8871 if (section
->start
== NULL
)
8874 free ((char *) section
->start
);
8875 section
->start
= NULL
;
8876 section
->address
= 0;
8881 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8883 char * name
= SECTION_NAME (section
);
8884 bfd_size_type length
;
8888 length
= section
->sh_size
;
8891 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8894 if (section
->sh_type
== SHT_NOBITS
)
8896 /* There is no point in dumping the contents of a debugging section
8897 which has the NOBITS type - the bits in the file will be random.
8898 This can happen when a file containing a .eh_frame section is
8899 stripped with the --only-keep-debug command line option. */
8900 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8904 if (const_strneq (name
, ".gnu.linkonce.wi."))
8905 name
= ".debug_info";
8907 /* See if we know how to display the contents of this section. */
8908 for (i
= 0; i
< max
; i
++)
8909 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8910 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8912 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8913 int secondary
= (section
!= find_section (name
));
8916 free_debug_section ((enum dwarf_section_display_enum
) i
);
8918 if (streq (sec
->uncompressed_name
, name
))
8919 sec
->name
= sec
->uncompressed_name
;
8921 sec
->name
= sec
->compressed_name
;
8922 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
8925 result
&= debug_displays
[i
].display (sec
, file
);
8927 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8928 free_debug_section ((enum dwarf_section_display_enum
) i
);
8936 printf (_("Unrecognized debug section: %s\n"), name
);
8943 /* Set DUMP_SECTS for all sections where dumps were requested
8944 based on section name. */
8947 initialise_dumps_byname (void)
8949 struct dump_list_entry
* cur
;
8951 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8956 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8957 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8959 request_dump_bynumber (i
, cur
->type
);
8964 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8970 process_section_contents (FILE * file
)
8972 Elf_Internal_Shdr
* section
;
8978 initialise_dumps_byname ();
8980 for (i
= 0, section
= section_headers
;
8981 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8984 #ifdef SUPPORT_DISASSEMBLY
8985 if (dump_sects
[i
] & DISASS_DUMP
)
8986 disassemble_section (section
, file
);
8988 if (dump_sects
[i
] & HEX_DUMP
)
8989 dump_section_as_bytes (section
, file
, FALSE
);
8991 if (dump_sects
[i
] & RELOC_DUMP
)
8992 dump_section_as_bytes (section
, file
, TRUE
);
8994 if (dump_sects
[i
] & STRING_DUMP
)
8995 dump_section_as_strings (section
, file
);
8997 if (dump_sects
[i
] & DEBUG_DUMP
)
8998 display_debug_section (section
, file
);
9001 /* Check to see if the user requested a
9002 dump of a section that does not exist. */
9003 while (i
++ < num_dump_sects
)
9005 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
9009 process_mips_fpe_exception (int mask
)
9014 if (mask
& OEX_FPU_INEX
)
9015 fputs ("INEX", stdout
), first
= 0;
9016 if (mask
& OEX_FPU_UFLO
)
9017 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9018 if (mask
& OEX_FPU_OFLO
)
9019 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9020 if (mask
& OEX_FPU_DIV0
)
9021 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9022 if (mask
& OEX_FPU_INVAL
)
9023 printf ("%sINVAL", first
? "" : "|");
9026 fputs ("0", stdout
);
9029 /* ARM EABI attributes section. */
9034 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9036 const char ** table
;
9037 } arm_attr_public_tag
;
9039 static const char * arm_attr_tag_CPU_arch
[] =
9040 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9041 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9042 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
9043 static const char * arm_attr_tag_THUMB_ISA_use
[] =
9044 {"No", "Thumb-1", "Thumb-2"};
9045 static const char * arm_attr_tag_VFP_arch
[] =
9046 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9047 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
9048 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
9049 static const char * arm_attr_tag_PCS_config
[] =
9050 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9051 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9052 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
9053 {"V6", "SB", "TLS", "Unused"};
9054 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
9055 {"Absolute", "PC-relative", "SB-relative", "None"};
9056 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
9057 {"Absolute", "PC-relative", "None"};
9058 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
9059 {"None", "direct", "GOT-indirect"};
9060 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
9061 {"None", "??? 1", "2", "??? 3", "4"};
9062 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
9063 static const char * arm_attr_tag_ABI_FP_denormal
[] =
9064 {"Unused", "Needed", "Sign only"};
9065 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
9066 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
9067 static const char * arm_attr_tag_ABI_FP_number_model
[] =
9068 {"Unused", "Finite", "RTABI", "IEEE 754"};
9069 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
9070 static const char * arm_attr_tag_ABI_align8_preserved
[] =
9071 {"No", "Yes, except leaf SP", "Yes"};
9072 static const char * arm_attr_tag_ABI_enum_size
[] =
9073 {"Unused", "small", "int", "forced to int"};
9074 static const char * arm_attr_tag_ABI_HardFP_use
[] =
9075 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9076 static const char * arm_attr_tag_ABI_VFP_args
[] =
9077 {"AAPCS", "VFP registers", "custom"};
9078 static const char * arm_attr_tag_ABI_WMMX_args
[] =
9079 {"AAPCS", "WMMX registers", "custom"};
9080 static const char * arm_attr_tag_ABI_optimization_goals
[] =
9081 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9082 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9083 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
9084 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9085 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9086 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
9087 static const char * arm_attr_tag_VFP_HP_extension
[] =
9088 {"Not Allowed", "Allowed"};
9089 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
9090 {"None", "IEEE 754", "Alternative Format"};
9091 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9092 static const char * arm_attr_tag_Virtualization_use
[] =
9093 {"Not Allowed", "Allowed"};
9094 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
9096 #define LOOKUP(id, name) \
9097 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9098 static arm_attr_public_tag arm_attr_public_tags
[] =
9100 {4, "CPU_raw_name", 1, NULL
},
9101 {5, "CPU_name", 1, NULL
},
9102 LOOKUP(6, CPU_arch
),
9103 {7, "CPU_arch_profile", 0, NULL
},
9104 LOOKUP(8, ARM_ISA_use
),
9105 LOOKUP(9, THUMB_ISA_use
),
9106 LOOKUP(10, VFP_arch
),
9107 LOOKUP(11, WMMX_arch
),
9108 LOOKUP(12, Advanced_SIMD_arch
),
9109 LOOKUP(13, PCS_config
),
9110 LOOKUP(14, ABI_PCS_R9_use
),
9111 LOOKUP(15, ABI_PCS_RW_data
),
9112 LOOKUP(16, ABI_PCS_RO_data
),
9113 LOOKUP(17, ABI_PCS_GOT_use
),
9114 LOOKUP(18, ABI_PCS_wchar_t
),
9115 LOOKUP(19, ABI_FP_rounding
),
9116 LOOKUP(20, ABI_FP_denormal
),
9117 LOOKUP(21, ABI_FP_exceptions
),
9118 LOOKUP(22, ABI_FP_user_exceptions
),
9119 LOOKUP(23, ABI_FP_number_model
),
9120 LOOKUP(24, ABI_align8_needed
),
9121 LOOKUP(25, ABI_align8_preserved
),
9122 LOOKUP(26, ABI_enum_size
),
9123 LOOKUP(27, ABI_HardFP_use
),
9124 LOOKUP(28, ABI_VFP_args
),
9125 LOOKUP(29, ABI_WMMX_args
),
9126 LOOKUP(30, ABI_optimization_goals
),
9127 LOOKUP(31, ABI_FP_optimization_goals
),
9128 {32, "compatibility", 0, NULL
},
9129 LOOKUP(34, CPU_unaligned_access
),
9130 LOOKUP(36, VFP_HP_extension
),
9131 LOOKUP(38, ABI_FP_16bit_format
),
9132 {64, "nodefaults", 0, NULL
},
9133 {65, "also_compatible_with", 0, NULL
},
9134 LOOKUP(66, T2EE_use
),
9135 {67, "conformance", 1, NULL
},
9136 LOOKUP(68, Virtualization_use
),
9137 LOOKUP(70, MPextension_use
)
9141 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9145 read_uleb128 (unsigned char * p
, unsigned int * plen
)
9159 val
|= ((unsigned int)c
& 0x7f) << shift
;
9168 static unsigned char *
9169 display_arm_attribute (unsigned char * p
)
9174 arm_attr_public_tag
* attr
;
9178 tag
= read_uleb128 (p
, &len
);
9181 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9183 if (arm_attr_public_tags
[i
].tag
== tag
)
9185 attr
= &arm_attr_public_tags
[i
];
9192 printf (" Tag_%s: ", attr
->name
);
9198 case 7: /* Tag_CPU_arch_profile. */
9199 val
= read_uleb128 (p
, &len
);
9203 case 0: printf ("None\n"); break;
9204 case 'A': printf ("Application\n"); break;
9205 case 'R': printf ("Realtime\n"); break;
9206 case 'M': printf ("Microcontroller\n"); break;
9207 default: printf ("??? (%d)\n", val
); break;
9211 case 32: /* Tag_compatibility. */
9212 val
= read_uleb128 (p
, &len
);
9214 printf ("flag = %d, vendor = %s\n", val
, p
);
9215 p
+= strlen ((char *) p
) + 1;
9218 case 64: /* Tag_nodefaults. */
9223 case 65: /* Tag_also_compatible_with. */
9224 val
= read_uleb128 (p
, &len
);
9226 if (val
== 6 /* Tag_CPU_arch. */)
9228 val
= read_uleb128 (p
, &len
);
9230 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
9231 printf ("??? (%d)\n", val
);
9233 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9237 while (*(p
++) != '\0' /* NUL terminator. */);
9251 assert (attr
->type
& 0x80);
9252 val
= read_uleb128 (p
, &len
);
9254 type
= attr
->type
& 0x7f;
9256 printf ("??? (%d)\n", val
);
9258 printf ("%s\n", attr
->table
[val
]);
9265 type
= 1; /* String. */
9267 type
= 2; /* uleb128. */
9268 printf (" Tag_unknown_%d: ", tag
);
9273 printf ("\"%s\"\n", p
);
9274 p
+= strlen ((char *) p
) + 1;
9278 val
= read_uleb128 (p
, &len
);
9280 printf ("%d (0x%x)\n", val
, val
);
9286 static unsigned char *
9287 display_gnu_attribute (unsigned char * p
,
9288 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9295 tag
= read_uleb128 (p
, &len
);
9298 /* Tag_compatibility is the only generic GNU attribute defined at
9302 val
= read_uleb128 (p
, &len
);
9304 printf ("flag = %d, vendor = %s\n", val
, p
);
9305 p
+= strlen ((char *) p
) + 1;
9309 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9310 return display_proc_gnu_attribute (p
, tag
);
9313 type
= 1; /* String. */
9315 type
= 2; /* uleb128. */
9316 printf (" Tag_unknown_%d: ", tag
);
9320 printf ("\"%s\"\n", p
);
9321 p
+= strlen ((char *) p
) + 1;
9325 val
= read_uleb128 (p
, &len
);
9327 printf ("%d (0x%x)\n", val
, val
);
9333 static unsigned char *
9334 display_power_gnu_attribute (unsigned char * p
, int tag
)
9340 if (tag
== Tag_GNU_Power_ABI_FP
)
9342 val
= read_uleb128 (p
, &len
);
9344 printf (" Tag_GNU_Power_ABI_FP: ");
9349 printf ("Hard or soft float\n");
9352 printf ("Hard float\n");
9355 printf ("Soft float\n");
9358 printf ("Single-precision hard float\n");
9361 printf ("??? (%d)\n", val
);
9367 if (tag
== Tag_GNU_Power_ABI_Vector
)
9369 val
= read_uleb128 (p
, &len
);
9371 printf (" Tag_GNU_Power_ABI_Vector: ");
9378 printf ("Generic\n");
9381 printf ("AltiVec\n");
9387 printf ("??? (%d)\n", val
);
9393 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9395 val
= read_uleb128 (p
, &len
);
9397 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9407 printf ("Memory\n");
9410 printf ("??? (%d)\n", val
);
9417 type
= 1; /* String. */
9419 type
= 2; /* uleb128. */
9420 printf (" Tag_unknown_%d: ", tag
);
9424 printf ("\"%s\"\n", p
);
9425 p
+= strlen ((char *) p
) + 1;
9429 val
= read_uleb128 (p
, &len
);
9431 printf ("%d (0x%x)\n", val
, val
);
9437 static unsigned char *
9438 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9444 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9446 val
= read_uleb128 (p
, &len
);
9448 printf (" Tag_GNU_MIPS_ABI_FP: ");
9453 printf ("Hard or soft float\n");
9456 printf ("Hard float (-mdouble-float)\n");
9459 printf ("Hard float (-msingle-float)\n");
9462 printf ("Soft float\n");
9465 printf ("64-bit float (-mips32r2 -mfp64)\n");
9468 printf ("??? (%d)\n", val
);
9475 type
= 1; /* String. */
9477 type
= 2; /* uleb128. */
9478 printf (" Tag_unknown_%d: ", tag
);
9482 printf ("\"%s\"\n", p
);
9483 p
+= strlen ((char *) p
) + 1;
9487 val
= read_uleb128 (p
, &len
);
9489 printf ("%d (0x%x)\n", val
, val
);
9496 process_attributes (FILE * file
,
9497 const char * public_name
,
9498 unsigned int proc_type
,
9499 unsigned char * (* display_pub_attribute
) (unsigned char *),
9500 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9502 Elf_Internal_Shdr
* sect
;
9503 unsigned char * contents
;
9505 unsigned char * end
;
9506 bfd_vma section_len
;
9510 /* Find the section header so that we get the size. */
9511 for (i
= 0, sect
= section_headers
;
9512 i
< elf_header
.e_shnum
;
9515 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9518 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
9519 sect
->sh_size
, _("attributes"));
9520 if (contents
== NULL
)
9526 len
= sect
->sh_size
- 1;
9532 bfd_boolean public_section
;
9533 bfd_boolean gnu_section
;
9535 section_len
= byte_get (p
, 4);
9538 if (section_len
> len
)
9540 printf (_("ERROR: Bad section length (%d > %d)\n"),
9541 (int) section_len
, (int) len
);
9546 printf ("Attribute Section: %s\n", p
);
9548 if (public_name
&& streq ((char *) p
, public_name
))
9549 public_section
= TRUE
;
9551 public_section
= FALSE
;
9553 if (streq ((char *) p
, "gnu"))
9556 gnu_section
= FALSE
;
9558 namelen
= strlen ((char *) p
) + 1;
9560 section_len
-= namelen
+ 4;
9562 while (section_len
> 0)
9568 size
= byte_get (p
, 4);
9569 if (size
> section_len
)
9571 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9572 (int) size
, (int) section_len
);
9576 section_len
-= size
;
9583 printf ("File Attributes\n");
9586 printf ("Section Attributes:");
9589 printf ("Symbol Attributes:");
9595 val
= read_uleb128 (p
, &j
);
9599 printf (" %d", val
);
9604 printf ("Unknown tag: %d\n", tag
);
9605 public_section
= FALSE
;
9612 p
= display_pub_attribute (p
);
9614 else if (gnu_section
)
9617 p
= display_gnu_attribute (p
,
9618 display_proc_gnu_attribute
);
9622 /* ??? Do something sensible, like dump hex. */
9623 printf (" Unknown section contexts\n");
9630 printf (_("Unknown format '%c'\n"), *p
);
9638 process_arm_specific (FILE * file
)
9640 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9641 display_arm_attribute
, NULL
);
9645 process_power_specific (FILE * file
)
9647 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9648 display_power_gnu_attribute
);
9651 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9652 Print the Address, Access and Initial fields of an entry at VMA ADDR
9653 and return the VMA of the next entry. */
9656 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9659 print_vma (addr
, LONG_HEX
);
9661 if (addr
< pltgot
+ 0xfff0)
9662 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9664 printf ("%10s", "");
9667 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9672 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9673 print_vma (entry
, LONG_HEX
);
9675 return addr
+ (is_32bit_elf
? 4 : 8);
9678 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9679 PLTGOT. Print the Address and Initial fields of an entry at VMA
9680 ADDR and return the VMA of the next entry. */
9683 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9686 print_vma (addr
, LONG_HEX
);
9689 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9694 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9695 print_vma (entry
, LONG_HEX
);
9697 return addr
+ (is_32bit_elf
? 4 : 8);
9701 process_mips_specific (FILE * file
)
9703 Elf_Internal_Dyn
* entry
;
9704 size_t liblist_offset
= 0;
9705 size_t liblistno
= 0;
9706 size_t conflictsno
= 0;
9707 size_t options_offset
= 0;
9708 size_t conflicts_offset
= 0;
9709 size_t pltrelsz
= 0;
9712 bfd_vma mips_pltgot
= 0;
9714 bfd_vma local_gotno
= 0;
9716 bfd_vma symtabno
= 0;
9718 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9719 display_mips_gnu_attribute
);
9721 /* We have a lot of special sections. Thanks SGI! */
9722 if (dynamic_section
== NULL
)
9723 /* No information available. */
9726 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9727 switch (entry
->d_tag
)
9729 case DT_MIPS_LIBLIST
:
9731 = offset_from_vma (file
, entry
->d_un
.d_val
,
9732 liblistno
* sizeof (Elf32_External_Lib
));
9734 case DT_MIPS_LIBLISTNO
:
9735 liblistno
= entry
->d_un
.d_val
;
9737 case DT_MIPS_OPTIONS
:
9738 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9740 case DT_MIPS_CONFLICT
:
9742 = offset_from_vma (file
, entry
->d_un
.d_val
,
9743 conflictsno
* sizeof (Elf32_External_Conflict
));
9745 case DT_MIPS_CONFLICTNO
:
9746 conflictsno
= entry
->d_un
.d_val
;
9749 pltgot
= entry
->d_un
.d_ptr
;
9751 case DT_MIPS_LOCAL_GOTNO
:
9752 local_gotno
= entry
->d_un
.d_val
;
9754 case DT_MIPS_GOTSYM
:
9755 gotsym
= entry
->d_un
.d_val
;
9757 case DT_MIPS_SYMTABNO
:
9758 symtabno
= entry
->d_un
.d_val
;
9760 case DT_MIPS_PLTGOT
:
9761 mips_pltgot
= entry
->d_un
.d_ptr
;
9764 pltrel
= entry
->d_un
.d_val
;
9767 pltrelsz
= entry
->d_un
.d_val
;
9770 jmprel
= entry
->d_un
.d_ptr
;
9776 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9778 Elf32_External_Lib
* elib
;
9781 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
9783 sizeof (Elf32_External_Lib
),
9787 printf ("\nSection '.liblist' contains %lu entries:\n",
9788 (unsigned long) liblistno
);
9789 fputs (" Library Time Stamp Checksum Version Flags\n",
9792 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9799 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9800 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9801 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9802 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9803 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9805 tmp
= gmtime (&atime
);
9806 snprintf (timebuf
, sizeof (timebuf
),
9807 "%04u-%02u-%02uT%02u:%02u:%02u",
9808 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9809 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9811 printf ("%3lu: ", (unsigned long) cnt
);
9812 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9813 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9815 printf ("<corrupt: %9ld>", liblist
.l_name
);
9816 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9819 if (liblist
.l_flags
== 0)
9830 { " EXACT_MATCH", LL_EXACT_MATCH
},
9831 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9832 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9833 { " EXPORTS", LL_EXPORTS
},
9834 { " DELAY_LOAD", LL_DELAY_LOAD
},
9835 { " DELTA", LL_DELTA
}
9837 int flags
= liblist
.l_flags
;
9840 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9841 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9843 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9844 flags
^= l_flags_vals
[fcnt
].bit
;
9847 printf (" %#x", (unsigned int) flags
);
9857 if (options_offset
!= 0)
9859 Elf_External_Options
* eopt
;
9860 Elf_Internal_Shdr
* sect
= section_headers
;
9861 Elf_Internal_Options
* iopt
;
9862 Elf_Internal_Options
* option
;
9866 /* Find the section header so that we get the size. */
9867 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9870 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
9871 sect
->sh_size
, _("options"));
9874 iopt
= (Elf_Internal_Options
*)
9875 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9878 error (_("Out of memory\n"));
9885 while (offset
< sect
->sh_size
)
9887 Elf_External_Options
* eoption
;
9889 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9891 option
->kind
= BYTE_GET (eoption
->kind
);
9892 option
->size
= BYTE_GET (eoption
->size
);
9893 option
->section
= BYTE_GET (eoption
->section
);
9894 option
->info
= BYTE_GET (eoption
->info
);
9896 offset
+= option
->size
;
9902 printf (_("\nSection '%s' contains %d entries:\n"),
9903 SECTION_NAME (sect
), cnt
);
9911 switch (option
->kind
)
9914 /* This shouldn't happen. */
9915 printf (" NULL %d %lx", option
->section
, option
->info
);
9918 printf (" REGINFO ");
9919 if (elf_header
.e_machine
== EM_MIPS
)
9922 Elf32_External_RegInfo
* ereg
;
9923 Elf32_RegInfo reginfo
;
9925 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9926 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9927 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9928 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9929 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9930 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9931 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9933 printf ("GPR %08lx GP 0x%lx\n",
9935 (unsigned long) reginfo
.ri_gp_value
);
9936 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9937 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9938 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9943 Elf64_External_RegInfo
* ereg
;
9944 Elf64_Internal_RegInfo reginfo
;
9946 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9947 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9948 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9949 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9950 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9951 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9952 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9954 printf ("GPR %08lx GP 0x",
9955 reginfo
.ri_gprmask
);
9956 printf_vma (reginfo
.ri_gp_value
);
9959 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9960 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9961 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9965 case ODK_EXCEPTIONS
:
9966 fputs (" EXCEPTIONS fpe_min(", stdout
);
9967 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9968 fputs (") fpe_max(", stdout
);
9969 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9970 fputs (")", stdout
);
9972 if (option
->info
& OEX_PAGE0
)
9973 fputs (" PAGE0", stdout
);
9974 if (option
->info
& OEX_SMM
)
9975 fputs (" SMM", stdout
);
9976 if (option
->info
& OEX_FPDBUG
)
9977 fputs (" FPDBUG", stdout
);
9978 if (option
->info
& OEX_DISMISS
)
9979 fputs (" DISMISS", stdout
);
9982 fputs (" PAD ", stdout
);
9983 if (option
->info
& OPAD_PREFIX
)
9984 fputs (" PREFIX", stdout
);
9985 if (option
->info
& OPAD_POSTFIX
)
9986 fputs (" POSTFIX", stdout
);
9987 if (option
->info
& OPAD_SYMBOL
)
9988 fputs (" SYMBOL", stdout
);
9991 fputs (" HWPATCH ", stdout
);
9992 if (option
->info
& OHW_R4KEOP
)
9993 fputs (" R4KEOP", stdout
);
9994 if (option
->info
& OHW_R8KPFETCH
)
9995 fputs (" R8KPFETCH", stdout
);
9996 if (option
->info
& OHW_R5KEOP
)
9997 fputs (" R5KEOP", stdout
);
9998 if (option
->info
& OHW_R5KCVTL
)
9999 fputs (" R5KCVTL", stdout
);
10002 fputs (" FILL ", stdout
);
10003 /* XXX Print content of info word? */
10006 fputs (" TAGS ", stdout
);
10007 /* XXX Print content of info word? */
10010 fputs (" HWAND ", stdout
);
10011 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10012 fputs (" R4KEOP_CHECKED", stdout
);
10013 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10014 fputs (" R4KEOP_CLEAN", stdout
);
10017 fputs (" HWOR ", stdout
);
10018 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10019 fputs (" R4KEOP_CHECKED", stdout
);
10020 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10021 fputs (" R4KEOP_CLEAN", stdout
);
10024 printf (" GP_GROUP %#06lx self-contained %#06lx",
10025 option
->info
& OGP_GROUP
,
10026 (option
->info
& OGP_SELF
) >> 16);
10029 printf (" IDENT %#06lx self-contained %#06lx",
10030 option
->info
& OGP_GROUP
,
10031 (option
->info
& OGP_SELF
) >> 16);
10034 /* This shouldn't happen. */
10035 printf (" %3d ??? %d %lx",
10036 option
->kind
, option
->section
, option
->info
);
10040 len
= sizeof (* eopt
);
10041 while (len
< option
->size
)
10042 if (((char *) option
)[len
] >= ' '
10043 && ((char *) option
)[len
] < 0x7f)
10044 printf ("%c", ((char *) option
)[len
++]);
10046 printf ("\\%03o", ((char *) option
)[len
++]);
10048 fputs ("\n", stdout
);
10056 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10058 Elf32_Conflict
* iconf
;
10061 if (dynamic_symbols
== NULL
)
10063 error (_("conflict list found without a dynamic symbol table\n"));
10067 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
10070 error (_("Out of memory\n"));
10076 Elf32_External_Conflict
* econf32
;
10078 econf32
= (Elf32_External_Conflict
*)
10079 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10080 sizeof (* econf32
), _("conflict"));
10084 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10085 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10091 Elf64_External_Conflict
* econf64
;
10093 econf64
= (Elf64_External_Conflict
*)
10094 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10095 sizeof (* econf64
), _("conflict"));
10099 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10100 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10105 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10106 (unsigned long) conflictsno
);
10107 puts (_(" Num: Index Value Name"));
10109 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10111 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10113 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10114 print_vma (psym
->st_value
, FULL_HEX
);
10116 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10117 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10119 printf ("<corrupt: %14ld>", psym
->st_name
);
10126 if (pltgot
!= 0 && local_gotno
!= 0)
10128 bfd_vma ent
, local_end
, global_end
;
10130 unsigned char * data
;
10134 addr_size
= (is_32bit_elf
? 4 : 8);
10135 local_end
= pltgot
+ local_gotno
* addr_size
;
10136 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10138 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10139 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10140 global_end
- pltgot
, 1, _("GOT"));
10141 printf (_("\nPrimary GOT:\n"));
10142 printf (_(" Canonical gp value: "));
10143 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10146 printf (_(" Reserved entries:\n"));
10147 printf (_(" %*s %10s %*s Purpose\n"),
10148 addr_size
* 2, "Address", "Access",
10149 addr_size
* 2, "Initial");
10150 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10151 printf (" Lazy resolver\n");
10153 && (byte_get (data
+ ent
- pltgot
, addr_size
)
10154 >> (addr_size
* 8 - 1)) != 0)
10156 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10157 printf (" Module pointer (GNU extension)\n");
10161 if (ent
< local_end
)
10163 printf (_(" Local entries:\n"));
10164 printf (_(" %*s %10s %*s\n"),
10165 addr_size
* 2, "Address", "Access",
10166 addr_size
* 2, "Initial");
10167 while (ent
< local_end
)
10169 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10175 if (gotsym
< symtabno
)
10179 printf (_(" Global entries:\n"));
10180 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10181 addr_size
* 2, "Address", "Access",
10182 addr_size
* 2, "Initial",
10183 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10184 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10185 for (i
= gotsym
; i
< symtabno
; i
++)
10187 Elf_Internal_Sym
* psym
;
10189 psym
= dynamic_symbols
+ i
;
10190 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10192 print_vma (psym
->st_value
, LONG_HEX
);
10193 printf (" %-7s %3s ",
10194 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10195 get_symbol_index_type (psym
->st_shndx
));
10196 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10197 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10199 printf ("<corrupt: %14ld>", psym
->st_name
);
10209 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10212 size_t offset
, rel_offset
;
10213 unsigned long count
, i
;
10214 unsigned char * data
;
10215 int addr_size
, sym_width
;
10216 Elf_Internal_Rela
* rels
;
10218 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10219 if (pltrel
== DT_RELA
)
10221 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10226 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10231 addr_size
= (is_32bit_elf
? 4 : 8);
10232 end
= mips_pltgot
+ (2 + count
) * addr_size
;
10234 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
10235 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
10237 printf (_("\nPLT GOT:\n\n"));
10238 printf (_(" Reserved entries:\n"));
10239 printf (_(" %*s %*s Purpose\n"),
10240 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10241 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10242 printf (" PLT lazy resolver\n");
10243 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10244 printf (" Module pointer\n");
10247 printf (_(" Entries:\n"));
10248 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10249 addr_size
* 2, "Address",
10250 addr_size
* 2, "Initial",
10251 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10252 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10253 for (i
= 0; i
< count
; i
++)
10255 Elf_Internal_Sym
* psym
;
10257 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10258 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10260 print_vma (psym
->st_value
, LONG_HEX
);
10261 printf (" %-7s %3s ",
10262 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10263 get_symbol_index_type (psym
->st_shndx
));
10264 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10265 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10267 printf ("<corrupt: %14ld>", psym
->st_name
);
10281 process_gnu_liblist (FILE * file
)
10283 Elf_Internal_Shdr
* section
;
10284 Elf_Internal_Shdr
* string_sec
;
10285 Elf32_External_Lib
* elib
;
10287 size_t strtab_size
;
10294 for (i
= 0, section
= section_headers
;
10295 i
< elf_header
.e_shnum
;
10298 switch (section
->sh_type
)
10300 case SHT_GNU_LIBLIST
:
10301 if (section
->sh_link
>= elf_header
.e_shnum
)
10304 elib
= (Elf32_External_Lib
*)
10305 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10310 string_sec
= section_headers
+ section
->sh_link
;
10312 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10313 string_sec
->sh_size
,
10314 _("liblist string table"));
10315 strtab_size
= string_sec
->sh_size
;
10318 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10324 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10325 SECTION_NAME (section
),
10326 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10328 puts (" Library Time Stamp Checksum Version Flags");
10330 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10338 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10339 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10340 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10341 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10342 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10344 tmp
= gmtime (&atime
);
10345 snprintf (timebuf
, sizeof (timebuf
),
10346 "%04u-%02u-%02uT%02u:%02u:%02u",
10347 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10348 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10350 printf ("%3lu: ", (unsigned long) cnt
);
10352 printf ("%-20s", liblist
.l_name
< strtab_size
10353 ? strtab
+ liblist
.l_name
: "<corrupt>");
10355 printf ("%-20.20s", liblist
.l_name
< strtab_size
10356 ? strtab
+ liblist
.l_name
: "<corrupt>");
10357 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10358 liblist
.l_version
, liblist
.l_flags
);
10368 static const char *
10369 get_note_type (unsigned e_type
)
10371 static char buff
[64];
10373 if (elf_header
.e_type
== ET_CORE
)
10377 return _("NT_AUXV (auxiliary vector)");
10379 return _("NT_PRSTATUS (prstatus structure)");
10381 return _("NT_FPREGSET (floating point registers)");
10383 return _("NT_PRPSINFO (prpsinfo structure)");
10384 case NT_TASKSTRUCT
:
10385 return _("NT_TASKSTRUCT (task structure)");
10387 return _("NT_PRXFPREG (user_xfpregs structure)");
10389 return _("NT_PPC_VMX (ppc Altivec registers)");
10391 return _("NT_PPC_VSX (ppc VSX registers)");
10392 case NT_S390_HIGH_GPRS
:
10393 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
10395 return _("NT_PSTATUS (pstatus structure)");
10397 return _("NT_FPREGS (floating point registers)");
10399 return _("NT_PSINFO (psinfo structure)");
10401 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10403 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10404 case NT_WIN32PSTATUS
:
10405 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10413 return _("NT_VERSION (version)");
10415 return _("NT_ARCH (architecture)");
10420 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10424 static const char *
10425 get_gnu_elf_note_type (unsigned e_type
)
10427 static char buff
[64];
10431 case NT_GNU_ABI_TAG
:
10432 return _("NT_GNU_ABI_TAG (ABI version tag)");
10434 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10435 case NT_GNU_BUILD_ID
:
10436 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10437 case NT_GNU_GOLD_VERSION
:
10438 return _("NT_GNU_GOLD_VERSION (gold version)");
10443 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10447 static const char *
10448 get_netbsd_elfcore_note_type (unsigned e_type
)
10450 static char buff
[64];
10452 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10454 /* NetBSD core "procinfo" structure. */
10455 return _("NetBSD procinfo structure");
10458 /* As of Jan 2002 there are no other machine-independent notes
10459 defined for NetBSD core files. If the note type is less
10460 than the start of the machine-dependent note types, we don't
10463 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10465 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10469 switch (elf_header
.e_machine
)
10471 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10472 and PT_GETFPREGS == mach+2. */
10477 case EM_SPARC32PLUS
:
10481 case NT_NETBSDCORE_FIRSTMACH
+0:
10482 return _("PT_GETREGS (reg structure)");
10483 case NT_NETBSDCORE_FIRSTMACH
+2:
10484 return _("PT_GETFPREGS (fpreg structure)");
10490 /* On all other arch's, PT_GETREGS == mach+1 and
10491 PT_GETFPREGS == mach+3. */
10495 case NT_NETBSDCORE_FIRSTMACH
+1:
10496 return _("PT_GETREGS (reg structure)");
10497 case NT_NETBSDCORE_FIRSTMACH
+3:
10498 return _("PT_GETFPREGS (fpreg structure)");
10504 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10505 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10509 /* Note that by the ELF standard, the name field is already null byte
10510 terminated, and namesz includes the terminating null byte.
10511 I.E. the value of namesz for the name "FSF" is 4.
10513 If the value of namesz is zero, there is no name present. */
10515 process_note (Elf_Internal_Note
* pnote
)
10517 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10520 if (pnote
->namesz
== 0)
10521 /* If there is no note name, then use the default set of
10522 note type strings. */
10523 nt
= get_note_type (pnote
->type
);
10525 else if (const_strneq (pnote
->namedata
, "GNU"))
10526 /* GNU-specific object file notes. */
10527 nt
= get_gnu_elf_note_type (pnote
->type
);
10529 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10530 /* NetBSD-specific core file notes. */
10531 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10533 else if (strneq (pnote
->namedata
, "SPU/", 4))
10535 /* SPU-specific core file notes. */
10536 nt
= pnote
->namedata
+ 4;
10541 /* Don't recognize this note name; just use the default set of
10542 note type strings. */
10543 nt
= get_note_type (pnote
->type
);
10545 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10551 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10553 Elf_External_Note
* pnotes
;
10554 Elf_External_Note
* external
;
10560 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
10567 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10568 (unsigned long) offset
, (unsigned long) length
);
10569 printf (_(" Owner\t\tData size\tDescription\n"));
10571 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10573 Elf_External_Note
* next
;
10574 Elf_Internal_Note inote
;
10575 char * temp
= NULL
;
10577 inote
.type
= BYTE_GET (external
->type
);
10578 inote
.namesz
= BYTE_GET (external
->namesz
);
10579 inote
.namedata
= external
->name
;
10580 inote
.descsz
= BYTE_GET (external
->descsz
);
10581 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10582 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10584 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10586 if (((char *) next
) > (((char *) pnotes
) + length
))
10588 warn (_("corrupt note found at offset %lx into core notes\n"),
10589 (unsigned long) ((char *) external
- (char *) pnotes
));
10590 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10591 inote
.type
, inote
.namesz
, inote
.descsz
);
10597 /* Verify that name is null terminated. It appears that at least
10598 one version of Linux (RedHat 6.0) generates corefiles that don't
10599 comply with the ELF spec by failing to include the null byte in
10601 if (inote
.namedata
[inote
.namesz
] != '\0')
10603 temp
= (char *) malloc (inote
.namesz
+ 1);
10607 error (_("Out of memory\n"));
10612 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10613 temp
[inote
.namesz
] = 0;
10615 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10616 inote
.namedata
= temp
;
10619 res
&= process_note (& inote
);
10634 process_corefile_note_segments (FILE * file
)
10636 Elf_Internal_Phdr
* segment
;
10640 if (! get_program_headers (file
))
10643 for (i
= 0, segment
= program_headers
;
10644 i
< elf_header
.e_phnum
;
10647 if (segment
->p_type
== PT_NOTE
)
10648 res
&= process_corefile_note_segment (file
,
10649 (bfd_vma
) segment
->p_offset
,
10650 (bfd_vma
) segment
->p_filesz
);
10657 process_note_sections (FILE * file
)
10659 Elf_Internal_Shdr
* section
;
10663 for (i
= 0, section
= section_headers
;
10664 i
< elf_header
.e_shnum
;
10666 if (section
->sh_type
== SHT_NOTE
)
10667 res
&= process_corefile_note_segment (file
,
10668 (bfd_vma
) section
->sh_offset
,
10669 (bfd_vma
) section
->sh_size
);
10675 process_notes (FILE * file
)
10677 /* If we have not been asked to display the notes then do nothing. */
10681 if (elf_header
.e_type
!= ET_CORE
)
10682 return process_note_sections (file
);
10684 /* No program headers means no NOTE segment. */
10685 if (elf_header
.e_phnum
> 0)
10686 return process_corefile_note_segments (file
);
10688 printf (_("No note segments present in the core file.\n"));
10693 process_arch_specific (FILE * file
)
10698 switch (elf_header
.e_machine
)
10701 return process_arm_specific (file
);
10703 case EM_MIPS_RS3_LE
:
10704 return process_mips_specific (file
);
10707 return process_power_specific (file
);
10716 get_file_header (FILE * file
)
10718 /* Read in the identity array. */
10719 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10722 /* Determine how to read the rest of the header. */
10723 switch (elf_header
.e_ident
[EI_DATA
])
10725 default: /* fall through */
10726 case ELFDATANONE
: /* fall through */
10728 byte_get
= byte_get_little_endian
;
10729 byte_put
= byte_put_little_endian
;
10732 byte_get
= byte_get_big_endian
;
10733 byte_put
= byte_put_big_endian
;
10737 /* For now we only support 32 bit and 64 bit ELF files. */
10738 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10740 /* Read in the rest of the header. */
10743 Elf32_External_Ehdr ehdr32
;
10745 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10748 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10749 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10750 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10751 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10752 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10753 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10754 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10755 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10756 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10757 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10758 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10759 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10760 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10764 Elf64_External_Ehdr ehdr64
;
10766 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10767 we will not be able to cope with the 64bit data found in
10768 64 ELF files. Detect this now and abort before we start
10769 overwriting things. */
10770 if (sizeof (bfd_vma
) < 8)
10772 error (_("This instance of readelf has been built without support for a\n\
10773 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10777 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10780 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10781 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10782 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10783 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10784 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10785 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10786 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10787 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10788 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10789 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10790 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10791 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10792 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10795 if (elf_header
.e_shoff
)
10797 /* There may be some extensions in the first section header. Don't
10798 bomb if we can't read it. */
10800 get_32bit_section_headers (file
, 1);
10802 get_64bit_section_headers (file
, 1);
10808 /* Process one ELF object file according to the command line options.
10809 This file may actually be stored in an archive. The file is
10810 positioned at the start of the ELF object. */
10813 process_object (char * file_name
, FILE * file
)
10817 if (! get_file_header (file
))
10819 error (_("%s: Failed to read file header\n"), file_name
);
10823 /* Initialise per file variables. */
10824 for (i
= ARRAY_SIZE (version_info
); i
--;)
10825 version_info
[i
] = 0;
10827 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10828 dynamic_info
[i
] = 0;
10830 /* Process the file. */
10832 printf (_("\nFile: %s\n"), file_name
);
10834 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10835 Note we do this even if cmdline_dump_sects is empty because we
10836 must make sure that the dump_sets array is zeroed out before each
10837 object file is processed. */
10838 if (num_dump_sects
> num_cmdline_dump_sects
)
10839 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10841 if (num_cmdline_dump_sects
> 0)
10843 if (num_dump_sects
== 0)
10844 /* A sneaky way of allocating the dump_sects array. */
10845 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10847 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10848 memcpy (dump_sects
, cmdline_dump_sects
,
10849 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10852 if (! process_file_header ())
10855 if (! process_section_headers (file
))
10857 /* Without loaded section headers we cannot process lots of
10859 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10861 if (! do_using_dynamic
)
10862 do_syms
= do_reloc
= 0;
10865 if (! process_section_groups (file
))
10867 /* Without loaded section groups we cannot process unwind. */
10871 if (process_program_headers (file
))
10872 process_dynamic_section (file
);
10874 process_relocs (file
);
10876 process_unwind (file
);
10878 process_symbol_table (file
);
10880 process_syminfo (file
);
10882 process_version_sections (file
);
10884 process_section_contents (file
);
10886 process_notes (file
);
10888 process_gnu_liblist (file
);
10890 process_arch_specific (file
);
10892 if (program_headers
)
10894 free (program_headers
);
10895 program_headers
= NULL
;
10898 if (section_headers
)
10900 free (section_headers
);
10901 section_headers
= NULL
;
10906 free (string_table
);
10907 string_table
= NULL
;
10908 string_table_length
= 0;
10911 if (dynamic_strings
)
10913 free (dynamic_strings
);
10914 dynamic_strings
= NULL
;
10915 dynamic_strings_length
= 0;
10918 if (dynamic_symbols
)
10920 free (dynamic_symbols
);
10921 dynamic_symbols
= NULL
;
10922 num_dynamic_syms
= 0;
10925 if (dynamic_syminfo
)
10927 free (dynamic_syminfo
);
10928 dynamic_syminfo
= NULL
;
10931 if (section_headers_groups
)
10933 free (section_headers_groups
);
10934 section_headers_groups
= NULL
;
10937 if (section_groups
)
10939 struct group_list
* g
;
10940 struct group_list
* next
;
10942 for (i
= 0; i
< group_count
; i
++)
10944 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10951 free (section_groups
);
10952 section_groups
= NULL
;
10955 free_debug_memory ();
10960 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10961 to the path name of the thin archive itself if necessary. Always returns
10962 a pointer to malloc'ed memory. */
10965 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10967 char * member_file_name
;
10968 const char * base_name
= lbasename (file_name
);
10970 /* This is a proxy entry for a thin archive member.
10971 If the extended name table contains an absolute path
10972 name, or if the archive is in the current directory,
10973 use the path name as given. Otherwise, we need to
10974 find the member relative to the directory where the
10975 archive is located. */
10976 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10978 member_file_name
= (char *) malloc (name_len
+ 1);
10979 if (member_file_name
== NULL
)
10981 error (_("Out of memory\n"));
10984 memcpy (member_file_name
, name
, name_len
);
10985 member_file_name
[name_len
] = '\0';
10989 /* Concatenate the path components of the archive file name
10990 to the relative path name from the extended name table. */
10991 size_t prefix_len
= base_name
- file_name
;
10992 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
10993 if (member_file_name
== NULL
)
10995 error (_("Out of memory\n"));
10998 memcpy (member_file_name
, file_name
, prefix_len
);
10999 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
11000 member_file_name
[prefix_len
+ name_len
] = '\0';
11002 return member_file_name
;
11005 /* Structure to hold information about an archive file. */
11007 struct archive_info
11009 char * file_name
; /* Archive file name. */
11010 FILE * file
; /* Open file descriptor. */
11011 unsigned long index_num
; /* Number of symbols in table. */
11012 unsigned long * index_array
; /* The array of member offsets. */
11013 char * sym_table
; /* The symbol table. */
11014 unsigned long sym_size
; /* Size of the symbol table. */
11015 char * longnames
; /* The long file names table. */
11016 unsigned long longnames_size
; /* Size of the long file names table. */
11017 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
11018 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
11019 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
11020 struct ar_hdr arhdr
; /* Current archive header. */
11023 /* Read the symbol table and long-name table from an archive. */
11026 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
11027 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
11030 unsigned long size
;
11032 arch
->file_name
= strdup (file_name
);
11034 arch
->index_num
= 0;
11035 arch
->index_array
= NULL
;
11036 arch
->sym_table
= NULL
;
11037 arch
->sym_size
= 0;
11038 arch
->longnames
= NULL
;
11039 arch
->longnames_size
= 0;
11040 arch
->nested_member_origin
= 0;
11041 arch
->is_thin_archive
= is_thin_archive
;
11042 arch
->next_arhdr_offset
= SARMAG
;
11044 /* Read the first archive member header. */
11045 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
11047 error (_("%s: failed to seek to first archive header\n"), file_name
);
11050 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11051 if (got
!= sizeof arch
->arhdr
)
11056 error (_("%s: failed to read archive header\n"), file_name
);
11060 /* See if this is the archive symbol table. */
11061 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
11062 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
11064 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11065 size
= size
+ (size
& 1);
11067 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
11072 /* A buffer used to hold numbers read in from an archive index.
11073 These are always 4 bytes long and stored in big-endian format. */
11074 #define SIZEOF_AR_INDEX_NUMBERS 4
11075 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
11076 unsigned char * index_buffer
;
11078 /* Check the size of the archive index. */
11079 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
11081 error (_("%s: the archive index is empty\n"), file_name
);
11085 /* Read the numer of entries in the archive index. */
11086 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
11087 if (got
!= sizeof (integer_buffer
))
11089 error (_("%s: failed to read archive index\n"), file_name
);
11092 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
11093 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11095 /* Read in the archive index. */
11096 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11098 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11099 file_name
, arch
->index_num
);
11102 index_buffer
= (unsigned char *)
11103 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11104 if (index_buffer
== NULL
)
11106 error (_("Out of memory whilst trying to read archive symbol index\n"));
11109 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11110 if (got
!= arch
->index_num
)
11112 free (index_buffer
);
11113 error (_("%s: failed to read archive index\n"), file_name
);
11116 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11118 /* Convert the index numbers into the host's numeric format. */
11119 arch
->index_array
= (long unsigned int *)
11120 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11121 if (arch
->index_array
== NULL
)
11123 free (index_buffer
);
11124 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11128 for (i
= 0; i
< arch
->index_num
; i
++)
11129 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11130 SIZEOF_AR_INDEX_NUMBERS
);
11131 free (index_buffer
);
11133 /* The remaining space in the header is taken up by the symbol table. */
11136 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11139 arch
->sym_table
= (char *) malloc (size
);
11140 arch
->sym_size
= size
;
11141 if (arch
->sym_table
== NULL
)
11143 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11146 got
= fread (arch
->sym_table
, 1, size
, file
);
11149 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11155 if (fseek (file
, size
, SEEK_CUR
) != 0)
11157 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11162 /* Read the next archive header. */
11163 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11164 if (got
!= sizeof arch
->arhdr
)
11168 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11172 else if (read_symbols
)
11173 printf (_("%s has no archive index\n"), file_name
);
11175 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11177 /* This is the archive string table holding long member names. */
11178 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11179 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11181 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11182 if (arch
->longnames
== NULL
)
11184 error (_("Out of memory reading long symbol names in archive\n"));
11188 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
11190 free (arch
->longnames
);
11191 arch
->longnames
= NULL
;
11192 error (_("%s: failed to read long symbol name string table\n"), file_name
);
11196 if ((arch
->longnames_size
& 1) != 0)
11203 /* Release the memory used for the archive information. */
11206 release_archive (struct archive_info
* arch
)
11208 if (arch
->file_name
!= NULL
)
11209 free (arch
->file_name
);
11210 if (arch
->index_array
!= NULL
)
11211 free (arch
->index_array
);
11212 if (arch
->sym_table
!= NULL
)
11213 free (arch
->sym_table
);
11214 if (arch
->longnames
!= NULL
)
11215 free (arch
->longnames
);
11218 /* Open and setup a nested archive, if not already open. */
11221 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
11223 FILE * member_file
;
11225 /* Have we already setup this archive? */
11226 if (nested_arch
->file_name
!= NULL
11227 && streq (nested_arch
->file_name
, member_file_name
))
11230 /* Close previous file and discard cached information. */
11231 if (nested_arch
->file
!= NULL
)
11232 fclose (nested_arch
->file
);
11233 release_archive (nested_arch
);
11235 member_file
= fopen (member_file_name
, "rb");
11236 if (member_file
== NULL
)
11238 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
11242 get_archive_member_name_at (struct archive_info
* arch
,
11243 unsigned long offset
,
11244 struct archive_info
* nested_arch
);
11246 /* Get the name of an archive member from the current archive header.
11247 For simple names, this will modify the ar_name field of the current
11248 archive header. For long names, it will return a pointer to the
11249 longnames table. For nested archives, it will open the nested archive
11250 and get the name recursively. NESTED_ARCH is a single-entry cache so
11251 we don't keep rereading the same information from a nested archive. */
11254 get_archive_member_name (struct archive_info
* arch
,
11255 struct archive_info
* nested_arch
)
11257 unsigned long j
, k
;
11259 if (arch
->arhdr
.ar_name
[0] == '/')
11261 /* We have a long name. */
11263 char * member_file_name
;
11264 char * member_name
;
11266 arch
->nested_member_origin
= 0;
11267 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11268 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11269 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11271 while ((j
< arch
->longnames_size
)
11272 && (arch
->longnames
[j
] != '\n')
11273 && (arch
->longnames
[j
] != '\0'))
11275 if (arch
->longnames
[j
-1] == '/')
11277 arch
->longnames
[j
] = '\0';
11279 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11280 return arch
->longnames
+ k
;
11282 /* This is a proxy for a member of a nested archive.
11283 Find the name of the member in that archive. */
11284 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11285 if (member_file_name
!= NULL
11286 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11287 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11289 free (member_file_name
);
11290 return member_name
;
11292 free (member_file_name
);
11294 /* Last resort: just return the name of the nested archive. */
11295 return arch
->longnames
+ k
;
11298 /* We have a normal (short) name. */
11300 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11302 arch
->arhdr
.ar_name
[j
] = '\0';
11303 return arch
->arhdr
.ar_name
;
11306 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11309 get_archive_member_name_at (struct archive_info
* arch
,
11310 unsigned long offset
,
11311 struct archive_info
* nested_arch
)
11315 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11317 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11320 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11321 if (got
!= sizeof arch
->arhdr
)
11323 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11326 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11328 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11332 return get_archive_member_name (arch
, nested_arch
);
11335 /* Construct a string showing the name of the archive member, qualified
11336 with the name of the containing archive file. For thin archives, we
11337 use square brackets to denote the indirection. For nested archives,
11338 we show the qualified name of the external member inside the square
11339 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11342 make_qualified_name (struct archive_info
* arch
,
11343 struct archive_info
* nested_arch
,
11344 char * member_name
)
11349 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11350 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11351 len
+= strlen (nested_arch
->file_name
) + 2;
11353 name
= (char *) malloc (len
);
11356 error (_("Out of memory\n"));
11360 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11361 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11362 else if (arch
->is_thin_archive
)
11363 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11365 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11370 /* Process an ELF archive.
11371 On entry the file is positioned just after the ARMAG string. */
11374 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11376 struct archive_info arch
;
11377 struct archive_info nested_arch
;
11379 size_t file_name_size
;
11384 /* The ARCH structure is used to hold information about this archive. */
11385 arch
.file_name
= NULL
;
11387 arch
.index_array
= NULL
;
11388 arch
.sym_table
= NULL
;
11389 arch
.longnames
= NULL
;
11391 /* The NESTED_ARCH structure is used as a single-item cache of information
11392 about a nested archive (when members of a thin archive reside within
11393 another regular archive file). */
11394 nested_arch
.file_name
= NULL
;
11395 nested_arch
.file
= NULL
;
11396 nested_arch
.index_array
= NULL
;
11397 nested_arch
.sym_table
= NULL
;
11398 nested_arch
.longnames
= NULL
;
11400 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11406 if (do_archive_index
)
11408 if (arch
.sym_table
== NULL
)
11409 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11413 unsigned long current_pos
;
11415 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11416 file_name
, arch
.index_num
, arch
.sym_size
);
11417 current_pos
= ftell (file
);
11419 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11421 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11423 char * member_name
;
11425 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11427 if (member_name
!= NULL
)
11429 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11431 if (qualified_name
!= NULL
)
11433 printf (_("Binary %s contains:\n"), qualified_name
);
11434 free (qualified_name
);
11439 if (l
>= arch
.sym_size
)
11441 error (_("%s: end of the symbol table reached before the end of the index\n"),
11445 printf ("\t%s\n", arch
.sym_table
+ l
);
11446 l
+= strlen (arch
.sym_table
+ l
) + 1;
11451 if (l
< arch
.sym_size
)
11452 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11455 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11457 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11463 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11464 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11465 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11466 && !do_section_groups
)
11468 ret
= 0; /* Archive index only. */
11473 file_name_size
= strlen (file_name
);
11480 char * qualified_name
;
11482 /* Read the next archive header. */
11483 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11485 error (_("%s: failed to seek to next archive header\n"), file_name
);
11488 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11489 if (got
!= sizeof arch
.arhdr
)
11493 error (_("%s: failed to read archive header\n"), file_name
);
11497 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11499 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11504 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11506 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11507 if (archive_file_size
& 01)
11508 ++archive_file_size
;
11510 name
= get_archive_member_name (&arch
, &nested_arch
);
11513 error (_("%s: bad archive file name\n"), file_name
);
11517 namelen
= strlen (name
);
11519 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11520 if (qualified_name
== NULL
)
11522 error (_("%s: bad archive file name\n"), file_name
);
11527 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11529 /* This is a proxy for an external member of a thin archive. */
11530 FILE * member_file
;
11531 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11532 if (member_file_name
== NULL
)
11538 member_file
= fopen (member_file_name
, "rb");
11539 if (member_file
== NULL
)
11541 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11542 free (member_file_name
);
11547 archive_file_offset
= arch
.nested_member_origin
;
11549 ret
|= process_object (qualified_name
, member_file
);
11551 fclose (member_file
);
11552 free (member_file_name
);
11554 else if (is_thin_archive
)
11556 /* This is a proxy for a member of a nested archive. */
11557 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11559 /* The nested archive file will have been opened and setup by
11560 get_archive_member_name. */
11561 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11563 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11568 ret
|= process_object (qualified_name
, nested_arch
.file
);
11572 archive_file_offset
= arch
.next_arhdr_offset
;
11573 arch
.next_arhdr_offset
+= archive_file_size
;
11575 ret
|= process_object (qualified_name
, file
);
11578 free (qualified_name
);
11582 if (nested_arch
.file
!= NULL
)
11583 fclose (nested_arch
.file
);
11584 release_archive (&nested_arch
);
11585 release_archive (&arch
);
11591 process_file (char * file_name
)
11594 struct stat statbuf
;
11595 char armag
[SARMAG
];
11598 if (stat (file_name
, &statbuf
) < 0)
11600 if (errno
== ENOENT
)
11601 error (_("'%s': No such file\n"), file_name
);
11603 error (_("Could not locate '%s'. System error message: %s\n"),
11604 file_name
, strerror (errno
));
11608 if (! S_ISREG (statbuf
.st_mode
))
11610 error (_("'%s' is not an ordinary file\n"), file_name
);
11614 file
= fopen (file_name
, "rb");
11617 error (_("Input file '%s' is not readable.\n"), file_name
);
11621 if (fread (armag
, SARMAG
, 1, file
) != 1)
11623 error (_("%s: Failed to read file's magic number\n"), file_name
);
11628 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11629 ret
= process_archive (file_name
, file
, FALSE
);
11630 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11631 ret
= process_archive (file_name
, file
, TRUE
);
11634 if (do_archive_index
)
11635 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11639 archive_file_size
= archive_file_offset
= 0;
11640 ret
= process_object (file_name
, file
);
11648 #ifdef SUPPORT_DISASSEMBLY
11649 /* Needed by the i386 disassembler. For extra credit, someone could
11650 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11654 print_address (unsigned int addr
, FILE * outfile
)
11656 fprintf (outfile
,"0x%8.8x", addr
);
11659 /* Needed by the i386 disassembler. */
11661 db_task_printsym (unsigned int addr
)
11663 print_address (addr
, stderr
);
11668 main (int argc
, char ** argv
)
11672 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11673 setlocale (LC_MESSAGES
, "");
11675 #if defined (HAVE_SETLOCALE)
11676 setlocale (LC_CTYPE
, "");
11678 bindtextdomain (PACKAGE
, LOCALEDIR
);
11679 textdomain (PACKAGE
);
11681 expandargv (&argc
, &argv
);
11683 parse_args (argc
, argv
);
11685 if (num_dump_sects
> 0)
11687 /* Make a copy of the dump_sects array. */
11688 cmdline_dump_sects
= (dump_type
*)
11689 malloc (num_dump_sects
* sizeof (* dump_sects
));
11690 if (cmdline_dump_sects
== NULL
)
11691 error (_("Out of memory allocating dump request table.\n"));
11694 memcpy (cmdline_dump_sects
, dump_sects
,
11695 num_dump_sects
* sizeof (* dump_sects
));
11696 num_cmdline_dump_sects
= num_dump_sects
;
11700 if (optind
< (argc
- 1))
11704 while (optind
< argc
)
11705 err
|= process_file (argv
[optind
++]);
11707 if (dump_sects
!= NULL
)
11709 if (cmdline_dump_sects
!= NULL
)
11710 free (cmdline_dump_sects
);