1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 Free Software Foundation, Inc.
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
9 This file is part of GNU Binutils.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
26 /* The difference between readelf and objdump:
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56 as this will allow us to read in and parse 64bit and 32bit ELF files.
57 Only do this if we believe that the compiler can support a 64 bit
58 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
105 #include "elf/fr30.h"
108 #include "elf/hppa.h"
109 #include "elf/i386.h"
110 #include "elf/i370.h"
111 #include "elf/i860.h"
112 #include "elf/i960.h"
113 #include "elf/ia64.h"
114 #include "elf/ip2k.h"
115 #include "elf/lm32.h"
116 #include "elf/iq2000.h"
117 #include "elf/m32c.h"
118 #include "elf/m32r.h"
119 #include "elf/m68k.h"
120 #include "elf/m68hc11.h"
121 #include "elf/mcore.h"
123 #include "elf/microblaze.h"
124 #include "elf/mips.h"
125 #include "elf/mmix.h"
126 #include "elf/mn10200.h"
127 #include "elf/mn10300.h"
129 #include "elf/msp430.h"
130 #include "elf/or32.h"
133 #include "elf/ppc64.h"
135 #include "elf/s390.h"
136 #include "elf/score.h"
138 #include "elf/sparc.h"
140 #include "elf/v850.h"
142 #include "elf/x86-64.h"
143 #include "elf/xc16x.h"
144 #include "elf/xstormy16.h"
145 #include "elf/xtensa.h"
150 #include "libiberty.h"
151 #include "safe-ctype.h"
152 #include "filenames.h"
154 char * program_name
= "readelf";
155 static long archive_file_offset
;
156 static unsigned long archive_file_size
;
157 static unsigned long dynamic_addr
;
158 static bfd_size_type dynamic_size
;
159 static unsigned int dynamic_nent
;
160 static char * dynamic_strings
;
161 static unsigned long dynamic_strings_length
;
162 static char * string_table
;
163 static unsigned long string_table_length
;
164 static unsigned long num_dynamic_syms
;
165 static Elf_Internal_Sym
* dynamic_symbols
;
166 static Elf_Internal_Syminfo
* dynamic_syminfo
;
167 static unsigned long dynamic_syminfo_offset
;
168 static unsigned int dynamic_syminfo_nent
;
169 static char program_interpreter
[PATH_MAX
];
170 static bfd_vma dynamic_info
[DT_ENCODING
];
171 static bfd_vma dynamic_info_DT_GNU_HASH
;
172 static bfd_vma version_info
[16];
173 static Elf_Internal_Ehdr elf_header
;
174 static Elf_Internal_Shdr
* section_headers
;
175 static Elf_Internal_Phdr
* program_headers
;
176 static Elf_Internal_Dyn
* dynamic_section
;
177 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
178 static int show_name
;
179 static int do_dynamic
;
181 static int do_dyn_syms
;
183 static int do_sections
;
184 static int do_section_groups
;
185 static int do_section_details
;
186 static int do_segments
;
187 static int do_unwind
;
188 static int do_using_dynamic
;
189 static int do_header
;
191 static int do_version
;
192 static int do_histogram
;
193 static int do_debugging
;
196 static int do_archive_index
;
197 static int is_32bit_elf
;
201 struct group_list
* next
;
202 unsigned int section_index
;
207 struct group_list
* root
;
208 unsigned int group_index
;
211 static size_t group_count
;
212 static struct group
* section_groups
;
213 static struct group
** section_headers_groups
;
216 /* Flag bits indicating particular types of dump. */
217 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
218 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
219 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
220 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
221 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
223 typedef unsigned char dump_type
;
225 /* A linked list of the section names for which dumps were requested. */
226 struct dump_list_entry
230 struct dump_list_entry
* next
;
232 static struct dump_list_entry
* dump_sects_byname
;
234 /* A dynamic array of flags indicating for which sections a dump
235 has been requested via command line switches. */
236 static dump_type
* cmdline_dump_sects
= NULL
;
237 static unsigned int num_cmdline_dump_sects
= 0;
239 /* A dynamic array of flags indicating for which sections a dump of
240 some kind has been requested. It is reset on a per-object file
241 basis and then initialised from the cmdline_dump_sects array,
242 the results of interpreting the -w switch, and the
243 dump_sects_byname list. */
244 static dump_type
* dump_sects
= NULL
;
245 static unsigned int num_dump_sects
= 0;
248 /* How to print a vma value. */
249 typedef enum print_mode
261 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
265 #define SECTION_NAME(X) \
266 ((X) == NULL ? "<none>" \
267 : string_table == NULL ? "<no-name>" \
268 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
269 : string_table + (X)->sh_name))
271 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
273 #define BYTE_GET(field) byte_get (field, sizeof (field))
275 #define GET_ELF_SYMBOLS(file, section) \
276 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
277 : get_64bit_elf_symbols (file, section))
279 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
280 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
281 already been called and verified that the string exists. */
282 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
284 /* This is just a bit of syntatic sugar. */
285 #define streq(a,b) (strcmp ((a), (b)) == 0)
286 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
287 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
290 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
295 if (size
== 0 || nmemb
== 0)
298 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
300 error (_("Unable to seek to 0x%lx for %s\n"),
301 (unsigned long) archive_file_offset
+ offset
, reason
);
308 /* Check for overflow. */
309 if (nmemb
< (~(size_t) 0 - 1) / size
)
310 /* + 1 so that we can '\0' terminate invalid string table sections. */
311 mvar
= malloc (size
* nmemb
+ 1);
315 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
316 (unsigned long)(size
* nmemb
), reason
);
320 ((char *) mvar
)[size
* nmemb
] = '\0';
323 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
325 error (_("Unable to read in 0x%lx bytes of %s\n"),
326 (unsigned long)(size
* nmemb
), reason
);
336 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
341 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
342 field
[6] = ((value
>> 24) >> 24) & 0xff;
343 field
[5] = ((value
>> 24) >> 16) & 0xff;
344 field
[4] = ((value
>> 24) >> 8) & 0xff;
347 field
[3] = (value
>> 24) & 0xff;
350 field
[2] = (value
>> 16) & 0xff;
353 field
[1] = (value
>> 8) & 0xff;
356 field
[0] = value
& 0xff;
360 error (_("Unhandled data length: %d\n"), size
);
365 /* Print a VMA value. */
368 print_vma (bfd_vma vma
, print_mode mode
)
381 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
388 return printf ("%5" BFD_VMA_FMT
"d", vma
);
396 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
399 return printf ("%" BFD_VMA_FMT
"d", vma
);
402 return printf ("%" BFD_VMA_FMT
"u", vma
);
407 /* Display a symbol on stdout. Handles the display of non-printing characters.
409 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
410 truncating as necessary. If WIDTH is negative then format the string to be
411 exactly - WIDTH characters, truncating or padding as necessary.
413 Returns the number of emitted characters. */
416 print_symbol (int width
, const char * symbol
)
419 bfd_boolean extra_padding
= FALSE
;
420 unsigned int num_printed
= 0;
424 /* Set the width to a very large value. This simplifies the code below. */
429 /* Keep the width positive. This also helps. */
431 extra_padding
= TRUE
;
440 /* Look for non-printing symbols inside the symbol's name.
441 This test is triggered in particular by the names generated
442 by the assembler for local labels. */
443 while (ISPRINT (* c
))
453 printf ("%.*s", len
, symbol
);
459 if (* c
== 0 || width
== 0)
462 /* Now display the non-printing character, if
463 there is room left in which to dipslay it. */
469 printf ("^%c", *c
+ 0x40);
479 printf ("<0x%.2x>", *c
);
488 if (extra_padding
&& width
> 0)
490 /* Fill in the remaining spaces. */
491 printf ("%-*s", width
, " ");
499 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
504 field
[7] = value
& 0xff;
505 field
[6] = (value
>> 8) & 0xff;
506 field
[5] = (value
>> 16) & 0xff;
507 field
[4] = (value
>> 24) & 0xff;
512 field
[3] = value
& 0xff;
516 field
[2] = value
& 0xff;
520 field
[1] = value
& 0xff;
524 field
[0] = value
& 0xff;
528 error (_("Unhandled data length: %d\n"), size
);
533 /* Return a pointer to section NAME, or NULL if no such section exists. */
535 static Elf_Internal_Shdr
*
536 find_section (const char * name
)
540 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
541 if (streq (SECTION_NAME (section_headers
+ i
), name
))
542 return section_headers
+ i
;
547 /* Guess the relocation size commonly used by the specific machines. */
550 guess_is_rela (unsigned int e_machine
)
554 /* Targets that use REL relocations. */
570 /* Targets that use RELA relocations. */
574 case EM_ALTERA_NIOS2
:
594 case EM_LATTICEMICO32
:
602 case EM_CYGNUS_MN10200
:
604 case EM_CYGNUS_MN10300
:
628 case EM_MICROBLAZE_OLD
:
649 warn (_("Don't know about relocations on this machine architecture\n"));
655 slurp_rela_relocs (FILE * file
,
656 unsigned long rel_offset
,
657 unsigned long rel_size
,
658 Elf_Internal_Rela
** relasp
,
659 unsigned long * nrelasp
)
661 Elf_Internal_Rela
* relas
;
662 unsigned long nrelas
;
667 Elf32_External_Rela
* erelas
;
669 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
670 rel_size
, _("relocs"));
674 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
676 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
677 sizeof (Elf_Internal_Rela
));
682 error (_("out of memory parsing relocs\n"));
686 for (i
= 0; i
< nrelas
; i
++)
688 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
689 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
690 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
697 Elf64_External_Rela
* erelas
;
699 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
700 rel_size
, _("relocs"));
704 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
706 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
707 sizeof (Elf_Internal_Rela
));
712 error (_("out of memory parsing relocs\n"));
716 for (i
= 0; i
< nrelas
; i
++)
718 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
719 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
720 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
722 /* The #ifdef BFD64 below is to prevent a compile time
723 warning. We know that if we do not have a 64 bit data
724 type that we will never execute this code anyway. */
726 if (elf_header
.e_machine
== EM_MIPS
727 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
729 /* In little-endian objects, r_info isn't really a
730 64-bit little-endian value: it has a 32-bit
731 little-endian symbol index followed by four
732 individual byte fields. Reorder INFO
734 bfd_vma inf
= relas
[i
].r_info
;
735 inf
= (((inf
& 0xffffffff) << 32)
736 | ((inf
>> 56) & 0xff)
737 | ((inf
>> 40) & 0xff00)
738 | ((inf
>> 24) & 0xff0000)
739 | ((inf
>> 8) & 0xff000000));
740 relas
[i
].r_info
= inf
;
753 slurp_rel_relocs (FILE * file
,
754 unsigned long rel_offset
,
755 unsigned long rel_size
,
756 Elf_Internal_Rela
** relsp
,
757 unsigned long * nrelsp
)
759 Elf_Internal_Rela
* rels
;
765 Elf32_External_Rel
* erels
;
767 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
768 rel_size
, _("relocs"));
772 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
774 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
779 error (_("out of memory parsing relocs\n"));
783 for (i
= 0; i
< nrels
; i
++)
785 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
786 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
787 rels
[i
].r_addend
= 0;
794 Elf64_External_Rel
* erels
;
796 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
797 rel_size
, _("relocs"));
801 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
803 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
808 error (_("out of memory parsing relocs\n"));
812 for (i
= 0; i
< nrels
; i
++)
814 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
815 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
816 rels
[i
].r_addend
= 0;
818 /* The #ifdef BFD64 below is to prevent a compile time
819 warning. We know that if we do not have a 64 bit data
820 type that we will never execute this code anyway. */
822 if (elf_header
.e_machine
== EM_MIPS
823 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
825 /* In little-endian objects, r_info isn't really a
826 64-bit little-endian value: it has a 32-bit
827 little-endian symbol index followed by four
828 individual byte fields. Reorder INFO
830 bfd_vma inf
= rels
[i
].r_info
;
831 inf
= (((inf
& 0xffffffff) << 32)
832 | ((inf
>> 56) & 0xff)
833 | ((inf
>> 40) & 0xff00)
834 | ((inf
>> 24) & 0xff0000)
835 | ((inf
>> 8) & 0xff000000));
836 rels
[i
].r_info
= inf
;
848 /* Returns the reloc type extracted from the reloc info field. */
851 get_reloc_type (bfd_vma reloc_info
)
854 return ELF32_R_TYPE (reloc_info
);
856 switch (elf_header
.e_machine
)
859 /* Note: We assume that reloc_info has already been adjusted for us. */
860 return ELF64_MIPS_R_TYPE (reloc_info
);
863 return ELF64_R_TYPE_ID (reloc_info
);
866 return ELF64_R_TYPE (reloc_info
);
870 /* Return the symbol index extracted from the reloc info field. */
873 get_reloc_symindex (bfd_vma reloc_info
)
875 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
878 /* Display the contents of the relocation data found at the specified
882 dump_relocations (FILE * file
,
883 unsigned long rel_offset
,
884 unsigned long rel_size
,
885 Elf_Internal_Sym
* symtab
,
888 unsigned long strtablen
,
892 Elf_Internal_Rela
* rels
;
894 if (is_rela
== UNKNOWN
)
895 is_rela
= guess_is_rela (elf_header
.e_machine
);
899 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
904 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
913 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
915 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
920 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
922 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
930 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
932 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
937 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
939 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
943 for (i
= 0; i
< rel_size
; i
++)
948 bfd_vma symtab_index
;
951 offset
= rels
[i
].r_offset
;
952 inf
= rels
[i
].r_info
;
954 type
= get_reloc_type (inf
);
955 symtab_index
= get_reloc_symindex (inf
);
959 printf ("%8.8lx %8.8lx ",
960 (unsigned long) offset
& 0xffffffff,
961 (unsigned long) inf
& 0xffffffff);
965 #if BFD_HOST_64BIT_LONG
967 ? "%16.16lx %16.16lx "
968 : "%12.12lx %12.12lx ",
970 #elif BFD_HOST_64BIT_LONG_LONG
973 ? "%16.16llx %16.16llx "
974 : "%12.12llx %12.12llx ",
978 ? "%16.16I64x %16.16I64x "
979 : "%12.12I64x %12.12I64x ",
984 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
985 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
986 _bfd_int64_high (offset
),
987 _bfd_int64_low (offset
),
988 _bfd_int64_high (inf
),
989 _bfd_int64_low (inf
));
993 switch (elf_header
.e_machine
)
1000 case EM_CYGNUS_M32R
:
1001 rtype
= elf_m32r_reloc_type (type
);
1006 rtype
= elf_i386_reloc_type (type
);
1011 rtype
= elf_m68hc11_reloc_type (type
);
1015 rtype
= elf_m68k_reloc_type (type
);
1019 rtype
= elf_i960_reloc_type (type
);
1024 rtype
= elf_avr_reloc_type (type
);
1027 case EM_OLD_SPARCV9
:
1028 case EM_SPARC32PLUS
:
1031 rtype
= elf_sparc_reloc_type (type
);
1035 rtype
= elf_spu_reloc_type (type
);
1039 case EM_CYGNUS_V850
:
1040 rtype
= v850_reloc_type (type
);
1044 case EM_CYGNUS_D10V
:
1045 rtype
= elf_d10v_reloc_type (type
);
1049 case EM_CYGNUS_D30V
:
1050 rtype
= elf_d30v_reloc_type (type
);
1054 rtype
= elf_dlx_reloc_type (type
);
1058 rtype
= elf_sh_reloc_type (type
);
1062 case EM_CYGNUS_MN10300
:
1063 rtype
= elf_mn10300_reloc_type (type
);
1067 case EM_CYGNUS_MN10200
:
1068 rtype
= elf_mn10200_reloc_type (type
);
1072 case EM_CYGNUS_FR30
:
1073 rtype
= elf_fr30_reloc_type (type
);
1077 rtype
= elf_frv_reloc_type (type
);
1081 rtype
= elf_mcore_reloc_type (type
);
1085 rtype
= elf_mmix_reloc_type (type
);
1090 rtype
= elf_msp430_reloc_type (type
);
1094 rtype
= elf_ppc_reloc_type (type
);
1098 rtype
= elf_ppc64_reloc_type (type
);
1102 case EM_MIPS_RS3_LE
:
1103 rtype
= elf_mips_reloc_type (type
);
1107 rtype
= elf_alpha_reloc_type (type
);
1111 rtype
= elf_arm_reloc_type (type
);
1115 rtype
= elf_arc_reloc_type (type
);
1119 rtype
= elf_hppa_reloc_type (type
);
1125 rtype
= elf_h8_reloc_type (type
);
1130 rtype
= elf_or32_reloc_type (type
);
1135 rtype
= elf_pj_reloc_type (type
);
1138 rtype
= elf_ia64_reloc_type (type
);
1142 rtype
= elf_cris_reloc_type (type
);
1146 rtype
= elf_i860_reloc_type (type
);
1151 rtype
= elf_x86_64_reloc_type (type
);
1155 rtype
= i370_reloc_type (type
);
1160 rtype
= elf_s390_reloc_type (type
);
1164 rtype
= elf_score_reloc_type (type
);
1168 rtype
= elf_xstormy16_reloc_type (type
);
1172 rtype
= elf_crx_reloc_type (type
);
1176 rtype
= elf_vax_reloc_type (type
);
1181 rtype
= elf_ip2k_reloc_type (type
);
1185 rtype
= elf_iq2000_reloc_type (type
);
1190 rtype
= elf_xtensa_reloc_type (type
);
1193 case EM_LATTICEMICO32
:
1194 rtype
= elf_lm32_reloc_type (type
);
1199 rtype
= elf_m32c_reloc_type (type
);
1203 rtype
= elf_mt_reloc_type (type
);
1207 rtype
= elf_bfin_reloc_type (type
);
1211 rtype
= elf_mep_reloc_type (type
);
1216 rtype
= elf_cr16_reloc_type (type
);
1220 case EM_MICROBLAZE_OLD
:
1221 rtype
= elf_microblaze_reloc_type (type
);
1225 rtype
= elf_rx_reloc_type (type
);
1230 rtype
= elf_xc16x_reloc_type (type
);
1235 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1237 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1239 if (elf_header
.e_machine
== EM_ALPHA
1241 && streq (rtype
, "R_ALPHA_LITUSE")
1244 switch (rels
[i
].r_addend
)
1246 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1247 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1248 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1249 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1250 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1251 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1252 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1253 default: rtype
= NULL
;
1256 printf (" (%s)", rtype
);
1260 printf (_("<unknown addend: %lx>"),
1261 (unsigned long) rels
[i
].r_addend
);
1264 else if (symtab_index
)
1266 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1267 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1270 Elf_Internal_Sym
* psym
;
1272 psym
= symtab
+ symtab_index
;
1276 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1280 unsigned int width
= is_32bit_elf
? 8 : 14;
1282 /* Relocations against GNU_IFUNC symbols do not use the value
1283 of the symbol as the address to relocate against. Instead
1284 they invoke the function named by the symbol and use its
1285 result as the address for relocation.
1287 To indicate this to the user, do not display the value of
1288 the symbol in the "Symbols's Value" field. Instead show
1289 its name followed by () as a hint that the symbol is
1293 || psym
->st_name
== 0
1294 || psym
->st_name
>= strtablen
)
1297 name
= strtab
+ psym
->st_name
;
1299 len
= print_symbol (width
, name
);
1300 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1304 print_vma (psym
->st_value
, LONG_HEX
);
1306 printf (is_32bit_elf
? " " : " ");
1309 if (psym
->st_name
== 0)
1311 const char * sec_name
= "<null>";
1314 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1316 if (psym
->st_shndx
< elf_header
.e_shnum
)
1318 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1319 else if (psym
->st_shndx
== SHN_ABS
)
1321 else if (psym
->st_shndx
== SHN_COMMON
)
1322 sec_name
= "COMMON";
1323 else if (elf_header
.e_machine
== EM_MIPS
1324 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1325 sec_name
= "SCOMMON";
1326 else if (elf_header
.e_machine
== EM_MIPS
1327 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1328 sec_name
= "SUNDEF";
1329 else if ((elf_header
.e_machine
== EM_X86_64
1330 || elf_header
.e_machine
== EM_L1OM
)
1331 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1332 sec_name
= "LARGE_COMMON";
1333 else if (elf_header
.e_machine
== EM_IA_64
1334 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1335 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1336 sec_name
= "ANSI_COM";
1337 else if (elf_header
.e_machine
== EM_IA_64
1338 && (elf_header
.e_ident
[EI_OSABI
]
1339 == ELFOSABI_OPENVMS
)
1340 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1341 sec_name
= "VMS_SYMVEC";
1344 sprintf (name_buf
, "<section 0x%x>",
1345 (unsigned int) psym
->st_shndx
);
1346 sec_name
= name_buf
;
1349 print_symbol (22, sec_name
);
1351 else if (strtab
== NULL
)
1352 printf (_("<string table index: %3ld>"), psym
->st_name
);
1353 else if (psym
->st_name
>= strtablen
)
1354 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1356 print_symbol (22, strtab
+ psym
->st_name
);
1360 long off
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1363 printf (" - %lx", - off
);
1365 printf (" + %lx", off
);
1371 printf ("%*c", is_32bit_elf
?
1372 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1373 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1376 if (elf_header
.e_machine
== EM_SPARCV9
1378 && streq (rtype
, "R_SPARC_OLO10"))
1379 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1384 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1386 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1387 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1388 const char * rtype2
= elf_mips_reloc_type (type2
);
1389 const char * rtype3
= elf_mips_reloc_type (type3
);
1391 printf (" Type2: ");
1394 printf (_("unrecognized: %-7lx"),
1395 (unsigned long) type2
& 0xffffffff);
1397 printf ("%-17.17s", rtype2
);
1399 printf ("\n Type3: ");
1402 printf (_("unrecognized: %-7lx"),
1403 (unsigned long) type3
& 0xffffffff);
1405 printf ("%-17.17s", rtype3
);
1416 get_mips_dynamic_type (unsigned long type
)
1420 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1421 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1422 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1423 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1424 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1425 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1426 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1427 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1428 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1429 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1430 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1431 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1432 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1433 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1434 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1435 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1436 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1437 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1438 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1439 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1440 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1441 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1442 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1443 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1444 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1445 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1446 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1447 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1448 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1449 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1450 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1451 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1452 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1453 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1454 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1455 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1456 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1457 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1458 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1459 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1460 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1461 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1462 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1463 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1464 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1471 get_sparc64_dynamic_type (unsigned long type
)
1475 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1482 get_ppc_dynamic_type (unsigned long type
)
1486 case DT_PPC_GOT
: return "PPC_GOT";
1487 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1494 get_ppc64_dynamic_type (unsigned long type
)
1498 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1499 case DT_PPC64_OPD
: return "PPC64_OPD";
1500 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1501 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1508 get_parisc_dynamic_type (unsigned long type
)
1512 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1513 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1514 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1515 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1516 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1517 case DT_HP_PREINIT
: return "HP_PREINIT";
1518 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1519 case DT_HP_NEEDED
: return "HP_NEEDED";
1520 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1521 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1522 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1523 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1524 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1525 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1526 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1527 case DT_HP_FILTERED
: return "HP_FILTERED";
1528 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1529 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1530 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1531 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1532 case DT_PLT
: return "PLT";
1533 case DT_PLT_SIZE
: return "PLT_SIZE";
1534 case DT_DLT
: return "DLT";
1535 case DT_DLT_SIZE
: return "DLT_SIZE";
1542 get_ia64_dynamic_type (unsigned long type
)
1546 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1547 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1548 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1549 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1550 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1551 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1552 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1553 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1554 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1555 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1556 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1557 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1558 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1559 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1560 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1561 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1562 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1563 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1564 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1565 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1566 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1567 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1568 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1569 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1570 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1571 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1572 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1573 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1574 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1575 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1576 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1583 get_alpha_dynamic_type (unsigned long type
)
1587 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1594 get_score_dynamic_type (unsigned long type
)
1598 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1599 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1600 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1601 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1602 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1603 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1611 get_dynamic_type (unsigned long type
)
1613 static char buff
[64];
1617 case DT_NULL
: return "NULL";
1618 case DT_NEEDED
: return "NEEDED";
1619 case DT_PLTRELSZ
: return "PLTRELSZ";
1620 case DT_PLTGOT
: return "PLTGOT";
1621 case DT_HASH
: return "HASH";
1622 case DT_STRTAB
: return "STRTAB";
1623 case DT_SYMTAB
: return "SYMTAB";
1624 case DT_RELA
: return "RELA";
1625 case DT_RELASZ
: return "RELASZ";
1626 case DT_RELAENT
: return "RELAENT";
1627 case DT_STRSZ
: return "STRSZ";
1628 case DT_SYMENT
: return "SYMENT";
1629 case DT_INIT
: return "INIT";
1630 case DT_FINI
: return "FINI";
1631 case DT_SONAME
: return "SONAME";
1632 case DT_RPATH
: return "RPATH";
1633 case DT_SYMBOLIC
: return "SYMBOLIC";
1634 case DT_REL
: return "REL";
1635 case DT_RELSZ
: return "RELSZ";
1636 case DT_RELENT
: return "RELENT";
1637 case DT_PLTREL
: return "PLTREL";
1638 case DT_DEBUG
: return "DEBUG";
1639 case DT_TEXTREL
: return "TEXTREL";
1640 case DT_JMPREL
: return "JMPREL";
1641 case DT_BIND_NOW
: return "BIND_NOW";
1642 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1643 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1644 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1645 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1646 case DT_RUNPATH
: return "RUNPATH";
1647 case DT_FLAGS
: return "FLAGS";
1649 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1650 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1652 case DT_CHECKSUM
: return "CHECKSUM";
1653 case DT_PLTPADSZ
: return "PLTPADSZ";
1654 case DT_MOVEENT
: return "MOVEENT";
1655 case DT_MOVESZ
: return "MOVESZ";
1656 case DT_FEATURE
: return "FEATURE";
1657 case DT_POSFLAG_1
: return "POSFLAG_1";
1658 case DT_SYMINSZ
: return "SYMINSZ";
1659 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1661 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1662 case DT_CONFIG
: return "CONFIG";
1663 case DT_DEPAUDIT
: return "DEPAUDIT";
1664 case DT_AUDIT
: return "AUDIT";
1665 case DT_PLTPAD
: return "PLTPAD";
1666 case DT_MOVETAB
: return "MOVETAB";
1667 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1669 case DT_VERSYM
: return "VERSYM";
1671 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1672 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1673 case DT_RELACOUNT
: return "RELACOUNT";
1674 case DT_RELCOUNT
: return "RELCOUNT";
1675 case DT_FLAGS_1
: return "FLAGS_1";
1676 case DT_VERDEF
: return "VERDEF";
1677 case DT_VERDEFNUM
: return "VERDEFNUM";
1678 case DT_VERNEED
: return "VERNEED";
1679 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1681 case DT_AUXILIARY
: return "AUXILIARY";
1682 case DT_USED
: return "USED";
1683 case DT_FILTER
: return "FILTER";
1685 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1686 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1687 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1688 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1689 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1690 case DT_GNU_HASH
: return "GNU_HASH";
1693 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1695 const char * result
;
1697 switch (elf_header
.e_machine
)
1700 case EM_MIPS_RS3_LE
:
1701 result
= get_mips_dynamic_type (type
);
1704 result
= get_sparc64_dynamic_type (type
);
1707 result
= get_ppc_dynamic_type (type
);
1710 result
= get_ppc64_dynamic_type (type
);
1713 result
= get_ia64_dynamic_type (type
);
1716 result
= get_alpha_dynamic_type (type
);
1719 result
= get_score_dynamic_type (type
);
1729 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1731 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1732 || (elf_header
.e_machine
== EM_PARISC
1733 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1735 const char * result
;
1737 switch (elf_header
.e_machine
)
1740 result
= get_parisc_dynamic_type (type
);
1743 result
= get_ia64_dynamic_type (type
);
1753 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1757 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1764 get_file_type (unsigned e_type
)
1766 static char buff
[32];
1770 case ET_NONE
: return _("NONE (None)");
1771 case ET_REL
: return _("REL (Relocatable file)");
1772 case ET_EXEC
: return _("EXEC (Executable file)");
1773 case ET_DYN
: return _("DYN (Shared object file)");
1774 case ET_CORE
: return _("CORE (Core file)");
1777 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1778 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1779 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1780 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1782 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1788 get_machine_name (unsigned e_machine
)
1790 static char buff
[64]; /* XXX */
1794 case EM_NONE
: return _("None");
1795 case EM_M32
: return "WE32100";
1796 case EM_SPARC
: return "Sparc";
1797 case EM_SPU
: return "SPU";
1798 case EM_386
: return "Intel 80386";
1799 case EM_68K
: return "MC68000";
1800 case EM_88K
: return "MC88000";
1801 case EM_486
: return "Intel 80486";
1802 case EM_860
: return "Intel 80860";
1803 case EM_MIPS
: return "MIPS R3000";
1804 case EM_S370
: return "IBM System/370";
1805 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1806 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1807 case EM_PARISC
: return "HPPA";
1808 case EM_PPC_OLD
: return "Power PC (old)";
1809 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1810 case EM_960
: return "Intel 90860";
1811 case EM_PPC
: return "PowerPC";
1812 case EM_PPC64
: return "PowerPC64";
1813 case EM_V800
: return "NEC V800";
1814 case EM_FR20
: return "Fujitsu FR20";
1815 case EM_RH32
: return "TRW RH32";
1816 case EM_MCORE
: return "MCORE";
1817 case EM_ARM
: return "ARM";
1818 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1819 case EM_SH
: return "Renesas / SuperH SH";
1820 case EM_SPARCV9
: return "Sparc v9";
1821 case EM_TRICORE
: return "Siemens Tricore";
1822 case EM_ARC
: return "ARC";
1823 case EM_H8_300
: return "Renesas H8/300";
1824 case EM_H8_300H
: return "Renesas H8/300H";
1825 case EM_H8S
: return "Renesas H8S";
1826 case EM_H8_500
: return "Renesas H8/500";
1827 case EM_IA_64
: return "Intel IA-64";
1828 case EM_MIPS_X
: return "Stanford MIPS-X";
1829 case EM_COLDFIRE
: return "Motorola Coldfire";
1830 case EM_68HC12
: return "Motorola M68HC12";
1831 case EM_ALPHA
: return "Alpha";
1832 case EM_CYGNUS_D10V
:
1833 case EM_D10V
: return "d10v";
1834 case EM_CYGNUS_D30V
:
1835 case EM_D30V
: return "d30v";
1836 case EM_CYGNUS_M32R
:
1837 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1838 case EM_CYGNUS_V850
:
1839 case EM_V850
: return "NEC v850";
1840 case EM_CYGNUS_MN10300
:
1841 case EM_MN10300
: return "mn10300";
1842 case EM_CYGNUS_MN10200
:
1843 case EM_MN10200
: return "mn10200";
1844 case EM_CYGNUS_FR30
:
1845 case EM_FR30
: return "Fujitsu FR30";
1846 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1848 case EM_PJ
: return "picoJava";
1849 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1850 case EM_PCP
: return "Siemens PCP";
1851 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1852 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1853 case EM_STARCORE
: return "Motorola Star*Core processor";
1854 case EM_ME16
: return "Toyota ME16 processor";
1855 case EM_ST100
: return "STMicroelectronics ST100 processor";
1856 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1857 case EM_PDSP
: return "Sony DSP processor";
1858 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1859 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1860 case EM_FX66
: return "Siemens FX66 microcontroller";
1861 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1862 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1863 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1864 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1865 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1866 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1867 case EM_SVX
: return "Silicon Graphics SVx";
1868 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1869 case EM_VAX
: return "Digital VAX";
1871 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1872 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1873 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1874 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1875 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1876 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1877 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1878 case EM_PRISM
: return "Vitesse Prism";
1879 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1880 case EM_L1OM
: return "Intel L1OM";
1882 case EM_S390
: return "IBM S/390";
1883 case EM_SCORE
: return "SUNPLUS S+Core";
1884 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1886 case EM_OR32
: return "OpenRISC";
1887 case EM_ARC_A5
: return "ARC International ARCompact processor";
1888 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1889 case EM_DLX
: return "OpenDLX";
1891 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1892 case EM_IQ2000
: return "Vitesse IQ2000";
1894 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1895 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1896 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1897 case EM_NS32K
: return "National Semiconductor 32000 series";
1898 case EM_TPC
: return "Tenor Network TPC processor";
1899 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1900 case EM_MAX
: return "MAX Processor";
1901 case EM_CR
: return "National Semiconductor CompactRISC";
1902 case EM_F2MC16
: return "Fujitsu F2MC16";
1903 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1904 case EM_LATTICEMICO32
: return "Lattice Mico32";
1906 case EM_M32C
: return "Renesas M32c";
1907 case EM_MT
: return "Morpho Techologies MT processor";
1908 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1909 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1910 case EM_SEP
: return "Sharp embedded microprocessor";
1911 case EM_ARCA
: return "Arca RISC microprocessor";
1912 case EM_UNICORE
: return "Unicore";
1913 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1914 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1915 case EM_NIOS32
: return "Altera Nios";
1916 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1918 case EM_XC16X
: return "Infineon Technologies xc16x";
1919 case EM_M16C
: return "Renesas M16C series microprocessors";
1920 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1921 case EM_CE
: return "Freescale Communication Engine RISC core";
1922 case EM_TSK3000
: return "Altium TSK3000 core";
1923 case EM_RS08
: return "Freescale RS08 embedded processor";
1924 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1925 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1926 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1927 case EM_SE_C17
: return "Seiko Epson C17 family";
1928 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
1929 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
1930 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
1931 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1932 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
1933 case EM_R32C
: return "Renesas R32C series microprocessors";
1934 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
1935 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
1936 case EM_8051
: return "Intel 8051 and variants";
1937 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
1938 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
1939 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
1940 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1941 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
1942 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
1943 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
1944 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1946 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1947 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1948 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1949 case EM_RX
: return "Renesas RX";
1950 case EM_METAG
: return "Imagination Technologies META processor architecture";
1951 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
1952 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
1953 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
1954 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
1955 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
1956 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
1957 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
1958 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
1959 case EM_CUDA
: return "NVIDIA CUDA architecture";
1961 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1967 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1972 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1973 e_flags
&= ~ EF_ARM_EABIMASK
;
1975 /* Handle "generic" ARM flags. */
1976 if (e_flags
& EF_ARM_RELEXEC
)
1978 strcat (buf
, ", relocatable executable");
1979 e_flags
&= ~ EF_ARM_RELEXEC
;
1982 if (e_flags
& EF_ARM_HASENTRY
)
1984 strcat (buf
, ", has entry point");
1985 e_flags
&= ~ EF_ARM_HASENTRY
;
1988 /* Now handle EABI specific flags. */
1992 strcat (buf
, ", <unrecognized EABI>");
1997 case EF_ARM_EABI_VER1
:
1998 strcat (buf
, ", Version1 EABI");
2003 /* Process flags one bit at a time. */
2004 flag
= e_flags
& - e_flags
;
2009 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2010 strcat (buf
, ", sorted symbol tables");
2020 case EF_ARM_EABI_VER2
:
2021 strcat (buf
, ", Version2 EABI");
2026 /* Process flags one bit at a time. */
2027 flag
= e_flags
& - e_flags
;
2032 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2033 strcat (buf
, ", sorted symbol tables");
2036 case EF_ARM_DYNSYMSUSESEGIDX
:
2037 strcat (buf
, ", dynamic symbols use segment index");
2040 case EF_ARM_MAPSYMSFIRST
:
2041 strcat (buf
, ", mapping symbols precede others");
2051 case EF_ARM_EABI_VER3
:
2052 strcat (buf
, ", Version3 EABI");
2055 case EF_ARM_EABI_VER4
:
2056 strcat (buf
, ", Version4 EABI");
2059 case EF_ARM_EABI_VER5
:
2060 strcat (buf
, ", Version5 EABI");
2066 /* Process flags one bit at a time. */
2067 flag
= e_flags
& - e_flags
;
2073 strcat (buf
, ", BE8");
2077 strcat (buf
, ", LE8");
2087 case EF_ARM_EABI_UNKNOWN
:
2088 strcat (buf
, ", GNU EABI");
2093 /* Process flags one bit at a time. */
2094 flag
= e_flags
& - e_flags
;
2099 case EF_ARM_INTERWORK
:
2100 strcat (buf
, ", interworking enabled");
2103 case EF_ARM_APCS_26
:
2104 strcat (buf
, ", uses APCS/26");
2107 case EF_ARM_APCS_FLOAT
:
2108 strcat (buf
, ", uses APCS/float");
2112 strcat (buf
, ", position independent");
2116 strcat (buf
, ", 8 bit structure alignment");
2119 case EF_ARM_NEW_ABI
:
2120 strcat (buf
, ", uses new ABI");
2123 case EF_ARM_OLD_ABI
:
2124 strcat (buf
, ", uses old ABI");
2127 case EF_ARM_SOFT_FLOAT
:
2128 strcat (buf
, ", software FP");
2131 case EF_ARM_VFP_FLOAT
:
2132 strcat (buf
, ", VFP");
2135 case EF_ARM_MAVERICK_FLOAT
:
2136 strcat (buf
, ", Maverick FP");
2147 strcat (buf
,", <unknown>");
2151 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2153 static char buf
[1024];
2165 decode_ARM_machine_flags (e_flags
, buf
);
2169 switch (e_flags
& EF_FRV_CPU_MASK
)
2171 case EF_FRV_CPU_GENERIC
:
2175 strcat (buf
, ", fr???");
2178 case EF_FRV_CPU_FR300
:
2179 strcat (buf
, ", fr300");
2182 case EF_FRV_CPU_FR400
:
2183 strcat (buf
, ", fr400");
2185 case EF_FRV_CPU_FR405
:
2186 strcat (buf
, ", fr405");
2189 case EF_FRV_CPU_FR450
:
2190 strcat (buf
, ", fr450");
2193 case EF_FRV_CPU_FR500
:
2194 strcat (buf
, ", fr500");
2196 case EF_FRV_CPU_FR550
:
2197 strcat (buf
, ", fr550");
2200 case EF_FRV_CPU_SIMPLE
:
2201 strcat (buf
, ", simple");
2203 case EF_FRV_CPU_TOMCAT
:
2204 strcat (buf
, ", tomcat");
2210 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2211 strcat (buf
, ", m68000");
2212 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2213 strcat (buf
, ", cpu32");
2214 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2215 strcat (buf
, ", fido_a");
2218 char const * isa
= _("unknown");
2219 char const * mac
= _("unknown mac");
2220 char const * additional
= NULL
;
2222 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2224 case EF_M68K_CF_ISA_A_NODIV
:
2226 additional
= ", nodiv";
2228 case EF_M68K_CF_ISA_A
:
2231 case EF_M68K_CF_ISA_A_PLUS
:
2234 case EF_M68K_CF_ISA_B_NOUSP
:
2236 additional
= ", nousp";
2238 case EF_M68K_CF_ISA_B
:
2242 strcat (buf
, ", cf, isa ");
2245 strcat (buf
, additional
);
2246 if (e_flags
& EF_M68K_CF_FLOAT
)
2247 strcat (buf
, ", float");
2248 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2253 case EF_M68K_CF_MAC
:
2256 case EF_M68K_CF_EMAC
:
2269 if (e_flags
& EF_PPC_EMB
)
2270 strcat (buf
, ", emb");
2272 if (e_flags
& EF_PPC_RELOCATABLE
)
2273 strcat (buf
, ", relocatable");
2275 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2276 strcat (buf
, ", relocatable-lib");
2280 case EM_CYGNUS_V850
:
2281 switch (e_flags
& EF_V850_ARCH
)
2284 strcat (buf
, ", v850e1");
2287 strcat (buf
, ", v850e");
2290 strcat (buf
, ", v850");
2293 strcat (buf
, ", unknown v850 architecture variant");
2299 case EM_CYGNUS_M32R
:
2300 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2301 strcat (buf
, ", m32r");
2305 case EM_MIPS_RS3_LE
:
2306 if (e_flags
& EF_MIPS_NOREORDER
)
2307 strcat (buf
, ", noreorder");
2309 if (e_flags
& EF_MIPS_PIC
)
2310 strcat (buf
, ", pic");
2312 if (e_flags
& EF_MIPS_CPIC
)
2313 strcat (buf
, ", cpic");
2315 if (e_flags
& EF_MIPS_UCODE
)
2316 strcat (buf
, ", ugen_reserved");
2318 if (e_flags
& EF_MIPS_ABI2
)
2319 strcat (buf
, ", abi2");
2321 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2322 strcat (buf
, ", odk first");
2324 if (e_flags
& EF_MIPS_32BITMODE
)
2325 strcat (buf
, ", 32bitmode");
2327 switch ((e_flags
& EF_MIPS_MACH
))
2329 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2330 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2331 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2332 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2333 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2334 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2335 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2336 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2337 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2338 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2339 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2340 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2341 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2342 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2343 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2345 /* We simply ignore the field in this case to avoid confusion:
2346 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2349 default: strcat (buf
, ", unknown CPU"); break;
2352 switch ((e_flags
& EF_MIPS_ABI
))
2354 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2355 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2356 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2357 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2359 /* We simply ignore the field in this case to avoid confusion:
2360 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2361 This means it is likely to be an o32 file, but not for
2364 default: strcat (buf
, ", unknown ABI"); break;
2367 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2368 strcat (buf
, ", mdmx");
2370 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2371 strcat (buf
, ", mips16");
2373 switch ((e_flags
& EF_MIPS_ARCH
))
2375 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2376 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2377 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2378 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2379 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2380 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2381 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2382 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2383 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2384 default: strcat (buf
, ", unknown ISA"); break;
2390 switch ((e_flags
& EF_SH_MACH_MASK
))
2392 case EF_SH1
: strcat (buf
, ", sh1"); break;
2393 case EF_SH2
: strcat (buf
, ", sh2"); break;
2394 case EF_SH3
: strcat (buf
, ", sh3"); break;
2395 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2396 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2397 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2398 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2399 case EF_SH4
: strcat (buf
, ", sh4"); break;
2400 case EF_SH5
: strcat (buf
, ", sh5"); break;
2401 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2402 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2403 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2404 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2405 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2406 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2407 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2408 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2409 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2410 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2411 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2412 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2413 default: strcat (buf
, ", unknown ISA"); break;
2419 if (e_flags
& EF_SPARC_32PLUS
)
2420 strcat (buf
, ", v8+");
2422 if (e_flags
& EF_SPARC_SUN_US1
)
2423 strcat (buf
, ", ultrasparcI");
2425 if (e_flags
& EF_SPARC_SUN_US3
)
2426 strcat (buf
, ", ultrasparcIII");
2428 if (e_flags
& EF_SPARC_HAL_R1
)
2429 strcat (buf
, ", halr1");
2431 if (e_flags
& EF_SPARC_LEDATA
)
2432 strcat (buf
, ", ledata");
2434 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2435 strcat (buf
, ", tso");
2437 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2438 strcat (buf
, ", pso");
2440 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2441 strcat (buf
, ", rmo");
2445 switch (e_flags
& EF_PARISC_ARCH
)
2447 case EFA_PARISC_1_0
:
2448 strcpy (buf
, ", PA-RISC 1.0");
2450 case EFA_PARISC_1_1
:
2451 strcpy (buf
, ", PA-RISC 1.1");
2453 case EFA_PARISC_2_0
:
2454 strcpy (buf
, ", PA-RISC 2.0");
2459 if (e_flags
& EF_PARISC_TRAPNIL
)
2460 strcat (buf
, ", trapnil");
2461 if (e_flags
& EF_PARISC_EXT
)
2462 strcat (buf
, ", ext");
2463 if (e_flags
& EF_PARISC_LSB
)
2464 strcat (buf
, ", lsb");
2465 if (e_flags
& EF_PARISC_WIDE
)
2466 strcat (buf
, ", wide");
2467 if (e_flags
& EF_PARISC_NO_KABP
)
2468 strcat (buf
, ", no kabp");
2469 if (e_flags
& EF_PARISC_LAZYSWAP
)
2470 strcat (buf
, ", lazyswap");
2475 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2476 strcat (buf
, ", new calling convention");
2478 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2479 strcat (buf
, ", gnu calling convention");
2483 if ((e_flags
& EF_IA_64_ABI64
))
2484 strcat (buf
, ", 64-bit");
2486 strcat (buf
, ", 32-bit");
2487 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2488 strcat (buf
, ", reduced fp model");
2489 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2490 strcat (buf
, ", no function descriptors, constant gp");
2491 else if ((e_flags
& EF_IA_64_CONS_GP
))
2492 strcat (buf
, ", constant gp");
2493 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2494 strcat (buf
, ", absolute");
2498 if ((e_flags
& EF_VAX_NONPIC
))
2499 strcat (buf
, ", non-PIC");
2500 if ((e_flags
& EF_VAX_DFLOAT
))
2501 strcat (buf
, ", D-Float");
2502 if ((e_flags
& EF_VAX_GFLOAT
))
2503 strcat (buf
, ", G-Float");
2507 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2508 strcat (buf
, ", 64-bit doubles");
2509 if (e_flags
& E_FLAG_RX_DSP
)
2510 strcat (buf
, ", dsp");
2518 get_osabi_name (unsigned int osabi
)
2520 static char buff
[32];
2524 case ELFOSABI_NONE
: return "UNIX - System V";
2525 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2526 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2527 case ELFOSABI_LINUX
: return "UNIX - Linux";
2528 case ELFOSABI_HURD
: return "GNU/Hurd";
2529 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2530 case ELFOSABI_AIX
: return "UNIX - AIX";
2531 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2532 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2533 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2534 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2535 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2536 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2537 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2538 case ELFOSABI_AROS
: return "AROS";
2539 case ELFOSABI_FENIXOS
: return "FenixOS";
2540 case ELFOSABI_STANDALONE
: return _("Standalone App");
2541 case ELFOSABI_ARM
: return "ARM";
2543 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2549 get_arm_segment_type (unsigned long type
)
2563 get_mips_segment_type (unsigned long type
)
2567 case PT_MIPS_REGINFO
:
2569 case PT_MIPS_RTPROC
:
2571 case PT_MIPS_OPTIONS
:
2581 get_parisc_segment_type (unsigned long type
)
2585 case PT_HP_TLS
: return "HP_TLS";
2586 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2587 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2588 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2589 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2590 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2591 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2592 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2593 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2594 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2595 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2596 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2597 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2598 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2599 case PT_HP_STACK
: return "HP_STACK";
2600 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2601 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2602 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2603 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2612 get_ia64_segment_type (unsigned long type
)
2616 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2617 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2618 case PT_HP_TLS
: return "HP_TLS";
2619 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2620 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2621 case PT_IA_64_HP_STACK
: return "HP_STACK";
2630 get_segment_type (unsigned long p_type
)
2632 static char buff
[32];
2636 case PT_NULL
: return "NULL";
2637 case PT_LOAD
: return "LOAD";
2638 case PT_DYNAMIC
: return "DYNAMIC";
2639 case PT_INTERP
: return "INTERP";
2640 case PT_NOTE
: return "NOTE";
2641 case PT_SHLIB
: return "SHLIB";
2642 case PT_PHDR
: return "PHDR";
2643 case PT_TLS
: return "TLS";
2645 case PT_GNU_EH_FRAME
:
2646 return "GNU_EH_FRAME";
2647 case PT_GNU_STACK
: return "GNU_STACK";
2648 case PT_GNU_RELRO
: return "GNU_RELRO";
2651 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2653 const char * result
;
2655 switch (elf_header
.e_machine
)
2658 result
= get_arm_segment_type (p_type
);
2661 case EM_MIPS_RS3_LE
:
2662 result
= get_mips_segment_type (p_type
);
2665 result
= get_parisc_segment_type (p_type
);
2668 result
= get_ia64_segment_type (p_type
);
2678 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2680 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2682 const char * result
;
2684 switch (elf_header
.e_machine
)
2687 result
= get_parisc_segment_type (p_type
);
2690 result
= get_ia64_segment_type (p_type
);
2700 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2703 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2710 get_mips_section_type_name (unsigned int sh_type
)
2714 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2715 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2716 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2717 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2718 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2719 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2720 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2721 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2722 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2723 case SHT_MIPS_RELD
: return "MIPS_RELD";
2724 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2725 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2726 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2727 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2728 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2729 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2730 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2731 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2732 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2733 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2734 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2735 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2736 case SHT_MIPS_LINE
: return "MIPS_LINE";
2737 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2738 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2739 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2740 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2741 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2742 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2743 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2744 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2745 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2746 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2747 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2748 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2749 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2750 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2751 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2752 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2760 get_parisc_section_type_name (unsigned int sh_type
)
2764 case SHT_PARISC_EXT
: return "PARISC_EXT";
2765 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2766 case SHT_PARISC_DOC
: return "PARISC_DOC";
2767 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2768 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2769 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2770 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2778 get_ia64_section_type_name (unsigned int sh_type
)
2780 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2781 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2782 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2786 case SHT_IA_64_EXT
: return "IA_64_EXT";
2787 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2788 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2789 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2790 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2791 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2792 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2793 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2794 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2795 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2803 get_x86_64_section_type_name (unsigned int sh_type
)
2807 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2815 get_arm_section_type_name (unsigned int sh_type
)
2819 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2820 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2821 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2822 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2823 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2831 get_section_type_name (unsigned int sh_type
)
2833 static char buff
[32];
2837 case SHT_NULL
: return "NULL";
2838 case SHT_PROGBITS
: return "PROGBITS";
2839 case SHT_SYMTAB
: return "SYMTAB";
2840 case SHT_STRTAB
: return "STRTAB";
2841 case SHT_RELA
: return "RELA";
2842 case SHT_HASH
: return "HASH";
2843 case SHT_DYNAMIC
: return "DYNAMIC";
2844 case SHT_NOTE
: return "NOTE";
2845 case SHT_NOBITS
: return "NOBITS";
2846 case SHT_REL
: return "REL";
2847 case SHT_SHLIB
: return "SHLIB";
2848 case SHT_DYNSYM
: return "DYNSYM";
2849 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2850 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2851 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2852 case SHT_GNU_HASH
: return "GNU_HASH";
2853 case SHT_GROUP
: return "GROUP";
2854 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2855 case SHT_GNU_verdef
: return "VERDEF";
2856 case SHT_GNU_verneed
: return "VERNEED";
2857 case SHT_GNU_versym
: return "VERSYM";
2858 case 0x6ffffff0: return "VERSYM";
2859 case 0x6ffffffc: return "VERDEF";
2860 case 0x7ffffffd: return "AUXILIARY";
2861 case 0x7fffffff: return "FILTER";
2862 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2865 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2867 const char * result
;
2869 switch (elf_header
.e_machine
)
2872 case EM_MIPS_RS3_LE
:
2873 result
= get_mips_section_type_name (sh_type
);
2876 result
= get_parisc_section_type_name (sh_type
);
2879 result
= get_ia64_section_type_name (sh_type
);
2883 result
= get_x86_64_section_type_name (sh_type
);
2886 result
= get_arm_section_type_name (sh_type
);
2896 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2898 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2900 const char * result
;
2902 switch (elf_header
.e_machine
)
2905 result
= get_ia64_section_type_name (sh_type
);
2915 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2917 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2918 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2920 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2926 #define OPTION_DEBUG_DUMP 512
2927 #define OPTION_DYN_SYMS 513
2929 static struct option options
[] =
2931 {"all", no_argument
, 0, 'a'},
2932 {"file-header", no_argument
, 0, 'h'},
2933 {"program-headers", no_argument
, 0, 'l'},
2934 {"headers", no_argument
, 0, 'e'},
2935 {"histogram", no_argument
, 0, 'I'},
2936 {"segments", no_argument
, 0, 'l'},
2937 {"sections", no_argument
, 0, 'S'},
2938 {"section-headers", no_argument
, 0, 'S'},
2939 {"section-groups", no_argument
, 0, 'g'},
2940 {"section-details", no_argument
, 0, 't'},
2941 {"full-section-name",no_argument
, 0, 'N'},
2942 {"symbols", no_argument
, 0, 's'},
2943 {"syms", no_argument
, 0, 's'},
2944 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
2945 {"relocs", no_argument
, 0, 'r'},
2946 {"notes", no_argument
, 0, 'n'},
2947 {"dynamic", no_argument
, 0, 'd'},
2948 {"arch-specific", no_argument
, 0, 'A'},
2949 {"version-info", no_argument
, 0, 'V'},
2950 {"use-dynamic", no_argument
, 0, 'D'},
2951 {"unwind", no_argument
, 0, 'u'},
2952 {"archive-index", no_argument
, 0, 'c'},
2953 {"hex-dump", required_argument
, 0, 'x'},
2954 {"relocated-dump", required_argument
, 0, 'R'},
2955 {"string-dump", required_argument
, 0, 'p'},
2956 #ifdef SUPPORT_DISASSEMBLY
2957 {"instruction-dump", required_argument
, 0, 'i'},
2959 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2961 {"version", no_argument
, 0, 'v'},
2962 {"wide", no_argument
, 0, 'W'},
2963 {"help", no_argument
, 0, 'H'},
2964 {0, no_argument
, 0, 0}
2968 usage (FILE * stream
)
2970 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2971 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2972 fprintf (stream
, _(" Options are:\n\
2973 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2974 -h --file-header Display the ELF file header\n\
2975 -l --program-headers Display the program headers\n\
2976 --segments An alias for --program-headers\n\
2977 -S --section-headers Display the sections' header\n\
2978 --sections An alias for --section-headers\n\
2979 -g --section-groups Display the section groups\n\
2980 -t --section-details Display the section details\n\
2981 -e --headers Equivalent to: -h -l -S\n\
2982 -s --syms Display the symbol table\n\
2983 --symbols An alias for --syms\n\
2984 --dyn-syms Display the dynamic symbol table\n\
2985 -n --notes Display the core notes (if present)\n\
2986 -r --relocs Display the relocations (if present)\n\
2987 -u --unwind Display the unwind info (if present)\n\
2988 -d --dynamic Display the dynamic section (if present)\n\
2989 -V --version-info Display the version sections (if present)\n\
2990 -A --arch-specific Display architecture specific information (if any).\n\
2991 -c --archive-index Display the symbol/file index in an archive\n\
2992 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2993 -x --hex-dump=<number|name>\n\
2994 Dump the contents of section <number|name> as bytes\n\
2995 -p --string-dump=<number|name>\n\
2996 Dump the contents of section <number|name> as strings\n\
2997 -R --relocated-dump=<number|name>\n\
2998 Dump the contents of section <number|name> as relocated bytes\n\
2999 -w[lLiaprmfFsoRt] or\n\
3000 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3001 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
3002 Display the contents of DWARF2 debug sections\n"));
3003 #ifdef SUPPORT_DISASSEMBLY
3004 fprintf (stream
, _("\
3005 -i --instruction-dump=<number|name>\n\
3006 Disassemble the contents of section <number|name>\n"));
3008 fprintf (stream
, _("\
3009 -I --histogram Display histogram of bucket list lengths\n\
3010 -W --wide Allow output width to exceed 80 characters\n\
3011 @<file> Read options from <file>\n\
3012 -H --help Display this information\n\
3013 -v --version Display the version number of readelf\n"));
3015 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3016 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3018 exit (stream
== stdout
? 0 : 1);
3021 /* Record the fact that the user wants the contents of section number
3022 SECTION to be displayed using the method(s) encoded as flags bits
3023 in TYPE. Note, TYPE can be zero if we are creating the array for
3027 request_dump_bynumber (unsigned int section
, dump_type type
)
3029 if (section
>= num_dump_sects
)
3031 dump_type
* new_dump_sects
;
3033 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3034 sizeof (* dump_sects
));
3036 if (new_dump_sects
== NULL
)
3037 error (_("Out of memory allocating dump request table.\n"));
3040 /* Copy current flag settings. */
3041 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3045 dump_sects
= new_dump_sects
;
3046 num_dump_sects
= section
+ 1;
3051 dump_sects
[section
] |= type
;
3056 /* Request a dump by section name. */
3059 request_dump_byname (const char * section
, dump_type type
)
3061 struct dump_list_entry
* new_request
;
3063 new_request
= (struct dump_list_entry
*)
3064 malloc (sizeof (struct dump_list_entry
));
3066 error (_("Out of memory allocating dump request table.\n"));
3068 new_request
->name
= strdup (section
);
3069 if (!new_request
->name
)
3070 error (_("Out of memory allocating dump request table.\n"));
3072 new_request
->type
= type
;
3074 new_request
->next
= dump_sects_byname
;
3075 dump_sects_byname
= new_request
;
3079 request_dump (dump_type type
)
3085 section
= strtoul (optarg
, & cp
, 0);
3087 if (! *cp
&& section
>= 0)
3088 request_dump_bynumber (section
, type
);
3090 request_dump_byname (optarg
, type
);
3095 parse_args (int argc
, char ** argv
)
3102 while ((c
= getopt_long
3103 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3121 do_section_groups
++;
3129 do_section_groups
++;
3134 do_section_details
++;
3178 request_dump (HEX_DUMP
);
3181 request_dump (STRING_DUMP
);
3184 request_dump (RELOC_DUMP
);
3191 dwarf_select_sections_all ();
3196 dwarf_select_sections_by_letters (optarg
);
3199 case OPTION_DEBUG_DUMP
:
3206 dwarf_select_sections_by_names (optarg
);
3209 case OPTION_DYN_SYMS
:
3212 #ifdef SUPPORT_DISASSEMBLY
3214 request_dump (DISASS_DUMP
);
3218 print_version (program_name
);
3227 /* xgettext:c-format */
3228 error (_("Invalid option '-%c'\n"), c
);
3235 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3236 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3237 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3238 && !do_section_groups
&& !do_archive_index
3243 warn (_("Nothing to do.\n"));
3249 get_elf_class (unsigned int elf_class
)
3251 static char buff
[32];
3255 case ELFCLASSNONE
: return _("none");
3256 case ELFCLASS32
: return "ELF32";
3257 case ELFCLASS64
: return "ELF64";
3259 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3265 get_data_encoding (unsigned int encoding
)
3267 static char buff
[32];
3271 case ELFDATANONE
: return _("none");
3272 case ELFDATA2LSB
: return _("2's complement, little endian");
3273 case ELFDATA2MSB
: return _("2's complement, big endian");
3275 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3280 /* Decode the data held in 'elf_header'. */
3283 process_file_header (void)
3285 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3286 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3287 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3288 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3291 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3295 init_dwarf_regnames (elf_header
.e_machine
);
3301 printf (_("ELF Header:\n"));
3302 printf (_(" Magic: "));
3303 for (i
= 0; i
< EI_NIDENT
; i
++)
3304 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3306 printf (_(" Class: %s\n"),
3307 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3308 printf (_(" Data: %s\n"),
3309 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3310 printf (_(" Version: %d %s\n"),
3311 elf_header
.e_ident
[EI_VERSION
],
3312 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3314 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3317 printf (_(" OS/ABI: %s\n"),
3318 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3319 printf (_(" ABI Version: %d\n"),
3320 elf_header
.e_ident
[EI_ABIVERSION
]);
3321 printf (_(" Type: %s\n"),
3322 get_file_type (elf_header
.e_type
));
3323 printf (_(" Machine: %s\n"),
3324 get_machine_name (elf_header
.e_machine
));
3325 printf (_(" Version: 0x%lx\n"),
3326 (unsigned long) elf_header
.e_version
);
3328 printf (_(" Entry point address: "));
3329 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3330 printf (_("\n Start of program headers: "));
3331 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3332 printf (_(" (bytes into file)\n Start of section headers: "));
3333 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3334 printf (_(" (bytes into file)\n"));
3336 printf (_(" Flags: 0x%lx%s\n"),
3337 (unsigned long) elf_header
.e_flags
,
3338 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3339 printf (_(" Size of this header: %ld (bytes)\n"),
3340 (long) elf_header
.e_ehsize
);
3341 printf (_(" Size of program headers: %ld (bytes)\n"),
3342 (long) elf_header
.e_phentsize
);
3343 printf (_(" Number of program headers: %ld"),
3344 (long) elf_header
.e_phnum
);
3345 if (section_headers
!= NULL
3346 && elf_header
.e_phnum
== PN_XNUM
3347 && section_headers
[0].sh_info
!= 0)
3348 printf (_(" (%ld)"), (long) section_headers
[0].sh_info
);
3349 putc ('\n', stdout
);
3350 printf (_(" Size of section headers: %ld (bytes)\n"),
3351 (long) elf_header
.e_shentsize
);
3352 printf (_(" Number of section headers: %ld"),
3353 (long) elf_header
.e_shnum
);
3354 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3355 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3356 putc ('\n', stdout
);
3357 printf (_(" Section header string table index: %ld"),
3358 (long) elf_header
.e_shstrndx
);
3359 if (section_headers
!= NULL
3360 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3361 printf (" (%u)", section_headers
[0].sh_link
);
3362 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3363 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3364 printf (" <corrupt: out of range>");
3365 putc ('\n', stdout
);
3368 if (section_headers
!= NULL
)
3370 if (elf_header
.e_phnum
== PN_XNUM
3371 && section_headers
[0].sh_info
!= 0)
3372 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3373 if (elf_header
.e_shnum
== SHN_UNDEF
)
3374 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3375 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3376 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3377 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3378 elf_header
.e_shstrndx
= SHN_UNDEF
;
3379 free (section_headers
);
3380 section_headers
= NULL
;
3388 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3390 Elf32_External_Phdr
* phdrs
;
3391 Elf32_External_Phdr
* external
;
3392 Elf_Internal_Phdr
* internal
;
3395 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3396 elf_header
.e_phentsize
,
3398 _("program headers"));
3402 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3403 i
< elf_header
.e_phnum
;
3404 i
++, internal
++, external
++)
3406 internal
->p_type
= BYTE_GET (external
->p_type
);
3407 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3408 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3409 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3410 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3411 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3412 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3413 internal
->p_align
= BYTE_GET (external
->p_align
);
3422 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3424 Elf64_External_Phdr
* phdrs
;
3425 Elf64_External_Phdr
* external
;
3426 Elf_Internal_Phdr
* internal
;
3429 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3430 elf_header
.e_phentsize
,
3432 _("program headers"));
3436 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3437 i
< elf_header
.e_phnum
;
3438 i
++, internal
++, external
++)
3440 internal
->p_type
= BYTE_GET (external
->p_type
);
3441 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3442 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3443 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3444 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3445 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3446 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3447 internal
->p_align
= BYTE_GET (external
->p_align
);
3455 /* Returns 1 if the program headers were read into `program_headers'. */
3458 get_program_headers (FILE * file
)
3460 Elf_Internal_Phdr
* phdrs
;
3462 /* Check cache of prior read. */
3463 if (program_headers
!= NULL
)
3466 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3467 sizeof (Elf_Internal_Phdr
));
3471 error (_("Out of memory\n"));
3476 ? get_32bit_program_headers (file
, phdrs
)
3477 : get_64bit_program_headers (file
, phdrs
))
3479 program_headers
= phdrs
;
3487 /* Returns 1 if the program headers were loaded. */
3490 process_program_headers (FILE * file
)
3492 Elf_Internal_Phdr
* segment
;
3495 if (elf_header
.e_phnum
== 0)
3498 printf (_("\nThere are no program headers in this file.\n"));
3502 if (do_segments
&& !do_header
)
3504 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3505 printf (_("Entry point "));
3506 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3507 printf (_("\nThere are %d program headers, starting at offset "),
3508 elf_header
.e_phnum
);
3509 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3513 if (! get_program_headers (file
))
3518 if (elf_header
.e_phnum
> 1)
3519 printf (_("\nProgram Headers:\n"));
3521 printf (_("\nProgram Headers:\n"));
3525 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3528 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3532 (_(" Type Offset VirtAddr PhysAddr\n"));
3534 (_(" FileSiz MemSiz Flags Align\n"));
3541 for (i
= 0, segment
= program_headers
;
3542 i
< elf_header
.e_phnum
;
3547 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3551 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3552 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3553 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3554 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3555 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3557 (segment
->p_flags
& PF_R
? 'R' : ' '),
3558 (segment
->p_flags
& PF_W
? 'W' : ' '),
3559 (segment
->p_flags
& PF_X
? 'E' : ' '));
3560 printf ("%#lx", (unsigned long) segment
->p_align
);
3564 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3565 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3568 print_vma (segment
->p_offset
, FULL_HEX
);
3572 print_vma (segment
->p_vaddr
, FULL_HEX
);
3574 print_vma (segment
->p_paddr
, FULL_HEX
);
3577 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3578 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3581 print_vma (segment
->p_filesz
, FULL_HEX
);
3585 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3586 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3589 print_vma (segment
->p_offset
, FULL_HEX
);
3593 (segment
->p_flags
& PF_R
? 'R' : ' '),
3594 (segment
->p_flags
& PF_W
? 'W' : ' '),
3595 (segment
->p_flags
& PF_X
? 'E' : ' '));
3597 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3598 printf ("%#lx", (unsigned long) segment
->p_align
);
3601 print_vma (segment
->p_align
, PREFIX_HEX
);
3606 print_vma (segment
->p_offset
, FULL_HEX
);
3608 print_vma (segment
->p_vaddr
, FULL_HEX
);
3610 print_vma (segment
->p_paddr
, FULL_HEX
);
3612 print_vma (segment
->p_filesz
, FULL_HEX
);
3614 print_vma (segment
->p_memsz
, FULL_HEX
);
3616 (segment
->p_flags
& PF_R
? 'R' : ' '),
3617 (segment
->p_flags
& PF_W
? 'W' : ' '),
3618 (segment
->p_flags
& PF_X
? 'E' : ' '));
3619 print_vma (segment
->p_align
, HEX
);
3623 switch (segment
->p_type
)
3627 error (_("more than one dynamic segment\n"));
3629 /* By default, assume that the .dynamic section is the first
3630 section in the DYNAMIC segment. */
3631 dynamic_addr
= segment
->p_offset
;
3632 dynamic_size
= segment
->p_filesz
;
3634 /* Try to locate the .dynamic section. If there is
3635 a section header table, we can easily locate it. */
3636 if (section_headers
!= NULL
)
3638 Elf_Internal_Shdr
* sec
;
3640 sec
= find_section (".dynamic");
3641 if (sec
== NULL
|| sec
->sh_size
== 0)
3643 error (_("no .dynamic section in the dynamic segment\n"));
3647 if (sec
->sh_type
== SHT_NOBITS
)
3653 dynamic_addr
= sec
->sh_offset
;
3654 dynamic_size
= sec
->sh_size
;
3656 if (dynamic_addr
< segment
->p_offset
3657 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3658 warn (_("the .dynamic section is not contained"
3659 " within the dynamic segment\n"));
3660 else if (dynamic_addr
> segment
->p_offset
)
3661 warn (_("the .dynamic section is not the first section"
3662 " in the dynamic segment.\n"));
3667 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3669 error (_("Unable to find program interpreter name\n"));
3673 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3675 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3676 error (_("Internal error: failed to create format string to display program interpreter\n"));
3678 program_interpreter
[0] = 0;
3679 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3680 error (_("Unable to read program interpreter name\n"));
3683 printf (_("\n [Requesting program interpreter: %s]"),
3684 program_interpreter
);
3690 putc ('\n', stdout
);
3693 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3695 printf (_("\n Section to Segment mapping:\n"));
3696 printf (_(" Segment Sections...\n"));
3698 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3701 Elf_Internal_Shdr
* section
;
3703 segment
= program_headers
+ i
;
3704 section
= section_headers
+ 1;
3706 printf (" %2.2d ", i
);
3708 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3710 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3711 printf ("%s ", SECTION_NAME (section
));
3722 /* Find the file offset corresponding to VMA by using the program headers. */
3725 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3727 Elf_Internal_Phdr
* seg
;
3729 if (! get_program_headers (file
))
3731 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3735 for (seg
= program_headers
;
3736 seg
< program_headers
+ elf_header
.e_phnum
;
3739 if (seg
->p_type
!= PT_LOAD
)
3742 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3743 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3744 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3747 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3748 (unsigned long) vma
);
3754 get_32bit_section_headers (FILE * file
, unsigned int num
)
3756 Elf32_External_Shdr
* shdrs
;
3757 Elf_Internal_Shdr
* internal
;
3760 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3761 elf_header
.e_shentsize
, num
,
3762 _("section headers"));
3766 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3767 sizeof (Elf_Internal_Shdr
));
3769 if (section_headers
== NULL
)
3771 error (_("Out of memory\n"));
3775 for (i
= 0, internal
= section_headers
;
3779 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3780 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3781 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3782 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3783 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3784 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3785 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3786 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3787 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3788 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3797 get_64bit_section_headers (FILE * file
, unsigned int num
)
3799 Elf64_External_Shdr
* shdrs
;
3800 Elf_Internal_Shdr
* internal
;
3803 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3804 elf_header
.e_shentsize
, num
,
3805 _("section headers"));
3809 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3810 sizeof (Elf_Internal_Shdr
));
3812 if (section_headers
== NULL
)
3814 error (_("Out of memory\n"));
3818 for (i
= 0, internal
= section_headers
;
3822 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3823 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3824 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3825 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3826 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3827 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3828 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3829 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3830 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3831 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3839 static Elf_Internal_Sym
*
3840 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3842 unsigned long number
;
3843 Elf32_External_Sym
* esyms
;
3844 Elf_External_Sym_Shndx
* shndx
;
3845 Elf_Internal_Sym
* isyms
;
3846 Elf_Internal_Sym
* psym
;
3849 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3850 section
->sh_size
, _("symbols"));
3855 if (symtab_shndx_hdr
!= NULL
3856 && (symtab_shndx_hdr
->sh_link
3857 == (unsigned long) (section
- section_headers
)))
3859 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3860 symtab_shndx_hdr
->sh_offset
,
3861 1, symtab_shndx_hdr
->sh_size
,
3870 number
= section
->sh_size
/ section
->sh_entsize
;
3871 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3875 error (_("Out of memory\n"));
3882 for (j
= 0, psym
= isyms
;
3886 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3887 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3888 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3889 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3890 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3892 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3893 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3894 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3895 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3896 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3906 static Elf_Internal_Sym
*
3907 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3909 unsigned long number
;
3910 Elf64_External_Sym
* esyms
;
3911 Elf_External_Sym_Shndx
* shndx
;
3912 Elf_Internal_Sym
* isyms
;
3913 Elf_Internal_Sym
* psym
;
3916 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3917 section
->sh_size
, _("symbols"));
3922 if (symtab_shndx_hdr
!= NULL
3923 && (symtab_shndx_hdr
->sh_link
3924 == (unsigned long) (section
- section_headers
)))
3926 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3927 symtab_shndx_hdr
->sh_offset
,
3928 1, symtab_shndx_hdr
->sh_size
,
3937 number
= section
->sh_size
/ section
->sh_entsize
;
3938 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3942 error (_("Out of memory\n"));
3949 for (j
= 0, psym
= isyms
;
3953 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3954 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3955 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3956 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3957 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3959 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3960 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3961 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3962 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3963 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3974 get_elf_section_flags (bfd_vma sh_flags
)
3976 static char buff
[1024];
3978 int field_size
= is_32bit_elf
? 8 : 16;
3980 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
3981 bfd_vma os_flags
= 0;
3982 bfd_vma proc_flags
= 0;
3983 bfd_vma unknown_flags
= 0;
3991 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3992 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3993 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3994 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3995 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
3996 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
3997 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
3998 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
3999 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4000 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4001 /* IA-64 specific. */
4002 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4003 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4004 /* IA-64 OpenVMS specific. */
4005 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4006 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4007 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4008 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4009 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4010 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4011 /* SPARC specific. */
4012 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4013 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4016 if (do_section_details
)
4018 sprintf (buff
, "[%*.*lx]: ",
4019 field_size
, field_size
, (unsigned long) sh_flags
);
4020 p
+= field_size
+ 4;
4027 flag
= sh_flags
& - sh_flags
;
4030 if (do_section_details
)
4034 case SHF_WRITE
: sindex
= 0; break;
4035 case SHF_ALLOC
: sindex
= 1; break;
4036 case SHF_EXECINSTR
: sindex
= 2; break;
4037 case SHF_MERGE
: sindex
= 3; break;
4038 case SHF_STRINGS
: sindex
= 4; break;
4039 case SHF_INFO_LINK
: sindex
= 5; break;
4040 case SHF_LINK_ORDER
: sindex
= 6; break;
4041 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4042 case SHF_GROUP
: sindex
= 8; break;
4043 case SHF_TLS
: sindex
= 9; break;
4047 switch (elf_header
.e_machine
)
4050 if (flag
== SHF_IA_64_SHORT
)
4052 else if (flag
== SHF_IA_64_NORECOV
)
4055 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4058 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4059 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4060 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4061 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4062 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4063 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4072 case EM_OLD_SPARCV9
:
4073 case EM_SPARC32PLUS
:
4076 if (flag
== SHF_EXCLUDE
)
4078 else if (flag
== SHF_ORDERED
)
4088 if (p
!= buff
+ field_size
+ 4)
4090 if (size
< (10 + 2))
4097 size
-= flags
[sindex
].len
;
4098 p
= stpcpy (p
, flags
[sindex
].str
);
4100 else if (flag
& SHF_MASKOS
)
4102 else if (flag
& SHF_MASKPROC
)
4105 unknown_flags
|= flag
;
4111 case SHF_WRITE
: *p
= 'W'; break;
4112 case SHF_ALLOC
: *p
= 'A'; break;
4113 case SHF_EXECINSTR
: *p
= 'X'; break;
4114 case SHF_MERGE
: *p
= 'M'; break;
4115 case SHF_STRINGS
: *p
= 'S'; break;
4116 case SHF_INFO_LINK
: *p
= 'I'; break;
4117 case SHF_LINK_ORDER
: *p
= 'L'; break;
4118 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4119 case SHF_GROUP
: *p
= 'G'; break;
4120 case SHF_TLS
: *p
= 'T'; break;
4123 if ((elf_header
.e_machine
== EM_X86_64
4124 || elf_header
.e_machine
== EM_L1OM
)
4125 && flag
== SHF_X86_64_LARGE
)
4127 else if (flag
& SHF_MASKOS
)
4130 sh_flags
&= ~ SHF_MASKOS
;
4132 else if (flag
& SHF_MASKPROC
)
4135 sh_flags
&= ~ SHF_MASKPROC
;
4145 if (do_section_details
)
4149 size
-= 5 + field_size
;
4150 if (p
!= buff
+ field_size
+ 4)
4158 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4159 (unsigned long) os_flags
);
4160 p
+= 5 + field_size
;
4164 size
-= 7 + field_size
;
4165 if (p
!= buff
+ field_size
+ 4)
4173 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4174 (unsigned long) proc_flags
);
4175 p
+= 7 + field_size
;
4179 size
-= 10 + field_size
;
4180 if (p
!= buff
+ field_size
+ 4)
4188 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4189 (unsigned long) unknown_flags
);
4190 p
+= 10 + field_size
;
4199 process_section_headers (FILE * file
)
4201 Elf_Internal_Shdr
* section
;
4204 section_headers
= NULL
;
4206 if (elf_header
.e_shnum
== 0)
4209 printf (_("\nThere are no sections in this file.\n"));
4214 if (do_sections
&& !do_header
)
4215 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4216 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4220 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4223 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4226 /* Read in the string table, so that we have names to display. */
4227 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4228 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4230 section
= section_headers
+ elf_header
.e_shstrndx
;
4232 if (section
->sh_size
!= 0)
4234 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4235 1, section
->sh_size
,
4238 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4242 /* Scan the sections for the dynamic symbol table
4243 and dynamic string table and debug sections. */
4244 dynamic_symbols
= NULL
;
4245 dynamic_strings
= NULL
;
4246 dynamic_syminfo
= NULL
;
4247 symtab_shndx_hdr
= NULL
;
4249 eh_addr_size
= is_32bit_elf
? 4 : 8;
4250 switch (elf_header
.e_machine
)
4253 case EM_MIPS_RS3_LE
:
4254 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4255 FDE addresses. However, the ABI also has a semi-official ILP32
4256 variant for which the normal FDE address size rules apply.
4258 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4259 section, where XX is the size of longs in bits. Unfortunately,
4260 earlier compilers provided no way of distinguishing ILP32 objects
4261 from LP64 objects, so if there's any doubt, we should assume that
4262 the official LP64 form is being used. */
4263 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4264 && find_section (".gcc_compiled_long32") == NULL
)
4270 switch (elf_header
.e_flags
& EF_H8_MACH
)
4272 case E_H8_MACH_H8300
:
4273 case E_H8_MACH_H8300HN
:
4274 case E_H8_MACH_H8300SN
:
4275 case E_H8_MACH_H8300SXN
:
4278 case E_H8_MACH_H8300H
:
4279 case E_H8_MACH_H8300S
:
4280 case E_H8_MACH_H8300SX
:
4288 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4290 case EF_M32C_CPU_M16C
:
4297 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4300 size_t expected_entsize \
4301 = is_32bit_elf ? size32 : size64; \
4302 if (section->sh_entsize != expected_entsize) \
4303 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4304 i, (unsigned long int) section->sh_entsize, \
4305 (unsigned long int) expected_entsize); \
4306 section->sh_entsize = expected_entsize; \
4309 #define CHECK_ENTSIZE(section, i, type) \
4310 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4311 sizeof (Elf64_External_##type))
4313 for (i
= 0, section
= section_headers
;
4314 i
< elf_header
.e_shnum
;
4317 char * name
= SECTION_NAME (section
);
4319 if (section
->sh_type
== SHT_DYNSYM
)
4321 if (dynamic_symbols
!= NULL
)
4323 error (_("File contains multiple dynamic symbol tables\n"));
4327 CHECK_ENTSIZE (section
, i
, Sym
);
4328 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4329 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4331 else if (section
->sh_type
== SHT_STRTAB
4332 && streq (name
, ".dynstr"))
4334 if (dynamic_strings
!= NULL
)
4336 error (_("File contains multiple dynamic string tables\n"));
4340 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4341 1, section
->sh_size
,
4342 _("dynamic strings"));
4343 dynamic_strings_length
= section
->sh_size
;
4345 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4347 if (symtab_shndx_hdr
!= NULL
)
4349 error (_("File contains multiple symtab shndx tables\n"));
4352 symtab_shndx_hdr
= section
;
4354 else if (section
->sh_type
== SHT_SYMTAB
)
4355 CHECK_ENTSIZE (section
, i
, Sym
);
4356 else if (section
->sh_type
== SHT_GROUP
)
4357 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4358 else if (section
->sh_type
== SHT_REL
)
4359 CHECK_ENTSIZE (section
, i
, Rel
);
4360 else if (section
->sh_type
== SHT_RELA
)
4361 CHECK_ENTSIZE (section
, i
, Rela
);
4362 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4363 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4364 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4365 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4366 && (const_strneq (name
, ".debug_")
4367 || const_strneq (name
, ".zdebug_")))
4370 name
+= sizeof (".zdebug_") - 1;
4372 name
+= sizeof (".debug_") - 1;
4375 || (do_debug_info
&& streq (name
, "info"))
4376 || (do_debug_info
&& streq (name
, "types"))
4377 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4378 || (do_debug_lines
&& streq (name
, "line"))
4379 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4380 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4381 || (do_debug_aranges
&& streq (name
, "aranges"))
4382 || (do_debug_ranges
&& streq (name
, "ranges"))
4383 || (do_debug_frames
&& streq (name
, "frame"))
4384 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4385 || (do_debug_str
&& streq (name
, "str"))
4386 || (do_debug_loc
&& streq (name
, "loc"))
4388 request_dump_bynumber (i
, DEBUG_DUMP
);
4390 /* Linkonce section to be combined with .debug_info at link time. */
4391 else if ((do_debugging
|| do_debug_info
)
4392 && const_strneq (name
, ".gnu.linkonce.wi."))
4393 request_dump_bynumber (i
, DEBUG_DUMP
);
4394 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4395 request_dump_bynumber (i
, DEBUG_DUMP
);
4401 if (elf_header
.e_shnum
> 1)
4402 printf (_("\nSection Headers:\n"));
4404 printf (_("\nSection Header:\n"));
4408 if (do_section_details
)
4410 printf (_(" [Nr] Name\n"));
4411 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4415 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4419 if (do_section_details
)
4421 printf (_(" [Nr] Name\n"));
4422 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4426 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4430 if (do_section_details
)
4432 printf (_(" [Nr] Name\n"));
4433 printf (_(" Type Address Offset Link\n"));
4434 printf (_(" Size EntSize Info Align\n"));
4438 printf (_(" [Nr] Name Type Address Offset\n"));
4439 printf (_(" Size EntSize Flags Link Info Align\n"));
4443 if (do_section_details
)
4444 printf (_(" Flags\n"));
4446 for (i
= 0, section
= section_headers
;
4447 i
< elf_header
.e_shnum
;
4450 if (do_section_details
)
4452 printf (" [%2u] %s\n",
4454 SECTION_NAME (section
));
4455 if (is_32bit_elf
|| do_wide
)
4456 printf (" %-15.15s ",
4457 get_section_type_name (section
->sh_type
));
4460 printf ((do_wide
? " [%2u] %-17s %-15s "
4461 : " [%2u] %-17.17s %-15.15s "),
4463 SECTION_NAME (section
),
4464 get_section_type_name (section
->sh_type
));
4468 const char * link_too_big
= NULL
;
4470 print_vma (section
->sh_addr
, LONG_HEX
);
4472 printf ( " %6.6lx %6.6lx %2.2lx",
4473 (unsigned long) section
->sh_offset
,
4474 (unsigned long) section
->sh_size
,
4475 (unsigned long) section
->sh_entsize
);
4477 if (do_section_details
)
4478 fputs (" ", stdout
);
4480 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4482 if (section
->sh_link
>= elf_header
.e_shnum
)
4485 /* The sh_link value is out of range. Normally this indicates
4486 an error but it can have special values in Solaris binaries. */
4487 switch (elf_header
.e_machine
)
4492 case EM_OLD_SPARCV9
:
4493 case EM_SPARC32PLUS
:
4496 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4497 link_too_big
= "BEFORE";
4498 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4499 link_too_big
= "AFTER";
4506 if (do_section_details
)
4508 if (link_too_big
!= NULL
&& * link_too_big
)
4509 printf ("<%s> ", link_too_big
);
4511 printf ("%2u ", section
->sh_link
);
4512 printf ("%3u %2lu\n", section
->sh_info
,
4513 (unsigned long) section
->sh_addralign
);
4516 printf ("%2u %3u %2lu\n",
4519 (unsigned long) section
->sh_addralign
);
4521 if (link_too_big
&& ! * link_too_big
)
4522 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4523 i
, section
->sh_link
);
4527 print_vma (section
->sh_addr
, LONG_HEX
);
4529 if ((long) section
->sh_offset
== section
->sh_offset
)
4530 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4534 print_vma (section
->sh_offset
, LONG_HEX
);
4537 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4538 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4542 print_vma (section
->sh_size
, LONG_HEX
);
4545 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4546 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4550 print_vma (section
->sh_entsize
, LONG_HEX
);
4553 if (do_section_details
)
4554 fputs (" ", stdout
);
4556 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4558 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4560 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4561 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4564 print_vma (section
->sh_addralign
, DEC
);
4568 else if (do_section_details
)
4570 printf (" %-15.15s ",
4571 get_section_type_name (section
->sh_type
));
4572 print_vma (section
->sh_addr
, LONG_HEX
);
4573 if ((long) section
->sh_offset
== section
->sh_offset
)
4574 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4578 print_vma (section
->sh_offset
, LONG_HEX
);
4580 printf (" %u\n ", section
->sh_link
);
4581 print_vma (section
->sh_size
, LONG_HEX
);
4583 print_vma (section
->sh_entsize
, LONG_HEX
);
4585 printf (" %-16u %lu\n",
4587 (unsigned long) section
->sh_addralign
);
4592 print_vma (section
->sh_addr
, LONG_HEX
);
4593 if ((long) section
->sh_offset
== section
->sh_offset
)
4594 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4598 print_vma (section
->sh_offset
, LONG_HEX
);
4601 print_vma (section
->sh_size
, LONG_HEX
);
4603 print_vma (section
->sh_entsize
, LONG_HEX
);
4605 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4607 printf (" %2u %3u %lu\n",
4610 (unsigned long) section
->sh_addralign
);
4613 if (do_section_details
)
4614 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4617 if (!do_section_details
)
4618 printf (_("Key to Flags:\n\
4619 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4620 I (info), L (link order), G (group), x (unknown)\n\
4621 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4627 get_group_flags (unsigned int flags
)
4629 static char buff
[32];
4636 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4643 process_section_groups (FILE * file
)
4645 Elf_Internal_Shdr
* section
;
4647 struct group
* group
;
4648 Elf_Internal_Shdr
* symtab_sec
;
4649 Elf_Internal_Shdr
* strtab_sec
;
4650 Elf_Internal_Sym
* symtab
;
4654 /* Don't process section groups unless needed. */
4655 if (!do_unwind
&& !do_section_groups
)
4658 if (elf_header
.e_shnum
== 0)
4660 if (do_section_groups
)
4661 printf (_("\nThere are no sections in this file.\n"));
4666 if (section_headers
== NULL
)
4668 error (_("Section headers are not available!\n"));
4672 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4673 sizeof (struct group
*));
4675 if (section_headers_groups
== NULL
)
4677 error (_("Out of memory\n"));
4681 /* Scan the sections for the group section. */
4683 for (i
= 0, section
= section_headers
;
4684 i
< elf_header
.e_shnum
;
4686 if (section
->sh_type
== SHT_GROUP
)
4689 if (group_count
== 0)
4691 if (do_section_groups
)
4692 printf (_("\nThere are no section groups in this file.\n"));
4697 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4699 if (section_groups
== NULL
)
4701 error (_("Out of memory\n"));
4710 for (i
= 0, section
= section_headers
, group
= section_groups
;
4711 i
< elf_header
.e_shnum
;
4714 if (section
->sh_type
== SHT_GROUP
)
4716 char * name
= SECTION_NAME (section
);
4718 unsigned char * start
;
4719 unsigned char * indices
;
4720 unsigned int entry
, j
, size
;
4721 Elf_Internal_Shdr
* sec
;
4722 Elf_Internal_Sym
* sym
;
4724 /* Get the symbol table. */
4725 if (section
->sh_link
>= elf_header
.e_shnum
4726 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4729 error (_("Bad sh_link in group section `%s'\n"), name
);
4733 if (symtab_sec
!= sec
)
4738 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4741 sym
= symtab
+ section
->sh_info
;
4743 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4745 if (sym
->st_shndx
== 0
4746 || sym
->st_shndx
>= elf_header
.e_shnum
)
4748 error (_("Bad sh_info in group section `%s'\n"), name
);
4752 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4761 /* Get the string table. */
4762 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4771 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4776 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4777 1, strtab_sec
->sh_size
,
4779 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4781 group_name
= sym
->st_name
< strtab_size
4782 ? strtab
+ sym
->st_name
: "<corrupt>";
4785 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4786 1, section
->sh_size
,
4790 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4791 entry
= byte_get (indices
, 4);
4794 if (do_section_groups
)
4796 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4797 get_group_flags (entry
), i
, name
, group_name
, size
);
4799 printf (_(" [Index] Name\n"));
4802 group
->group_index
= i
;
4804 for (j
= 0; j
< size
; j
++)
4806 struct group_list
* g
;
4808 entry
= byte_get (indices
, 4);
4811 if (entry
>= elf_header
.e_shnum
)
4813 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4814 entry
, i
, elf_header
.e_shnum
- 1);
4818 if (section_headers_groups
[entry
] != NULL
)
4822 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4824 section_headers_groups
[entry
]->group_index
);
4829 /* Intel C/C++ compiler may put section 0 in a
4830 section group. We just warn it the first time
4831 and ignore it afterwards. */
4832 static int warned
= 0;
4835 error (_("section 0 in group section [%5u]\n"),
4836 section_headers_groups
[entry
]->group_index
);
4842 section_headers_groups
[entry
] = group
;
4844 if (do_section_groups
)
4846 sec
= section_headers
+ entry
;
4847 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4850 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
4851 g
->section_index
= entry
;
4852 g
->next
= group
->root
;
4876 } dynamic_relocations
[] =
4878 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4879 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4880 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4883 /* Process the reloc section. */
4886 process_relocs (FILE * file
)
4888 unsigned long rel_size
;
4889 unsigned long rel_offset
;
4895 if (do_using_dynamic
)
4899 int has_dynamic_reloc
;
4902 has_dynamic_reloc
= 0;
4904 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4906 is_rela
= dynamic_relocations
[i
].rela
;
4907 name
= dynamic_relocations
[i
].name
;
4908 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4909 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4911 has_dynamic_reloc
|= rel_size
;
4913 if (is_rela
== UNKNOWN
)
4915 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4916 switch (dynamic_info
[DT_PLTREL
])
4930 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4931 name
, rel_offset
, rel_size
);
4933 dump_relocations (file
,
4934 offset_from_vma (file
, rel_offset
, rel_size
),
4936 dynamic_symbols
, num_dynamic_syms
,
4937 dynamic_strings
, dynamic_strings_length
, is_rela
);
4941 if (! has_dynamic_reloc
)
4942 printf (_("\nThere are no dynamic relocations in this file.\n"));
4946 Elf_Internal_Shdr
* section
;
4950 for (i
= 0, section
= section_headers
;
4951 i
< elf_header
.e_shnum
;
4954 if ( section
->sh_type
!= SHT_RELA
4955 && section
->sh_type
!= SHT_REL
)
4958 rel_offset
= section
->sh_offset
;
4959 rel_size
= section
->sh_size
;
4963 Elf_Internal_Shdr
* strsec
;
4966 printf (_("\nRelocation section "));
4968 if (string_table
== NULL
)
4969 printf ("%d", section
->sh_name
);
4971 printf (_("'%s'"), SECTION_NAME (section
));
4973 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4974 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4976 is_rela
= section
->sh_type
== SHT_RELA
;
4978 if (section
->sh_link
!= 0
4979 && section
->sh_link
< elf_header
.e_shnum
)
4981 Elf_Internal_Shdr
* symsec
;
4982 Elf_Internal_Sym
* symtab
;
4983 unsigned long nsyms
;
4984 unsigned long strtablen
= 0;
4985 char * strtab
= NULL
;
4987 symsec
= section_headers
+ section
->sh_link
;
4988 if (symsec
->sh_type
!= SHT_SYMTAB
4989 && symsec
->sh_type
!= SHT_DYNSYM
)
4992 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4993 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4998 if (symsec
->sh_link
!= 0
4999 && symsec
->sh_link
< elf_header
.e_shnum
)
5001 strsec
= section_headers
+ symsec
->sh_link
;
5003 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5006 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5009 dump_relocations (file
, rel_offset
, rel_size
,
5010 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5016 dump_relocations (file
, rel_offset
, rel_size
,
5017 NULL
, 0, NULL
, 0, is_rela
);
5024 printf (_("\nThere are no relocations in this file.\n"));
5030 /* Process the unwind section. */
5032 #include "unwind-ia64.h"
5034 /* An absolute address consists of a section and an offset. If the
5035 section is NULL, the offset itself is the address, otherwise, the
5036 address equals to LOAD_ADDRESS(section) + offset. */
5040 unsigned short section
;
5044 #define ABSADDR(a) \
5046 ? section_headers [(a).section].sh_addr + (a).offset \
5049 struct ia64_unw_table_entry
5051 struct absaddr start
;
5053 struct absaddr info
;
5056 struct ia64_unw_aux_info
5059 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5060 unsigned long table_len
; /* Length of unwind table. */
5061 unsigned char * info
; /* Unwind info. */
5062 unsigned long info_size
; /* Size of unwind info. */
5063 bfd_vma info_addr
; /* starting address of unwind info. */
5064 bfd_vma seg_base
; /* Starting address of segment. */
5065 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5066 unsigned long nsyms
; /* Number of symbols. */
5067 char * strtab
; /* The string table. */
5068 unsigned long strtab_size
; /* Size of string table. */
5072 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5073 unsigned long nsyms
,
5074 const char * strtab
,
5075 unsigned long strtab_size
,
5076 struct absaddr addr
,
5077 const char ** symname
,
5080 bfd_vma dist
= 0x100000;
5081 Elf_Internal_Sym
* sym
;
5082 Elf_Internal_Sym
* best
= NULL
;
5085 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5087 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5088 && sym
->st_name
!= 0
5089 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5090 && addr
.offset
>= sym
->st_value
5091 && addr
.offset
- sym
->st_value
< dist
)
5094 dist
= addr
.offset
- sym
->st_value
;
5101 *symname
= (best
->st_name
>= strtab_size
5102 ? "<corrupt>" : strtab
+ best
->st_name
);
5107 *offset
= addr
.offset
;
5111 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5113 struct ia64_unw_table_entry
* tp
;
5116 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5120 const unsigned char * dp
;
5121 const unsigned char * head
;
5122 const char * procname
;
5124 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5125 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5127 fputs ("\n<", stdout
);
5131 fputs (procname
, stdout
);
5134 printf ("+%lx", (unsigned long) offset
);
5137 fputs (">: [", stdout
);
5138 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5139 fputc ('-', stdout
);
5140 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5141 printf ("], info at +0x%lx\n",
5142 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5144 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5145 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5147 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5148 (unsigned) UNW_VER (stamp
),
5149 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5150 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5151 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5152 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5154 if (UNW_VER (stamp
) != 1)
5156 printf ("\tUnknown version.\n");
5161 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5162 dp
= unw_decode (dp
, in_body
, & in_body
);
5167 slurp_ia64_unwind_table (FILE * file
,
5168 struct ia64_unw_aux_info
* aux
,
5169 Elf_Internal_Shdr
* sec
)
5171 unsigned long size
, nrelas
, i
;
5172 Elf_Internal_Phdr
* seg
;
5173 struct ia64_unw_table_entry
* tep
;
5174 Elf_Internal_Shdr
* relsec
;
5175 Elf_Internal_Rela
* rela
;
5176 Elf_Internal_Rela
* rp
;
5177 unsigned char * table
;
5179 Elf_Internal_Sym
* sym
;
5180 const char * relname
;
5182 /* First, find the starting address of the segment that includes
5185 if (elf_header
.e_phnum
)
5187 if (! get_program_headers (file
))
5190 for (seg
= program_headers
;
5191 seg
< program_headers
+ elf_header
.e_phnum
;
5194 if (seg
->p_type
!= PT_LOAD
)
5197 if (sec
->sh_addr
>= seg
->p_vaddr
5198 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5200 aux
->seg_base
= seg
->p_vaddr
;
5206 /* Second, build the unwind table from the contents of the unwind section: */
5207 size
= sec
->sh_size
;
5208 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5213 aux
->table
= (struct ia64_unw_table_entry
*)
5214 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5216 for (tp
= table
; tp
< table
+ size
; ++tep
)
5218 tep
->start
.section
= SHN_UNDEF
;
5219 tep
->end
.section
= SHN_UNDEF
;
5220 tep
->info
.section
= SHN_UNDEF
;
5221 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5222 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5223 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5224 tep
->start
.offset
+= aux
->seg_base
;
5225 tep
->end
.offset
+= aux
->seg_base
;
5226 tep
->info
.offset
+= aux
->seg_base
;
5230 /* Third, apply any relocations to the unwind table: */
5231 for (relsec
= section_headers
;
5232 relsec
< section_headers
+ elf_header
.e_shnum
;
5235 if (relsec
->sh_type
!= SHT_RELA
5236 || relsec
->sh_info
>= elf_header
.e_shnum
5237 || section_headers
+ relsec
->sh_info
!= sec
)
5240 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5244 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5246 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5247 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5249 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5251 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5255 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5257 switch (rp
->r_offset
/eh_addr_size
% 3)
5260 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5261 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5264 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5265 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5268 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5269 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5279 aux
->table_len
= size
/ (3 * eh_addr_size
);
5284 ia64_process_unwind (FILE * file
)
5286 Elf_Internal_Shdr
* sec
;
5287 Elf_Internal_Shdr
* unwsec
= NULL
;
5288 Elf_Internal_Shdr
* strsec
;
5289 unsigned long i
, unwcount
= 0, unwstart
= 0;
5290 struct ia64_unw_aux_info aux
;
5292 memset (& aux
, 0, sizeof (aux
));
5294 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5296 if (sec
->sh_type
== SHT_SYMTAB
5297 && sec
->sh_link
< elf_header
.e_shnum
)
5299 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5300 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5302 strsec
= section_headers
+ sec
->sh_link
;
5303 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5306 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5308 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5313 printf (_("\nThere are no unwind sections in this file.\n"));
5315 while (unwcount
-- > 0)
5320 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5321 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5322 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5329 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5331 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5333 /* We need to find which section group it is in. */
5334 struct group_list
* g
= section_headers_groups
[i
]->root
;
5336 for (; g
!= NULL
; g
= g
->next
)
5338 sec
= section_headers
+ g
->section_index
;
5340 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5345 i
= elf_header
.e_shnum
;
5347 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5349 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5350 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5351 suffix
= SECTION_NAME (unwsec
) + len
;
5352 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5354 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5355 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5360 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5361 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5362 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5363 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5365 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5366 suffix
= SECTION_NAME (unwsec
) + len
;
5367 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5369 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5370 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5374 if (i
== elf_header
.e_shnum
)
5376 printf (_("\nCould not find unwind info section for "));
5378 if (string_table
== NULL
)
5379 printf ("%d", unwsec
->sh_name
);
5381 printf (_("'%s'"), SECTION_NAME (unwsec
));
5385 aux
.info_size
= sec
->sh_size
;
5386 aux
.info_addr
= sec
->sh_addr
;
5387 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5391 printf (_("\nUnwind section "));
5393 if (string_table
== NULL
)
5394 printf ("%d", unwsec
->sh_name
);
5396 printf (_("'%s'"), SECTION_NAME (unwsec
));
5398 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5399 (unsigned long) unwsec
->sh_offset
,
5400 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5402 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5404 if (aux
.table_len
> 0)
5405 dump_ia64_unwind (& aux
);
5408 free ((char *) aux
.table
);
5410 free ((char *) aux
.info
);
5419 free ((char *) aux
.strtab
);
5424 struct hppa_unw_table_entry
5426 struct absaddr start
;
5428 unsigned int Cannot_unwind
:1; /* 0 */
5429 unsigned int Millicode
:1; /* 1 */
5430 unsigned int Millicode_save_sr0
:1; /* 2 */
5431 unsigned int Region_description
:2; /* 3..4 */
5432 unsigned int reserved1
:1; /* 5 */
5433 unsigned int Entry_SR
:1; /* 6 */
5434 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5435 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5436 unsigned int Args_stored
:1; /* 16 */
5437 unsigned int Variable_Frame
:1; /* 17 */
5438 unsigned int Separate_Package_Body
:1; /* 18 */
5439 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5440 unsigned int Stack_Overflow_Check
:1; /* 20 */
5441 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5442 unsigned int Ada_Region
:1; /* 22 */
5443 unsigned int cxx_info
:1; /* 23 */
5444 unsigned int cxx_try_catch
:1; /* 24 */
5445 unsigned int sched_entry_seq
:1; /* 25 */
5446 unsigned int reserved2
:1; /* 26 */
5447 unsigned int Save_SP
:1; /* 27 */
5448 unsigned int Save_RP
:1; /* 28 */
5449 unsigned int Save_MRP_in_frame
:1; /* 29 */
5450 unsigned int extn_ptr_defined
:1; /* 30 */
5451 unsigned int Cleanup_defined
:1; /* 31 */
5453 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5454 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5455 unsigned int Large_frame
:1; /* 2 */
5456 unsigned int Pseudo_SP_Set
:1; /* 3 */
5457 unsigned int reserved4
:1; /* 4 */
5458 unsigned int Total_frame_size
:27; /* 5..31 */
5461 struct hppa_unw_aux_info
5463 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5464 unsigned long table_len
; /* Length of unwind table. */
5465 bfd_vma seg_base
; /* Starting address of segment. */
5466 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5467 unsigned long nsyms
; /* Number of symbols. */
5468 char * strtab
; /* The string table. */
5469 unsigned long strtab_size
; /* Size of string table. */
5473 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5475 struct hppa_unw_table_entry
* tp
;
5477 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5480 const char * procname
;
5482 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5483 aux
->strtab_size
, tp
->start
, &procname
,
5486 fputs ("\n<", stdout
);
5490 fputs (procname
, stdout
);
5493 printf ("+%lx", (unsigned long) offset
);
5496 fputs (">: [", stdout
);
5497 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5498 fputc ('-', stdout
);
5499 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5502 #define PF(_m) if (tp->_m) printf (#_m " ");
5503 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5506 PF(Millicode_save_sr0
);
5507 /* PV(Region_description); */
5513 PF(Separate_Package_Body
);
5514 PF(Frame_Extension_Millicode
);
5515 PF(Stack_Overflow_Check
);
5516 PF(Two_Instruction_SP_Increment
);
5520 PF(sched_entry_seq
);
5523 PF(Save_MRP_in_frame
);
5524 PF(extn_ptr_defined
);
5525 PF(Cleanup_defined
);
5526 PF(MPE_XL_interrupt_marker
);
5527 PF(HP_UX_interrupt_marker
);
5530 PV(Total_frame_size
);
5539 slurp_hppa_unwind_table (FILE * file
,
5540 struct hppa_unw_aux_info
* aux
,
5541 Elf_Internal_Shdr
* sec
)
5543 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5544 Elf_Internal_Phdr
* seg
;
5545 struct hppa_unw_table_entry
* tep
;
5546 Elf_Internal_Shdr
* relsec
;
5547 Elf_Internal_Rela
* rela
;
5548 Elf_Internal_Rela
* rp
;
5549 unsigned char * table
;
5551 Elf_Internal_Sym
* sym
;
5552 const char * relname
;
5554 /* First, find the starting address of the segment that includes
5557 if (elf_header
.e_phnum
)
5559 if (! get_program_headers (file
))
5562 for (seg
= program_headers
;
5563 seg
< program_headers
+ elf_header
.e_phnum
;
5566 if (seg
->p_type
!= PT_LOAD
)
5569 if (sec
->sh_addr
>= seg
->p_vaddr
5570 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5572 aux
->seg_base
= seg
->p_vaddr
;
5578 /* Second, build the unwind table from the contents of the unwind
5580 size
= sec
->sh_size
;
5581 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5587 nentries
= size
/ unw_ent_size
;
5588 size
= unw_ent_size
* nentries
;
5590 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5591 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5593 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5595 unsigned int tmp1
, tmp2
;
5597 tep
->start
.section
= SHN_UNDEF
;
5598 tep
->end
.section
= SHN_UNDEF
;
5600 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5601 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5602 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5603 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5605 tep
->start
.offset
+= aux
->seg_base
;
5606 tep
->end
.offset
+= aux
->seg_base
;
5608 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5609 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5610 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5611 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5612 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5613 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5614 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5615 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5616 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5617 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5618 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5619 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5620 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5621 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5622 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5623 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5624 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5625 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5626 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5627 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5628 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5629 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5630 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5631 tep
->Cleanup_defined
= tmp1
& 0x1;
5633 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5634 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5635 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5636 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5637 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5638 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5642 /* Third, apply any relocations to the unwind table. */
5643 for (relsec
= section_headers
;
5644 relsec
< section_headers
+ elf_header
.e_shnum
;
5647 if (relsec
->sh_type
!= SHT_RELA
5648 || relsec
->sh_info
>= elf_header
.e_shnum
5649 || section_headers
+ relsec
->sh_info
!= sec
)
5652 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5656 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5658 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5659 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5661 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5662 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5664 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5668 i
= rp
->r_offset
/ unw_ent_size
;
5670 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5673 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5674 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
5677 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5678 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
5688 aux
->table_len
= nentries
;
5694 hppa_process_unwind (FILE * file
)
5696 struct hppa_unw_aux_info aux
;
5697 Elf_Internal_Shdr
* unwsec
= NULL
;
5698 Elf_Internal_Shdr
* strsec
;
5699 Elf_Internal_Shdr
* sec
;
5702 memset (& aux
, 0, sizeof (aux
));
5704 if (string_table
== NULL
)
5707 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5709 if (sec
->sh_type
== SHT_SYMTAB
5710 && sec
->sh_link
< elf_header
.e_shnum
)
5712 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5713 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5715 strsec
= section_headers
+ sec
->sh_link
;
5716 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5719 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5721 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5726 printf (_("\nThere are no unwind sections in this file.\n"));
5728 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5730 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5732 printf (_("\nUnwind section "));
5733 printf (_("'%s'"), SECTION_NAME (sec
));
5735 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5736 (unsigned long) sec
->sh_offset
,
5737 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5739 slurp_hppa_unwind_table (file
, &aux
, sec
);
5740 if (aux
.table_len
> 0)
5741 dump_hppa_unwind (&aux
);
5744 free ((char *) aux
.table
);
5752 free ((char *) aux
.strtab
);
5758 process_unwind (FILE * file
)
5760 struct unwind_handler
5763 int (* handler
)(FILE *);
5766 { EM_IA_64
, ia64_process_unwind
},
5767 { EM_PARISC
, hppa_process_unwind
},
5775 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5776 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5777 return handlers
[i
].handler (file
);
5779 printf (_("\nThere are no unwind sections in this file.\n"));
5784 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5786 switch (entry
->d_tag
)
5789 if (entry
->d_un
.d_val
== 0)
5793 static const char * opts
[] =
5795 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5796 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5797 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5798 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5803 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5804 if (entry
->d_un
.d_val
& (1 << cnt
))
5806 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5813 case DT_MIPS_IVERSION
:
5814 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5815 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5817 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5820 case DT_MIPS_TIME_STAMP
:
5825 time_t atime
= entry
->d_un
.d_val
;
5826 tmp
= gmtime (&atime
);
5827 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5828 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5829 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5830 printf ("Time Stamp: %s\n", timebuf
);
5834 case DT_MIPS_RLD_VERSION
:
5835 case DT_MIPS_LOCAL_GOTNO
:
5836 case DT_MIPS_CONFLICTNO
:
5837 case DT_MIPS_LIBLISTNO
:
5838 case DT_MIPS_SYMTABNO
:
5839 case DT_MIPS_UNREFEXTNO
:
5840 case DT_MIPS_HIPAGENO
:
5841 case DT_MIPS_DELTA_CLASS_NO
:
5842 case DT_MIPS_DELTA_INSTANCE_NO
:
5843 case DT_MIPS_DELTA_RELOC_NO
:
5844 case DT_MIPS_DELTA_SYM_NO
:
5845 case DT_MIPS_DELTA_CLASSSYM_NO
:
5846 case DT_MIPS_COMPACT_SIZE
:
5847 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5851 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5857 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5859 switch (entry
->d_tag
)
5861 case DT_HP_DLD_FLAGS
:
5870 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5871 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5872 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5873 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5874 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5875 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5876 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5877 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5878 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5879 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5880 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5881 { DT_HP_GST
, "HP_GST" },
5882 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5883 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5884 { DT_HP_NODELETE
, "HP_NODELETE" },
5885 { DT_HP_GROUP
, "HP_GROUP" },
5886 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5890 bfd_vma val
= entry
->d_un
.d_val
;
5892 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5893 if (val
& flags
[cnt
].bit
)
5897 fputs (flags
[cnt
].str
, stdout
);
5899 val
^= flags
[cnt
].bit
;
5902 if (val
!= 0 || first
)
5906 print_vma (val
, HEX
);
5912 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5919 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5921 switch (entry
->d_tag
)
5923 case DT_IA_64_PLT_RESERVE
:
5924 /* First 3 slots reserved. */
5925 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5927 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5931 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5938 get_32bit_dynamic_section (FILE * file
)
5940 Elf32_External_Dyn
* edyn
;
5941 Elf32_External_Dyn
* ext
;
5942 Elf_Internal_Dyn
* entry
;
5944 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5945 dynamic_size
, _("dynamic section"));
5949 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5950 might not have the luxury of section headers. Look for the DT_NULL
5951 terminator to determine the number of entries. */
5952 for (ext
= edyn
, dynamic_nent
= 0;
5953 (char *) ext
< (char *) edyn
+ dynamic_size
;
5957 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5961 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5963 if (dynamic_section
== NULL
)
5965 error (_("Out of memory\n"));
5970 for (ext
= edyn
, entry
= dynamic_section
;
5971 entry
< dynamic_section
+ dynamic_nent
;
5974 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5975 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5984 get_64bit_dynamic_section (FILE * file
)
5986 Elf64_External_Dyn
* edyn
;
5987 Elf64_External_Dyn
* ext
;
5988 Elf_Internal_Dyn
* entry
;
5990 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5991 dynamic_size
, _("dynamic section"));
5995 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5996 might not have the luxury of section headers. Look for the DT_NULL
5997 terminator to determine the number of entries. */
5998 for (ext
= edyn
, dynamic_nent
= 0;
5999 (char *) ext
< (char *) edyn
+ dynamic_size
;
6003 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
6007 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
6009 if (dynamic_section
== NULL
)
6011 error (_("Out of memory\n"));
6016 for (ext
= edyn
, entry
= dynamic_section
;
6017 entry
< dynamic_section
+ dynamic_nent
;
6020 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6021 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6030 print_dynamic_flags (bfd_vma flags
)
6038 flag
= flags
& - flags
;
6048 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6049 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6050 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6051 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6052 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6053 default: fputs ("unknown", stdout
); break;
6059 /* Parse and display the contents of the dynamic section. */
6062 process_dynamic_section (FILE * file
)
6064 Elf_Internal_Dyn
* entry
;
6066 if (dynamic_size
== 0)
6069 printf (_("\nThere is no dynamic section in this file.\n"));
6076 if (! get_32bit_dynamic_section (file
))
6079 else if (! get_64bit_dynamic_section (file
))
6082 /* Find the appropriate symbol table. */
6083 if (dynamic_symbols
== NULL
)
6085 for (entry
= dynamic_section
;
6086 entry
< dynamic_section
+ dynamic_nent
;
6089 Elf_Internal_Shdr section
;
6091 if (entry
->d_tag
!= DT_SYMTAB
)
6094 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6096 /* Since we do not know how big the symbol table is,
6097 we default to reading in the entire file (!) and
6098 processing that. This is overkill, I know, but it
6100 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6102 if (archive_file_offset
!= 0)
6103 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6106 if (fseek (file
, 0, SEEK_END
))
6107 error (_("Unable to seek to end of file!\n"));
6109 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6113 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6115 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6117 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6118 if (num_dynamic_syms
< 1)
6120 error (_("Unable to determine the number of symbols to load\n"));
6124 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6128 /* Similarly find a string table. */
6129 if (dynamic_strings
== NULL
)
6131 for (entry
= dynamic_section
;
6132 entry
< dynamic_section
+ dynamic_nent
;
6135 unsigned long offset
;
6138 if (entry
->d_tag
!= DT_STRTAB
)
6141 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6143 /* Since we do not know how big the string table is,
6144 we default to reading in the entire file (!) and
6145 processing that. This is overkill, I know, but it
6148 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6150 if (archive_file_offset
!= 0)
6151 str_tab_len
= archive_file_size
- offset
;
6154 if (fseek (file
, 0, SEEK_END
))
6155 error (_("Unable to seek to end of file\n"));
6156 str_tab_len
= ftell (file
) - offset
;
6159 if (str_tab_len
< 1)
6162 (_("Unable to determine the length of the dynamic string table\n"));
6166 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6168 _("dynamic string table"));
6169 dynamic_strings_length
= str_tab_len
;
6174 /* And find the syminfo section if available. */
6175 if (dynamic_syminfo
== NULL
)
6177 unsigned long syminsz
= 0;
6179 for (entry
= dynamic_section
;
6180 entry
< dynamic_section
+ dynamic_nent
;
6183 if (entry
->d_tag
== DT_SYMINENT
)
6185 /* Note: these braces are necessary to avoid a syntax
6186 error from the SunOS4 C compiler. */
6187 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6189 else if (entry
->d_tag
== DT_SYMINSZ
)
6190 syminsz
= entry
->d_un
.d_val
;
6191 else if (entry
->d_tag
== DT_SYMINFO
)
6192 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6196 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6198 Elf_External_Syminfo
* extsyminfo
;
6199 Elf_External_Syminfo
* extsym
;
6200 Elf_Internal_Syminfo
* syminfo
;
6202 /* There is a syminfo section. Read the data. */
6203 extsyminfo
= (Elf_External_Syminfo
*)
6204 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6205 _("symbol information"));
6209 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6210 if (dynamic_syminfo
== NULL
)
6212 error (_("Out of memory\n"));
6216 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6217 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6218 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6219 ++syminfo
, ++extsym
)
6221 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6222 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6229 if (do_dynamic
&& dynamic_addr
)
6230 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6231 dynamic_addr
, dynamic_nent
);
6233 printf (_(" Tag Type Name/Value\n"));
6235 for (entry
= dynamic_section
;
6236 entry
< dynamic_section
+ dynamic_nent
;
6244 print_vma (entry
->d_tag
, FULL_HEX
);
6245 dtype
= get_dynamic_type (entry
->d_tag
);
6246 printf (" (%s)%*s", dtype
,
6247 ((is_32bit_elf
? 27 : 19)
6248 - (int) strlen (dtype
)),
6252 switch (entry
->d_tag
)
6256 print_dynamic_flags (entry
->d_un
.d_val
);
6266 switch (entry
->d_tag
)
6269 printf (_("Auxiliary library"));
6273 printf (_("Filter library"));
6277 printf (_("Configuration file"));
6281 printf (_("Dependency audit library"));
6285 printf (_("Audit library"));
6289 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6290 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6294 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6303 printf (_("Flags:"));
6305 if (entry
->d_un
.d_val
== 0)
6306 printf (_(" None\n"));
6309 unsigned long int val
= entry
->d_un
.d_val
;
6311 if (val
& DTF_1_PARINIT
)
6313 printf (" PARINIT");
6314 val
^= DTF_1_PARINIT
;
6316 if (val
& DTF_1_CONFEXP
)
6318 printf (" CONFEXP");
6319 val
^= DTF_1_CONFEXP
;
6322 printf (" %lx", val
);
6331 printf (_("Flags:"));
6333 if (entry
->d_un
.d_val
== 0)
6334 printf (_(" None\n"));
6337 unsigned long int val
= entry
->d_un
.d_val
;
6339 if (val
& DF_P1_LAZYLOAD
)
6341 printf (" LAZYLOAD");
6342 val
^= DF_P1_LAZYLOAD
;
6344 if (val
& DF_P1_GROUPPERM
)
6346 printf (" GROUPPERM");
6347 val
^= DF_P1_GROUPPERM
;
6350 printf (" %lx", val
);
6359 printf (_("Flags:"));
6360 if (entry
->d_un
.d_val
== 0)
6361 printf (_(" None\n"));
6364 unsigned long int val
= entry
->d_un
.d_val
;
6371 if (val
& DF_1_GLOBAL
)
6376 if (val
& DF_1_GROUP
)
6381 if (val
& DF_1_NODELETE
)
6383 printf (" NODELETE");
6384 val
^= DF_1_NODELETE
;
6386 if (val
& DF_1_LOADFLTR
)
6388 printf (" LOADFLTR");
6389 val
^= DF_1_LOADFLTR
;
6391 if (val
& DF_1_INITFIRST
)
6393 printf (" INITFIRST");
6394 val
^= DF_1_INITFIRST
;
6396 if (val
& DF_1_NOOPEN
)
6401 if (val
& DF_1_ORIGIN
)
6406 if (val
& DF_1_DIRECT
)
6411 if (val
& DF_1_TRANS
)
6416 if (val
& DF_1_INTERPOSE
)
6418 printf (" INTERPOSE");
6419 val
^= DF_1_INTERPOSE
;
6421 if (val
& DF_1_NODEFLIB
)
6423 printf (" NODEFLIB");
6424 val
^= DF_1_NODEFLIB
;
6426 if (val
& DF_1_NODUMP
)
6431 if (val
& DF_1_CONLFAT
)
6433 printf (" CONLFAT");
6434 val
^= DF_1_CONLFAT
;
6437 printf (" %lx", val
);
6444 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6446 puts (get_dynamic_type (entry
->d_un
.d_val
));
6466 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6472 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6473 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6479 switch (entry
->d_tag
)
6482 printf (_("Shared library: [%s]"), name
);
6484 if (streq (name
, program_interpreter
))
6485 printf (_(" program interpreter"));
6489 printf (_("Library soname: [%s]"), name
);
6493 printf (_("Library rpath: [%s]"), name
);
6497 printf (_("Library runpath: [%s]"), name
);
6501 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6506 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6519 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6523 case DT_INIT_ARRAYSZ
:
6524 case DT_FINI_ARRAYSZ
:
6525 case DT_GNU_CONFLICTSZ
:
6526 case DT_GNU_LIBLISTSZ
:
6529 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6530 printf (" (bytes)\n");
6540 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6553 if (entry
->d_tag
== DT_USED
6554 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6556 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6560 printf (_("Not needed object: [%s]\n"), name
);
6565 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6571 /* The value of this entry is ignored. */
6576 case DT_GNU_PRELINKED
:
6580 time_t atime
= entry
->d_un
.d_val
;
6582 tmp
= gmtime (&atime
);
6583 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6584 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6585 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6591 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6594 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6600 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6601 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6606 switch (elf_header
.e_machine
)
6609 case EM_MIPS_RS3_LE
:
6610 dynamic_section_mips_val (entry
);
6613 dynamic_section_parisc_val (entry
);
6616 dynamic_section_ia64_val (entry
);
6619 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6631 get_ver_flags (unsigned int flags
)
6633 static char buff
[32];
6640 if (flags
& VER_FLG_BASE
)
6641 strcat (buff
, "BASE ");
6643 if (flags
& VER_FLG_WEAK
)
6645 if (flags
& VER_FLG_BASE
)
6646 strcat (buff
, "| ");
6648 strcat (buff
, "WEAK ");
6651 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6652 strcat (buff
, "| <unknown>");
6657 /* Display the contents of the version sections. */
6660 process_version_sections (FILE * file
)
6662 Elf_Internal_Shdr
* section
;
6669 for (i
= 0, section
= section_headers
;
6670 i
< elf_header
.e_shnum
;
6673 switch (section
->sh_type
)
6675 case SHT_GNU_verdef
:
6677 Elf_External_Verdef
* edefs
;
6685 (_("\nVersion definition section '%s' contains %u entries:\n"),
6686 SECTION_NAME (section
), section
->sh_info
);
6688 printf (_(" Addr: 0x"));
6689 printf_vma (section
->sh_addr
);
6690 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6691 (unsigned long) section
->sh_offset
, section
->sh_link
,
6692 section
->sh_link
< elf_header
.e_shnum
6693 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6696 edefs
= (Elf_External_Verdef
*)
6697 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
6698 _("version definition section"));
6699 endbuf
= (char *) edefs
+ section
->sh_size
;
6703 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6706 Elf_External_Verdef
* edef
;
6707 Elf_Internal_Verdef ent
;
6708 Elf_External_Verdaux
* eaux
;
6709 Elf_Internal_Verdaux aux
;
6713 vstart
= ((char *) edefs
) + idx
;
6714 if (vstart
+ sizeof (*edef
) > endbuf
)
6717 edef
= (Elf_External_Verdef
*) vstart
;
6719 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6720 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6721 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6722 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6723 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6724 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6725 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6727 printf (_(" %#06x: Rev: %d Flags: %s"),
6728 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6730 printf (_(" Index: %d Cnt: %d "),
6731 ent
.vd_ndx
, ent
.vd_cnt
);
6733 vstart
+= ent
.vd_aux
;
6735 eaux
= (Elf_External_Verdaux
*) vstart
;
6737 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6738 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6740 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6741 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6743 printf (_("Name index: %ld\n"), aux
.vda_name
);
6745 isum
= idx
+ ent
.vd_aux
;
6747 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6749 isum
+= aux
.vda_next
;
6750 vstart
+= aux
.vda_next
;
6752 eaux
= (Elf_External_Verdaux
*) vstart
;
6753 if (vstart
+ sizeof (*eaux
) > endbuf
)
6756 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6757 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6759 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6760 printf (_(" %#06x: Parent %d: %s\n"),
6761 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6763 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6764 isum
, j
, aux
.vda_name
);
6767 printf (_(" Version def aux past end of section\n"));
6771 if (cnt
< section
->sh_info
)
6772 printf (_(" Version definition past end of section\n"));
6778 case SHT_GNU_verneed
:
6780 Elf_External_Verneed
* eneed
;
6787 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6788 SECTION_NAME (section
), section
->sh_info
);
6790 printf (_(" Addr: 0x"));
6791 printf_vma (section
->sh_addr
);
6792 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6793 (unsigned long) section
->sh_offset
, section
->sh_link
,
6794 section
->sh_link
< elf_header
.e_shnum
6795 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6798 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
6799 section
->sh_offset
, 1,
6801 _("version need section"));
6802 endbuf
= (char *) eneed
+ section
->sh_size
;
6806 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6808 Elf_External_Verneed
* entry
;
6809 Elf_Internal_Verneed ent
;
6814 vstart
= ((char *) eneed
) + idx
;
6815 if (vstart
+ sizeof (*entry
) > endbuf
)
6818 entry
= (Elf_External_Verneed
*) vstart
;
6820 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6821 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6822 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6823 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6824 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6826 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6828 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6829 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6831 printf (_(" File: %lx"), ent
.vn_file
);
6833 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6835 vstart
+= ent
.vn_aux
;
6837 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6839 Elf_External_Vernaux
* eaux
;
6840 Elf_Internal_Vernaux aux
;
6842 if (vstart
+ sizeof (*eaux
) > endbuf
)
6844 eaux
= (Elf_External_Vernaux
*) vstart
;
6846 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6847 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6848 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6849 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6850 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6852 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6853 printf (_(" %#06x: Name: %s"),
6854 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6856 printf (_(" %#06x: Name index: %lx"),
6857 isum
, aux
.vna_name
);
6859 printf (_(" Flags: %s Version: %d\n"),
6860 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6862 isum
+= aux
.vna_next
;
6863 vstart
+= aux
.vna_next
;
6866 printf (_(" Version need aux past end of section\n"));
6870 if (cnt
< section
->sh_info
)
6871 printf (_(" Version need past end of section\n"));
6877 case SHT_GNU_versym
:
6879 Elf_Internal_Shdr
* link_section
;
6882 unsigned char * edata
;
6883 unsigned short * data
;
6885 Elf_Internal_Sym
* symbols
;
6886 Elf_Internal_Shdr
* string_sec
;
6889 if (section
->sh_link
>= elf_header
.e_shnum
)
6892 link_section
= section_headers
+ section
->sh_link
;
6893 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6895 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6900 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6902 string_sec
= section_headers
+ link_section
->sh_link
;
6904 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6905 string_sec
->sh_size
,
6906 _("version string table"));
6910 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6911 SECTION_NAME (section
), total
);
6913 printf (_(" Addr: "));
6914 printf_vma (section
->sh_addr
);
6915 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6916 (unsigned long) section
->sh_offset
, section
->sh_link
,
6917 SECTION_NAME (link_section
));
6919 off
= offset_from_vma (file
,
6920 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6921 total
* sizeof (short));
6922 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
6924 _("version symbol data"));
6931 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
6933 for (cnt
= total
; cnt
--;)
6934 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6939 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6942 int check_def
, check_need
;
6945 printf (" %03x:", cnt
);
6947 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6948 switch (data
[cnt
+ j
])
6951 fputs (_(" 0 (*local*) "), stdout
);
6955 fputs (_(" 1 (*global*) "), stdout
);
6959 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
6960 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
6964 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6965 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6968 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6975 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6977 Elf_Internal_Verneed ivn
;
6978 unsigned long offset
;
6980 offset
= offset_from_vma
6981 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6982 sizeof (Elf_External_Verneed
));
6986 Elf_Internal_Vernaux ivna
;
6987 Elf_External_Verneed evn
;
6988 Elf_External_Vernaux evna
;
6989 unsigned long a_off
;
6991 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6994 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6995 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6997 a_off
= offset
+ ivn
.vn_aux
;
7001 get_data (&evna
, file
, a_off
, sizeof (evna
),
7002 1, _("version need aux (2)"));
7004 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7005 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7007 a_off
+= ivna
.vna_next
;
7009 while (ivna
.vna_other
!= data
[cnt
+ j
]
7010 && ivna
.vna_next
!= 0);
7012 if (ivna
.vna_other
== data
[cnt
+ j
])
7014 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7016 if (ivna
.vna_name
>= string_sec
->sh_size
)
7017 name
= _("*invalid*");
7019 name
= strtab
+ ivna
.vna_name
;
7020 nn
+= printf ("(%s%-*s",
7022 12 - (int) strlen (name
),
7028 offset
+= ivn
.vn_next
;
7030 while (ivn
.vn_next
);
7033 if (check_def
&& data
[cnt
+ j
] != 0x8001
7034 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7036 Elf_Internal_Verdef ivd
;
7037 Elf_External_Verdef evd
;
7038 unsigned long offset
;
7040 offset
= offset_from_vma
7041 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7046 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
7049 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7050 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7052 offset
+= ivd
.vd_next
;
7054 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
7055 && ivd
.vd_next
!= 0);
7057 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
7059 Elf_External_Verdaux evda
;
7060 Elf_Internal_Verdaux ivda
;
7062 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7064 get_data (&evda
, file
,
7065 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7067 _("version def aux"));
7069 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7071 if (ivda
.vda_name
>= string_sec
->sh_size
)
7072 name
= _("*invalid*");
7074 name
= strtab
+ ivda
.vda_name
;
7075 nn
+= printf ("(%s%-*s",
7077 12 - (int) strlen (name
),
7083 printf ("%*c", 18 - nn
, ' ');
7101 printf (_("\nNo version information found in this file.\n"));
7107 get_symbol_binding (unsigned int binding
)
7109 static char buff
[32];
7113 case STB_LOCAL
: return "LOCAL";
7114 case STB_GLOBAL
: return "GLOBAL";
7115 case STB_WEAK
: return "WEAK";
7117 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7118 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7120 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7122 if (binding
== STB_GNU_UNIQUE
7123 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7124 /* GNU/Linux is still using the default value 0. */
7125 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7127 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7130 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7136 get_symbol_type (unsigned int type
)
7138 static char buff
[32];
7142 case STT_NOTYPE
: return "NOTYPE";
7143 case STT_OBJECT
: return "OBJECT";
7144 case STT_FUNC
: return "FUNC";
7145 case STT_SECTION
: return "SECTION";
7146 case STT_FILE
: return "FILE";
7147 case STT_COMMON
: return "COMMON";
7148 case STT_TLS
: return "TLS";
7149 case STT_RELC
: return "RELC";
7150 case STT_SRELC
: return "SRELC";
7152 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7154 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7155 return "THUMB_FUNC";
7157 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7160 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7161 return "PARISC_MILLI";
7163 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7165 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7167 if (elf_header
.e_machine
== EM_PARISC
)
7169 if (type
== STT_HP_OPAQUE
)
7171 if (type
== STT_HP_STUB
)
7175 if (type
== STT_GNU_IFUNC
7176 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7177 /* GNU/Linux is still using the default value 0. */
7178 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7181 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7184 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7190 get_symbol_visibility (unsigned int visibility
)
7194 case STV_DEFAULT
: return "DEFAULT";
7195 case STV_INTERNAL
: return "INTERNAL";
7196 case STV_HIDDEN
: return "HIDDEN";
7197 case STV_PROTECTED
: return "PROTECTED";
7203 get_mips_symbol_other (unsigned int other
)
7207 case STO_OPTIONAL
: return "OPTIONAL";
7208 case STO_MIPS16
: return "MIPS16";
7209 case STO_MIPS_PLT
: return "MIPS PLT";
7210 case STO_MIPS_PIC
: return "MIPS PIC";
7211 default: return NULL
;
7216 get_symbol_other (unsigned int other
)
7218 const char * result
= NULL
;
7219 static char buff
[32];
7224 switch (elf_header
.e_machine
)
7227 result
= get_mips_symbol_other (other
);
7235 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7240 get_symbol_index_type (unsigned int type
)
7242 static char buff
[32];
7246 case SHN_UNDEF
: return "UND";
7247 case SHN_ABS
: return "ABS";
7248 case SHN_COMMON
: return "COM";
7250 if (type
== SHN_IA_64_ANSI_COMMON
7251 && elf_header
.e_machine
== EM_IA_64
7252 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7254 else if ((elf_header
.e_machine
== EM_X86_64
7255 || elf_header
.e_machine
== EM_L1OM
)
7256 && type
== SHN_X86_64_LCOMMON
)
7258 else if (type
== SHN_MIPS_SCOMMON
7259 && elf_header
.e_machine
== EM_MIPS
)
7261 else if (type
== SHN_MIPS_SUNDEFINED
7262 && elf_header
.e_machine
== EM_MIPS
)
7264 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7265 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7266 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7267 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7268 else if (type
>= SHN_LORESERVE
)
7269 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7271 sprintf (buff
, "%3d", type
);
7279 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7281 unsigned char * e_data
;
7284 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
7288 error (_("Out of memory\n"));
7292 if (fread (e_data
, ent_size
, number
, file
) != number
)
7294 error (_("Unable to read in dynamic data\n"));
7298 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
7302 error (_("Out of memory\n"));
7308 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7316 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7318 Elf_Internal_Sym
* psym
;
7321 psym
= dynamic_symbols
+ si
;
7323 n
= print_vma (si
, DEC_5
);
7325 fputs (" " + n
, stdout
);
7326 printf (" %3lu: ", hn
);
7327 print_vma (psym
->st_value
, LONG_HEX
);
7329 print_vma (psym
->st_size
, DEC_5
);
7331 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7332 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7333 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7334 /* Check to see if any other bits in the st_other field are set.
7335 Note - displaying this information disrupts the layout of the
7336 table being generated, but for the moment this case is very
7338 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7339 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7340 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7341 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7342 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7344 printf (" <corrupt: %14ld>", psym
->st_name
);
7348 /* Dump the symbol table. */
7350 process_symbol_table (FILE * file
)
7352 Elf_Internal_Shdr
* section
;
7353 bfd_vma nbuckets
= 0;
7354 bfd_vma nchains
= 0;
7355 bfd_vma
* buckets
= NULL
;
7356 bfd_vma
* chains
= NULL
;
7357 bfd_vma ngnubuckets
= 0;
7358 bfd_vma
* gnubuckets
= NULL
;
7359 bfd_vma
* gnuchains
= NULL
;
7360 bfd_vma gnusymidx
= 0;
7362 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
7365 if (dynamic_info
[DT_HASH
]
7367 || (do_using_dynamic
7369 && dynamic_strings
!= NULL
)))
7371 unsigned char nb
[8];
7372 unsigned char nc
[8];
7373 int hash_ent_size
= 4;
7375 if ((elf_header
.e_machine
== EM_ALPHA
7376 || elf_header
.e_machine
== EM_S390
7377 || elf_header
.e_machine
== EM_S390_OLD
)
7378 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7382 (archive_file_offset
7383 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7384 sizeof nb
+ sizeof nc
)),
7387 error (_("Unable to seek to start of dynamic information\n"));
7391 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7393 error (_("Failed to read in number of buckets\n"));
7397 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7399 error (_("Failed to read in number of chains\n"));
7403 nbuckets
= byte_get (nb
, hash_ent_size
);
7404 nchains
= byte_get (nc
, hash_ent_size
);
7406 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7407 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7410 if (buckets
== NULL
|| chains
== NULL
)
7412 if (do_using_dynamic
)
7423 if (dynamic_info_DT_GNU_HASH
7425 || (do_using_dynamic
7427 && dynamic_strings
!= NULL
)))
7429 unsigned char nb
[16];
7430 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7431 bfd_vma buckets_vma
;
7434 (archive_file_offset
7435 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7439 error (_("Unable to seek to start of dynamic information\n"));
7443 if (fread (nb
, 16, 1, file
) != 1)
7445 error (_("Failed to read in number of buckets\n"));
7449 ngnubuckets
= byte_get (nb
, 4);
7450 gnusymidx
= byte_get (nb
+ 4, 4);
7451 bitmaskwords
= byte_get (nb
+ 8, 4);
7452 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7454 buckets_vma
+= bitmaskwords
* 4;
7456 buckets_vma
+= bitmaskwords
* 8;
7459 (archive_file_offset
7460 + offset_from_vma (file
, buckets_vma
, 4)),
7463 error (_("Unable to seek to start of dynamic information\n"));
7467 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7469 if (gnubuckets
== NULL
)
7472 for (i
= 0; i
< ngnubuckets
; i
++)
7473 if (gnubuckets
[i
] != 0)
7475 if (gnubuckets
[i
] < gnusymidx
)
7478 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7479 maxchain
= gnubuckets
[i
];
7482 if (maxchain
== 0xffffffff)
7485 maxchain
-= gnusymidx
;
7488 (archive_file_offset
7489 + offset_from_vma (file
, buckets_vma
7490 + 4 * (ngnubuckets
+ maxchain
), 4)),
7493 error (_("Unable to seek to start of dynamic information\n"));
7499 if (fread (nb
, 4, 1, file
) != 1)
7501 error (_("Failed to determine last chain length\n"));
7505 if (maxchain
+ 1 == 0)
7510 while ((byte_get (nb
, 4) & 1) == 0);
7513 (archive_file_offset
7514 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7517 error (_("Unable to seek to start of dynamic information\n"));
7521 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7524 if (gnuchains
== NULL
)
7529 if (do_using_dynamic
)
7534 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7537 && dynamic_strings
!= NULL
)
7541 if (dynamic_info
[DT_HASH
])
7545 printf (_("\nSymbol table for image:\n"));
7547 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7549 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7551 for (hn
= 0; hn
< nbuckets
; hn
++)
7556 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7557 print_dynamic_symbol (si
, hn
);
7561 if (dynamic_info_DT_GNU_HASH
)
7563 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7565 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7567 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7569 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7570 if (gnubuckets
[hn
] != 0)
7572 bfd_vma si
= gnubuckets
[hn
];
7573 bfd_vma off
= si
- gnusymidx
;
7577 print_dynamic_symbol (si
, hn
);
7580 while ((gnuchains
[off
++] & 1) == 0);
7584 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
7588 for (i
= 0, section
= section_headers
;
7589 i
< elf_header
.e_shnum
;
7593 char * strtab
= NULL
;
7594 unsigned long int strtab_size
= 0;
7595 Elf_Internal_Sym
* symtab
;
7596 Elf_Internal_Sym
* psym
;
7598 if ((section
->sh_type
!= SHT_SYMTAB
7599 && section
->sh_type
!= SHT_DYNSYM
)
7601 && section
->sh_type
== SHT_SYMTAB
))
7604 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7605 SECTION_NAME (section
),
7606 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7608 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7610 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7612 symtab
= GET_ELF_SYMBOLS (file
, section
);
7616 if (section
->sh_link
== elf_header
.e_shstrndx
)
7618 strtab
= string_table
;
7619 strtab_size
= string_table_length
;
7621 else if (section
->sh_link
< elf_header
.e_shnum
)
7623 Elf_Internal_Shdr
* string_sec
;
7625 string_sec
= section_headers
+ section
->sh_link
;
7627 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
7628 1, string_sec
->sh_size
,
7630 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7633 for (si
= 0, psym
= symtab
;
7634 si
< section
->sh_size
/ section
->sh_entsize
;
7637 printf ("%6d: ", si
);
7638 print_vma (psym
->st_value
, LONG_HEX
);
7640 print_vma (psym
->st_size
, DEC_5
);
7641 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7642 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7643 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7644 /* Check to see if any other bits in the st_other field are set.
7645 Note - displaying this information disrupts the layout of the
7646 table being generated, but for the moment this case is very rare. */
7647 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7648 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7649 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7650 print_symbol (25, psym
->st_name
< strtab_size
7651 ? strtab
+ psym
->st_name
: "<corrupt>");
7653 if (section
->sh_type
== SHT_DYNSYM
&&
7654 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7656 unsigned char data
[2];
7657 unsigned short vers_data
;
7658 unsigned long offset
;
7662 offset
= offset_from_vma
7663 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7664 sizeof data
+ si
* sizeof (vers_data
));
7666 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7667 sizeof (data
), 1, _("version data"));
7669 vers_data
= byte_get (data
, 2);
7671 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7672 && section_headers
[psym
->st_shndx
].sh_type
7675 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7677 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
7679 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7680 && (is_nobits
|| ! check_def
))
7682 Elf_External_Verneed evn
;
7683 Elf_Internal_Verneed ivn
;
7684 Elf_Internal_Vernaux ivna
;
7686 /* We must test both. */
7687 offset
= offset_from_vma
7688 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7693 unsigned long vna_off
;
7695 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7698 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7699 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7701 vna_off
= offset
+ ivn
.vn_aux
;
7705 Elf_External_Vernaux evna
;
7707 get_data (&evna
, file
, vna_off
,
7709 _("version need aux (3)"));
7711 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7712 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7713 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7715 vna_off
+= ivna
.vna_next
;
7717 while (ivna
.vna_other
!= vers_data
7718 && ivna
.vna_next
!= 0);
7720 if (ivna
.vna_other
== vers_data
)
7723 offset
+= ivn
.vn_next
;
7725 while (ivn
.vn_next
!= 0);
7727 if (ivna
.vna_other
== vers_data
)
7730 ivna
.vna_name
< strtab_size
7731 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7735 else if (! is_nobits
)
7736 error (_("bad dynamic symbol\n"));
7743 if (vers_data
!= 0x8001
7744 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7746 Elf_Internal_Verdef ivd
;
7747 Elf_Internal_Verdaux ivda
;
7748 Elf_External_Verdaux evda
;
7751 off
= offset_from_vma
7753 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7754 sizeof (Elf_External_Verdef
));
7758 Elf_External_Verdef evd
;
7760 get_data (&evd
, file
, off
, sizeof (evd
),
7761 1, _("version def"));
7763 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7764 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7765 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7769 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
7770 && ivd
.vd_next
!= 0);
7775 get_data (&evda
, file
, off
, sizeof (evda
),
7776 1, _("version def aux"));
7778 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7780 if (psym
->st_name
!= ivda
.vda_name
)
7781 printf ((vers_data
& VERSYM_HIDDEN
)
7783 ivda
.vda_name
< strtab_size
7784 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7794 if (strtab
!= string_table
)
7800 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7802 if (do_histogram
&& buckets
!= NULL
)
7804 unsigned long * lengths
;
7805 unsigned long * counts
;
7808 unsigned long maxlength
= 0;
7809 unsigned long nzero_counts
= 0;
7810 unsigned long nsyms
= 0;
7812 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7813 (unsigned long) nbuckets
);
7814 printf (_(" Length Number %% of total Coverage\n"));
7816 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
7817 if (lengths
== NULL
)
7819 error (_("Out of memory\n"));
7822 for (hn
= 0; hn
< nbuckets
; ++hn
)
7824 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7827 if (maxlength
< ++lengths
[hn
])
7832 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7835 error (_("Out of memory\n"));
7839 for (hn
= 0; hn
< nbuckets
; ++hn
)
7840 ++counts
[lengths
[hn
]];
7845 printf (" 0 %-10lu (%5.1f%%)\n",
7846 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7847 for (i
= 1; i
<= maxlength
; ++i
)
7849 nzero_counts
+= counts
[i
] * i
;
7850 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7851 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7852 (nzero_counts
* 100.0) / nsyms
);
7860 if (buckets
!= NULL
)
7866 if (do_histogram
&& gnubuckets
!= NULL
)
7868 unsigned long * lengths
;
7869 unsigned long * counts
;
7871 unsigned long maxlength
= 0;
7872 unsigned long nzero_counts
= 0;
7873 unsigned long nsyms
= 0;
7875 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
7876 if (lengths
== NULL
)
7878 error (_("Out of memory\n"));
7882 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7883 (unsigned long) ngnubuckets
);
7884 printf (_(" Length Number %% of total Coverage\n"));
7886 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7887 if (gnubuckets
[hn
] != 0)
7889 bfd_vma off
, length
= 1;
7891 for (off
= gnubuckets
[hn
] - gnusymidx
;
7892 (gnuchains
[off
] & 1) == 0; ++off
)
7894 lengths
[hn
] = length
;
7895 if (length
> maxlength
)
7900 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7903 error (_("Out of memory\n"));
7907 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7908 ++counts
[lengths
[hn
]];
7910 if (ngnubuckets
> 0)
7913 printf (" 0 %-10lu (%5.1f%%)\n",
7914 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7915 for (j
= 1; j
<= maxlength
; ++j
)
7917 nzero_counts
+= counts
[j
] * j
;
7918 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7919 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7920 (nzero_counts
* 100.0) / nsyms
);
7934 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7938 if (dynamic_syminfo
== NULL
7940 /* No syminfo, this is ok. */
7943 /* There better should be a dynamic symbol section. */
7944 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7948 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7949 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7951 printf (_(" Num: Name BoundTo Flags\n"));
7952 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7954 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7956 printf ("%4d: ", i
);
7957 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7958 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7960 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7963 switch (dynamic_syminfo
[i
].si_boundto
)
7965 case SYMINFO_BT_SELF
:
7966 fputs ("SELF ", stdout
);
7968 case SYMINFO_BT_PARENT
:
7969 fputs ("PARENT ", stdout
);
7972 if (dynamic_syminfo
[i
].si_boundto
> 0
7973 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7974 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7976 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7980 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7984 if (flags
& SYMINFO_FLG_DIRECT
)
7986 if (flags
& SYMINFO_FLG_PASSTHRU
)
7987 printf (" PASSTHRU");
7988 if (flags
& SYMINFO_FLG_COPY
)
7990 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7991 printf (" LAZYLOAD");
7999 /* Check to see if the given reloc needs to be handled in a target specific
8000 manner. If so then process the reloc and return TRUE otherwise return
8004 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
8005 unsigned char * start
,
8006 Elf_Internal_Sym
* symtab
)
8008 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
8010 switch (elf_header
.e_machine
)
8013 case EM_CYGNUS_MN10300
:
8015 static Elf_Internal_Sym
* saved_sym
= NULL
;
8019 case 34: /* R_MN10300_ALIGN */
8021 case 33: /* R_MN10300_SYM_DIFF */
8022 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
8024 case 1: /* R_MN10300_32 */
8025 case 2: /* R_MN10300_16 */
8026 if (saved_sym
!= NULL
)
8030 value
= reloc
->r_addend
8031 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
8032 - saved_sym
->st_value
);
8034 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
8041 if (saved_sym
!= NULL
)
8042 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8052 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8053 DWARF debug sections. This is a target specific test. Note - we do not
8054 go through the whole including-target-headers-multiple-times route, (as
8055 we have already done with <elf/h8.h>) because this would become very
8056 messy and even then this function would have to contain target specific
8057 information (the names of the relocs instead of their numeric values).
8058 FIXME: This is not the correct way to solve this problem. The proper way
8059 is to have target specific reloc sizing and typing functions created by
8060 the reloc-macros.h header, in the same way that it already creates the
8061 reloc naming functions. */
8064 is_32bit_abs_reloc (unsigned int reloc_type
)
8066 switch (elf_header
.e_machine
)
8070 return reloc_type
== 1; /* R_386_32. */
8072 return reloc_type
== 1; /* R_68K_32. */
8074 return reloc_type
== 1; /* R_860_32. */
8076 return reloc_type
== 1; /* XXX Is this right ? */
8078 return reloc_type
== 1; /* R_ARC_32. */
8080 return reloc_type
== 2; /* R_ARM_ABS32 */
8083 return reloc_type
== 1;
8085 return reloc_type
== 0x12; /* R_byte4_data. */
8087 return reloc_type
== 3; /* R_CRIS_32. */
8090 return reloc_type
== 3; /* R_CR16_NUM32. */
8092 return reloc_type
== 15; /* R_CRX_NUM32. */
8094 return reloc_type
== 1;
8095 case EM_CYGNUS_D10V
:
8097 return reloc_type
== 6; /* R_D10V_32. */
8098 case EM_CYGNUS_D30V
:
8100 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8102 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8103 case EM_CYGNUS_FR30
:
8105 return reloc_type
== 3; /* R_FR30_32. */
8109 return reloc_type
== 1; /* R_H8_DIR32. */
8111 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8114 return reloc_type
== 2; /* R_IP2K_32. */
8116 return reloc_type
== 2; /* R_IQ2000_32. */
8117 case EM_LATTICEMICO32
:
8118 return reloc_type
== 3; /* R_LM32_32. */
8121 return reloc_type
== 3; /* R_M32C_32. */
8123 return reloc_type
== 34; /* R_M32R_32_RELA. */
8125 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8127 return reloc_type
== 4; /* R_MEP_32. */
8129 return reloc_type
== 2; /* R_MIPS_32. */
8131 return reloc_type
== 4; /* R_MMIX_32. */
8132 case EM_CYGNUS_MN10200
:
8134 return reloc_type
== 1; /* R_MN10200_32. */
8135 case EM_CYGNUS_MN10300
:
8137 return reloc_type
== 1; /* R_MN10300_32. */
8140 return reloc_type
== 1; /* R_MSP43_32. */
8142 return reloc_type
== 2; /* R_MT_32. */
8143 case EM_ALTERA_NIOS2
:
8145 return reloc_type
== 1; /* R_NIOS_32. */
8148 return reloc_type
== 1; /* R_OR32_32. */
8150 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8151 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8154 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8156 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8158 return reloc_type
== 1; /* R_PPC_ADDR32. */
8160 return reloc_type
== 1; /* R_RX_DIR32. */
8162 return reloc_type
== 1; /* R_I370_ADDR31. */
8165 return reloc_type
== 4; /* R_S390_32. */
8167 return reloc_type
== 8; /* R_SCORE_ABS32. */
8169 return reloc_type
== 1; /* R_SH_DIR32. */
8170 case EM_SPARC32PLUS
:
8173 return reloc_type
== 3 /* R_SPARC_32. */
8174 || reloc_type
== 23; /* R_SPARC_UA32. */
8176 return reloc_type
== 6; /* R_SPU_ADDR32 */
8177 case EM_CYGNUS_V850
:
8179 return reloc_type
== 6; /* R_V850_ABS32. */
8181 return reloc_type
== 1; /* R_VAX_32. */
8184 return reloc_type
== 10; /* R_X86_64_32. */
8187 return reloc_type
== 3; /* R_XC16C_ABS_32. */
8189 return reloc_type
== 1; /* R_XSTROMY16_32. */
8192 return reloc_type
== 1; /* R_XTENSA_32. */
8194 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8195 elf_header
.e_machine
);
8200 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8201 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8204 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8206 switch (elf_header
.e_machine
)
8210 return reloc_type
== 2; /* R_386_PC32. */
8212 return reloc_type
== 4; /* R_68K_PC32. */
8214 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8216 return reloc_type
== 3; /* R_ARM_REL32 */
8218 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8220 return reloc_type
== 26; /* R_PPC_REL32. */
8222 return reloc_type
== 26; /* R_PPC64_REL32. */
8225 return reloc_type
== 5; /* R_390_PC32. */
8227 return reloc_type
== 2; /* R_SH_REL32. */
8228 case EM_SPARC32PLUS
:
8231 return reloc_type
== 6; /* R_SPARC_DISP32. */
8233 return reloc_type
== 13; /* R_SPU_REL32. */
8236 return reloc_type
== 2; /* R_X86_64_PC32. */
8239 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8241 /* Do not abort or issue an error message here. Not all targets use
8242 pc-relative 32-bit relocs in their DWARF debug information and we
8243 have already tested for target coverage in is_32bit_abs_reloc. A
8244 more helpful warning message will be generated by apply_relocations
8245 anyway, so just return. */
8250 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8251 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8254 is_64bit_abs_reloc (unsigned int reloc_type
)
8256 switch (elf_header
.e_machine
)
8259 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8261 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8263 return reloc_type
== 80; /* R_PARISC_DIR64. */
8265 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8266 case EM_SPARC32PLUS
:
8269 return reloc_type
== 54; /* R_SPARC_UA64. */
8272 return reloc_type
== 1; /* R_X86_64_64. */
8275 return reloc_type
== 22; /* R_S390_64 */
8277 return reloc_type
== 18; /* R_MIPS_64 */
8283 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8284 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8287 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8289 switch (elf_header
.e_machine
)
8292 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8294 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8296 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8298 return reloc_type
== 44; /* R_PPC64_REL64 */
8299 case EM_SPARC32PLUS
:
8302 return reloc_type
== 46; /* R_SPARC_DISP64 */
8305 return reloc_type
== 24; /* R_X86_64_PC64 */
8308 return reloc_type
== 23; /* R_S390_PC64 */
8314 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8315 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8318 is_24bit_abs_reloc (unsigned int reloc_type
)
8320 switch (elf_header
.e_machine
)
8322 case EM_CYGNUS_MN10200
:
8324 return reloc_type
== 4; /* R_MN10200_24. */
8330 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8331 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8334 is_16bit_abs_reloc (unsigned int reloc_type
)
8336 switch (elf_header
.e_machine
)
8340 return reloc_type
== 4; /* R_AVR_16. */
8341 case EM_CYGNUS_D10V
:
8343 return reloc_type
== 3; /* R_D10V_16. */
8347 return reloc_type
== R_H8_DIR16
;
8350 return reloc_type
== 1; /* R_IP2K_16. */
8353 return reloc_type
== 1; /* R_M32C_16 */
8356 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8357 case EM_ALTERA_NIOS2
:
8359 return reloc_type
== 9; /* R_NIOS_16. */
8362 return reloc_type
== 2; /* R_XC16C_ABS_16. */
8368 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8369 relocation entries (possibly formerly used for SHT_GROUP sections). */
8372 is_none_reloc (unsigned int reloc_type
)
8374 switch (elf_header
.e_machine
)
8376 case EM_68K
: /* R_68K_NONE. */
8377 case EM_386
: /* R_386_NONE. */
8378 case EM_SPARC32PLUS
:
8380 case EM_SPARC
: /* R_SPARC_NONE. */
8381 case EM_MIPS
: /* R_MIPS_NONE. */
8382 case EM_PARISC
: /* R_PARISC_NONE. */
8383 case EM_ALPHA
: /* R_ALPHA_NONE. */
8384 case EM_PPC
: /* R_PPC_NONE. */
8385 case EM_PPC64
: /* R_PPC64_NONE. */
8386 case EM_ARM
: /* R_ARM_NONE. */
8387 case EM_IA_64
: /* R_IA64_NONE. */
8388 case EM_SH
: /* R_SH_NONE. */
8390 case EM_S390
: /* R_390_NONE. */
8391 case EM_CRIS
: /* R_CRIS_NONE. */
8392 case EM_X86_64
: /* R_X86_64_NONE. */
8393 case EM_L1OM
: /* R_X86_64_NONE. */
8394 case EM_MN10300
: /* R_MN10300_NONE. */
8395 case EM_M32R
: /* R_M32R_NONE. */
8397 case EM_C166
: /* R_XC16X_NONE. */
8398 return reloc_type
== 0;
8401 return (reloc_type
== 0 /* R_XTENSA_NONE. */
8402 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
8403 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
8404 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
8409 /* Apply relocations to a section.
8410 Note: So far support has been added only for those relocations
8411 which can be found in debug sections.
8412 FIXME: Add support for more relocations ? */
8415 apply_relocations (void * file
,
8416 Elf_Internal_Shdr
* section
,
8417 unsigned char * start
)
8419 Elf_Internal_Shdr
* relsec
;
8420 unsigned char * end
= start
+ section
->sh_size
;
8422 if (elf_header
.e_type
!= ET_REL
)
8425 /* Find the reloc section associated with the section. */
8426 for (relsec
= section_headers
;
8427 relsec
< section_headers
+ elf_header
.e_shnum
;
8430 bfd_boolean is_rela
;
8431 unsigned long num_relocs
;
8432 Elf_Internal_Rela
* relocs
;
8433 Elf_Internal_Rela
* rp
;
8434 Elf_Internal_Shdr
* symsec
;
8435 Elf_Internal_Sym
* symtab
;
8436 Elf_Internal_Sym
* sym
;
8438 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8439 || relsec
->sh_info
>= elf_header
.e_shnum
8440 || section_headers
+ relsec
->sh_info
!= section
8441 || relsec
->sh_size
== 0
8442 || relsec
->sh_link
>= elf_header
.e_shnum
)
8445 is_rela
= relsec
->sh_type
== SHT_RELA
;
8449 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
8450 relsec
->sh_size
, & relocs
, & num_relocs
))
8455 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
8456 relsec
->sh_size
, & relocs
, & num_relocs
))
8460 /* SH uses RELA but uses in place value instead of the addend field. */
8461 if (elf_header
.e_machine
== EM_SH
)
8464 symsec
= section_headers
+ relsec
->sh_link
;
8465 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
8467 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8470 unsigned int reloc_type
;
8471 unsigned int reloc_size
;
8472 unsigned char * rloc
;
8474 reloc_type
= get_reloc_type (rp
->r_info
);
8476 if (target_specific_reloc_handling (rp
, start
, symtab
))
8478 else if (is_none_reloc (reloc_type
))
8480 else if (is_32bit_abs_reloc (reloc_type
)
8481 || is_32bit_pcrel_reloc (reloc_type
))
8483 else if (is_64bit_abs_reloc (reloc_type
)
8484 || is_64bit_pcrel_reloc (reloc_type
))
8486 else if (is_24bit_abs_reloc (reloc_type
))
8488 else if (is_16bit_abs_reloc (reloc_type
))
8492 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8493 reloc_type
, SECTION_NAME (section
));
8497 rloc
= start
+ rp
->r_offset
;
8498 if ((rloc
+ reloc_size
) > end
)
8500 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8501 (unsigned long) rp
->r_offset
,
8502 SECTION_NAME (section
));
8506 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8508 /* If the reloc has a symbol associated with it,
8509 make sure that it is of an appropriate type.
8511 Relocations against symbols without type can happen.
8512 Gcc -feliminate-dwarf2-dups may generate symbols
8513 without type for debug info.
8515 Icc generates relocations against function symbols
8516 instead of local labels.
8518 Relocations against object symbols can happen, eg when
8519 referencing a global array. For an example of this see
8520 the _clz.o binary in libgcc.a. */
8522 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8524 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8525 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8526 (long int)(rp
- relocs
),
8527 SECTION_NAME (relsec
));
8533 addend
+= rp
->r_addend
;
8534 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8536 || (elf_header
.e_machine
== EM_XTENSA
8538 || ((elf_header
.e_machine
== EM_PJ
8539 || elf_header
.e_machine
== EM_PJ_OLD
)
8540 && reloc_type
== 1))
8541 addend
+= byte_get (rloc
, reloc_size
);
8543 if (is_32bit_pcrel_reloc (reloc_type
)
8544 || is_64bit_pcrel_reloc (reloc_type
))
8546 /* On HPPA, all pc-relative relocations are biased by 8. */
8547 if (elf_header
.e_machine
== EM_PARISC
)
8549 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8553 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
8562 #ifdef SUPPORT_DISASSEMBLY
8564 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8566 printf (_("\nAssembly dump of section %s\n"),
8567 SECTION_NAME (section
));
8569 /* XXX -- to be done --- XXX */
8575 /* Reads in the contents of SECTION from FILE, returning a pointer
8576 to a malloc'ed buffer or NULL if something went wrong. */
8579 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8581 bfd_size_type num_bytes
;
8583 num_bytes
= section
->sh_size
;
8585 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8587 printf (_("\nSection '%s' has no data to dump.\n"),
8588 SECTION_NAME (section
));
8592 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8593 _("section contents"));
8598 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8600 Elf_Internal_Shdr
* relsec
;
8601 bfd_size_type num_bytes
;
8606 char * name
= SECTION_NAME (section
);
8607 bfd_boolean some_strings_shown
;
8609 start
= get_section_contents (section
, file
);
8613 printf (_("\nString dump of section '%s':\n"), name
);
8615 /* If the section being dumped has relocations against it the user might
8616 be expecting these relocations to have been applied. Check for this
8617 case and issue a warning message in order to avoid confusion.
8618 FIXME: Maybe we ought to have an option that dumps a section with
8620 for (relsec
= section_headers
;
8621 relsec
< section_headers
+ elf_header
.e_shnum
;
8624 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8625 || relsec
->sh_info
>= elf_header
.e_shnum
8626 || section_headers
+ relsec
->sh_info
!= section
8627 || relsec
->sh_size
== 0
8628 || relsec
->sh_link
>= elf_header
.e_shnum
)
8631 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8635 num_bytes
= section
->sh_size
;
8636 addr
= section
->sh_addr
;
8638 end
= start
+ num_bytes
;
8639 some_strings_shown
= FALSE
;
8643 while (!ISPRINT (* data
))
8650 /* PR 11128: Use two separate invocations in order to work
8651 around bugs in the Solaris 8 implementation of printf. */
8652 printf (" [%6tx] ", data
- start
);
8653 printf ("%s\n", data
);
8655 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8657 data
+= strlen (data
);
8658 some_strings_shown
= TRUE
;
8662 if (! some_strings_shown
)
8663 printf (_(" No strings found in this section."));
8671 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8673 bfd_boolean relocate
)
8675 Elf_Internal_Shdr
* relsec
;
8676 bfd_size_type bytes
;
8678 unsigned char * data
;
8679 unsigned char * start
;
8681 start
= (unsigned char *) get_section_contents (section
, file
);
8685 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8689 apply_relocations (file
, section
, start
);
8693 /* If the section being dumped has relocations against it the user might
8694 be expecting these relocations to have been applied. Check for this
8695 case and issue a warning message in order to avoid confusion.
8696 FIXME: Maybe we ought to have an option that dumps a section with
8698 for (relsec
= section_headers
;
8699 relsec
< section_headers
+ elf_header
.e_shnum
;
8702 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8703 || relsec
->sh_info
>= elf_header
.e_shnum
8704 || section_headers
+ relsec
->sh_info
!= section
8705 || relsec
->sh_size
== 0
8706 || relsec
->sh_link
>= elf_header
.e_shnum
)
8709 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8714 addr
= section
->sh_addr
;
8715 bytes
= section
->sh_size
;
8724 lbytes
= (bytes
> 16 ? 16 : bytes
);
8726 printf (" 0x%8.8lx ", (unsigned long) addr
);
8728 for (j
= 0; j
< 16; j
++)
8731 printf ("%2.2x", data
[j
]);
8739 for (j
= 0; j
< lbytes
; j
++)
8742 if (k
>= ' ' && k
< 0x7f)
8760 /* Uncompresses a section that was compressed using zlib, in place.
8761 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8764 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8767 /* These are just to quiet gcc. */
8772 dwarf_size_type compressed_size
= *size
;
8773 unsigned char * compressed_buffer
= *buffer
;
8774 dwarf_size_type uncompressed_size
;
8775 unsigned char * uncompressed_buffer
;
8778 dwarf_size_type header_size
= 12;
8780 /* Read the zlib header. In this case, it should be "ZLIB" followed
8781 by the uncompressed section size, 8 bytes in big-endian order. */
8782 if (compressed_size
< header_size
8783 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8786 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8787 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8788 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8789 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8790 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8791 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8792 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8793 uncompressed_size
+= compressed_buffer
[11];
8795 /* It is possible the section consists of several compressed
8796 buffers concatenated together, so we uncompress in a loop. */
8800 strm
.avail_in
= compressed_size
- header_size
;
8801 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8802 strm
.avail_out
= uncompressed_size
;
8803 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
8805 rc
= inflateInit (& strm
);
8806 while (strm
.avail_in
> 0)
8810 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8811 + (uncompressed_size
- strm
.avail_out
));
8812 rc
= inflate (&strm
, Z_FINISH
);
8813 if (rc
!= Z_STREAM_END
)
8815 rc
= inflateReset (& strm
);
8817 rc
= inflateEnd (& strm
);
8819 || strm
.avail_out
!= 0)
8822 free (compressed_buffer
);
8823 *buffer
= uncompressed_buffer
;
8824 *size
= uncompressed_size
;
8828 free (uncompressed_buffer
);
8830 #endif /* HAVE_ZLIB_H */
8834 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8835 Elf_Internal_Shdr
* sec
, void * file
)
8837 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8839 int section_is_compressed
;
8841 /* If it is already loaded, do nothing. */
8842 if (section
->start
!= NULL
)
8845 section_is_compressed
= section
->name
== section
->compressed_name
;
8847 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8848 section
->address
= sec
->sh_addr
;
8849 section
->size
= sec
->sh_size
;
8850 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
8853 if (section
->start
== NULL
)
8856 if (section_is_compressed
)
8857 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8860 if (debug_displays
[debug
].relocate
)
8861 apply_relocations ((FILE *) file
, sec
, section
->start
);
8867 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8869 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8870 Elf_Internal_Shdr
* sec
;
8872 /* Locate the debug section. */
8873 sec
= find_section (section
->uncompressed_name
);
8875 section
->name
= section
->uncompressed_name
;
8878 sec
= find_section (section
->compressed_name
);
8880 section
->name
= section
->compressed_name
;
8885 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
8889 free_debug_section (enum dwarf_section_display_enum debug
)
8891 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8893 if (section
->start
== NULL
)
8896 free ((char *) section
->start
);
8897 section
->start
= NULL
;
8898 section
->address
= 0;
8903 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8905 char * name
= SECTION_NAME (section
);
8906 bfd_size_type length
;
8910 length
= section
->sh_size
;
8913 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8916 if (section
->sh_type
== SHT_NOBITS
)
8918 /* There is no point in dumping the contents of a debugging section
8919 which has the NOBITS type - the bits in the file will be random.
8920 This can happen when a file containing a .eh_frame section is
8921 stripped with the --only-keep-debug command line option. */
8922 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8926 if (const_strneq (name
, ".gnu.linkonce.wi."))
8927 name
= ".debug_info";
8929 /* See if we know how to display the contents of this section. */
8930 for (i
= 0; i
< max
; i
++)
8931 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8932 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8934 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8935 int secondary
= (section
!= find_section (name
));
8938 free_debug_section ((enum dwarf_section_display_enum
) i
);
8940 if (streq (sec
->uncompressed_name
, name
))
8941 sec
->name
= sec
->uncompressed_name
;
8943 sec
->name
= sec
->compressed_name
;
8944 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
8947 result
&= debug_displays
[i
].display (sec
, file
);
8949 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8950 free_debug_section ((enum dwarf_section_display_enum
) i
);
8958 printf (_("Unrecognized debug section: %s\n"), name
);
8965 /* Set DUMP_SECTS for all sections where dumps were requested
8966 based on section name. */
8969 initialise_dumps_byname (void)
8971 struct dump_list_entry
* cur
;
8973 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8978 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8979 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8981 request_dump_bynumber (i
, cur
->type
);
8986 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8992 process_section_contents (FILE * file
)
8994 Elf_Internal_Shdr
* section
;
9000 initialise_dumps_byname ();
9002 for (i
= 0, section
= section_headers
;
9003 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9006 #ifdef SUPPORT_DISASSEMBLY
9007 if (dump_sects
[i
] & DISASS_DUMP
)
9008 disassemble_section (section
, file
);
9010 if (dump_sects
[i
] & HEX_DUMP
)
9011 dump_section_as_bytes (section
, file
, FALSE
);
9013 if (dump_sects
[i
] & RELOC_DUMP
)
9014 dump_section_as_bytes (section
, file
, TRUE
);
9016 if (dump_sects
[i
] & STRING_DUMP
)
9017 dump_section_as_strings (section
, file
);
9019 if (dump_sects
[i
] & DEBUG_DUMP
)
9020 display_debug_section (section
, file
);
9023 /* Check to see if the user requested a
9024 dump of a section that does not exist. */
9025 while (i
++ < num_dump_sects
)
9027 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
9031 process_mips_fpe_exception (int mask
)
9036 if (mask
& OEX_FPU_INEX
)
9037 fputs ("INEX", stdout
), first
= 0;
9038 if (mask
& OEX_FPU_UFLO
)
9039 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9040 if (mask
& OEX_FPU_OFLO
)
9041 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9042 if (mask
& OEX_FPU_DIV0
)
9043 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9044 if (mask
& OEX_FPU_INVAL
)
9045 printf ("%sINVAL", first
? "" : "|");
9048 fputs ("0", stdout
);
9051 /* ARM EABI attributes section. */
9056 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9058 const char ** table
;
9059 } arm_attr_public_tag
;
9061 static const char * arm_attr_tag_CPU_arch
[] =
9062 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9063 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9064 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
9065 static const char * arm_attr_tag_THUMB_ISA_use
[] =
9066 {"No", "Thumb-1", "Thumb-2"};
9067 static const char * arm_attr_tag_VFP_arch
[] =
9068 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9069 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
9070 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
9071 static const char * arm_attr_tag_PCS_config
[] =
9072 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9073 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9074 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
9075 {"V6", "SB", "TLS", "Unused"};
9076 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
9077 {"Absolute", "PC-relative", "SB-relative", "None"};
9078 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
9079 {"Absolute", "PC-relative", "None"};
9080 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
9081 {"None", "direct", "GOT-indirect"};
9082 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
9083 {"None", "??? 1", "2", "??? 3", "4"};
9084 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
9085 static const char * arm_attr_tag_ABI_FP_denormal
[] =
9086 {"Unused", "Needed", "Sign only"};
9087 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
9088 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
9089 static const char * arm_attr_tag_ABI_FP_number_model
[] =
9090 {"Unused", "Finite", "RTABI", "IEEE 754"};
9091 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
9092 static const char * arm_attr_tag_ABI_align8_preserved
[] =
9093 {"No", "Yes, except leaf SP", "Yes"};
9094 static const char * arm_attr_tag_ABI_enum_size
[] =
9095 {"Unused", "small", "int", "forced to int"};
9096 static const char * arm_attr_tag_ABI_HardFP_use
[] =
9097 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9098 static const char * arm_attr_tag_ABI_VFP_args
[] =
9099 {"AAPCS", "VFP registers", "custom"};
9100 static const char * arm_attr_tag_ABI_WMMX_args
[] =
9101 {"AAPCS", "WMMX registers", "custom"};
9102 static const char * arm_attr_tag_ABI_optimization_goals
[] =
9103 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9104 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9105 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
9106 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9107 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9108 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
9109 static const char * arm_attr_tag_VFP_HP_extension
[] =
9110 {"Not Allowed", "Allowed"};
9111 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
9112 {"None", "IEEE 754", "Alternative Format"};
9113 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9114 static const char * arm_attr_tag_Virtualization_use
[] =
9115 {"Not Allowed", "Allowed"};
9116 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
9118 #define LOOKUP(id, name) \
9119 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9120 static arm_attr_public_tag arm_attr_public_tags
[] =
9122 {4, "CPU_raw_name", 1, NULL
},
9123 {5, "CPU_name", 1, NULL
},
9124 LOOKUP(6, CPU_arch
),
9125 {7, "CPU_arch_profile", 0, NULL
},
9126 LOOKUP(8, ARM_ISA_use
),
9127 LOOKUP(9, THUMB_ISA_use
),
9128 LOOKUP(10, VFP_arch
),
9129 LOOKUP(11, WMMX_arch
),
9130 LOOKUP(12, Advanced_SIMD_arch
),
9131 LOOKUP(13, PCS_config
),
9132 LOOKUP(14, ABI_PCS_R9_use
),
9133 LOOKUP(15, ABI_PCS_RW_data
),
9134 LOOKUP(16, ABI_PCS_RO_data
),
9135 LOOKUP(17, ABI_PCS_GOT_use
),
9136 LOOKUP(18, ABI_PCS_wchar_t
),
9137 LOOKUP(19, ABI_FP_rounding
),
9138 LOOKUP(20, ABI_FP_denormal
),
9139 LOOKUP(21, ABI_FP_exceptions
),
9140 LOOKUP(22, ABI_FP_user_exceptions
),
9141 LOOKUP(23, ABI_FP_number_model
),
9142 LOOKUP(24, ABI_align8_needed
),
9143 LOOKUP(25, ABI_align8_preserved
),
9144 LOOKUP(26, ABI_enum_size
),
9145 LOOKUP(27, ABI_HardFP_use
),
9146 LOOKUP(28, ABI_VFP_args
),
9147 LOOKUP(29, ABI_WMMX_args
),
9148 LOOKUP(30, ABI_optimization_goals
),
9149 LOOKUP(31, ABI_FP_optimization_goals
),
9150 {32, "compatibility", 0, NULL
},
9151 LOOKUP(34, CPU_unaligned_access
),
9152 LOOKUP(36, VFP_HP_extension
),
9153 LOOKUP(38, ABI_FP_16bit_format
),
9154 {64, "nodefaults", 0, NULL
},
9155 {65, "also_compatible_with", 0, NULL
},
9156 LOOKUP(66, T2EE_use
),
9157 {67, "conformance", 1, NULL
},
9158 LOOKUP(68, Virtualization_use
),
9159 LOOKUP(70, MPextension_use
)
9163 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9167 read_uleb128 (unsigned char * p
, unsigned int * plen
)
9181 val
|= ((unsigned int)c
& 0x7f) << shift
;
9190 static unsigned char *
9191 display_arm_attribute (unsigned char * p
)
9196 arm_attr_public_tag
* attr
;
9200 tag
= read_uleb128 (p
, &len
);
9203 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9205 if (arm_attr_public_tags
[i
].tag
== tag
)
9207 attr
= &arm_attr_public_tags
[i
];
9214 printf (" Tag_%s: ", attr
->name
);
9220 case 7: /* Tag_CPU_arch_profile. */
9221 val
= read_uleb128 (p
, &len
);
9225 case 0: printf ("None\n"); break;
9226 case 'A': printf ("Application\n"); break;
9227 case 'R': printf ("Realtime\n"); break;
9228 case 'M': printf ("Microcontroller\n"); break;
9229 default: printf ("??? (%d)\n", val
); break;
9233 case 32: /* Tag_compatibility. */
9234 val
= read_uleb128 (p
, &len
);
9236 printf ("flag = %d, vendor = %s\n", val
, p
);
9237 p
+= strlen ((char *) p
) + 1;
9240 case 64: /* Tag_nodefaults. */
9245 case 65: /* Tag_also_compatible_with. */
9246 val
= read_uleb128 (p
, &len
);
9248 if (val
== 6 /* Tag_CPU_arch. */)
9250 val
= read_uleb128 (p
, &len
);
9252 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
9253 printf ("??? (%d)\n", val
);
9255 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9259 while (*(p
++) != '\0' /* NUL terminator. */);
9273 assert (attr
->type
& 0x80);
9274 val
= read_uleb128 (p
, &len
);
9276 type
= attr
->type
& 0x7f;
9278 printf ("??? (%d)\n", val
);
9280 printf ("%s\n", attr
->table
[val
]);
9287 type
= 1; /* String. */
9289 type
= 2; /* uleb128. */
9290 printf (" Tag_unknown_%d: ", tag
);
9295 printf ("\"%s\"\n", p
);
9296 p
+= strlen ((char *) p
) + 1;
9300 val
= read_uleb128 (p
, &len
);
9302 printf ("%d (0x%x)\n", val
, val
);
9308 static unsigned char *
9309 display_gnu_attribute (unsigned char * p
,
9310 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9317 tag
= read_uleb128 (p
, &len
);
9320 /* Tag_compatibility is the only generic GNU attribute defined at
9324 val
= read_uleb128 (p
, &len
);
9326 printf ("flag = %d, vendor = %s\n", val
, p
);
9327 p
+= strlen ((char *) p
) + 1;
9331 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9332 return display_proc_gnu_attribute (p
, tag
);
9335 type
= 1; /* String. */
9337 type
= 2; /* uleb128. */
9338 printf (" Tag_unknown_%d: ", tag
);
9342 printf ("\"%s\"\n", p
);
9343 p
+= strlen ((char *) p
) + 1;
9347 val
= read_uleb128 (p
, &len
);
9349 printf ("%d (0x%x)\n", val
, val
);
9355 static unsigned char *
9356 display_power_gnu_attribute (unsigned char * p
, int tag
)
9362 if (tag
== Tag_GNU_Power_ABI_FP
)
9364 val
= read_uleb128 (p
, &len
);
9366 printf (" Tag_GNU_Power_ABI_FP: ");
9371 printf ("Hard or soft float\n");
9374 printf ("Hard float\n");
9377 printf ("Soft float\n");
9380 printf ("Single-precision hard float\n");
9383 printf ("??? (%d)\n", val
);
9389 if (tag
== Tag_GNU_Power_ABI_Vector
)
9391 val
= read_uleb128 (p
, &len
);
9393 printf (" Tag_GNU_Power_ABI_Vector: ");
9400 printf ("Generic\n");
9403 printf ("AltiVec\n");
9409 printf ("??? (%d)\n", val
);
9415 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9417 val
= read_uleb128 (p
, &len
);
9419 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9429 printf ("Memory\n");
9432 printf ("??? (%d)\n", val
);
9439 type
= 1; /* String. */
9441 type
= 2; /* uleb128. */
9442 printf (" Tag_unknown_%d: ", tag
);
9446 printf ("\"%s\"\n", p
);
9447 p
+= strlen ((char *) p
) + 1;
9451 val
= read_uleb128 (p
, &len
);
9453 printf ("%d (0x%x)\n", val
, val
);
9459 static unsigned char *
9460 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9466 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9468 val
= read_uleb128 (p
, &len
);
9470 printf (" Tag_GNU_MIPS_ABI_FP: ");
9475 printf ("Hard or soft float\n");
9478 printf ("Hard float (-mdouble-float)\n");
9481 printf ("Hard float (-msingle-float)\n");
9484 printf ("Soft float\n");
9487 printf ("64-bit float (-mips32r2 -mfp64)\n");
9490 printf ("??? (%d)\n", val
);
9497 type
= 1; /* String. */
9499 type
= 2; /* uleb128. */
9500 printf (" Tag_unknown_%d: ", tag
);
9504 printf ("\"%s\"\n", p
);
9505 p
+= strlen ((char *) p
) + 1;
9509 val
= read_uleb128 (p
, &len
);
9511 printf ("%d (0x%x)\n", val
, val
);
9518 process_attributes (FILE * file
,
9519 const char * public_name
,
9520 unsigned int proc_type
,
9521 unsigned char * (* display_pub_attribute
) (unsigned char *),
9522 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9524 Elf_Internal_Shdr
* sect
;
9525 unsigned char * contents
;
9527 unsigned char * end
;
9528 bfd_vma section_len
;
9532 /* Find the section header so that we get the size. */
9533 for (i
= 0, sect
= section_headers
;
9534 i
< elf_header
.e_shnum
;
9537 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9540 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
9541 sect
->sh_size
, _("attributes"));
9542 if (contents
== NULL
)
9548 len
= sect
->sh_size
- 1;
9554 bfd_boolean public_section
;
9555 bfd_boolean gnu_section
;
9557 section_len
= byte_get (p
, 4);
9560 if (section_len
> len
)
9562 printf (_("ERROR: Bad section length (%d > %d)\n"),
9563 (int) section_len
, (int) len
);
9568 printf ("Attribute Section: %s\n", p
);
9570 if (public_name
&& streq ((char *) p
, public_name
))
9571 public_section
= TRUE
;
9573 public_section
= FALSE
;
9575 if (streq ((char *) p
, "gnu"))
9578 gnu_section
= FALSE
;
9580 namelen
= strlen ((char *) p
) + 1;
9582 section_len
-= namelen
+ 4;
9584 while (section_len
> 0)
9590 size
= byte_get (p
, 4);
9591 if (size
> section_len
)
9593 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9594 (int) size
, (int) section_len
);
9598 section_len
-= size
;
9605 printf ("File Attributes\n");
9608 printf ("Section Attributes:");
9611 printf ("Symbol Attributes:");
9617 val
= read_uleb128 (p
, &j
);
9621 printf (" %d", val
);
9626 printf ("Unknown tag: %d\n", tag
);
9627 public_section
= FALSE
;
9634 p
= display_pub_attribute (p
);
9636 else if (gnu_section
)
9639 p
= display_gnu_attribute (p
,
9640 display_proc_gnu_attribute
);
9644 /* ??? Do something sensible, like dump hex. */
9645 printf (" Unknown section contexts\n");
9652 printf (_("Unknown format '%c'\n"), *p
);
9660 process_arm_specific (FILE * file
)
9662 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9663 display_arm_attribute
, NULL
);
9667 process_power_specific (FILE * file
)
9669 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9670 display_power_gnu_attribute
);
9673 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9674 Print the Address, Access and Initial fields of an entry at VMA ADDR
9675 and return the VMA of the next entry. */
9678 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9681 print_vma (addr
, LONG_HEX
);
9683 if (addr
< pltgot
+ 0xfff0)
9684 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9686 printf ("%10s", "");
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);
9700 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9701 PLTGOT. Print the Address and Initial fields of an entry at VMA
9702 ADDR and return the VMA of the next entry. */
9705 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9708 print_vma (addr
, LONG_HEX
);
9711 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9716 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9717 print_vma (entry
, LONG_HEX
);
9719 return addr
+ (is_32bit_elf
? 4 : 8);
9723 process_mips_specific (FILE * file
)
9725 Elf_Internal_Dyn
* entry
;
9726 size_t liblist_offset
= 0;
9727 size_t liblistno
= 0;
9728 size_t conflictsno
= 0;
9729 size_t options_offset
= 0;
9730 size_t conflicts_offset
= 0;
9731 size_t pltrelsz
= 0;
9734 bfd_vma mips_pltgot
= 0;
9736 bfd_vma local_gotno
= 0;
9738 bfd_vma symtabno
= 0;
9740 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9741 display_mips_gnu_attribute
);
9743 /* We have a lot of special sections. Thanks SGI! */
9744 if (dynamic_section
== NULL
)
9745 /* No information available. */
9748 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9749 switch (entry
->d_tag
)
9751 case DT_MIPS_LIBLIST
:
9753 = offset_from_vma (file
, entry
->d_un
.d_val
,
9754 liblistno
* sizeof (Elf32_External_Lib
));
9756 case DT_MIPS_LIBLISTNO
:
9757 liblistno
= entry
->d_un
.d_val
;
9759 case DT_MIPS_OPTIONS
:
9760 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9762 case DT_MIPS_CONFLICT
:
9764 = offset_from_vma (file
, entry
->d_un
.d_val
,
9765 conflictsno
* sizeof (Elf32_External_Conflict
));
9767 case DT_MIPS_CONFLICTNO
:
9768 conflictsno
= entry
->d_un
.d_val
;
9771 pltgot
= entry
->d_un
.d_ptr
;
9773 case DT_MIPS_LOCAL_GOTNO
:
9774 local_gotno
= entry
->d_un
.d_val
;
9776 case DT_MIPS_GOTSYM
:
9777 gotsym
= entry
->d_un
.d_val
;
9779 case DT_MIPS_SYMTABNO
:
9780 symtabno
= entry
->d_un
.d_val
;
9782 case DT_MIPS_PLTGOT
:
9783 mips_pltgot
= entry
->d_un
.d_ptr
;
9786 pltrel
= entry
->d_un
.d_val
;
9789 pltrelsz
= entry
->d_un
.d_val
;
9792 jmprel
= entry
->d_un
.d_ptr
;
9798 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9800 Elf32_External_Lib
* elib
;
9803 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
9805 sizeof (Elf32_External_Lib
),
9809 printf ("\nSection '.liblist' contains %lu entries:\n",
9810 (unsigned long) liblistno
);
9811 fputs (" Library Time Stamp Checksum Version Flags\n",
9814 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9821 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9822 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9823 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9824 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9825 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9827 tmp
= gmtime (&atime
);
9828 snprintf (timebuf
, sizeof (timebuf
),
9829 "%04u-%02u-%02uT%02u:%02u:%02u",
9830 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9831 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9833 printf ("%3lu: ", (unsigned long) cnt
);
9834 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9835 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9837 printf ("<corrupt: %9ld>", liblist
.l_name
);
9838 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9841 if (liblist
.l_flags
== 0)
9852 { " EXACT_MATCH", LL_EXACT_MATCH
},
9853 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9854 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9855 { " EXPORTS", LL_EXPORTS
},
9856 { " DELAY_LOAD", LL_DELAY_LOAD
},
9857 { " DELTA", LL_DELTA
}
9859 int flags
= liblist
.l_flags
;
9862 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9863 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9865 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9866 flags
^= l_flags_vals
[fcnt
].bit
;
9869 printf (" %#x", (unsigned int) flags
);
9879 if (options_offset
!= 0)
9881 Elf_External_Options
* eopt
;
9882 Elf_Internal_Shdr
* sect
= section_headers
;
9883 Elf_Internal_Options
* iopt
;
9884 Elf_Internal_Options
* option
;
9888 /* Find the section header so that we get the size. */
9889 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9892 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
9893 sect
->sh_size
, _("options"));
9896 iopt
= (Elf_Internal_Options
*)
9897 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9900 error (_("Out of memory\n"));
9907 while (offset
< sect
->sh_size
)
9909 Elf_External_Options
* eoption
;
9911 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9913 option
->kind
= BYTE_GET (eoption
->kind
);
9914 option
->size
= BYTE_GET (eoption
->size
);
9915 option
->section
= BYTE_GET (eoption
->section
);
9916 option
->info
= BYTE_GET (eoption
->info
);
9918 offset
+= option
->size
;
9924 printf (_("\nSection '%s' contains %d entries:\n"),
9925 SECTION_NAME (sect
), cnt
);
9933 switch (option
->kind
)
9936 /* This shouldn't happen. */
9937 printf (" NULL %d %lx", option
->section
, option
->info
);
9940 printf (" REGINFO ");
9941 if (elf_header
.e_machine
== EM_MIPS
)
9944 Elf32_External_RegInfo
* ereg
;
9945 Elf32_RegInfo reginfo
;
9947 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9948 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9949 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9950 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9951 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9952 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9953 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9955 printf ("GPR %08lx GP 0x%lx\n",
9957 (unsigned long) reginfo
.ri_gp_value
);
9958 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9959 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9960 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9965 Elf64_External_RegInfo
* ereg
;
9966 Elf64_Internal_RegInfo reginfo
;
9968 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9969 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9970 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9971 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9972 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9973 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9974 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9976 printf ("GPR %08lx GP 0x",
9977 reginfo
.ri_gprmask
);
9978 printf_vma (reginfo
.ri_gp_value
);
9981 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9982 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9983 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9987 case ODK_EXCEPTIONS
:
9988 fputs (" EXCEPTIONS fpe_min(", stdout
);
9989 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9990 fputs (") fpe_max(", stdout
);
9991 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9992 fputs (")", stdout
);
9994 if (option
->info
& OEX_PAGE0
)
9995 fputs (" PAGE0", stdout
);
9996 if (option
->info
& OEX_SMM
)
9997 fputs (" SMM", stdout
);
9998 if (option
->info
& OEX_FPDBUG
)
9999 fputs (" FPDBUG", stdout
);
10000 if (option
->info
& OEX_DISMISS
)
10001 fputs (" DISMISS", stdout
);
10004 fputs (" PAD ", stdout
);
10005 if (option
->info
& OPAD_PREFIX
)
10006 fputs (" PREFIX", stdout
);
10007 if (option
->info
& OPAD_POSTFIX
)
10008 fputs (" POSTFIX", stdout
);
10009 if (option
->info
& OPAD_SYMBOL
)
10010 fputs (" SYMBOL", stdout
);
10013 fputs (" HWPATCH ", stdout
);
10014 if (option
->info
& OHW_R4KEOP
)
10015 fputs (" R4KEOP", stdout
);
10016 if (option
->info
& OHW_R8KPFETCH
)
10017 fputs (" R8KPFETCH", stdout
);
10018 if (option
->info
& OHW_R5KEOP
)
10019 fputs (" R5KEOP", stdout
);
10020 if (option
->info
& OHW_R5KCVTL
)
10021 fputs (" R5KCVTL", stdout
);
10024 fputs (" FILL ", stdout
);
10025 /* XXX Print content of info word? */
10028 fputs (" TAGS ", stdout
);
10029 /* XXX Print content of info word? */
10032 fputs (" HWAND ", stdout
);
10033 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10034 fputs (" R4KEOP_CHECKED", stdout
);
10035 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10036 fputs (" R4KEOP_CLEAN", stdout
);
10039 fputs (" HWOR ", stdout
);
10040 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10041 fputs (" R4KEOP_CHECKED", stdout
);
10042 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10043 fputs (" R4KEOP_CLEAN", stdout
);
10046 printf (" GP_GROUP %#06lx self-contained %#06lx",
10047 option
->info
& OGP_GROUP
,
10048 (option
->info
& OGP_SELF
) >> 16);
10051 printf (" IDENT %#06lx self-contained %#06lx",
10052 option
->info
& OGP_GROUP
,
10053 (option
->info
& OGP_SELF
) >> 16);
10056 /* This shouldn't happen. */
10057 printf (" %3d ??? %d %lx",
10058 option
->kind
, option
->section
, option
->info
);
10062 len
= sizeof (* eopt
);
10063 while (len
< option
->size
)
10064 if (((char *) option
)[len
] >= ' '
10065 && ((char *) option
)[len
] < 0x7f)
10066 printf ("%c", ((char *) option
)[len
++]);
10068 printf ("\\%03o", ((char *) option
)[len
++]);
10070 fputs ("\n", stdout
);
10078 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10080 Elf32_Conflict
* iconf
;
10083 if (dynamic_symbols
== NULL
)
10085 error (_("conflict list found without a dynamic symbol table\n"));
10089 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
10092 error (_("Out of memory\n"));
10098 Elf32_External_Conflict
* econf32
;
10100 econf32
= (Elf32_External_Conflict
*)
10101 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10102 sizeof (* econf32
), _("conflict"));
10106 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10107 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10113 Elf64_External_Conflict
* econf64
;
10115 econf64
= (Elf64_External_Conflict
*)
10116 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10117 sizeof (* econf64
), _("conflict"));
10121 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10122 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10127 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10128 (unsigned long) conflictsno
);
10129 puts (_(" Num: Index Value Name"));
10131 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10133 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10135 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10136 print_vma (psym
->st_value
, FULL_HEX
);
10138 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10139 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10141 printf ("<corrupt: %14ld>", psym
->st_name
);
10148 if (pltgot
!= 0 && local_gotno
!= 0)
10150 bfd_vma ent
, local_end
, global_end
;
10152 unsigned char * data
;
10156 addr_size
= (is_32bit_elf
? 4 : 8);
10157 local_end
= pltgot
+ local_gotno
* addr_size
;
10158 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10160 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10161 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10162 global_end
- pltgot
, 1, _("GOT"));
10163 printf (_("\nPrimary GOT:\n"));
10164 printf (_(" Canonical gp value: "));
10165 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10168 printf (_(" Reserved entries:\n"));
10169 printf (_(" %*s %10s %*s Purpose\n"),
10170 addr_size
* 2, "Address", "Access",
10171 addr_size
* 2, "Initial");
10172 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10173 printf (" Lazy resolver\n");
10175 && (byte_get (data
+ ent
- pltgot
, addr_size
)
10176 >> (addr_size
* 8 - 1)) != 0)
10178 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10179 printf (" Module pointer (GNU extension)\n");
10183 if (ent
< local_end
)
10185 printf (_(" Local entries:\n"));
10186 printf (_(" %*s %10s %*s\n"),
10187 addr_size
* 2, "Address", "Access",
10188 addr_size
* 2, "Initial");
10189 while (ent
< local_end
)
10191 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10197 if (gotsym
< symtabno
)
10201 printf (_(" Global entries:\n"));
10202 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10203 addr_size
* 2, "Address", "Access",
10204 addr_size
* 2, "Initial",
10205 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10206 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10207 for (i
= gotsym
; i
< symtabno
; i
++)
10209 Elf_Internal_Sym
* psym
;
10211 psym
= dynamic_symbols
+ i
;
10212 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10214 print_vma (psym
->st_value
, LONG_HEX
);
10215 printf (" %-7s %3s ",
10216 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10217 get_symbol_index_type (psym
->st_shndx
));
10218 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10219 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10221 printf ("<corrupt: %14ld>", psym
->st_name
);
10231 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10234 size_t offset
, rel_offset
;
10235 unsigned long count
, i
;
10236 unsigned char * data
;
10237 int addr_size
, sym_width
;
10238 Elf_Internal_Rela
* rels
;
10240 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10241 if (pltrel
== DT_RELA
)
10243 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10248 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10253 addr_size
= (is_32bit_elf
? 4 : 8);
10254 end
= mips_pltgot
+ (2 + count
) * addr_size
;
10256 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
10257 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
10259 printf (_("\nPLT GOT:\n\n"));
10260 printf (_(" Reserved entries:\n"));
10261 printf (_(" %*s %*s Purpose\n"),
10262 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10263 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10264 printf (" PLT lazy resolver\n");
10265 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10266 printf (" Module pointer\n");
10269 printf (_(" Entries:\n"));
10270 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10271 addr_size
* 2, "Address",
10272 addr_size
* 2, "Initial",
10273 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10274 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10275 for (i
= 0; i
< count
; i
++)
10277 Elf_Internal_Sym
* psym
;
10279 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10280 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10282 print_vma (psym
->st_value
, LONG_HEX
);
10283 printf (" %-7s %3s ",
10284 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10285 get_symbol_index_type (psym
->st_shndx
));
10286 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10287 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10289 printf ("<corrupt: %14ld>", psym
->st_name
);
10303 process_gnu_liblist (FILE * file
)
10305 Elf_Internal_Shdr
* section
;
10306 Elf_Internal_Shdr
* string_sec
;
10307 Elf32_External_Lib
* elib
;
10309 size_t strtab_size
;
10316 for (i
= 0, section
= section_headers
;
10317 i
< elf_header
.e_shnum
;
10320 switch (section
->sh_type
)
10322 case SHT_GNU_LIBLIST
:
10323 if (section
->sh_link
>= elf_header
.e_shnum
)
10326 elib
= (Elf32_External_Lib
*)
10327 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10332 string_sec
= section_headers
+ section
->sh_link
;
10334 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10335 string_sec
->sh_size
,
10336 _("liblist string table"));
10337 strtab_size
= string_sec
->sh_size
;
10340 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10346 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10347 SECTION_NAME (section
),
10348 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10350 puts (" Library Time Stamp Checksum Version Flags");
10352 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10360 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10361 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10362 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10363 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10364 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10366 tmp
= gmtime (&atime
);
10367 snprintf (timebuf
, sizeof (timebuf
),
10368 "%04u-%02u-%02uT%02u:%02u:%02u",
10369 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10370 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10372 printf ("%3lu: ", (unsigned long) cnt
);
10374 printf ("%-20s", liblist
.l_name
< strtab_size
10375 ? strtab
+ liblist
.l_name
: "<corrupt>");
10377 printf ("%-20.20s", liblist
.l_name
< strtab_size
10378 ? strtab
+ liblist
.l_name
: "<corrupt>");
10379 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10380 liblist
.l_version
, liblist
.l_flags
);
10390 static const char *
10391 get_note_type (unsigned e_type
)
10393 static char buff
[64];
10395 if (elf_header
.e_type
== ET_CORE
)
10399 return _("NT_AUXV (auxiliary vector)");
10401 return _("NT_PRSTATUS (prstatus structure)");
10403 return _("NT_FPREGSET (floating point registers)");
10405 return _("NT_PRPSINFO (prpsinfo structure)");
10406 case NT_TASKSTRUCT
:
10407 return _("NT_TASKSTRUCT (task structure)");
10409 return _("NT_PRXFPREG (user_xfpregs structure)");
10411 return _("NT_PPC_VMX (ppc Altivec registers)");
10413 return _("NT_PPC_VSX (ppc VSX registers)");
10414 case NT_S390_HIGH_GPRS
:
10415 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
10417 return _("NT_PSTATUS (pstatus structure)");
10419 return _("NT_FPREGS (floating point registers)");
10421 return _("NT_PSINFO (psinfo structure)");
10423 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10425 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10426 case NT_WIN32PSTATUS
:
10427 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10435 return _("NT_VERSION (version)");
10437 return _("NT_ARCH (architecture)");
10442 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10446 static const char *
10447 get_gnu_elf_note_type (unsigned e_type
)
10449 static char buff
[64];
10453 case NT_GNU_ABI_TAG
:
10454 return _("NT_GNU_ABI_TAG (ABI version tag)");
10456 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10457 case NT_GNU_BUILD_ID
:
10458 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10459 case NT_GNU_GOLD_VERSION
:
10460 return _("NT_GNU_GOLD_VERSION (gold version)");
10465 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10469 static const char *
10470 get_netbsd_elfcore_note_type (unsigned e_type
)
10472 static char buff
[64];
10474 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10476 /* NetBSD core "procinfo" structure. */
10477 return _("NetBSD procinfo structure");
10480 /* As of Jan 2002 there are no other machine-independent notes
10481 defined for NetBSD core files. If the note type is less
10482 than the start of the machine-dependent note types, we don't
10485 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10487 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10491 switch (elf_header
.e_machine
)
10493 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10494 and PT_GETFPREGS == mach+2. */
10499 case EM_SPARC32PLUS
:
10503 case NT_NETBSDCORE_FIRSTMACH
+0:
10504 return _("PT_GETREGS (reg structure)");
10505 case NT_NETBSDCORE_FIRSTMACH
+2:
10506 return _("PT_GETFPREGS (fpreg structure)");
10512 /* On all other arch's, PT_GETREGS == mach+1 and
10513 PT_GETFPREGS == mach+3. */
10517 case NT_NETBSDCORE_FIRSTMACH
+1:
10518 return _("PT_GETREGS (reg structure)");
10519 case NT_NETBSDCORE_FIRSTMACH
+3:
10520 return _("PT_GETFPREGS (fpreg structure)");
10526 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10527 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10531 /* Note that by the ELF standard, the name field is already null byte
10532 terminated, and namesz includes the terminating null byte.
10533 I.E. the value of namesz for the name "FSF" is 4.
10535 If the value of namesz is zero, there is no name present. */
10537 process_note (Elf_Internal_Note
* pnote
)
10539 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10542 if (pnote
->namesz
== 0)
10543 /* If there is no note name, then use the default set of
10544 note type strings. */
10545 nt
= get_note_type (pnote
->type
);
10547 else if (const_strneq (pnote
->namedata
, "GNU"))
10548 /* GNU-specific object file notes. */
10549 nt
= get_gnu_elf_note_type (pnote
->type
);
10551 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10552 /* NetBSD-specific core file notes. */
10553 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10555 else if (strneq (pnote
->namedata
, "SPU/", 4))
10557 /* SPU-specific core file notes. */
10558 nt
= pnote
->namedata
+ 4;
10563 /* Don't recognize this note name; just use the default set of
10564 note type strings. */
10565 nt
= get_note_type (pnote
->type
);
10567 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10573 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10575 Elf_External_Note
* pnotes
;
10576 Elf_External_Note
* external
;
10582 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
10589 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10590 (unsigned long) offset
, (unsigned long) length
);
10591 printf (_(" Owner\t\tData size\tDescription\n"));
10593 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10595 Elf_External_Note
* next
;
10596 Elf_Internal_Note inote
;
10597 char * temp
= NULL
;
10599 inote
.type
= BYTE_GET (external
->type
);
10600 inote
.namesz
= BYTE_GET (external
->namesz
);
10601 inote
.namedata
= external
->name
;
10602 inote
.descsz
= BYTE_GET (external
->descsz
);
10603 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10604 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10606 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10608 if (((char *) next
) > (((char *) pnotes
) + length
))
10610 warn (_("corrupt note found at offset %lx into core notes\n"),
10611 (unsigned long) ((char *) external
- (char *) pnotes
));
10612 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10613 inote
.type
, inote
.namesz
, inote
.descsz
);
10619 /* Verify that name is null terminated. It appears that at least
10620 one version of Linux (RedHat 6.0) generates corefiles that don't
10621 comply with the ELF spec by failing to include the null byte in
10623 if (inote
.namedata
[inote
.namesz
] != '\0')
10625 temp
= (char *) malloc (inote
.namesz
+ 1);
10629 error (_("Out of memory\n"));
10634 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10635 temp
[inote
.namesz
] = 0;
10637 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10638 inote
.namedata
= temp
;
10641 res
&= process_note (& inote
);
10656 process_corefile_note_segments (FILE * file
)
10658 Elf_Internal_Phdr
* segment
;
10662 if (! get_program_headers (file
))
10665 for (i
= 0, segment
= program_headers
;
10666 i
< elf_header
.e_phnum
;
10669 if (segment
->p_type
== PT_NOTE
)
10670 res
&= process_corefile_note_segment (file
,
10671 (bfd_vma
) segment
->p_offset
,
10672 (bfd_vma
) segment
->p_filesz
);
10679 process_note_sections (FILE * file
)
10681 Elf_Internal_Shdr
* section
;
10685 for (i
= 0, section
= section_headers
;
10686 i
< elf_header
.e_shnum
;
10688 if (section
->sh_type
== SHT_NOTE
)
10689 res
&= process_corefile_note_segment (file
,
10690 (bfd_vma
) section
->sh_offset
,
10691 (bfd_vma
) section
->sh_size
);
10697 process_notes (FILE * file
)
10699 /* If we have not been asked to display the notes then do nothing. */
10703 if (elf_header
.e_type
!= ET_CORE
)
10704 return process_note_sections (file
);
10706 /* No program headers means no NOTE segment. */
10707 if (elf_header
.e_phnum
> 0)
10708 return process_corefile_note_segments (file
);
10710 printf (_("No note segments present in the core file.\n"));
10715 process_arch_specific (FILE * file
)
10720 switch (elf_header
.e_machine
)
10723 return process_arm_specific (file
);
10725 case EM_MIPS_RS3_LE
:
10726 return process_mips_specific (file
);
10729 return process_power_specific (file
);
10738 get_file_header (FILE * file
)
10740 /* Read in the identity array. */
10741 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10744 /* Determine how to read the rest of the header. */
10745 switch (elf_header
.e_ident
[EI_DATA
])
10747 default: /* fall through */
10748 case ELFDATANONE
: /* fall through */
10750 byte_get
= byte_get_little_endian
;
10751 byte_put
= byte_put_little_endian
;
10754 byte_get
= byte_get_big_endian
;
10755 byte_put
= byte_put_big_endian
;
10759 /* For now we only support 32 bit and 64 bit ELF files. */
10760 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10762 /* Read in the rest of the header. */
10765 Elf32_External_Ehdr ehdr32
;
10767 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10770 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10771 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10772 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10773 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10774 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10775 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10776 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10777 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10778 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10779 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10780 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10781 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10782 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10786 Elf64_External_Ehdr ehdr64
;
10788 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10789 we will not be able to cope with the 64bit data found in
10790 64 ELF files. Detect this now and abort before we start
10791 overwriting things. */
10792 if (sizeof (bfd_vma
) < 8)
10794 error (_("This instance of readelf has been built without support for a\n\
10795 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10799 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10802 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10803 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10804 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10805 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10806 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10807 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10808 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10809 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10810 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10811 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10812 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10813 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10814 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10817 if (elf_header
.e_shoff
)
10819 /* There may be some extensions in the first section header. Don't
10820 bomb if we can't read it. */
10822 get_32bit_section_headers (file
, 1);
10824 get_64bit_section_headers (file
, 1);
10830 /* Process one ELF object file according to the command line options.
10831 This file may actually be stored in an archive. The file is
10832 positioned at the start of the ELF object. */
10835 process_object (char * file_name
, FILE * file
)
10839 if (! get_file_header (file
))
10841 error (_("%s: Failed to read file header\n"), file_name
);
10845 /* Initialise per file variables. */
10846 for (i
= ARRAY_SIZE (version_info
); i
--;)
10847 version_info
[i
] = 0;
10849 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10850 dynamic_info
[i
] = 0;
10852 /* Process the file. */
10854 printf (_("\nFile: %s\n"), file_name
);
10856 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10857 Note we do this even if cmdline_dump_sects is empty because we
10858 must make sure that the dump_sets array is zeroed out before each
10859 object file is processed. */
10860 if (num_dump_sects
> num_cmdline_dump_sects
)
10861 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10863 if (num_cmdline_dump_sects
> 0)
10865 if (num_dump_sects
== 0)
10866 /* A sneaky way of allocating the dump_sects array. */
10867 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10869 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10870 memcpy (dump_sects
, cmdline_dump_sects
,
10871 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10874 if (! process_file_header ())
10877 if (! process_section_headers (file
))
10879 /* Without loaded section headers we cannot process lots of
10881 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10883 if (! do_using_dynamic
)
10884 do_syms
= do_dyn_syms
= do_reloc
= 0;
10887 if (! process_section_groups (file
))
10889 /* Without loaded section groups we cannot process unwind. */
10893 if (process_program_headers (file
))
10894 process_dynamic_section (file
);
10896 process_relocs (file
);
10898 process_unwind (file
);
10900 process_symbol_table (file
);
10902 process_syminfo (file
);
10904 process_version_sections (file
);
10906 process_section_contents (file
);
10908 process_notes (file
);
10910 process_gnu_liblist (file
);
10912 process_arch_specific (file
);
10914 if (program_headers
)
10916 free (program_headers
);
10917 program_headers
= NULL
;
10920 if (section_headers
)
10922 free (section_headers
);
10923 section_headers
= NULL
;
10928 free (string_table
);
10929 string_table
= NULL
;
10930 string_table_length
= 0;
10933 if (dynamic_strings
)
10935 free (dynamic_strings
);
10936 dynamic_strings
= NULL
;
10937 dynamic_strings_length
= 0;
10940 if (dynamic_symbols
)
10942 free (dynamic_symbols
);
10943 dynamic_symbols
= NULL
;
10944 num_dynamic_syms
= 0;
10947 if (dynamic_syminfo
)
10949 free (dynamic_syminfo
);
10950 dynamic_syminfo
= NULL
;
10953 if (section_headers_groups
)
10955 free (section_headers_groups
);
10956 section_headers_groups
= NULL
;
10959 if (section_groups
)
10961 struct group_list
* g
;
10962 struct group_list
* next
;
10964 for (i
= 0; i
< group_count
; i
++)
10966 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10973 free (section_groups
);
10974 section_groups
= NULL
;
10977 free_debug_memory ();
10982 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10983 to the path name of the thin archive itself if necessary. Always returns
10984 a pointer to malloc'ed memory. */
10987 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10989 char * member_file_name
;
10990 const char * base_name
= lbasename (file_name
);
10992 /* This is a proxy entry for a thin archive member.
10993 If the extended name table contains an absolute path
10994 name, or if the archive is in the current directory,
10995 use the path name as given. Otherwise, we need to
10996 find the member relative to the directory where the
10997 archive is located. */
10998 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
11000 member_file_name
= (char *) malloc (name_len
+ 1);
11001 if (member_file_name
== NULL
)
11003 error (_("Out of memory\n"));
11006 memcpy (member_file_name
, name
, name_len
);
11007 member_file_name
[name_len
] = '\0';
11011 /* Concatenate the path components of the archive file name
11012 to the relative path name from the extended name table. */
11013 size_t prefix_len
= base_name
- file_name
;
11014 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
11015 if (member_file_name
== NULL
)
11017 error (_("Out of memory\n"));
11020 memcpy (member_file_name
, file_name
, prefix_len
);
11021 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
11022 member_file_name
[prefix_len
+ name_len
] = '\0';
11024 return member_file_name
;
11027 /* Structure to hold information about an archive file. */
11029 struct archive_info
11031 char * file_name
; /* Archive file name. */
11032 FILE * file
; /* Open file descriptor. */
11033 unsigned long index_num
; /* Number of symbols in table. */
11034 unsigned long * index_array
; /* The array of member offsets. */
11035 char * sym_table
; /* The symbol table. */
11036 unsigned long sym_size
; /* Size of the symbol table. */
11037 char * longnames
; /* The long file names table. */
11038 unsigned long longnames_size
; /* Size of the long file names table. */
11039 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
11040 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
11041 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
11042 struct ar_hdr arhdr
; /* Current archive header. */
11045 /* Read the symbol table and long-name table from an archive. */
11048 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
11049 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
11052 unsigned long size
;
11054 arch
->file_name
= strdup (file_name
);
11056 arch
->index_num
= 0;
11057 arch
->index_array
= NULL
;
11058 arch
->sym_table
= NULL
;
11059 arch
->sym_size
= 0;
11060 arch
->longnames
= NULL
;
11061 arch
->longnames_size
= 0;
11062 arch
->nested_member_origin
= 0;
11063 arch
->is_thin_archive
= is_thin_archive
;
11064 arch
->next_arhdr_offset
= SARMAG
;
11066 /* Read the first archive member header. */
11067 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
11069 error (_("%s: failed to seek to first archive header\n"), file_name
);
11072 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11073 if (got
!= sizeof arch
->arhdr
)
11078 error (_("%s: failed to read archive header\n"), file_name
);
11082 /* See if this is the archive symbol table. */
11083 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
11084 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
11086 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11087 size
= size
+ (size
& 1);
11089 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
11094 /* A buffer used to hold numbers read in from an archive index.
11095 These are always 4 bytes long and stored in big-endian format. */
11096 #define SIZEOF_AR_INDEX_NUMBERS 4
11097 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
11098 unsigned char * index_buffer
;
11100 /* Check the size of the archive index. */
11101 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
11103 error (_("%s: the archive index is empty\n"), file_name
);
11107 /* Read the numer of entries in the archive index. */
11108 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
11109 if (got
!= sizeof (integer_buffer
))
11111 error (_("%s: failed to read archive index\n"), file_name
);
11114 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
11115 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11117 /* Read in the archive index. */
11118 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11120 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11121 file_name
, arch
->index_num
);
11124 index_buffer
= (unsigned char *)
11125 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11126 if (index_buffer
== NULL
)
11128 error (_("Out of memory whilst trying to read archive symbol index\n"));
11131 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11132 if (got
!= arch
->index_num
)
11134 free (index_buffer
);
11135 error (_("%s: failed to read archive index\n"), file_name
);
11138 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11140 /* Convert the index numbers into the host's numeric format. */
11141 arch
->index_array
= (long unsigned int *)
11142 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11143 if (arch
->index_array
== NULL
)
11145 free (index_buffer
);
11146 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11150 for (i
= 0; i
< arch
->index_num
; i
++)
11151 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11152 SIZEOF_AR_INDEX_NUMBERS
);
11153 free (index_buffer
);
11155 /* The remaining space in the header is taken up by the symbol table. */
11158 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11161 arch
->sym_table
= (char *) malloc (size
);
11162 arch
->sym_size
= size
;
11163 if (arch
->sym_table
== NULL
)
11165 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11168 got
= fread (arch
->sym_table
, 1, size
, file
);
11171 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11177 if (fseek (file
, size
, SEEK_CUR
) != 0)
11179 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11184 /* Read the next archive header. */
11185 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11186 if (got
!= sizeof arch
->arhdr
)
11190 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11194 else if (read_symbols
)
11195 printf (_("%s has no archive index\n"), file_name
);
11197 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11199 /* This is the archive string table holding long member names. */
11200 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11201 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11203 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11204 if (arch
->longnames
== NULL
)
11206 error (_("Out of memory reading long symbol names in archive\n"));
11210 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
11212 free (arch
->longnames
);
11213 arch
->longnames
= NULL
;
11214 error (_("%s: failed to read long symbol name string table\n"), file_name
);
11218 if ((arch
->longnames_size
& 1) != 0)
11225 /* Release the memory used for the archive information. */
11228 release_archive (struct archive_info
* arch
)
11230 if (arch
->file_name
!= NULL
)
11231 free (arch
->file_name
);
11232 if (arch
->index_array
!= NULL
)
11233 free (arch
->index_array
);
11234 if (arch
->sym_table
!= NULL
)
11235 free (arch
->sym_table
);
11236 if (arch
->longnames
!= NULL
)
11237 free (arch
->longnames
);
11240 /* Open and setup a nested archive, if not already open. */
11243 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
11245 FILE * member_file
;
11247 /* Have we already setup this archive? */
11248 if (nested_arch
->file_name
!= NULL
11249 && streq (nested_arch
->file_name
, member_file_name
))
11252 /* Close previous file and discard cached information. */
11253 if (nested_arch
->file
!= NULL
)
11254 fclose (nested_arch
->file
);
11255 release_archive (nested_arch
);
11257 member_file
= fopen (member_file_name
, "rb");
11258 if (member_file
== NULL
)
11260 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
11264 get_archive_member_name_at (struct archive_info
* arch
,
11265 unsigned long offset
,
11266 struct archive_info
* nested_arch
);
11268 /* Get the name of an archive member from the current archive header.
11269 For simple names, this will modify the ar_name field of the current
11270 archive header. For long names, it will return a pointer to the
11271 longnames table. For nested archives, it will open the nested archive
11272 and get the name recursively. NESTED_ARCH is a single-entry cache so
11273 we don't keep rereading the same information from a nested archive. */
11276 get_archive_member_name (struct archive_info
* arch
,
11277 struct archive_info
* nested_arch
)
11279 unsigned long j
, k
;
11281 if (arch
->arhdr
.ar_name
[0] == '/')
11283 /* We have a long name. */
11285 char * member_file_name
;
11286 char * member_name
;
11288 arch
->nested_member_origin
= 0;
11289 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11290 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11291 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11293 while ((j
< arch
->longnames_size
)
11294 && (arch
->longnames
[j
] != '\n')
11295 && (arch
->longnames
[j
] != '\0'))
11297 if (arch
->longnames
[j
-1] == '/')
11299 arch
->longnames
[j
] = '\0';
11301 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11302 return arch
->longnames
+ k
;
11304 /* This is a proxy for a member of a nested archive.
11305 Find the name of the member in that archive. */
11306 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11307 if (member_file_name
!= NULL
11308 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11309 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11311 free (member_file_name
);
11312 return member_name
;
11314 free (member_file_name
);
11316 /* Last resort: just return the name of the nested archive. */
11317 return arch
->longnames
+ k
;
11320 /* We have a normal (short) name. */
11322 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11324 arch
->arhdr
.ar_name
[j
] = '\0';
11325 return arch
->arhdr
.ar_name
;
11328 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11331 get_archive_member_name_at (struct archive_info
* arch
,
11332 unsigned long offset
,
11333 struct archive_info
* nested_arch
)
11337 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11339 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11342 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11343 if (got
!= sizeof arch
->arhdr
)
11345 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11348 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11350 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11354 return get_archive_member_name (arch
, nested_arch
);
11357 /* Construct a string showing the name of the archive member, qualified
11358 with the name of the containing archive file. For thin archives, we
11359 use square brackets to denote the indirection. For nested archives,
11360 we show the qualified name of the external member inside the square
11361 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11364 make_qualified_name (struct archive_info
* arch
,
11365 struct archive_info
* nested_arch
,
11366 char * member_name
)
11371 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11372 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11373 len
+= strlen (nested_arch
->file_name
) + 2;
11375 name
= (char *) malloc (len
);
11378 error (_("Out of memory\n"));
11382 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11383 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11384 else if (arch
->is_thin_archive
)
11385 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11387 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11392 /* Process an ELF archive.
11393 On entry the file is positioned just after the ARMAG string. */
11396 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11398 struct archive_info arch
;
11399 struct archive_info nested_arch
;
11401 size_t file_name_size
;
11406 /* The ARCH structure is used to hold information about this archive. */
11407 arch
.file_name
= NULL
;
11409 arch
.index_array
= NULL
;
11410 arch
.sym_table
= NULL
;
11411 arch
.longnames
= NULL
;
11413 /* The NESTED_ARCH structure is used as a single-item cache of information
11414 about a nested archive (when members of a thin archive reside within
11415 another regular archive file). */
11416 nested_arch
.file_name
= NULL
;
11417 nested_arch
.file
= NULL
;
11418 nested_arch
.index_array
= NULL
;
11419 nested_arch
.sym_table
= NULL
;
11420 nested_arch
.longnames
= NULL
;
11422 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11428 if (do_archive_index
)
11430 if (arch
.sym_table
== NULL
)
11431 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11435 unsigned long current_pos
;
11437 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11438 file_name
, arch
.index_num
, arch
.sym_size
);
11439 current_pos
= ftell (file
);
11441 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11443 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11445 char * member_name
;
11447 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11449 if (member_name
!= NULL
)
11451 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11453 if (qualified_name
!= NULL
)
11455 printf (_("Binary %s contains:\n"), qualified_name
);
11456 free (qualified_name
);
11461 if (l
>= arch
.sym_size
)
11463 error (_("%s: end of the symbol table reached before the end of the index\n"),
11467 printf ("\t%s\n", arch
.sym_table
+ l
);
11468 l
+= strlen (arch
.sym_table
+ l
) + 1;
11473 if (l
< arch
.sym_size
)
11474 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11477 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11479 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11485 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11486 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11487 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11488 && !do_section_groups
&& !do_dyn_syms
)
11490 ret
= 0; /* Archive index only. */
11495 file_name_size
= strlen (file_name
);
11502 char * qualified_name
;
11504 /* Read the next archive header. */
11505 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11507 error (_("%s: failed to seek to next archive header\n"), file_name
);
11510 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11511 if (got
!= sizeof arch
.arhdr
)
11515 error (_("%s: failed to read archive header\n"), file_name
);
11519 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11521 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11526 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11528 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11529 if (archive_file_size
& 01)
11530 ++archive_file_size
;
11532 name
= get_archive_member_name (&arch
, &nested_arch
);
11535 error (_("%s: bad archive file name\n"), file_name
);
11539 namelen
= strlen (name
);
11541 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11542 if (qualified_name
== NULL
)
11544 error (_("%s: bad archive file name\n"), file_name
);
11549 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11551 /* This is a proxy for an external member of a thin archive. */
11552 FILE * member_file
;
11553 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11554 if (member_file_name
== NULL
)
11560 member_file
= fopen (member_file_name
, "rb");
11561 if (member_file
== NULL
)
11563 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11564 free (member_file_name
);
11569 archive_file_offset
= arch
.nested_member_origin
;
11571 ret
|= process_object (qualified_name
, member_file
);
11573 fclose (member_file
);
11574 free (member_file_name
);
11576 else if (is_thin_archive
)
11578 /* This is a proxy for a member of a nested archive. */
11579 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11581 /* The nested archive file will have been opened and setup by
11582 get_archive_member_name. */
11583 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11585 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11590 ret
|= process_object (qualified_name
, nested_arch
.file
);
11594 archive_file_offset
= arch
.next_arhdr_offset
;
11595 arch
.next_arhdr_offset
+= archive_file_size
;
11597 ret
|= process_object (qualified_name
, file
);
11600 free (qualified_name
);
11604 if (nested_arch
.file
!= NULL
)
11605 fclose (nested_arch
.file
);
11606 release_archive (&nested_arch
);
11607 release_archive (&arch
);
11613 process_file (char * file_name
)
11616 struct stat statbuf
;
11617 char armag
[SARMAG
];
11620 if (stat (file_name
, &statbuf
) < 0)
11622 if (errno
== ENOENT
)
11623 error (_("'%s': No such file\n"), file_name
);
11625 error (_("Could not locate '%s'. System error message: %s\n"),
11626 file_name
, strerror (errno
));
11630 if (! S_ISREG (statbuf
.st_mode
))
11632 error (_("'%s' is not an ordinary file\n"), file_name
);
11636 file
= fopen (file_name
, "rb");
11639 error (_("Input file '%s' is not readable.\n"), file_name
);
11643 if (fread (armag
, SARMAG
, 1, file
) != 1)
11645 error (_("%s: Failed to read file's magic number\n"), file_name
);
11650 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11651 ret
= process_archive (file_name
, file
, FALSE
);
11652 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11653 ret
= process_archive (file_name
, file
, TRUE
);
11656 if (do_archive_index
)
11657 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11661 archive_file_size
= archive_file_offset
= 0;
11662 ret
= process_object (file_name
, file
);
11670 #ifdef SUPPORT_DISASSEMBLY
11671 /* Needed by the i386 disassembler. For extra credit, someone could
11672 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11676 print_address (unsigned int addr
, FILE * outfile
)
11678 fprintf (outfile
,"0x%8.8x", addr
);
11681 /* Needed by the i386 disassembler. */
11683 db_task_printsym (unsigned int addr
)
11685 print_address (addr
, stderr
);
11690 main (int argc
, char ** argv
)
11694 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11695 setlocale (LC_MESSAGES
, "");
11697 #if defined (HAVE_SETLOCALE)
11698 setlocale (LC_CTYPE
, "");
11700 bindtextdomain (PACKAGE
, LOCALEDIR
);
11701 textdomain (PACKAGE
);
11703 expandargv (&argc
, &argv
);
11705 parse_args (argc
, argv
);
11707 if (num_dump_sects
> 0)
11709 /* Make a copy of the dump_sects array. */
11710 cmdline_dump_sects
= (dump_type
*)
11711 malloc (num_dump_sects
* sizeof (* dump_sects
));
11712 if (cmdline_dump_sects
== NULL
)
11713 error (_("Out of memory allocating dump request table.\n"));
11716 memcpy (cmdline_dump_sects
, dump_sects
,
11717 num_dump_sects
* sizeof (* dump_sects
));
11718 num_cmdline_dump_sects
= num_dump_sects
;
11722 if (optind
< (argc
- 1))
11726 while (optind
< argc
)
11727 err
|= process_file (argv
[optind
++]);
11729 if (dump_sects
!= NULL
)
11731 if (cmdline_dump_sects
!= NULL
)
11732 free (cmdline_dump_sects
);