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");
2513 if (e_flags
& EF_S390_HIGH_GPRS
)
2514 strcat (buf
, ", highgprs");
2522 get_osabi_name (unsigned int osabi
)
2524 static char buff
[32];
2528 case ELFOSABI_NONE
: return "UNIX - System V";
2529 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2530 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2531 case ELFOSABI_LINUX
: return "UNIX - Linux";
2532 case ELFOSABI_HURD
: return "GNU/Hurd";
2533 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2534 case ELFOSABI_AIX
: return "UNIX - AIX";
2535 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2536 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2537 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2538 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2539 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2540 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2541 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2542 case ELFOSABI_AROS
: return "AROS";
2543 case ELFOSABI_FENIXOS
: return "FenixOS";
2544 case ELFOSABI_STANDALONE
: return _("Standalone App");
2545 case ELFOSABI_ARM
: return "ARM";
2547 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2553 get_arm_segment_type (unsigned long type
)
2567 get_mips_segment_type (unsigned long type
)
2571 case PT_MIPS_REGINFO
:
2573 case PT_MIPS_RTPROC
:
2575 case PT_MIPS_OPTIONS
:
2585 get_parisc_segment_type (unsigned long type
)
2589 case PT_HP_TLS
: return "HP_TLS";
2590 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2591 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2592 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2593 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2594 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2595 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2596 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2597 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2598 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2599 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2600 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2601 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2602 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2603 case PT_HP_STACK
: return "HP_STACK";
2604 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2605 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2606 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2607 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2616 get_ia64_segment_type (unsigned long type
)
2620 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2621 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2622 case PT_HP_TLS
: return "HP_TLS";
2623 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2624 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2625 case PT_IA_64_HP_STACK
: return "HP_STACK";
2634 get_segment_type (unsigned long p_type
)
2636 static char buff
[32];
2640 case PT_NULL
: return "NULL";
2641 case PT_LOAD
: return "LOAD";
2642 case PT_DYNAMIC
: return "DYNAMIC";
2643 case PT_INTERP
: return "INTERP";
2644 case PT_NOTE
: return "NOTE";
2645 case PT_SHLIB
: return "SHLIB";
2646 case PT_PHDR
: return "PHDR";
2647 case PT_TLS
: return "TLS";
2649 case PT_GNU_EH_FRAME
:
2650 return "GNU_EH_FRAME";
2651 case PT_GNU_STACK
: return "GNU_STACK";
2652 case PT_GNU_RELRO
: return "GNU_RELRO";
2655 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2657 const char * result
;
2659 switch (elf_header
.e_machine
)
2662 result
= get_arm_segment_type (p_type
);
2665 case EM_MIPS_RS3_LE
:
2666 result
= get_mips_segment_type (p_type
);
2669 result
= get_parisc_segment_type (p_type
);
2672 result
= get_ia64_segment_type (p_type
);
2682 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2684 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2686 const char * result
;
2688 switch (elf_header
.e_machine
)
2691 result
= get_parisc_segment_type (p_type
);
2694 result
= get_ia64_segment_type (p_type
);
2704 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2707 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2714 get_mips_section_type_name (unsigned int sh_type
)
2718 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2719 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2720 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2721 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2722 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2723 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2724 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2725 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2726 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2727 case SHT_MIPS_RELD
: return "MIPS_RELD";
2728 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2729 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2730 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2731 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2732 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2733 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2734 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2735 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2736 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2737 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2738 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2739 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2740 case SHT_MIPS_LINE
: return "MIPS_LINE";
2741 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2742 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2743 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2744 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2745 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2746 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2747 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2748 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2749 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2750 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2751 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2752 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2753 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2754 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2755 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2756 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2764 get_parisc_section_type_name (unsigned int sh_type
)
2768 case SHT_PARISC_EXT
: return "PARISC_EXT";
2769 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2770 case SHT_PARISC_DOC
: return "PARISC_DOC";
2771 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2772 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2773 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2774 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2782 get_ia64_section_type_name (unsigned int sh_type
)
2784 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2785 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2786 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2790 case SHT_IA_64_EXT
: return "IA_64_EXT";
2791 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2792 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2793 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2794 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2795 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2796 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2797 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2798 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2799 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2807 get_x86_64_section_type_name (unsigned int sh_type
)
2811 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2819 get_arm_section_type_name (unsigned int sh_type
)
2823 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2824 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2825 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2826 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2827 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2835 get_section_type_name (unsigned int sh_type
)
2837 static char buff
[32];
2841 case SHT_NULL
: return "NULL";
2842 case SHT_PROGBITS
: return "PROGBITS";
2843 case SHT_SYMTAB
: return "SYMTAB";
2844 case SHT_STRTAB
: return "STRTAB";
2845 case SHT_RELA
: return "RELA";
2846 case SHT_HASH
: return "HASH";
2847 case SHT_DYNAMIC
: return "DYNAMIC";
2848 case SHT_NOTE
: return "NOTE";
2849 case SHT_NOBITS
: return "NOBITS";
2850 case SHT_REL
: return "REL";
2851 case SHT_SHLIB
: return "SHLIB";
2852 case SHT_DYNSYM
: return "DYNSYM";
2853 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2854 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2855 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2856 case SHT_GNU_HASH
: return "GNU_HASH";
2857 case SHT_GROUP
: return "GROUP";
2858 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2859 case SHT_GNU_verdef
: return "VERDEF";
2860 case SHT_GNU_verneed
: return "VERNEED";
2861 case SHT_GNU_versym
: return "VERSYM";
2862 case 0x6ffffff0: return "VERSYM";
2863 case 0x6ffffffc: return "VERDEF";
2864 case 0x7ffffffd: return "AUXILIARY";
2865 case 0x7fffffff: return "FILTER";
2866 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2869 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2871 const char * result
;
2873 switch (elf_header
.e_machine
)
2876 case EM_MIPS_RS3_LE
:
2877 result
= get_mips_section_type_name (sh_type
);
2880 result
= get_parisc_section_type_name (sh_type
);
2883 result
= get_ia64_section_type_name (sh_type
);
2887 result
= get_x86_64_section_type_name (sh_type
);
2890 result
= get_arm_section_type_name (sh_type
);
2900 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2902 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2904 const char * result
;
2906 switch (elf_header
.e_machine
)
2909 result
= get_ia64_section_type_name (sh_type
);
2919 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2921 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2922 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2924 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2930 #define OPTION_DEBUG_DUMP 512
2931 #define OPTION_DYN_SYMS 513
2933 static struct option options
[] =
2935 {"all", no_argument
, 0, 'a'},
2936 {"file-header", no_argument
, 0, 'h'},
2937 {"program-headers", no_argument
, 0, 'l'},
2938 {"headers", no_argument
, 0, 'e'},
2939 {"histogram", no_argument
, 0, 'I'},
2940 {"segments", no_argument
, 0, 'l'},
2941 {"sections", no_argument
, 0, 'S'},
2942 {"section-headers", no_argument
, 0, 'S'},
2943 {"section-groups", no_argument
, 0, 'g'},
2944 {"section-details", no_argument
, 0, 't'},
2945 {"full-section-name",no_argument
, 0, 'N'},
2946 {"symbols", no_argument
, 0, 's'},
2947 {"syms", no_argument
, 0, 's'},
2948 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
2949 {"relocs", no_argument
, 0, 'r'},
2950 {"notes", no_argument
, 0, 'n'},
2951 {"dynamic", no_argument
, 0, 'd'},
2952 {"arch-specific", no_argument
, 0, 'A'},
2953 {"version-info", no_argument
, 0, 'V'},
2954 {"use-dynamic", no_argument
, 0, 'D'},
2955 {"unwind", no_argument
, 0, 'u'},
2956 {"archive-index", no_argument
, 0, 'c'},
2957 {"hex-dump", required_argument
, 0, 'x'},
2958 {"relocated-dump", required_argument
, 0, 'R'},
2959 {"string-dump", required_argument
, 0, 'p'},
2960 #ifdef SUPPORT_DISASSEMBLY
2961 {"instruction-dump", required_argument
, 0, 'i'},
2963 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2965 {"version", no_argument
, 0, 'v'},
2966 {"wide", no_argument
, 0, 'W'},
2967 {"help", no_argument
, 0, 'H'},
2968 {0, no_argument
, 0, 0}
2972 usage (FILE * stream
)
2974 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2975 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2976 fprintf (stream
, _(" Options are:\n\
2977 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2978 -h --file-header Display the ELF file header\n\
2979 -l --program-headers Display the program headers\n\
2980 --segments An alias for --program-headers\n\
2981 -S --section-headers Display the sections' header\n\
2982 --sections An alias for --section-headers\n\
2983 -g --section-groups Display the section groups\n\
2984 -t --section-details Display the section details\n\
2985 -e --headers Equivalent to: -h -l -S\n\
2986 -s --syms Display the symbol table\n\
2987 --symbols An alias for --syms\n\
2988 --dyn-syms Display the dynamic symbol table\n\
2989 -n --notes Display the core notes (if present)\n\
2990 -r --relocs Display the relocations (if present)\n\
2991 -u --unwind Display the unwind info (if present)\n\
2992 -d --dynamic Display the dynamic section (if present)\n\
2993 -V --version-info Display the version sections (if present)\n\
2994 -A --arch-specific Display architecture specific information (if any).\n\
2995 -c --archive-index Display the symbol/file index in an archive\n\
2996 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2997 -x --hex-dump=<number|name>\n\
2998 Dump the contents of section <number|name> as bytes\n\
2999 -p --string-dump=<number|name>\n\
3000 Dump the contents of section <number|name> as strings\n\
3001 -R --relocated-dump=<number|name>\n\
3002 Dump the contents of section <number|name> as relocated bytes\n\
3003 -w[lLiaprmfFsoRt] or\n\
3004 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3005 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
3006 Display the contents of DWARF2 debug sections\n"));
3007 #ifdef SUPPORT_DISASSEMBLY
3008 fprintf (stream
, _("\
3009 -i --instruction-dump=<number|name>\n\
3010 Disassemble the contents of section <number|name>\n"));
3012 fprintf (stream
, _("\
3013 -I --histogram Display histogram of bucket list lengths\n\
3014 -W --wide Allow output width to exceed 80 characters\n\
3015 @<file> Read options from <file>\n\
3016 -H --help Display this information\n\
3017 -v --version Display the version number of readelf\n"));
3019 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3020 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3022 exit (stream
== stdout
? 0 : 1);
3025 /* Record the fact that the user wants the contents of section number
3026 SECTION to be displayed using the method(s) encoded as flags bits
3027 in TYPE. Note, TYPE can be zero if we are creating the array for
3031 request_dump_bynumber (unsigned int section
, dump_type type
)
3033 if (section
>= num_dump_sects
)
3035 dump_type
* new_dump_sects
;
3037 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3038 sizeof (* dump_sects
));
3040 if (new_dump_sects
== NULL
)
3041 error (_("Out of memory allocating dump request table.\n"));
3044 /* Copy current flag settings. */
3045 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3049 dump_sects
= new_dump_sects
;
3050 num_dump_sects
= section
+ 1;
3055 dump_sects
[section
] |= type
;
3060 /* Request a dump by section name. */
3063 request_dump_byname (const char * section
, dump_type type
)
3065 struct dump_list_entry
* new_request
;
3067 new_request
= (struct dump_list_entry
*)
3068 malloc (sizeof (struct dump_list_entry
));
3070 error (_("Out of memory allocating dump request table.\n"));
3072 new_request
->name
= strdup (section
);
3073 if (!new_request
->name
)
3074 error (_("Out of memory allocating dump request table.\n"));
3076 new_request
->type
= type
;
3078 new_request
->next
= dump_sects_byname
;
3079 dump_sects_byname
= new_request
;
3083 request_dump (dump_type type
)
3089 section
= strtoul (optarg
, & cp
, 0);
3091 if (! *cp
&& section
>= 0)
3092 request_dump_bynumber (section
, type
);
3094 request_dump_byname (optarg
, type
);
3099 parse_args (int argc
, char ** argv
)
3106 while ((c
= getopt_long
3107 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3125 do_section_groups
++;
3133 do_section_groups
++;
3138 do_section_details
++;
3182 request_dump (HEX_DUMP
);
3185 request_dump (STRING_DUMP
);
3188 request_dump (RELOC_DUMP
);
3195 dwarf_select_sections_all ();
3200 dwarf_select_sections_by_letters (optarg
);
3203 case OPTION_DEBUG_DUMP
:
3210 dwarf_select_sections_by_names (optarg
);
3213 case OPTION_DYN_SYMS
:
3216 #ifdef SUPPORT_DISASSEMBLY
3218 request_dump (DISASS_DUMP
);
3222 print_version (program_name
);
3231 /* xgettext:c-format */
3232 error (_("Invalid option '-%c'\n"), c
);
3239 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3240 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3241 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3242 && !do_section_groups
&& !do_archive_index
3247 warn (_("Nothing to do.\n"));
3253 get_elf_class (unsigned int elf_class
)
3255 static char buff
[32];
3259 case ELFCLASSNONE
: return _("none");
3260 case ELFCLASS32
: return "ELF32";
3261 case ELFCLASS64
: return "ELF64";
3263 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3269 get_data_encoding (unsigned int encoding
)
3271 static char buff
[32];
3275 case ELFDATANONE
: return _("none");
3276 case ELFDATA2LSB
: return _("2's complement, little endian");
3277 case ELFDATA2MSB
: return _("2's complement, big endian");
3279 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3284 /* Decode the data held in 'elf_header'. */
3287 process_file_header (void)
3289 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3290 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3291 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3292 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3295 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3299 init_dwarf_regnames (elf_header
.e_machine
);
3305 printf (_("ELF Header:\n"));
3306 printf (_(" Magic: "));
3307 for (i
= 0; i
< EI_NIDENT
; i
++)
3308 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3310 printf (_(" Class: %s\n"),
3311 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3312 printf (_(" Data: %s\n"),
3313 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3314 printf (_(" Version: %d %s\n"),
3315 elf_header
.e_ident
[EI_VERSION
],
3316 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3318 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3321 printf (_(" OS/ABI: %s\n"),
3322 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3323 printf (_(" ABI Version: %d\n"),
3324 elf_header
.e_ident
[EI_ABIVERSION
]);
3325 printf (_(" Type: %s\n"),
3326 get_file_type (elf_header
.e_type
));
3327 printf (_(" Machine: %s\n"),
3328 get_machine_name (elf_header
.e_machine
));
3329 printf (_(" Version: 0x%lx\n"),
3330 (unsigned long) elf_header
.e_version
);
3332 printf (_(" Entry point address: "));
3333 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3334 printf (_("\n Start of program headers: "));
3335 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3336 printf (_(" (bytes into file)\n Start of section headers: "));
3337 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3338 printf (_(" (bytes into file)\n"));
3340 printf (_(" Flags: 0x%lx%s\n"),
3341 (unsigned long) elf_header
.e_flags
,
3342 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3343 printf (_(" Size of this header: %ld (bytes)\n"),
3344 (long) elf_header
.e_ehsize
);
3345 printf (_(" Size of program headers: %ld (bytes)\n"),
3346 (long) elf_header
.e_phentsize
);
3347 printf (_(" Number of program headers: %ld"),
3348 (long) elf_header
.e_phnum
);
3349 if (section_headers
!= NULL
3350 && elf_header
.e_phnum
== PN_XNUM
3351 && section_headers
[0].sh_info
!= 0)
3352 printf (_(" (%ld)"), (long) section_headers
[0].sh_info
);
3353 putc ('\n', stdout
);
3354 printf (_(" Size of section headers: %ld (bytes)\n"),
3355 (long) elf_header
.e_shentsize
);
3356 printf (_(" Number of section headers: %ld"),
3357 (long) elf_header
.e_shnum
);
3358 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3359 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3360 putc ('\n', stdout
);
3361 printf (_(" Section header string table index: %ld"),
3362 (long) elf_header
.e_shstrndx
);
3363 if (section_headers
!= NULL
3364 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3365 printf (" (%u)", section_headers
[0].sh_link
);
3366 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3367 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3368 printf (" <corrupt: out of range>");
3369 putc ('\n', stdout
);
3372 if (section_headers
!= NULL
)
3374 if (elf_header
.e_phnum
== PN_XNUM
3375 && section_headers
[0].sh_info
!= 0)
3376 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3377 if (elf_header
.e_shnum
== SHN_UNDEF
)
3378 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3379 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3380 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3381 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3382 elf_header
.e_shstrndx
= SHN_UNDEF
;
3383 free (section_headers
);
3384 section_headers
= NULL
;
3392 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3394 Elf32_External_Phdr
* phdrs
;
3395 Elf32_External_Phdr
* external
;
3396 Elf_Internal_Phdr
* internal
;
3399 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3400 elf_header
.e_phentsize
,
3402 _("program headers"));
3406 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3407 i
< elf_header
.e_phnum
;
3408 i
++, internal
++, external
++)
3410 internal
->p_type
= BYTE_GET (external
->p_type
);
3411 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3412 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3413 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3414 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3415 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3416 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3417 internal
->p_align
= BYTE_GET (external
->p_align
);
3426 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3428 Elf64_External_Phdr
* phdrs
;
3429 Elf64_External_Phdr
* external
;
3430 Elf_Internal_Phdr
* internal
;
3433 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3434 elf_header
.e_phentsize
,
3436 _("program headers"));
3440 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3441 i
< elf_header
.e_phnum
;
3442 i
++, internal
++, external
++)
3444 internal
->p_type
= BYTE_GET (external
->p_type
);
3445 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3446 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3447 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3448 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3449 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3450 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3451 internal
->p_align
= BYTE_GET (external
->p_align
);
3459 /* Returns 1 if the program headers were read into `program_headers'. */
3462 get_program_headers (FILE * file
)
3464 Elf_Internal_Phdr
* phdrs
;
3466 /* Check cache of prior read. */
3467 if (program_headers
!= NULL
)
3470 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3471 sizeof (Elf_Internal_Phdr
));
3475 error (_("Out of memory\n"));
3480 ? get_32bit_program_headers (file
, phdrs
)
3481 : get_64bit_program_headers (file
, phdrs
))
3483 program_headers
= phdrs
;
3491 /* Returns 1 if the program headers were loaded. */
3494 process_program_headers (FILE * file
)
3496 Elf_Internal_Phdr
* segment
;
3499 if (elf_header
.e_phnum
== 0)
3502 printf (_("\nThere are no program headers in this file.\n"));
3506 if (do_segments
&& !do_header
)
3508 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3509 printf (_("Entry point "));
3510 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3511 printf (_("\nThere are %d program headers, starting at offset "),
3512 elf_header
.e_phnum
);
3513 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3517 if (! get_program_headers (file
))
3522 if (elf_header
.e_phnum
> 1)
3523 printf (_("\nProgram Headers:\n"));
3525 printf (_("\nProgram Headers:\n"));
3529 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3532 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3536 (_(" Type Offset VirtAddr PhysAddr\n"));
3538 (_(" FileSiz MemSiz Flags Align\n"));
3545 for (i
= 0, segment
= program_headers
;
3546 i
< elf_header
.e_phnum
;
3551 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3555 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3556 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3557 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3558 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3559 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3561 (segment
->p_flags
& PF_R
? 'R' : ' '),
3562 (segment
->p_flags
& PF_W
? 'W' : ' '),
3563 (segment
->p_flags
& PF_X
? 'E' : ' '));
3564 printf ("%#lx", (unsigned long) segment
->p_align
);
3568 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3569 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3572 print_vma (segment
->p_offset
, FULL_HEX
);
3576 print_vma (segment
->p_vaddr
, FULL_HEX
);
3578 print_vma (segment
->p_paddr
, FULL_HEX
);
3581 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3582 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3585 print_vma (segment
->p_filesz
, FULL_HEX
);
3589 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3590 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3593 print_vma (segment
->p_offset
, FULL_HEX
);
3597 (segment
->p_flags
& PF_R
? 'R' : ' '),
3598 (segment
->p_flags
& PF_W
? 'W' : ' '),
3599 (segment
->p_flags
& PF_X
? 'E' : ' '));
3601 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3602 printf ("%#lx", (unsigned long) segment
->p_align
);
3605 print_vma (segment
->p_align
, PREFIX_HEX
);
3610 print_vma (segment
->p_offset
, FULL_HEX
);
3612 print_vma (segment
->p_vaddr
, FULL_HEX
);
3614 print_vma (segment
->p_paddr
, FULL_HEX
);
3616 print_vma (segment
->p_filesz
, FULL_HEX
);
3618 print_vma (segment
->p_memsz
, FULL_HEX
);
3620 (segment
->p_flags
& PF_R
? 'R' : ' '),
3621 (segment
->p_flags
& PF_W
? 'W' : ' '),
3622 (segment
->p_flags
& PF_X
? 'E' : ' '));
3623 print_vma (segment
->p_align
, HEX
);
3627 switch (segment
->p_type
)
3631 error (_("more than one dynamic segment\n"));
3633 /* By default, assume that the .dynamic section is the first
3634 section in the DYNAMIC segment. */
3635 dynamic_addr
= segment
->p_offset
;
3636 dynamic_size
= segment
->p_filesz
;
3638 /* Try to locate the .dynamic section. If there is
3639 a section header table, we can easily locate it. */
3640 if (section_headers
!= NULL
)
3642 Elf_Internal_Shdr
* sec
;
3644 sec
= find_section (".dynamic");
3645 if (sec
== NULL
|| sec
->sh_size
== 0)
3647 error (_("no .dynamic section in the dynamic segment\n"));
3651 if (sec
->sh_type
== SHT_NOBITS
)
3657 dynamic_addr
= sec
->sh_offset
;
3658 dynamic_size
= sec
->sh_size
;
3660 if (dynamic_addr
< segment
->p_offset
3661 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3662 warn (_("the .dynamic section is not contained"
3663 " within the dynamic segment\n"));
3664 else if (dynamic_addr
> segment
->p_offset
)
3665 warn (_("the .dynamic section is not the first section"
3666 " in the dynamic segment.\n"));
3671 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3673 error (_("Unable to find program interpreter name\n"));
3677 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3679 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3680 error (_("Internal error: failed to create format string to display program interpreter\n"));
3682 program_interpreter
[0] = 0;
3683 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3684 error (_("Unable to read program interpreter name\n"));
3687 printf (_("\n [Requesting program interpreter: %s]"),
3688 program_interpreter
);
3694 putc ('\n', stdout
);
3697 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3699 printf (_("\n Section to Segment mapping:\n"));
3700 printf (_(" Segment Sections...\n"));
3702 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3705 Elf_Internal_Shdr
* section
;
3707 segment
= program_headers
+ i
;
3708 section
= section_headers
+ 1;
3710 printf (" %2.2d ", i
);
3712 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3714 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3715 printf ("%s ", SECTION_NAME (section
));
3726 /* Find the file offset corresponding to VMA by using the program headers. */
3729 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3731 Elf_Internal_Phdr
* seg
;
3733 if (! get_program_headers (file
))
3735 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3739 for (seg
= program_headers
;
3740 seg
< program_headers
+ elf_header
.e_phnum
;
3743 if (seg
->p_type
!= PT_LOAD
)
3746 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3747 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3748 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3751 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3752 (unsigned long) vma
);
3758 get_32bit_section_headers (FILE * file
, unsigned int num
)
3760 Elf32_External_Shdr
* shdrs
;
3761 Elf_Internal_Shdr
* internal
;
3764 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3765 elf_header
.e_shentsize
, num
,
3766 _("section headers"));
3770 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3771 sizeof (Elf_Internal_Shdr
));
3773 if (section_headers
== NULL
)
3775 error (_("Out of memory\n"));
3779 for (i
= 0, internal
= section_headers
;
3783 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3784 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3785 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3786 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3787 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3788 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3789 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3790 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3791 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3792 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3801 get_64bit_section_headers (FILE * file
, unsigned int num
)
3803 Elf64_External_Shdr
* shdrs
;
3804 Elf_Internal_Shdr
* internal
;
3807 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3808 elf_header
.e_shentsize
, num
,
3809 _("section headers"));
3813 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3814 sizeof (Elf_Internal_Shdr
));
3816 if (section_headers
== NULL
)
3818 error (_("Out of memory\n"));
3822 for (i
= 0, internal
= section_headers
;
3826 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3827 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3828 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3829 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3830 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3831 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3832 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3833 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3834 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3835 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3843 static Elf_Internal_Sym
*
3844 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3846 unsigned long number
;
3847 Elf32_External_Sym
* esyms
;
3848 Elf_External_Sym_Shndx
* shndx
;
3849 Elf_Internal_Sym
* isyms
;
3850 Elf_Internal_Sym
* psym
;
3853 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3854 section
->sh_size
, _("symbols"));
3859 if (symtab_shndx_hdr
!= NULL
3860 && (symtab_shndx_hdr
->sh_link
3861 == (unsigned long) (section
- section_headers
)))
3863 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3864 symtab_shndx_hdr
->sh_offset
,
3865 1, symtab_shndx_hdr
->sh_size
,
3874 number
= section
->sh_size
/ section
->sh_entsize
;
3875 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3879 error (_("Out of memory\n"));
3886 for (j
= 0, psym
= isyms
;
3890 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3891 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3892 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3893 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3894 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3896 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3897 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3898 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3899 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3900 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3910 static Elf_Internal_Sym
*
3911 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3913 unsigned long number
;
3914 Elf64_External_Sym
* esyms
;
3915 Elf_External_Sym_Shndx
* shndx
;
3916 Elf_Internal_Sym
* isyms
;
3917 Elf_Internal_Sym
* psym
;
3920 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3921 section
->sh_size
, _("symbols"));
3926 if (symtab_shndx_hdr
!= NULL
3927 && (symtab_shndx_hdr
->sh_link
3928 == (unsigned long) (section
- section_headers
)))
3930 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3931 symtab_shndx_hdr
->sh_offset
,
3932 1, symtab_shndx_hdr
->sh_size
,
3941 number
= section
->sh_size
/ section
->sh_entsize
;
3942 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3946 error (_("Out of memory\n"));
3953 for (j
= 0, psym
= isyms
;
3957 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3958 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3959 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3960 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3961 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3963 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3964 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3965 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3966 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3967 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3978 get_elf_section_flags (bfd_vma sh_flags
)
3980 static char buff
[1024];
3982 int field_size
= is_32bit_elf
? 8 : 16;
3984 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
3985 bfd_vma os_flags
= 0;
3986 bfd_vma proc_flags
= 0;
3987 bfd_vma unknown_flags
= 0;
3995 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3996 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3997 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3998 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3999 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4000 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4001 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4002 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4003 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4004 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4005 /* IA-64 specific. */
4006 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4007 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4008 /* IA-64 OpenVMS specific. */
4009 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4010 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4011 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4012 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4013 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4014 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4015 /* SPARC specific. */
4016 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4017 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4020 if (do_section_details
)
4022 sprintf (buff
, "[%*.*lx]: ",
4023 field_size
, field_size
, (unsigned long) sh_flags
);
4024 p
+= field_size
+ 4;
4031 flag
= sh_flags
& - sh_flags
;
4034 if (do_section_details
)
4038 case SHF_WRITE
: sindex
= 0; break;
4039 case SHF_ALLOC
: sindex
= 1; break;
4040 case SHF_EXECINSTR
: sindex
= 2; break;
4041 case SHF_MERGE
: sindex
= 3; break;
4042 case SHF_STRINGS
: sindex
= 4; break;
4043 case SHF_INFO_LINK
: sindex
= 5; break;
4044 case SHF_LINK_ORDER
: sindex
= 6; break;
4045 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4046 case SHF_GROUP
: sindex
= 8; break;
4047 case SHF_TLS
: sindex
= 9; break;
4051 switch (elf_header
.e_machine
)
4054 if (flag
== SHF_IA_64_SHORT
)
4056 else if (flag
== SHF_IA_64_NORECOV
)
4059 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4062 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4063 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4064 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4065 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4066 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4067 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4076 case EM_OLD_SPARCV9
:
4077 case EM_SPARC32PLUS
:
4080 if (flag
== SHF_EXCLUDE
)
4082 else if (flag
== SHF_ORDERED
)
4092 if (p
!= buff
+ field_size
+ 4)
4094 if (size
< (10 + 2))
4101 size
-= flags
[sindex
].len
;
4102 p
= stpcpy (p
, flags
[sindex
].str
);
4104 else if (flag
& SHF_MASKOS
)
4106 else if (flag
& SHF_MASKPROC
)
4109 unknown_flags
|= flag
;
4115 case SHF_WRITE
: *p
= 'W'; break;
4116 case SHF_ALLOC
: *p
= 'A'; break;
4117 case SHF_EXECINSTR
: *p
= 'X'; break;
4118 case SHF_MERGE
: *p
= 'M'; break;
4119 case SHF_STRINGS
: *p
= 'S'; break;
4120 case SHF_INFO_LINK
: *p
= 'I'; break;
4121 case SHF_LINK_ORDER
: *p
= 'L'; break;
4122 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4123 case SHF_GROUP
: *p
= 'G'; break;
4124 case SHF_TLS
: *p
= 'T'; break;
4127 if ((elf_header
.e_machine
== EM_X86_64
4128 || elf_header
.e_machine
== EM_L1OM
)
4129 && flag
== SHF_X86_64_LARGE
)
4131 else if (flag
& SHF_MASKOS
)
4134 sh_flags
&= ~ SHF_MASKOS
;
4136 else if (flag
& SHF_MASKPROC
)
4139 sh_flags
&= ~ SHF_MASKPROC
;
4149 if (do_section_details
)
4153 size
-= 5 + field_size
;
4154 if (p
!= buff
+ field_size
+ 4)
4162 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4163 (unsigned long) os_flags
);
4164 p
+= 5 + field_size
;
4168 size
-= 7 + field_size
;
4169 if (p
!= buff
+ field_size
+ 4)
4177 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4178 (unsigned long) proc_flags
);
4179 p
+= 7 + field_size
;
4183 size
-= 10 + field_size
;
4184 if (p
!= buff
+ field_size
+ 4)
4192 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4193 (unsigned long) unknown_flags
);
4194 p
+= 10 + field_size
;
4203 process_section_headers (FILE * file
)
4205 Elf_Internal_Shdr
* section
;
4208 section_headers
= NULL
;
4210 if (elf_header
.e_shnum
== 0)
4213 printf (_("\nThere are no sections in this file.\n"));
4218 if (do_sections
&& !do_header
)
4219 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4220 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4224 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4227 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4230 /* Read in the string table, so that we have names to display. */
4231 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4232 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4234 section
= section_headers
+ elf_header
.e_shstrndx
;
4236 if (section
->sh_size
!= 0)
4238 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4239 1, section
->sh_size
,
4242 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4246 /* Scan the sections for the dynamic symbol table
4247 and dynamic string table and debug sections. */
4248 dynamic_symbols
= NULL
;
4249 dynamic_strings
= NULL
;
4250 dynamic_syminfo
= NULL
;
4251 symtab_shndx_hdr
= NULL
;
4253 eh_addr_size
= is_32bit_elf
? 4 : 8;
4254 switch (elf_header
.e_machine
)
4257 case EM_MIPS_RS3_LE
:
4258 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4259 FDE addresses. However, the ABI also has a semi-official ILP32
4260 variant for which the normal FDE address size rules apply.
4262 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4263 section, where XX is the size of longs in bits. Unfortunately,
4264 earlier compilers provided no way of distinguishing ILP32 objects
4265 from LP64 objects, so if there's any doubt, we should assume that
4266 the official LP64 form is being used. */
4267 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4268 && find_section (".gcc_compiled_long32") == NULL
)
4274 switch (elf_header
.e_flags
& EF_H8_MACH
)
4276 case E_H8_MACH_H8300
:
4277 case E_H8_MACH_H8300HN
:
4278 case E_H8_MACH_H8300SN
:
4279 case E_H8_MACH_H8300SXN
:
4282 case E_H8_MACH_H8300H
:
4283 case E_H8_MACH_H8300S
:
4284 case E_H8_MACH_H8300SX
:
4292 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4294 case EF_M32C_CPU_M16C
:
4301 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4304 size_t expected_entsize \
4305 = is_32bit_elf ? size32 : size64; \
4306 if (section->sh_entsize != expected_entsize) \
4307 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4308 i, (unsigned long int) section->sh_entsize, \
4309 (unsigned long int) expected_entsize); \
4310 section->sh_entsize = expected_entsize; \
4313 #define CHECK_ENTSIZE(section, i, type) \
4314 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4315 sizeof (Elf64_External_##type))
4317 for (i
= 0, section
= section_headers
;
4318 i
< elf_header
.e_shnum
;
4321 char * name
= SECTION_NAME (section
);
4323 if (section
->sh_type
== SHT_DYNSYM
)
4325 if (dynamic_symbols
!= NULL
)
4327 error (_("File contains multiple dynamic symbol tables\n"));
4331 CHECK_ENTSIZE (section
, i
, Sym
);
4332 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4333 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4335 else if (section
->sh_type
== SHT_STRTAB
4336 && streq (name
, ".dynstr"))
4338 if (dynamic_strings
!= NULL
)
4340 error (_("File contains multiple dynamic string tables\n"));
4344 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4345 1, section
->sh_size
,
4346 _("dynamic strings"));
4347 dynamic_strings_length
= section
->sh_size
;
4349 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4351 if (symtab_shndx_hdr
!= NULL
)
4353 error (_("File contains multiple symtab shndx tables\n"));
4356 symtab_shndx_hdr
= section
;
4358 else if (section
->sh_type
== SHT_SYMTAB
)
4359 CHECK_ENTSIZE (section
, i
, Sym
);
4360 else if (section
->sh_type
== SHT_GROUP
)
4361 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4362 else if (section
->sh_type
== SHT_REL
)
4363 CHECK_ENTSIZE (section
, i
, Rel
);
4364 else if (section
->sh_type
== SHT_RELA
)
4365 CHECK_ENTSIZE (section
, i
, Rela
);
4366 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4367 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4368 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4369 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4370 && (const_strneq (name
, ".debug_")
4371 || const_strneq (name
, ".zdebug_")))
4374 name
+= sizeof (".zdebug_") - 1;
4376 name
+= sizeof (".debug_") - 1;
4379 || (do_debug_info
&& streq (name
, "info"))
4380 || (do_debug_info
&& streq (name
, "types"))
4381 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4382 || (do_debug_lines
&& streq (name
, "line"))
4383 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4384 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4385 || (do_debug_aranges
&& streq (name
, "aranges"))
4386 || (do_debug_ranges
&& streq (name
, "ranges"))
4387 || (do_debug_frames
&& streq (name
, "frame"))
4388 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4389 || (do_debug_str
&& streq (name
, "str"))
4390 || (do_debug_loc
&& streq (name
, "loc"))
4392 request_dump_bynumber (i
, DEBUG_DUMP
);
4394 /* Linkonce section to be combined with .debug_info at link time. */
4395 else if ((do_debugging
|| do_debug_info
)
4396 && const_strneq (name
, ".gnu.linkonce.wi."))
4397 request_dump_bynumber (i
, DEBUG_DUMP
);
4398 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4399 request_dump_bynumber (i
, DEBUG_DUMP
);
4405 if (elf_header
.e_shnum
> 1)
4406 printf (_("\nSection Headers:\n"));
4408 printf (_("\nSection Header:\n"));
4412 if (do_section_details
)
4414 printf (_(" [Nr] Name\n"));
4415 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4419 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4423 if (do_section_details
)
4425 printf (_(" [Nr] Name\n"));
4426 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4430 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4434 if (do_section_details
)
4436 printf (_(" [Nr] Name\n"));
4437 printf (_(" Type Address Offset Link\n"));
4438 printf (_(" Size EntSize Info Align\n"));
4442 printf (_(" [Nr] Name Type Address Offset\n"));
4443 printf (_(" Size EntSize Flags Link Info Align\n"));
4447 if (do_section_details
)
4448 printf (_(" Flags\n"));
4450 for (i
= 0, section
= section_headers
;
4451 i
< elf_header
.e_shnum
;
4454 if (do_section_details
)
4456 printf (" [%2u] %s\n",
4458 SECTION_NAME (section
));
4459 if (is_32bit_elf
|| do_wide
)
4460 printf (" %-15.15s ",
4461 get_section_type_name (section
->sh_type
));
4464 printf ((do_wide
? " [%2u] %-17s %-15s "
4465 : " [%2u] %-17.17s %-15.15s "),
4467 SECTION_NAME (section
),
4468 get_section_type_name (section
->sh_type
));
4472 const char * link_too_big
= NULL
;
4474 print_vma (section
->sh_addr
, LONG_HEX
);
4476 printf ( " %6.6lx %6.6lx %2.2lx",
4477 (unsigned long) section
->sh_offset
,
4478 (unsigned long) section
->sh_size
,
4479 (unsigned long) section
->sh_entsize
);
4481 if (do_section_details
)
4482 fputs (" ", stdout
);
4484 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4486 if (section
->sh_link
>= elf_header
.e_shnum
)
4489 /* The sh_link value is out of range. Normally this indicates
4490 an error but it can have special values in Solaris binaries. */
4491 switch (elf_header
.e_machine
)
4496 case EM_OLD_SPARCV9
:
4497 case EM_SPARC32PLUS
:
4500 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4501 link_too_big
= "BEFORE";
4502 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4503 link_too_big
= "AFTER";
4510 if (do_section_details
)
4512 if (link_too_big
!= NULL
&& * link_too_big
)
4513 printf ("<%s> ", link_too_big
);
4515 printf ("%2u ", section
->sh_link
);
4516 printf ("%3u %2lu\n", section
->sh_info
,
4517 (unsigned long) section
->sh_addralign
);
4520 printf ("%2u %3u %2lu\n",
4523 (unsigned long) section
->sh_addralign
);
4525 if (link_too_big
&& ! * link_too_big
)
4526 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4527 i
, section
->sh_link
);
4531 print_vma (section
->sh_addr
, LONG_HEX
);
4533 if ((long) section
->sh_offset
== section
->sh_offset
)
4534 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4538 print_vma (section
->sh_offset
, LONG_HEX
);
4541 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4542 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4546 print_vma (section
->sh_size
, LONG_HEX
);
4549 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4550 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4554 print_vma (section
->sh_entsize
, LONG_HEX
);
4557 if (do_section_details
)
4558 fputs (" ", stdout
);
4560 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4562 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4564 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4565 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4568 print_vma (section
->sh_addralign
, DEC
);
4572 else if (do_section_details
)
4574 printf (" %-15.15s ",
4575 get_section_type_name (section
->sh_type
));
4576 print_vma (section
->sh_addr
, LONG_HEX
);
4577 if ((long) section
->sh_offset
== section
->sh_offset
)
4578 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4582 print_vma (section
->sh_offset
, LONG_HEX
);
4584 printf (" %u\n ", section
->sh_link
);
4585 print_vma (section
->sh_size
, LONG_HEX
);
4587 print_vma (section
->sh_entsize
, LONG_HEX
);
4589 printf (" %-16u %lu\n",
4591 (unsigned long) section
->sh_addralign
);
4596 print_vma (section
->sh_addr
, LONG_HEX
);
4597 if ((long) section
->sh_offset
== section
->sh_offset
)
4598 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4602 print_vma (section
->sh_offset
, LONG_HEX
);
4605 print_vma (section
->sh_size
, LONG_HEX
);
4607 print_vma (section
->sh_entsize
, LONG_HEX
);
4609 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4611 printf (" %2u %3u %lu\n",
4614 (unsigned long) section
->sh_addralign
);
4617 if (do_section_details
)
4618 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4621 if (!do_section_details
)
4622 printf (_("Key to Flags:\n\
4623 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4624 I (info), L (link order), G (group), x (unknown)\n\
4625 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4631 get_group_flags (unsigned int flags
)
4633 static char buff
[32];
4640 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4647 process_section_groups (FILE * file
)
4649 Elf_Internal_Shdr
* section
;
4651 struct group
* group
;
4652 Elf_Internal_Shdr
* symtab_sec
;
4653 Elf_Internal_Shdr
* strtab_sec
;
4654 Elf_Internal_Sym
* symtab
;
4658 /* Don't process section groups unless needed. */
4659 if (!do_unwind
&& !do_section_groups
)
4662 if (elf_header
.e_shnum
== 0)
4664 if (do_section_groups
)
4665 printf (_("\nThere are no sections in this file.\n"));
4670 if (section_headers
== NULL
)
4672 error (_("Section headers are not available!\n"));
4676 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4677 sizeof (struct group
*));
4679 if (section_headers_groups
== NULL
)
4681 error (_("Out of memory\n"));
4685 /* Scan the sections for the group section. */
4687 for (i
= 0, section
= section_headers
;
4688 i
< elf_header
.e_shnum
;
4690 if (section
->sh_type
== SHT_GROUP
)
4693 if (group_count
== 0)
4695 if (do_section_groups
)
4696 printf (_("\nThere are no section groups in this file.\n"));
4701 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4703 if (section_groups
== NULL
)
4705 error (_("Out of memory\n"));
4714 for (i
= 0, section
= section_headers
, group
= section_groups
;
4715 i
< elf_header
.e_shnum
;
4718 if (section
->sh_type
== SHT_GROUP
)
4720 char * name
= SECTION_NAME (section
);
4722 unsigned char * start
;
4723 unsigned char * indices
;
4724 unsigned int entry
, j
, size
;
4725 Elf_Internal_Shdr
* sec
;
4726 Elf_Internal_Sym
* sym
;
4728 /* Get the symbol table. */
4729 if (section
->sh_link
>= elf_header
.e_shnum
4730 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4733 error (_("Bad sh_link in group section `%s'\n"), name
);
4737 if (symtab_sec
!= sec
)
4742 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4745 sym
= symtab
+ section
->sh_info
;
4747 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4749 if (sym
->st_shndx
== 0
4750 || sym
->st_shndx
>= elf_header
.e_shnum
)
4752 error (_("Bad sh_info in group section `%s'\n"), name
);
4756 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4765 /* Get the string table. */
4766 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4775 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4780 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4781 1, strtab_sec
->sh_size
,
4783 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4785 group_name
= sym
->st_name
< strtab_size
4786 ? strtab
+ sym
->st_name
: "<corrupt>";
4789 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4790 1, section
->sh_size
,
4794 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4795 entry
= byte_get (indices
, 4);
4798 if (do_section_groups
)
4800 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4801 get_group_flags (entry
), i
, name
, group_name
, size
);
4803 printf (_(" [Index] Name\n"));
4806 group
->group_index
= i
;
4808 for (j
= 0; j
< size
; j
++)
4810 struct group_list
* g
;
4812 entry
= byte_get (indices
, 4);
4815 if (entry
>= elf_header
.e_shnum
)
4817 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4818 entry
, i
, elf_header
.e_shnum
- 1);
4822 if (section_headers_groups
[entry
] != NULL
)
4826 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4828 section_headers_groups
[entry
]->group_index
);
4833 /* Intel C/C++ compiler may put section 0 in a
4834 section group. We just warn it the first time
4835 and ignore it afterwards. */
4836 static int warned
= 0;
4839 error (_("section 0 in group section [%5u]\n"),
4840 section_headers_groups
[entry
]->group_index
);
4846 section_headers_groups
[entry
] = group
;
4848 if (do_section_groups
)
4850 sec
= section_headers
+ entry
;
4851 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4854 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
4855 g
->section_index
= entry
;
4856 g
->next
= group
->root
;
4880 } dynamic_relocations
[] =
4882 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4883 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4884 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4887 /* Process the reloc section. */
4890 process_relocs (FILE * file
)
4892 unsigned long rel_size
;
4893 unsigned long rel_offset
;
4899 if (do_using_dynamic
)
4903 int has_dynamic_reloc
;
4906 has_dynamic_reloc
= 0;
4908 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4910 is_rela
= dynamic_relocations
[i
].rela
;
4911 name
= dynamic_relocations
[i
].name
;
4912 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4913 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4915 has_dynamic_reloc
|= rel_size
;
4917 if (is_rela
== UNKNOWN
)
4919 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4920 switch (dynamic_info
[DT_PLTREL
])
4934 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4935 name
, rel_offset
, rel_size
);
4937 dump_relocations (file
,
4938 offset_from_vma (file
, rel_offset
, rel_size
),
4940 dynamic_symbols
, num_dynamic_syms
,
4941 dynamic_strings
, dynamic_strings_length
, is_rela
);
4945 if (! has_dynamic_reloc
)
4946 printf (_("\nThere are no dynamic relocations in this file.\n"));
4950 Elf_Internal_Shdr
* section
;
4954 for (i
= 0, section
= section_headers
;
4955 i
< elf_header
.e_shnum
;
4958 if ( section
->sh_type
!= SHT_RELA
4959 && section
->sh_type
!= SHT_REL
)
4962 rel_offset
= section
->sh_offset
;
4963 rel_size
= section
->sh_size
;
4967 Elf_Internal_Shdr
* strsec
;
4970 printf (_("\nRelocation section "));
4972 if (string_table
== NULL
)
4973 printf ("%d", section
->sh_name
);
4975 printf (_("'%s'"), SECTION_NAME (section
));
4977 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4978 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4980 is_rela
= section
->sh_type
== SHT_RELA
;
4982 if (section
->sh_link
!= 0
4983 && section
->sh_link
< elf_header
.e_shnum
)
4985 Elf_Internal_Shdr
* symsec
;
4986 Elf_Internal_Sym
* symtab
;
4987 unsigned long nsyms
;
4988 unsigned long strtablen
= 0;
4989 char * strtab
= NULL
;
4991 symsec
= section_headers
+ section
->sh_link
;
4992 if (symsec
->sh_type
!= SHT_SYMTAB
4993 && symsec
->sh_type
!= SHT_DYNSYM
)
4996 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4997 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5002 if (symsec
->sh_link
!= 0
5003 && symsec
->sh_link
< elf_header
.e_shnum
)
5005 strsec
= section_headers
+ symsec
->sh_link
;
5007 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5010 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5013 dump_relocations (file
, rel_offset
, rel_size
,
5014 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5020 dump_relocations (file
, rel_offset
, rel_size
,
5021 NULL
, 0, NULL
, 0, is_rela
);
5028 printf (_("\nThere are no relocations in this file.\n"));
5034 /* Process the unwind section. */
5036 #include "unwind-ia64.h"
5038 /* An absolute address consists of a section and an offset. If the
5039 section is NULL, the offset itself is the address, otherwise, the
5040 address equals to LOAD_ADDRESS(section) + offset. */
5044 unsigned short section
;
5048 #define ABSADDR(a) \
5050 ? section_headers [(a).section].sh_addr + (a).offset \
5053 struct ia64_unw_table_entry
5055 struct absaddr start
;
5057 struct absaddr info
;
5060 struct ia64_unw_aux_info
5063 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5064 unsigned long table_len
; /* Length of unwind table. */
5065 unsigned char * info
; /* Unwind info. */
5066 unsigned long info_size
; /* Size of unwind info. */
5067 bfd_vma info_addr
; /* starting address of unwind info. */
5068 bfd_vma seg_base
; /* Starting address of segment. */
5069 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5070 unsigned long nsyms
; /* Number of symbols. */
5071 char * strtab
; /* The string table. */
5072 unsigned long strtab_size
; /* Size of string table. */
5076 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5077 unsigned long nsyms
,
5078 const char * strtab
,
5079 unsigned long strtab_size
,
5080 struct absaddr addr
,
5081 const char ** symname
,
5084 bfd_vma dist
= 0x100000;
5085 Elf_Internal_Sym
* sym
;
5086 Elf_Internal_Sym
* best
= NULL
;
5089 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5091 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5092 && sym
->st_name
!= 0
5093 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5094 && addr
.offset
>= sym
->st_value
5095 && addr
.offset
- sym
->st_value
< dist
)
5098 dist
= addr
.offset
- sym
->st_value
;
5105 *symname
= (best
->st_name
>= strtab_size
5106 ? "<corrupt>" : strtab
+ best
->st_name
);
5111 *offset
= addr
.offset
;
5115 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5117 struct ia64_unw_table_entry
* tp
;
5120 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5124 const unsigned char * dp
;
5125 const unsigned char * head
;
5126 const char * procname
;
5128 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5129 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5131 fputs ("\n<", stdout
);
5135 fputs (procname
, stdout
);
5138 printf ("+%lx", (unsigned long) offset
);
5141 fputs (">: [", stdout
);
5142 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5143 fputc ('-', stdout
);
5144 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5145 printf ("], info at +0x%lx\n",
5146 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5148 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5149 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5151 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5152 (unsigned) UNW_VER (stamp
),
5153 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5154 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5155 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5156 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5158 if (UNW_VER (stamp
) != 1)
5160 printf ("\tUnknown version.\n");
5165 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5166 dp
= unw_decode (dp
, in_body
, & in_body
);
5171 slurp_ia64_unwind_table (FILE * file
,
5172 struct ia64_unw_aux_info
* aux
,
5173 Elf_Internal_Shdr
* sec
)
5175 unsigned long size
, nrelas
, i
;
5176 Elf_Internal_Phdr
* seg
;
5177 struct ia64_unw_table_entry
* tep
;
5178 Elf_Internal_Shdr
* relsec
;
5179 Elf_Internal_Rela
* rela
;
5180 Elf_Internal_Rela
* rp
;
5181 unsigned char * table
;
5183 Elf_Internal_Sym
* sym
;
5184 const char * relname
;
5186 /* First, find the starting address of the segment that includes
5189 if (elf_header
.e_phnum
)
5191 if (! get_program_headers (file
))
5194 for (seg
= program_headers
;
5195 seg
< program_headers
+ elf_header
.e_phnum
;
5198 if (seg
->p_type
!= PT_LOAD
)
5201 if (sec
->sh_addr
>= seg
->p_vaddr
5202 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5204 aux
->seg_base
= seg
->p_vaddr
;
5210 /* Second, build the unwind table from the contents of the unwind section: */
5211 size
= sec
->sh_size
;
5212 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5217 aux
->table
= (struct ia64_unw_table_entry
*)
5218 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5220 for (tp
= table
; tp
< table
+ size
; ++tep
)
5222 tep
->start
.section
= SHN_UNDEF
;
5223 tep
->end
.section
= SHN_UNDEF
;
5224 tep
->info
.section
= SHN_UNDEF
;
5225 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5226 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5227 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5228 tep
->start
.offset
+= aux
->seg_base
;
5229 tep
->end
.offset
+= aux
->seg_base
;
5230 tep
->info
.offset
+= aux
->seg_base
;
5234 /* Third, apply any relocations to the unwind table: */
5235 for (relsec
= section_headers
;
5236 relsec
< section_headers
+ elf_header
.e_shnum
;
5239 if (relsec
->sh_type
!= SHT_RELA
5240 || relsec
->sh_info
>= elf_header
.e_shnum
5241 || section_headers
+ relsec
->sh_info
!= sec
)
5244 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5248 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5250 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5251 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5253 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5255 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5259 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5261 switch (rp
->r_offset
/eh_addr_size
% 3)
5264 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5265 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5268 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5269 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5272 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5273 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5283 aux
->table_len
= size
/ (3 * eh_addr_size
);
5288 ia64_process_unwind (FILE * file
)
5290 Elf_Internal_Shdr
* sec
;
5291 Elf_Internal_Shdr
* unwsec
= NULL
;
5292 Elf_Internal_Shdr
* strsec
;
5293 unsigned long i
, unwcount
= 0, unwstart
= 0;
5294 struct ia64_unw_aux_info aux
;
5296 memset (& aux
, 0, sizeof (aux
));
5298 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5300 if (sec
->sh_type
== SHT_SYMTAB
5301 && sec
->sh_link
< elf_header
.e_shnum
)
5303 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5304 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5306 strsec
= section_headers
+ sec
->sh_link
;
5307 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5310 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5312 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5317 printf (_("\nThere are no unwind sections in this file.\n"));
5319 while (unwcount
-- > 0)
5324 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5325 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5326 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5333 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5335 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5337 /* We need to find which section group it is in. */
5338 struct group_list
* g
= section_headers_groups
[i
]->root
;
5340 for (; g
!= NULL
; g
= g
->next
)
5342 sec
= section_headers
+ g
->section_index
;
5344 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5349 i
= elf_header
.e_shnum
;
5351 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5353 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5354 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5355 suffix
= SECTION_NAME (unwsec
) + len
;
5356 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5358 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5359 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5364 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5365 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5366 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5367 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5369 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5370 suffix
= SECTION_NAME (unwsec
) + len
;
5371 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5373 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5374 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5378 if (i
== elf_header
.e_shnum
)
5380 printf (_("\nCould not find unwind info section for "));
5382 if (string_table
== NULL
)
5383 printf ("%d", unwsec
->sh_name
);
5385 printf (_("'%s'"), SECTION_NAME (unwsec
));
5389 aux
.info_size
= sec
->sh_size
;
5390 aux
.info_addr
= sec
->sh_addr
;
5391 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5395 printf (_("\nUnwind section "));
5397 if (string_table
== NULL
)
5398 printf ("%d", unwsec
->sh_name
);
5400 printf (_("'%s'"), SECTION_NAME (unwsec
));
5402 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5403 (unsigned long) unwsec
->sh_offset
,
5404 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5406 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5408 if (aux
.table_len
> 0)
5409 dump_ia64_unwind (& aux
);
5412 free ((char *) aux
.table
);
5414 free ((char *) aux
.info
);
5423 free ((char *) aux
.strtab
);
5428 struct hppa_unw_table_entry
5430 struct absaddr start
;
5432 unsigned int Cannot_unwind
:1; /* 0 */
5433 unsigned int Millicode
:1; /* 1 */
5434 unsigned int Millicode_save_sr0
:1; /* 2 */
5435 unsigned int Region_description
:2; /* 3..4 */
5436 unsigned int reserved1
:1; /* 5 */
5437 unsigned int Entry_SR
:1; /* 6 */
5438 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5439 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5440 unsigned int Args_stored
:1; /* 16 */
5441 unsigned int Variable_Frame
:1; /* 17 */
5442 unsigned int Separate_Package_Body
:1; /* 18 */
5443 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5444 unsigned int Stack_Overflow_Check
:1; /* 20 */
5445 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5446 unsigned int Ada_Region
:1; /* 22 */
5447 unsigned int cxx_info
:1; /* 23 */
5448 unsigned int cxx_try_catch
:1; /* 24 */
5449 unsigned int sched_entry_seq
:1; /* 25 */
5450 unsigned int reserved2
:1; /* 26 */
5451 unsigned int Save_SP
:1; /* 27 */
5452 unsigned int Save_RP
:1; /* 28 */
5453 unsigned int Save_MRP_in_frame
:1; /* 29 */
5454 unsigned int extn_ptr_defined
:1; /* 30 */
5455 unsigned int Cleanup_defined
:1; /* 31 */
5457 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5458 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5459 unsigned int Large_frame
:1; /* 2 */
5460 unsigned int Pseudo_SP_Set
:1; /* 3 */
5461 unsigned int reserved4
:1; /* 4 */
5462 unsigned int Total_frame_size
:27; /* 5..31 */
5465 struct hppa_unw_aux_info
5467 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5468 unsigned long table_len
; /* Length of unwind table. */
5469 bfd_vma seg_base
; /* Starting address of segment. */
5470 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5471 unsigned long nsyms
; /* Number of symbols. */
5472 char * strtab
; /* The string table. */
5473 unsigned long strtab_size
; /* Size of string table. */
5477 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5479 struct hppa_unw_table_entry
* tp
;
5481 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5484 const char * procname
;
5486 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5487 aux
->strtab_size
, tp
->start
, &procname
,
5490 fputs ("\n<", stdout
);
5494 fputs (procname
, stdout
);
5497 printf ("+%lx", (unsigned long) offset
);
5500 fputs (">: [", stdout
);
5501 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5502 fputc ('-', stdout
);
5503 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5506 #define PF(_m) if (tp->_m) printf (#_m " ");
5507 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5510 PF(Millicode_save_sr0
);
5511 /* PV(Region_description); */
5517 PF(Separate_Package_Body
);
5518 PF(Frame_Extension_Millicode
);
5519 PF(Stack_Overflow_Check
);
5520 PF(Two_Instruction_SP_Increment
);
5524 PF(sched_entry_seq
);
5527 PF(Save_MRP_in_frame
);
5528 PF(extn_ptr_defined
);
5529 PF(Cleanup_defined
);
5530 PF(MPE_XL_interrupt_marker
);
5531 PF(HP_UX_interrupt_marker
);
5534 PV(Total_frame_size
);
5543 slurp_hppa_unwind_table (FILE * file
,
5544 struct hppa_unw_aux_info
* aux
,
5545 Elf_Internal_Shdr
* sec
)
5547 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5548 Elf_Internal_Phdr
* seg
;
5549 struct hppa_unw_table_entry
* tep
;
5550 Elf_Internal_Shdr
* relsec
;
5551 Elf_Internal_Rela
* rela
;
5552 Elf_Internal_Rela
* rp
;
5553 unsigned char * table
;
5555 Elf_Internal_Sym
* sym
;
5556 const char * relname
;
5558 /* First, find the starting address of the segment that includes
5561 if (elf_header
.e_phnum
)
5563 if (! get_program_headers (file
))
5566 for (seg
= program_headers
;
5567 seg
< program_headers
+ elf_header
.e_phnum
;
5570 if (seg
->p_type
!= PT_LOAD
)
5573 if (sec
->sh_addr
>= seg
->p_vaddr
5574 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5576 aux
->seg_base
= seg
->p_vaddr
;
5582 /* Second, build the unwind table from the contents of the unwind
5584 size
= sec
->sh_size
;
5585 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5591 nentries
= size
/ unw_ent_size
;
5592 size
= unw_ent_size
* nentries
;
5594 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5595 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5597 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5599 unsigned int tmp1
, tmp2
;
5601 tep
->start
.section
= SHN_UNDEF
;
5602 tep
->end
.section
= SHN_UNDEF
;
5604 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5605 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5606 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5607 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5609 tep
->start
.offset
+= aux
->seg_base
;
5610 tep
->end
.offset
+= aux
->seg_base
;
5612 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5613 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5614 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5615 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5616 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5617 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5618 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5619 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5620 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5621 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5622 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5623 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5624 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5625 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5626 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5627 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5628 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5629 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5630 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5631 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5632 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5633 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5634 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5635 tep
->Cleanup_defined
= tmp1
& 0x1;
5637 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5638 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5639 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5640 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5641 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5642 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5646 /* Third, apply any relocations to the unwind table. */
5647 for (relsec
= section_headers
;
5648 relsec
< section_headers
+ elf_header
.e_shnum
;
5651 if (relsec
->sh_type
!= SHT_RELA
5652 || relsec
->sh_info
>= elf_header
.e_shnum
5653 || section_headers
+ relsec
->sh_info
!= sec
)
5656 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5660 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5662 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5663 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5665 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5666 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5668 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5672 i
= rp
->r_offset
/ unw_ent_size
;
5674 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5677 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5678 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
5681 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5682 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
5692 aux
->table_len
= nentries
;
5698 hppa_process_unwind (FILE * file
)
5700 struct hppa_unw_aux_info aux
;
5701 Elf_Internal_Shdr
* unwsec
= NULL
;
5702 Elf_Internal_Shdr
* strsec
;
5703 Elf_Internal_Shdr
* sec
;
5706 memset (& aux
, 0, sizeof (aux
));
5708 if (string_table
== NULL
)
5711 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5713 if (sec
->sh_type
== SHT_SYMTAB
5714 && sec
->sh_link
< elf_header
.e_shnum
)
5716 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5717 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5719 strsec
= section_headers
+ sec
->sh_link
;
5720 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5723 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5725 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5730 printf (_("\nThere are no unwind sections in this file.\n"));
5732 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5734 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5736 printf (_("\nUnwind section "));
5737 printf (_("'%s'"), SECTION_NAME (sec
));
5739 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5740 (unsigned long) sec
->sh_offset
,
5741 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5743 slurp_hppa_unwind_table (file
, &aux
, sec
);
5744 if (aux
.table_len
> 0)
5745 dump_hppa_unwind (&aux
);
5748 free ((char *) aux
.table
);
5756 free ((char *) aux
.strtab
);
5762 process_unwind (FILE * file
)
5764 struct unwind_handler
5767 int (* handler
)(FILE *);
5770 { EM_IA_64
, ia64_process_unwind
},
5771 { EM_PARISC
, hppa_process_unwind
},
5779 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5780 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5781 return handlers
[i
].handler (file
);
5783 printf (_("\nThere are no unwind sections in this file.\n"));
5788 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5790 switch (entry
->d_tag
)
5793 if (entry
->d_un
.d_val
== 0)
5797 static const char * opts
[] =
5799 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5800 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5801 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5802 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5807 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5808 if (entry
->d_un
.d_val
& (1 << cnt
))
5810 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5817 case DT_MIPS_IVERSION
:
5818 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5819 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5821 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5824 case DT_MIPS_TIME_STAMP
:
5829 time_t atime
= entry
->d_un
.d_val
;
5830 tmp
= gmtime (&atime
);
5831 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5832 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5833 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5834 printf ("Time Stamp: %s\n", timebuf
);
5838 case DT_MIPS_RLD_VERSION
:
5839 case DT_MIPS_LOCAL_GOTNO
:
5840 case DT_MIPS_CONFLICTNO
:
5841 case DT_MIPS_LIBLISTNO
:
5842 case DT_MIPS_SYMTABNO
:
5843 case DT_MIPS_UNREFEXTNO
:
5844 case DT_MIPS_HIPAGENO
:
5845 case DT_MIPS_DELTA_CLASS_NO
:
5846 case DT_MIPS_DELTA_INSTANCE_NO
:
5847 case DT_MIPS_DELTA_RELOC_NO
:
5848 case DT_MIPS_DELTA_SYM_NO
:
5849 case DT_MIPS_DELTA_CLASSSYM_NO
:
5850 case DT_MIPS_COMPACT_SIZE
:
5851 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5855 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5861 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5863 switch (entry
->d_tag
)
5865 case DT_HP_DLD_FLAGS
:
5874 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5875 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5876 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5877 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5878 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5879 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5880 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5881 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5882 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5883 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5884 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5885 { DT_HP_GST
, "HP_GST" },
5886 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5887 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5888 { DT_HP_NODELETE
, "HP_NODELETE" },
5889 { DT_HP_GROUP
, "HP_GROUP" },
5890 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5894 bfd_vma val
= entry
->d_un
.d_val
;
5896 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5897 if (val
& flags
[cnt
].bit
)
5901 fputs (flags
[cnt
].str
, stdout
);
5903 val
^= flags
[cnt
].bit
;
5906 if (val
!= 0 || first
)
5910 print_vma (val
, HEX
);
5916 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5923 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5925 switch (entry
->d_tag
)
5927 case DT_IA_64_PLT_RESERVE
:
5928 /* First 3 slots reserved. */
5929 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5931 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5935 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5942 get_32bit_dynamic_section (FILE * file
)
5944 Elf32_External_Dyn
* edyn
;
5945 Elf32_External_Dyn
* ext
;
5946 Elf_Internal_Dyn
* entry
;
5948 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5949 dynamic_size
, _("dynamic section"));
5953 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5954 might not have the luxury of section headers. Look for the DT_NULL
5955 terminator to determine the number of entries. */
5956 for (ext
= edyn
, dynamic_nent
= 0;
5957 (char *) ext
< (char *) edyn
+ dynamic_size
;
5961 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5965 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5967 if (dynamic_section
== NULL
)
5969 error (_("Out of memory\n"));
5974 for (ext
= edyn
, entry
= dynamic_section
;
5975 entry
< dynamic_section
+ dynamic_nent
;
5978 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5979 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5988 get_64bit_dynamic_section (FILE * file
)
5990 Elf64_External_Dyn
* edyn
;
5991 Elf64_External_Dyn
* ext
;
5992 Elf_Internal_Dyn
* entry
;
5994 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5995 dynamic_size
, _("dynamic section"));
5999 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6000 might not have the luxury of section headers. Look for the DT_NULL
6001 terminator to determine the number of entries. */
6002 for (ext
= edyn
, dynamic_nent
= 0;
6003 (char *) ext
< (char *) edyn
+ dynamic_size
;
6007 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
6011 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
6013 if (dynamic_section
== NULL
)
6015 error (_("Out of memory\n"));
6020 for (ext
= edyn
, entry
= dynamic_section
;
6021 entry
< dynamic_section
+ dynamic_nent
;
6024 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6025 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6034 print_dynamic_flags (bfd_vma flags
)
6042 flag
= flags
& - flags
;
6052 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6053 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6054 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6055 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6056 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6057 default: fputs ("unknown", stdout
); break;
6063 /* Parse and display the contents of the dynamic section. */
6066 process_dynamic_section (FILE * file
)
6068 Elf_Internal_Dyn
* entry
;
6070 if (dynamic_size
== 0)
6073 printf (_("\nThere is no dynamic section in this file.\n"));
6080 if (! get_32bit_dynamic_section (file
))
6083 else if (! get_64bit_dynamic_section (file
))
6086 /* Find the appropriate symbol table. */
6087 if (dynamic_symbols
== NULL
)
6089 for (entry
= dynamic_section
;
6090 entry
< dynamic_section
+ dynamic_nent
;
6093 Elf_Internal_Shdr section
;
6095 if (entry
->d_tag
!= DT_SYMTAB
)
6098 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6100 /* Since we do not know how big the symbol table is,
6101 we default to reading in the entire file (!) and
6102 processing that. This is overkill, I know, but it
6104 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6106 if (archive_file_offset
!= 0)
6107 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6110 if (fseek (file
, 0, SEEK_END
))
6111 error (_("Unable to seek to end of file!\n"));
6113 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6117 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6119 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6121 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6122 if (num_dynamic_syms
< 1)
6124 error (_("Unable to determine the number of symbols to load\n"));
6128 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6132 /* Similarly find a string table. */
6133 if (dynamic_strings
== NULL
)
6135 for (entry
= dynamic_section
;
6136 entry
< dynamic_section
+ dynamic_nent
;
6139 unsigned long offset
;
6142 if (entry
->d_tag
!= DT_STRTAB
)
6145 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6147 /* Since we do not know how big the string table is,
6148 we default to reading in the entire file (!) and
6149 processing that. This is overkill, I know, but it
6152 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6154 if (archive_file_offset
!= 0)
6155 str_tab_len
= archive_file_size
- offset
;
6158 if (fseek (file
, 0, SEEK_END
))
6159 error (_("Unable to seek to end of file\n"));
6160 str_tab_len
= ftell (file
) - offset
;
6163 if (str_tab_len
< 1)
6166 (_("Unable to determine the length of the dynamic string table\n"));
6170 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6172 _("dynamic string table"));
6173 dynamic_strings_length
= str_tab_len
;
6178 /* And find the syminfo section if available. */
6179 if (dynamic_syminfo
== NULL
)
6181 unsigned long syminsz
= 0;
6183 for (entry
= dynamic_section
;
6184 entry
< dynamic_section
+ dynamic_nent
;
6187 if (entry
->d_tag
== DT_SYMINENT
)
6189 /* Note: these braces are necessary to avoid a syntax
6190 error from the SunOS4 C compiler. */
6191 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6193 else if (entry
->d_tag
== DT_SYMINSZ
)
6194 syminsz
= entry
->d_un
.d_val
;
6195 else if (entry
->d_tag
== DT_SYMINFO
)
6196 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6200 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6202 Elf_External_Syminfo
* extsyminfo
;
6203 Elf_External_Syminfo
* extsym
;
6204 Elf_Internal_Syminfo
* syminfo
;
6206 /* There is a syminfo section. Read the data. */
6207 extsyminfo
= (Elf_External_Syminfo
*)
6208 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6209 _("symbol information"));
6213 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6214 if (dynamic_syminfo
== NULL
)
6216 error (_("Out of memory\n"));
6220 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6221 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6222 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6223 ++syminfo
, ++extsym
)
6225 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6226 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6233 if (do_dynamic
&& dynamic_addr
)
6234 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6235 dynamic_addr
, dynamic_nent
);
6237 printf (_(" Tag Type Name/Value\n"));
6239 for (entry
= dynamic_section
;
6240 entry
< dynamic_section
+ dynamic_nent
;
6248 print_vma (entry
->d_tag
, FULL_HEX
);
6249 dtype
= get_dynamic_type (entry
->d_tag
);
6250 printf (" (%s)%*s", dtype
,
6251 ((is_32bit_elf
? 27 : 19)
6252 - (int) strlen (dtype
)),
6256 switch (entry
->d_tag
)
6260 print_dynamic_flags (entry
->d_un
.d_val
);
6270 switch (entry
->d_tag
)
6273 printf (_("Auxiliary library"));
6277 printf (_("Filter library"));
6281 printf (_("Configuration file"));
6285 printf (_("Dependency audit library"));
6289 printf (_("Audit library"));
6293 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6294 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6298 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6307 printf (_("Flags:"));
6309 if (entry
->d_un
.d_val
== 0)
6310 printf (_(" None\n"));
6313 unsigned long int val
= entry
->d_un
.d_val
;
6315 if (val
& DTF_1_PARINIT
)
6317 printf (" PARINIT");
6318 val
^= DTF_1_PARINIT
;
6320 if (val
& DTF_1_CONFEXP
)
6322 printf (" CONFEXP");
6323 val
^= DTF_1_CONFEXP
;
6326 printf (" %lx", val
);
6335 printf (_("Flags:"));
6337 if (entry
->d_un
.d_val
== 0)
6338 printf (_(" None\n"));
6341 unsigned long int val
= entry
->d_un
.d_val
;
6343 if (val
& DF_P1_LAZYLOAD
)
6345 printf (" LAZYLOAD");
6346 val
^= DF_P1_LAZYLOAD
;
6348 if (val
& DF_P1_GROUPPERM
)
6350 printf (" GROUPPERM");
6351 val
^= DF_P1_GROUPPERM
;
6354 printf (" %lx", val
);
6363 printf (_("Flags:"));
6364 if (entry
->d_un
.d_val
== 0)
6365 printf (_(" None\n"));
6368 unsigned long int val
= entry
->d_un
.d_val
;
6375 if (val
& DF_1_GLOBAL
)
6380 if (val
& DF_1_GROUP
)
6385 if (val
& DF_1_NODELETE
)
6387 printf (" NODELETE");
6388 val
^= DF_1_NODELETE
;
6390 if (val
& DF_1_LOADFLTR
)
6392 printf (" LOADFLTR");
6393 val
^= DF_1_LOADFLTR
;
6395 if (val
& DF_1_INITFIRST
)
6397 printf (" INITFIRST");
6398 val
^= DF_1_INITFIRST
;
6400 if (val
& DF_1_NOOPEN
)
6405 if (val
& DF_1_ORIGIN
)
6410 if (val
& DF_1_DIRECT
)
6415 if (val
& DF_1_TRANS
)
6420 if (val
& DF_1_INTERPOSE
)
6422 printf (" INTERPOSE");
6423 val
^= DF_1_INTERPOSE
;
6425 if (val
& DF_1_NODEFLIB
)
6427 printf (" NODEFLIB");
6428 val
^= DF_1_NODEFLIB
;
6430 if (val
& DF_1_NODUMP
)
6435 if (val
& DF_1_CONLFAT
)
6437 printf (" CONLFAT");
6438 val
^= DF_1_CONLFAT
;
6441 printf (" %lx", val
);
6448 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6450 puts (get_dynamic_type (entry
->d_un
.d_val
));
6470 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6476 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6477 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6483 switch (entry
->d_tag
)
6486 printf (_("Shared library: [%s]"), name
);
6488 if (streq (name
, program_interpreter
))
6489 printf (_(" program interpreter"));
6493 printf (_("Library soname: [%s]"), name
);
6497 printf (_("Library rpath: [%s]"), name
);
6501 printf (_("Library runpath: [%s]"), name
);
6505 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6510 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6523 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6527 case DT_INIT_ARRAYSZ
:
6528 case DT_FINI_ARRAYSZ
:
6529 case DT_GNU_CONFLICTSZ
:
6530 case DT_GNU_LIBLISTSZ
:
6533 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6534 printf (" (bytes)\n");
6544 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6557 if (entry
->d_tag
== DT_USED
6558 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6560 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6564 printf (_("Not needed object: [%s]\n"), name
);
6569 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6575 /* The value of this entry is ignored. */
6580 case DT_GNU_PRELINKED
:
6584 time_t atime
= entry
->d_un
.d_val
;
6586 tmp
= gmtime (&atime
);
6587 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6588 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6589 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6595 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6598 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6604 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6605 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6610 switch (elf_header
.e_machine
)
6613 case EM_MIPS_RS3_LE
:
6614 dynamic_section_mips_val (entry
);
6617 dynamic_section_parisc_val (entry
);
6620 dynamic_section_ia64_val (entry
);
6623 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6635 get_ver_flags (unsigned int flags
)
6637 static char buff
[32];
6644 if (flags
& VER_FLG_BASE
)
6645 strcat (buff
, "BASE ");
6647 if (flags
& VER_FLG_WEAK
)
6649 if (flags
& VER_FLG_BASE
)
6650 strcat (buff
, "| ");
6652 strcat (buff
, "WEAK ");
6655 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6656 strcat (buff
, "| <unknown>");
6661 /* Display the contents of the version sections. */
6664 process_version_sections (FILE * file
)
6666 Elf_Internal_Shdr
* section
;
6673 for (i
= 0, section
= section_headers
;
6674 i
< elf_header
.e_shnum
;
6677 switch (section
->sh_type
)
6679 case SHT_GNU_verdef
:
6681 Elf_External_Verdef
* edefs
;
6689 (_("\nVersion definition section '%s' contains %u entries:\n"),
6690 SECTION_NAME (section
), section
->sh_info
);
6692 printf (_(" Addr: 0x"));
6693 printf_vma (section
->sh_addr
);
6694 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6695 (unsigned long) section
->sh_offset
, section
->sh_link
,
6696 section
->sh_link
< elf_header
.e_shnum
6697 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6700 edefs
= (Elf_External_Verdef
*)
6701 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
6702 _("version definition section"));
6703 endbuf
= (char *) edefs
+ section
->sh_size
;
6707 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6710 Elf_External_Verdef
* edef
;
6711 Elf_Internal_Verdef ent
;
6712 Elf_External_Verdaux
* eaux
;
6713 Elf_Internal_Verdaux aux
;
6717 vstart
= ((char *) edefs
) + idx
;
6718 if (vstart
+ sizeof (*edef
) > endbuf
)
6721 edef
= (Elf_External_Verdef
*) vstart
;
6723 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6724 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6725 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6726 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6727 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6728 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6729 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6731 printf (_(" %#06x: Rev: %d Flags: %s"),
6732 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6734 printf (_(" Index: %d Cnt: %d "),
6735 ent
.vd_ndx
, ent
.vd_cnt
);
6737 vstart
+= ent
.vd_aux
;
6739 eaux
= (Elf_External_Verdaux
*) vstart
;
6741 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6742 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6744 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6745 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6747 printf (_("Name index: %ld\n"), aux
.vda_name
);
6749 isum
= idx
+ ent
.vd_aux
;
6751 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6753 isum
+= aux
.vda_next
;
6754 vstart
+= aux
.vda_next
;
6756 eaux
= (Elf_External_Verdaux
*) vstart
;
6757 if (vstart
+ sizeof (*eaux
) > endbuf
)
6760 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6761 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6763 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6764 printf (_(" %#06x: Parent %d: %s\n"),
6765 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6767 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6768 isum
, j
, aux
.vda_name
);
6771 printf (_(" Version def aux past end of section\n"));
6775 if (cnt
< section
->sh_info
)
6776 printf (_(" Version definition past end of section\n"));
6782 case SHT_GNU_verneed
:
6784 Elf_External_Verneed
* eneed
;
6791 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6792 SECTION_NAME (section
), section
->sh_info
);
6794 printf (_(" Addr: 0x"));
6795 printf_vma (section
->sh_addr
);
6796 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6797 (unsigned long) section
->sh_offset
, section
->sh_link
,
6798 section
->sh_link
< elf_header
.e_shnum
6799 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6802 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
6803 section
->sh_offset
, 1,
6805 _("version need section"));
6806 endbuf
= (char *) eneed
+ section
->sh_size
;
6810 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6812 Elf_External_Verneed
* entry
;
6813 Elf_Internal_Verneed ent
;
6818 vstart
= ((char *) eneed
) + idx
;
6819 if (vstart
+ sizeof (*entry
) > endbuf
)
6822 entry
= (Elf_External_Verneed
*) vstart
;
6824 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6825 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6826 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6827 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6828 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6830 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6832 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6833 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6835 printf (_(" File: %lx"), ent
.vn_file
);
6837 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6839 vstart
+= ent
.vn_aux
;
6841 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6843 Elf_External_Vernaux
* eaux
;
6844 Elf_Internal_Vernaux aux
;
6846 if (vstart
+ sizeof (*eaux
) > endbuf
)
6848 eaux
= (Elf_External_Vernaux
*) vstart
;
6850 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6851 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6852 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6853 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6854 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6856 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6857 printf (_(" %#06x: Name: %s"),
6858 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6860 printf (_(" %#06x: Name index: %lx"),
6861 isum
, aux
.vna_name
);
6863 printf (_(" Flags: %s Version: %d\n"),
6864 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6866 isum
+= aux
.vna_next
;
6867 vstart
+= aux
.vna_next
;
6870 printf (_(" Version need aux past end of section\n"));
6874 if (cnt
< section
->sh_info
)
6875 printf (_(" Version need past end of section\n"));
6881 case SHT_GNU_versym
:
6883 Elf_Internal_Shdr
* link_section
;
6886 unsigned char * edata
;
6887 unsigned short * data
;
6889 Elf_Internal_Sym
* symbols
;
6890 Elf_Internal_Shdr
* string_sec
;
6893 if (section
->sh_link
>= elf_header
.e_shnum
)
6896 link_section
= section_headers
+ section
->sh_link
;
6897 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6899 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6904 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6906 string_sec
= section_headers
+ link_section
->sh_link
;
6908 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6909 string_sec
->sh_size
,
6910 _("version string table"));
6914 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6915 SECTION_NAME (section
), total
);
6917 printf (_(" Addr: "));
6918 printf_vma (section
->sh_addr
);
6919 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6920 (unsigned long) section
->sh_offset
, section
->sh_link
,
6921 SECTION_NAME (link_section
));
6923 off
= offset_from_vma (file
,
6924 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6925 total
* sizeof (short));
6926 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
6928 _("version symbol data"));
6935 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
6937 for (cnt
= total
; cnt
--;)
6938 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6943 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6946 int check_def
, check_need
;
6949 printf (" %03x:", cnt
);
6951 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6952 switch (data
[cnt
+ j
])
6955 fputs (_(" 0 (*local*) "), stdout
);
6959 fputs (_(" 1 (*global*) "), stdout
);
6963 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
6964 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
6968 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6969 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6972 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6979 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6981 Elf_Internal_Verneed ivn
;
6982 unsigned long offset
;
6984 offset
= offset_from_vma
6985 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6986 sizeof (Elf_External_Verneed
));
6990 Elf_Internal_Vernaux ivna
;
6991 Elf_External_Verneed evn
;
6992 Elf_External_Vernaux evna
;
6993 unsigned long a_off
;
6995 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6998 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6999 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7001 a_off
= offset
+ ivn
.vn_aux
;
7005 get_data (&evna
, file
, a_off
, sizeof (evna
),
7006 1, _("version need aux (2)"));
7008 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7009 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7011 a_off
+= ivna
.vna_next
;
7013 while (ivna
.vna_other
!= data
[cnt
+ j
]
7014 && ivna
.vna_next
!= 0);
7016 if (ivna
.vna_other
== data
[cnt
+ j
])
7018 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7020 if (ivna
.vna_name
>= string_sec
->sh_size
)
7021 name
= _("*invalid*");
7023 name
= strtab
+ ivna
.vna_name
;
7024 nn
+= printf ("(%s%-*s",
7026 12 - (int) strlen (name
),
7032 offset
+= ivn
.vn_next
;
7034 while (ivn
.vn_next
);
7037 if (check_def
&& data
[cnt
+ j
] != 0x8001
7038 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7040 Elf_Internal_Verdef ivd
;
7041 Elf_External_Verdef evd
;
7042 unsigned long offset
;
7044 offset
= offset_from_vma
7045 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7050 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
7053 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7054 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7056 offset
+= ivd
.vd_next
;
7058 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
7059 && ivd
.vd_next
!= 0);
7061 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
7063 Elf_External_Verdaux evda
;
7064 Elf_Internal_Verdaux ivda
;
7066 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7068 get_data (&evda
, file
,
7069 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7071 _("version def aux"));
7073 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7075 if (ivda
.vda_name
>= string_sec
->sh_size
)
7076 name
= _("*invalid*");
7078 name
= strtab
+ ivda
.vda_name
;
7079 nn
+= printf ("(%s%-*s",
7081 12 - (int) strlen (name
),
7087 printf ("%*c", 18 - nn
, ' ');
7105 printf (_("\nNo version information found in this file.\n"));
7111 get_symbol_binding (unsigned int binding
)
7113 static char buff
[32];
7117 case STB_LOCAL
: return "LOCAL";
7118 case STB_GLOBAL
: return "GLOBAL";
7119 case STB_WEAK
: return "WEAK";
7121 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7122 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7124 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7126 if (binding
== STB_GNU_UNIQUE
7127 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7128 /* GNU/Linux is still using the default value 0. */
7129 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7131 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7134 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7140 get_symbol_type (unsigned int type
)
7142 static char buff
[32];
7146 case STT_NOTYPE
: return "NOTYPE";
7147 case STT_OBJECT
: return "OBJECT";
7148 case STT_FUNC
: return "FUNC";
7149 case STT_SECTION
: return "SECTION";
7150 case STT_FILE
: return "FILE";
7151 case STT_COMMON
: return "COMMON";
7152 case STT_TLS
: return "TLS";
7153 case STT_RELC
: return "RELC";
7154 case STT_SRELC
: return "SRELC";
7156 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7158 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7159 return "THUMB_FUNC";
7161 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7164 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7165 return "PARISC_MILLI";
7167 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7169 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7171 if (elf_header
.e_machine
== EM_PARISC
)
7173 if (type
== STT_HP_OPAQUE
)
7175 if (type
== STT_HP_STUB
)
7179 if (type
== STT_GNU_IFUNC
7180 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7181 /* GNU/Linux is still using the default value 0. */
7182 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7185 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7188 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7194 get_symbol_visibility (unsigned int visibility
)
7198 case STV_DEFAULT
: return "DEFAULT";
7199 case STV_INTERNAL
: return "INTERNAL";
7200 case STV_HIDDEN
: return "HIDDEN";
7201 case STV_PROTECTED
: return "PROTECTED";
7207 get_mips_symbol_other (unsigned int other
)
7211 case STO_OPTIONAL
: return "OPTIONAL";
7212 case STO_MIPS16
: return "MIPS16";
7213 case STO_MIPS_PLT
: return "MIPS PLT";
7214 case STO_MIPS_PIC
: return "MIPS PIC";
7215 default: return NULL
;
7220 get_symbol_other (unsigned int other
)
7222 const char * result
= NULL
;
7223 static char buff
[32];
7228 switch (elf_header
.e_machine
)
7231 result
= get_mips_symbol_other (other
);
7239 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7244 get_symbol_index_type (unsigned int type
)
7246 static char buff
[32];
7250 case SHN_UNDEF
: return "UND";
7251 case SHN_ABS
: return "ABS";
7252 case SHN_COMMON
: return "COM";
7254 if (type
== SHN_IA_64_ANSI_COMMON
7255 && elf_header
.e_machine
== EM_IA_64
7256 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7258 else if ((elf_header
.e_machine
== EM_X86_64
7259 || elf_header
.e_machine
== EM_L1OM
)
7260 && type
== SHN_X86_64_LCOMMON
)
7262 else if (type
== SHN_MIPS_SCOMMON
7263 && elf_header
.e_machine
== EM_MIPS
)
7265 else if (type
== SHN_MIPS_SUNDEFINED
7266 && elf_header
.e_machine
== EM_MIPS
)
7268 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7269 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7270 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7271 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7272 else if (type
>= SHN_LORESERVE
)
7273 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7275 sprintf (buff
, "%3d", type
);
7283 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7285 unsigned char * e_data
;
7288 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
7292 error (_("Out of memory\n"));
7296 if (fread (e_data
, ent_size
, number
, file
) != number
)
7298 error (_("Unable to read in dynamic data\n"));
7302 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
7306 error (_("Out of memory\n"));
7312 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7320 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7322 Elf_Internal_Sym
* psym
;
7325 psym
= dynamic_symbols
+ si
;
7327 n
= print_vma (si
, DEC_5
);
7329 fputs (" " + n
, stdout
);
7330 printf (" %3lu: ", hn
);
7331 print_vma (psym
->st_value
, LONG_HEX
);
7333 print_vma (psym
->st_size
, DEC_5
);
7335 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7336 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7337 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7338 /* Check to see if any other bits in the st_other field are set.
7339 Note - displaying this information disrupts the layout of the
7340 table being generated, but for the moment this case is very
7342 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7343 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7344 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7345 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7346 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7348 printf (" <corrupt: %14ld>", psym
->st_name
);
7352 /* Dump the symbol table. */
7354 process_symbol_table (FILE * file
)
7356 Elf_Internal_Shdr
* section
;
7357 bfd_vma nbuckets
= 0;
7358 bfd_vma nchains
= 0;
7359 bfd_vma
* buckets
= NULL
;
7360 bfd_vma
* chains
= NULL
;
7361 bfd_vma ngnubuckets
= 0;
7362 bfd_vma
* gnubuckets
= NULL
;
7363 bfd_vma
* gnuchains
= NULL
;
7364 bfd_vma gnusymidx
= 0;
7366 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
7369 if (dynamic_info
[DT_HASH
]
7371 || (do_using_dynamic
7373 && dynamic_strings
!= NULL
)))
7375 unsigned char nb
[8];
7376 unsigned char nc
[8];
7377 int hash_ent_size
= 4;
7379 if ((elf_header
.e_machine
== EM_ALPHA
7380 || elf_header
.e_machine
== EM_S390
7381 || elf_header
.e_machine
== EM_S390_OLD
)
7382 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7386 (archive_file_offset
7387 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7388 sizeof nb
+ sizeof nc
)),
7391 error (_("Unable to seek to start of dynamic information\n"));
7395 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7397 error (_("Failed to read in number of buckets\n"));
7401 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7403 error (_("Failed to read in number of chains\n"));
7407 nbuckets
= byte_get (nb
, hash_ent_size
);
7408 nchains
= byte_get (nc
, hash_ent_size
);
7410 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7411 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7414 if (buckets
== NULL
|| chains
== NULL
)
7416 if (do_using_dynamic
)
7427 if (dynamic_info_DT_GNU_HASH
7429 || (do_using_dynamic
7431 && dynamic_strings
!= NULL
)))
7433 unsigned char nb
[16];
7434 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7435 bfd_vma buckets_vma
;
7438 (archive_file_offset
7439 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7443 error (_("Unable to seek to start of dynamic information\n"));
7447 if (fread (nb
, 16, 1, file
) != 1)
7449 error (_("Failed to read in number of buckets\n"));
7453 ngnubuckets
= byte_get (nb
, 4);
7454 gnusymidx
= byte_get (nb
+ 4, 4);
7455 bitmaskwords
= byte_get (nb
+ 8, 4);
7456 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7458 buckets_vma
+= bitmaskwords
* 4;
7460 buckets_vma
+= bitmaskwords
* 8;
7463 (archive_file_offset
7464 + offset_from_vma (file
, buckets_vma
, 4)),
7467 error (_("Unable to seek to start of dynamic information\n"));
7471 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7473 if (gnubuckets
== NULL
)
7476 for (i
= 0; i
< ngnubuckets
; i
++)
7477 if (gnubuckets
[i
] != 0)
7479 if (gnubuckets
[i
] < gnusymidx
)
7482 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7483 maxchain
= gnubuckets
[i
];
7486 if (maxchain
== 0xffffffff)
7489 maxchain
-= gnusymidx
;
7492 (archive_file_offset
7493 + offset_from_vma (file
, buckets_vma
7494 + 4 * (ngnubuckets
+ maxchain
), 4)),
7497 error (_("Unable to seek to start of dynamic information\n"));
7503 if (fread (nb
, 4, 1, file
) != 1)
7505 error (_("Failed to determine last chain length\n"));
7509 if (maxchain
+ 1 == 0)
7514 while ((byte_get (nb
, 4) & 1) == 0);
7517 (archive_file_offset
7518 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7521 error (_("Unable to seek to start of dynamic information\n"));
7525 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7528 if (gnuchains
== NULL
)
7533 if (do_using_dynamic
)
7538 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7541 && dynamic_strings
!= NULL
)
7545 if (dynamic_info
[DT_HASH
])
7549 printf (_("\nSymbol table for image:\n"));
7551 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7553 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7555 for (hn
= 0; hn
< nbuckets
; hn
++)
7560 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7561 print_dynamic_symbol (si
, hn
);
7565 if (dynamic_info_DT_GNU_HASH
)
7567 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7569 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7571 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7573 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7574 if (gnubuckets
[hn
] != 0)
7576 bfd_vma si
= gnubuckets
[hn
];
7577 bfd_vma off
= si
- gnusymidx
;
7581 print_dynamic_symbol (si
, hn
);
7584 while ((gnuchains
[off
++] & 1) == 0);
7588 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
7592 for (i
= 0, section
= section_headers
;
7593 i
< elf_header
.e_shnum
;
7597 char * strtab
= NULL
;
7598 unsigned long int strtab_size
= 0;
7599 Elf_Internal_Sym
* symtab
;
7600 Elf_Internal_Sym
* psym
;
7602 if ((section
->sh_type
!= SHT_SYMTAB
7603 && section
->sh_type
!= SHT_DYNSYM
)
7605 && section
->sh_type
== SHT_SYMTAB
))
7608 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7609 SECTION_NAME (section
),
7610 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7612 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7614 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7616 symtab
= GET_ELF_SYMBOLS (file
, section
);
7620 if (section
->sh_link
== elf_header
.e_shstrndx
)
7622 strtab
= string_table
;
7623 strtab_size
= string_table_length
;
7625 else if (section
->sh_link
< elf_header
.e_shnum
)
7627 Elf_Internal_Shdr
* string_sec
;
7629 string_sec
= section_headers
+ section
->sh_link
;
7631 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
7632 1, string_sec
->sh_size
,
7634 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7637 for (si
= 0, psym
= symtab
;
7638 si
< section
->sh_size
/ section
->sh_entsize
;
7641 printf ("%6d: ", si
);
7642 print_vma (psym
->st_value
, LONG_HEX
);
7644 print_vma (psym
->st_size
, DEC_5
);
7645 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7646 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7647 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7648 /* Check to see if any other bits in the st_other field are set.
7649 Note - displaying this information disrupts the layout of the
7650 table being generated, but for the moment this case is very rare. */
7651 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7652 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7653 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7654 print_symbol (25, psym
->st_name
< strtab_size
7655 ? strtab
+ psym
->st_name
: "<corrupt>");
7657 if (section
->sh_type
== SHT_DYNSYM
&&
7658 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7660 unsigned char data
[2];
7661 unsigned short vers_data
;
7662 unsigned long offset
;
7666 offset
= offset_from_vma
7667 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7668 sizeof data
+ si
* sizeof (vers_data
));
7670 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7671 sizeof (data
), 1, _("version data"));
7673 vers_data
= byte_get (data
, 2);
7675 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7676 && section_headers
[psym
->st_shndx
].sh_type
7679 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7681 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
7683 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7684 && (is_nobits
|| ! check_def
))
7686 Elf_External_Verneed evn
;
7687 Elf_Internal_Verneed ivn
;
7688 Elf_Internal_Vernaux ivna
;
7690 /* We must test both. */
7691 offset
= offset_from_vma
7692 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7697 unsigned long vna_off
;
7699 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7702 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7703 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7705 vna_off
= offset
+ ivn
.vn_aux
;
7709 Elf_External_Vernaux evna
;
7711 get_data (&evna
, file
, vna_off
,
7713 _("version need aux (3)"));
7715 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7716 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7717 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7719 vna_off
+= ivna
.vna_next
;
7721 while (ivna
.vna_other
!= vers_data
7722 && ivna
.vna_next
!= 0);
7724 if (ivna
.vna_other
== vers_data
)
7727 offset
+= ivn
.vn_next
;
7729 while (ivn
.vn_next
!= 0);
7731 if (ivna
.vna_other
== vers_data
)
7734 ivna
.vna_name
< strtab_size
7735 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7739 else if (! is_nobits
)
7740 error (_("bad dynamic symbol\n"));
7747 if (vers_data
!= 0x8001
7748 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7750 Elf_Internal_Verdef ivd
;
7751 Elf_Internal_Verdaux ivda
;
7752 Elf_External_Verdaux evda
;
7755 off
= offset_from_vma
7757 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7758 sizeof (Elf_External_Verdef
));
7762 Elf_External_Verdef evd
;
7764 get_data (&evd
, file
, off
, sizeof (evd
),
7765 1, _("version def"));
7767 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7768 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7769 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7773 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
7774 && ivd
.vd_next
!= 0);
7779 get_data (&evda
, file
, off
, sizeof (evda
),
7780 1, _("version def aux"));
7782 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7784 if (psym
->st_name
!= ivda
.vda_name
)
7785 printf ((vers_data
& VERSYM_HIDDEN
)
7787 ivda
.vda_name
< strtab_size
7788 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7798 if (strtab
!= string_table
)
7804 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7806 if (do_histogram
&& buckets
!= NULL
)
7808 unsigned long * lengths
;
7809 unsigned long * counts
;
7812 unsigned long maxlength
= 0;
7813 unsigned long nzero_counts
= 0;
7814 unsigned long nsyms
= 0;
7816 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7817 (unsigned long) nbuckets
);
7818 printf (_(" Length Number %% of total Coverage\n"));
7820 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
7821 if (lengths
== NULL
)
7823 error (_("Out of memory\n"));
7826 for (hn
= 0; hn
< nbuckets
; ++hn
)
7828 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7831 if (maxlength
< ++lengths
[hn
])
7836 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7839 error (_("Out of memory\n"));
7843 for (hn
= 0; hn
< nbuckets
; ++hn
)
7844 ++counts
[lengths
[hn
]];
7849 printf (" 0 %-10lu (%5.1f%%)\n",
7850 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7851 for (i
= 1; i
<= maxlength
; ++i
)
7853 nzero_counts
+= counts
[i
] * i
;
7854 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7855 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7856 (nzero_counts
* 100.0) / nsyms
);
7864 if (buckets
!= NULL
)
7870 if (do_histogram
&& gnubuckets
!= NULL
)
7872 unsigned long * lengths
;
7873 unsigned long * counts
;
7875 unsigned long maxlength
= 0;
7876 unsigned long nzero_counts
= 0;
7877 unsigned long nsyms
= 0;
7879 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
7880 if (lengths
== NULL
)
7882 error (_("Out of memory\n"));
7886 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7887 (unsigned long) ngnubuckets
);
7888 printf (_(" Length Number %% of total Coverage\n"));
7890 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7891 if (gnubuckets
[hn
] != 0)
7893 bfd_vma off
, length
= 1;
7895 for (off
= gnubuckets
[hn
] - gnusymidx
;
7896 (gnuchains
[off
] & 1) == 0; ++off
)
7898 lengths
[hn
] = length
;
7899 if (length
> maxlength
)
7904 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7907 error (_("Out of memory\n"));
7911 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7912 ++counts
[lengths
[hn
]];
7914 if (ngnubuckets
> 0)
7917 printf (" 0 %-10lu (%5.1f%%)\n",
7918 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7919 for (j
= 1; j
<= maxlength
; ++j
)
7921 nzero_counts
+= counts
[j
] * j
;
7922 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7923 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7924 (nzero_counts
* 100.0) / nsyms
);
7938 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7942 if (dynamic_syminfo
== NULL
7944 /* No syminfo, this is ok. */
7947 /* There better should be a dynamic symbol section. */
7948 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7952 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7953 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7955 printf (_(" Num: Name BoundTo Flags\n"));
7956 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7958 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7960 printf ("%4d: ", i
);
7961 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7962 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7964 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7967 switch (dynamic_syminfo
[i
].si_boundto
)
7969 case SYMINFO_BT_SELF
:
7970 fputs ("SELF ", stdout
);
7972 case SYMINFO_BT_PARENT
:
7973 fputs ("PARENT ", stdout
);
7976 if (dynamic_syminfo
[i
].si_boundto
> 0
7977 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7978 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7980 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7984 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7988 if (flags
& SYMINFO_FLG_DIRECT
)
7990 if (flags
& SYMINFO_FLG_PASSTHRU
)
7991 printf (" PASSTHRU");
7992 if (flags
& SYMINFO_FLG_COPY
)
7994 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7995 printf (" LAZYLOAD");
8003 /* Check to see if the given reloc needs to be handled in a target specific
8004 manner. If so then process the reloc and return TRUE otherwise return
8008 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
8009 unsigned char * start
,
8010 Elf_Internal_Sym
* symtab
)
8012 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
8014 switch (elf_header
.e_machine
)
8017 case EM_CYGNUS_MN10300
:
8019 static Elf_Internal_Sym
* saved_sym
= NULL
;
8023 case 34: /* R_MN10300_ALIGN */
8025 case 33: /* R_MN10300_SYM_DIFF */
8026 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
8028 case 1: /* R_MN10300_32 */
8029 case 2: /* R_MN10300_16 */
8030 if (saved_sym
!= NULL
)
8034 value
= reloc
->r_addend
8035 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
8036 - saved_sym
->st_value
);
8038 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
8045 if (saved_sym
!= NULL
)
8046 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8056 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8057 DWARF debug sections. This is a target specific test. Note - we do not
8058 go through the whole including-target-headers-multiple-times route, (as
8059 we have already done with <elf/h8.h>) because this would become very
8060 messy and even then this function would have to contain target specific
8061 information (the names of the relocs instead of their numeric values).
8062 FIXME: This is not the correct way to solve this problem. The proper way
8063 is to have target specific reloc sizing and typing functions created by
8064 the reloc-macros.h header, in the same way that it already creates the
8065 reloc naming functions. */
8068 is_32bit_abs_reloc (unsigned int reloc_type
)
8070 switch (elf_header
.e_machine
)
8074 return reloc_type
== 1; /* R_386_32. */
8076 return reloc_type
== 1; /* R_68K_32. */
8078 return reloc_type
== 1; /* R_860_32. */
8080 return reloc_type
== 1; /* XXX Is this right ? */
8082 return reloc_type
== 1; /* R_ARC_32. */
8084 return reloc_type
== 2; /* R_ARM_ABS32 */
8087 return reloc_type
== 1;
8089 return reloc_type
== 0x12; /* R_byte4_data. */
8091 return reloc_type
== 3; /* R_CRIS_32. */
8094 return reloc_type
== 3; /* R_CR16_NUM32. */
8096 return reloc_type
== 15; /* R_CRX_NUM32. */
8098 return reloc_type
== 1;
8099 case EM_CYGNUS_D10V
:
8101 return reloc_type
== 6; /* R_D10V_32. */
8102 case EM_CYGNUS_D30V
:
8104 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8106 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8107 case EM_CYGNUS_FR30
:
8109 return reloc_type
== 3; /* R_FR30_32. */
8113 return reloc_type
== 1; /* R_H8_DIR32. */
8115 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8118 return reloc_type
== 2; /* R_IP2K_32. */
8120 return reloc_type
== 2; /* R_IQ2000_32. */
8121 case EM_LATTICEMICO32
:
8122 return reloc_type
== 3; /* R_LM32_32. */
8125 return reloc_type
== 3; /* R_M32C_32. */
8127 return reloc_type
== 34; /* R_M32R_32_RELA. */
8129 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8131 return reloc_type
== 4; /* R_MEP_32. */
8133 return reloc_type
== 2; /* R_MIPS_32. */
8135 return reloc_type
== 4; /* R_MMIX_32. */
8136 case EM_CYGNUS_MN10200
:
8138 return reloc_type
== 1; /* R_MN10200_32. */
8139 case EM_CYGNUS_MN10300
:
8141 return reloc_type
== 1; /* R_MN10300_32. */
8144 return reloc_type
== 1; /* R_MSP43_32. */
8146 return reloc_type
== 2; /* R_MT_32. */
8147 case EM_ALTERA_NIOS2
:
8149 return reloc_type
== 1; /* R_NIOS_32. */
8152 return reloc_type
== 1; /* R_OR32_32. */
8154 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8155 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8158 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8160 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8162 return reloc_type
== 1; /* R_PPC_ADDR32. */
8164 return reloc_type
== 1; /* R_RX_DIR32. */
8166 return reloc_type
== 1; /* R_I370_ADDR31. */
8169 return reloc_type
== 4; /* R_S390_32. */
8171 return reloc_type
== 8; /* R_SCORE_ABS32. */
8173 return reloc_type
== 1; /* R_SH_DIR32. */
8174 case EM_SPARC32PLUS
:
8177 return reloc_type
== 3 /* R_SPARC_32. */
8178 || reloc_type
== 23; /* R_SPARC_UA32. */
8180 return reloc_type
== 6; /* R_SPU_ADDR32 */
8181 case EM_CYGNUS_V850
:
8183 return reloc_type
== 6; /* R_V850_ABS32. */
8185 return reloc_type
== 1; /* R_VAX_32. */
8188 return reloc_type
== 10; /* R_X86_64_32. */
8191 return reloc_type
== 3; /* R_XC16C_ABS_32. */
8193 return reloc_type
== 1; /* R_XSTROMY16_32. */
8196 return reloc_type
== 1; /* R_XTENSA_32. */
8198 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8199 elf_header
.e_machine
);
8204 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8205 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8208 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8210 switch (elf_header
.e_machine
)
8214 return reloc_type
== 2; /* R_386_PC32. */
8216 return reloc_type
== 4; /* R_68K_PC32. */
8218 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8220 return reloc_type
== 3; /* R_ARM_REL32 */
8222 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8224 return reloc_type
== 26; /* R_PPC_REL32. */
8226 return reloc_type
== 26; /* R_PPC64_REL32. */
8229 return reloc_type
== 5; /* R_390_PC32. */
8231 return reloc_type
== 2; /* R_SH_REL32. */
8232 case EM_SPARC32PLUS
:
8235 return reloc_type
== 6; /* R_SPARC_DISP32. */
8237 return reloc_type
== 13; /* R_SPU_REL32. */
8240 return reloc_type
== 2; /* R_X86_64_PC32. */
8243 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8245 /* Do not abort or issue an error message here. Not all targets use
8246 pc-relative 32-bit relocs in their DWARF debug information and we
8247 have already tested for target coverage in is_32bit_abs_reloc. A
8248 more helpful warning message will be generated by apply_relocations
8249 anyway, so just return. */
8254 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8255 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8258 is_64bit_abs_reloc (unsigned int reloc_type
)
8260 switch (elf_header
.e_machine
)
8263 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8265 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8267 return reloc_type
== 80; /* R_PARISC_DIR64. */
8269 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8270 case EM_SPARC32PLUS
:
8273 return reloc_type
== 54; /* R_SPARC_UA64. */
8276 return reloc_type
== 1; /* R_X86_64_64. */
8279 return reloc_type
== 22; /* R_S390_64 */
8281 return reloc_type
== 18; /* R_MIPS_64 */
8287 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8288 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8291 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8293 switch (elf_header
.e_machine
)
8296 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8298 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8300 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8302 return reloc_type
== 44; /* R_PPC64_REL64 */
8303 case EM_SPARC32PLUS
:
8306 return reloc_type
== 46; /* R_SPARC_DISP64 */
8309 return reloc_type
== 24; /* R_X86_64_PC64 */
8312 return reloc_type
== 23; /* R_S390_PC64 */
8318 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8319 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8322 is_24bit_abs_reloc (unsigned int reloc_type
)
8324 switch (elf_header
.e_machine
)
8326 case EM_CYGNUS_MN10200
:
8328 return reloc_type
== 4; /* R_MN10200_24. */
8334 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8335 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8338 is_16bit_abs_reloc (unsigned int reloc_type
)
8340 switch (elf_header
.e_machine
)
8344 return reloc_type
== 4; /* R_AVR_16. */
8345 case EM_CYGNUS_D10V
:
8347 return reloc_type
== 3; /* R_D10V_16. */
8351 return reloc_type
== R_H8_DIR16
;
8354 return reloc_type
== 1; /* R_IP2K_16. */
8357 return reloc_type
== 1; /* R_M32C_16 */
8360 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8361 case EM_ALTERA_NIOS2
:
8363 return reloc_type
== 9; /* R_NIOS_16. */
8366 return reloc_type
== 2; /* R_XC16C_ABS_16. */
8372 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8373 relocation entries (possibly formerly used for SHT_GROUP sections). */
8376 is_none_reloc (unsigned int reloc_type
)
8378 switch (elf_header
.e_machine
)
8380 case EM_68K
: /* R_68K_NONE. */
8381 case EM_386
: /* R_386_NONE. */
8382 case EM_SPARC32PLUS
:
8384 case EM_SPARC
: /* R_SPARC_NONE. */
8385 case EM_MIPS
: /* R_MIPS_NONE. */
8386 case EM_PARISC
: /* R_PARISC_NONE. */
8387 case EM_ALPHA
: /* R_ALPHA_NONE. */
8388 case EM_PPC
: /* R_PPC_NONE. */
8389 case EM_PPC64
: /* R_PPC64_NONE. */
8390 case EM_ARM
: /* R_ARM_NONE. */
8391 case EM_IA_64
: /* R_IA64_NONE. */
8392 case EM_SH
: /* R_SH_NONE. */
8394 case EM_S390
: /* R_390_NONE. */
8395 case EM_CRIS
: /* R_CRIS_NONE. */
8396 case EM_X86_64
: /* R_X86_64_NONE. */
8397 case EM_L1OM
: /* R_X86_64_NONE. */
8398 case EM_MN10300
: /* R_MN10300_NONE. */
8399 case EM_M32R
: /* R_M32R_NONE. */
8401 case EM_C166
: /* R_XC16X_NONE. */
8402 return reloc_type
== 0;
8405 return (reloc_type
== 0 /* R_XTENSA_NONE. */
8406 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
8407 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
8408 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
8413 /* Apply relocations to a section.
8414 Note: So far support has been added only for those relocations
8415 which can be found in debug sections.
8416 FIXME: Add support for more relocations ? */
8419 apply_relocations (void * file
,
8420 Elf_Internal_Shdr
* section
,
8421 unsigned char * start
)
8423 Elf_Internal_Shdr
* relsec
;
8424 unsigned char * end
= start
+ section
->sh_size
;
8426 if (elf_header
.e_type
!= ET_REL
)
8429 /* Find the reloc section associated with the section. */
8430 for (relsec
= section_headers
;
8431 relsec
< section_headers
+ elf_header
.e_shnum
;
8434 bfd_boolean is_rela
;
8435 unsigned long num_relocs
;
8436 Elf_Internal_Rela
* relocs
;
8437 Elf_Internal_Rela
* rp
;
8438 Elf_Internal_Shdr
* symsec
;
8439 Elf_Internal_Sym
* symtab
;
8440 Elf_Internal_Sym
* sym
;
8442 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8443 || relsec
->sh_info
>= elf_header
.e_shnum
8444 || section_headers
+ relsec
->sh_info
!= section
8445 || relsec
->sh_size
== 0
8446 || relsec
->sh_link
>= elf_header
.e_shnum
)
8449 is_rela
= relsec
->sh_type
== SHT_RELA
;
8453 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
8454 relsec
->sh_size
, & relocs
, & num_relocs
))
8459 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
8460 relsec
->sh_size
, & relocs
, & num_relocs
))
8464 /* SH uses RELA but uses in place value instead of the addend field. */
8465 if (elf_header
.e_machine
== EM_SH
)
8468 symsec
= section_headers
+ relsec
->sh_link
;
8469 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
8471 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8474 unsigned int reloc_type
;
8475 unsigned int reloc_size
;
8476 unsigned char * rloc
;
8478 reloc_type
= get_reloc_type (rp
->r_info
);
8480 if (target_specific_reloc_handling (rp
, start
, symtab
))
8482 else if (is_none_reloc (reloc_type
))
8484 else if (is_32bit_abs_reloc (reloc_type
)
8485 || is_32bit_pcrel_reloc (reloc_type
))
8487 else if (is_64bit_abs_reloc (reloc_type
)
8488 || is_64bit_pcrel_reloc (reloc_type
))
8490 else if (is_24bit_abs_reloc (reloc_type
))
8492 else if (is_16bit_abs_reloc (reloc_type
))
8496 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8497 reloc_type
, SECTION_NAME (section
));
8501 rloc
= start
+ rp
->r_offset
;
8502 if ((rloc
+ reloc_size
) > end
)
8504 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8505 (unsigned long) rp
->r_offset
,
8506 SECTION_NAME (section
));
8510 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8512 /* If the reloc has a symbol associated with it,
8513 make sure that it is of an appropriate type.
8515 Relocations against symbols without type can happen.
8516 Gcc -feliminate-dwarf2-dups may generate symbols
8517 without type for debug info.
8519 Icc generates relocations against function symbols
8520 instead of local labels.
8522 Relocations against object symbols can happen, eg when
8523 referencing a global array. For an example of this see
8524 the _clz.o binary in libgcc.a. */
8526 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8528 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8529 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8530 (long int)(rp
- relocs
),
8531 SECTION_NAME (relsec
));
8537 addend
+= rp
->r_addend
;
8538 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8540 || (elf_header
.e_machine
== EM_XTENSA
8542 || ((elf_header
.e_machine
== EM_PJ
8543 || elf_header
.e_machine
== EM_PJ_OLD
)
8544 && reloc_type
== 1))
8545 addend
+= byte_get (rloc
, reloc_size
);
8547 if (is_32bit_pcrel_reloc (reloc_type
)
8548 || is_64bit_pcrel_reloc (reloc_type
))
8550 /* On HPPA, all pc-relative relocations are biased by 8. */
8551 if (elf_header
.e_machine
== EM_PARISC
)
8553 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8557 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
8566 #ifdef SUPPORT_DISASSEMBLY
8568 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8570 printf (_("\nAssembly dump of section %s\n"),
8571 SECTION_NAME (section
));
8573 /* XXX -- to be done --- XXX */
8579 /* Reads in the contents of SECTION from FILE, returning a pointer
8580 to a malloc'ed buffer or NULL if something went wrong. */
8583 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8585 bfd_size_type num_bytes
;
8587 num_bytes
= section
->sh_size
;
8589 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8591 printf (_("\nSection '%s' has no data to dump.\n"),
8592 SECTION_NAME (section
));
8596 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8597 _("section contents"));
8602 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8604 Elf_Internal_Shdr
* relsec
;
8605 bfd_size_type num_bytes
;
8610 char * name
= SECTION_NAME (section
);
8611 bfd_boolean some_strings_shown
;
8613 start
= get_section_contents (section
, file
);
8617 printf (_("\nString dump of section '%s':\n"), name
);
8619 /* If the section being dumped has relocations against it the user might
8620 be expecting these relocations to have been applied. Check for this
8621 case and issue a warning message in order to avoid confusion.
8622 FIXME: Maybe we ought to have an option that dumps a section with
8624 for (relsec
= section_headers
;
8625 relsec
< section_headers
+ elf_header
.e_shnum
;
8628 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8629 || relsec
->sh_info
>= elf_header
.e_shnum
8630 || section_headers
+ relsec
->sh_info
!= section
8631 || relsec
->sh_size
== 0
8632 || relsec
->sh_link
>= elf_header
.e_shnum
)
8635 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8639 num_bytes
= section
->sh_size
;
8640 addr
= section
->sh_addr
;
8642 end
= start
+ num_bytes
;
8643 some_strings_shown
= FALSE
;
8647 while (!ISPRINT (* data
))
8654 /* PR 11128: Use two separate invocations in order to work
8655 around bugs in the Solaris 8 implementation of printf. */
8656 printf (" [%6tx] ", data
- start
);
8657 printf ("%s\n", data
);
8659 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8661 data
+= strlen (data
);
8662 some_strings_shown
= TRUE
;
8666 if (! some_strings_shown
)
8667 printf (_(" No strings found in this section."));
8675 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8677 bfd_boolean relocate
)
8679 Elf_Internal_Shdr
* relsec
;
8680 bfd_size_type bytes
;
8682 unsigned char * data
;
8683 unsigned char * start
;
8685 start
= (unsigned char *) get_section_contents (section
, file
);
8689 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8693 apply_relocations (file
, section
, start
);
8697 /* If the section being dumped has relocations against it the user might
8698 be expecting these relocations to have been applied. Check for this
8699 case and issue a warning message in order to avoid confusion.
8700 FIXME: Maybe we ought to have an option that dumps a section with
8702 for (relsec
= section_headers
;
8703 relsec
< section_headers
+ elf_header
.e_shnum
;
8706 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8707 || relsec
->sh_info
>= elf_header
.e_shnum
8708 || section_headers
+ relsec
->sh_info
!= section
8709 || relsec
->sh_size
== 0
8710 || relsec
->sh_link
>= elf_header
.e_shnum
)
8713 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8718 addr
= section
->sh_addr
;
8719 bytes
= section
->sh_size
;
8728 lbytes
= (bytes
> 16 ? 16 : bytes
);
8730 printf (" 0x%8.8lx ", (unsigned long) addr
);
8732 for (j
= 0; j
< 16; j
++)
8735 printf ("%2.2x", data
[j
]);
8743 for (j
= 0; j
< lbytes
; j
++)
8746 if (k
>= ' ' && k
< 0x7f)
8764 /* Uncompresses a section that was compressed using zlib, in place.
8765 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8768 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8771 /* These are just to quiet gcc. */
8776 dwarf_size_type compressed_size
= *size
;
8777 unsigned char * compressed_buffer
= *buffer
;
8778 dwarf_size_type uncompressed_size
;
8779 unsigned char * uncompressed_buffer
;
8782 dwarf_size_type header_size
= 12;
8784 /* Read the zlib header. In this case, it should be "ZLIB" followed
8785 by the uncompressed section size, 8 bytes in big-endian order. */
8786 if (compressed_size
< header_size
8787 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8790 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8791 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8792 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8793 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8794 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8795 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8796 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8797 uncompressed_size
+= compressed_buffer
[11];
8799 /* It is possible the section consists of several compressed
8800 buffers concatenated together, so we uncompress in a loop. */
8804 strm
.avail_in
= compressed_size
- header_size
;
8805 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8806 strm
.avail_out
= uncompressed_size
;
8807 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
8809 rc
= inflateInit (& strm
);
8810 while (strm
.avail_in
> 0)
8814 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8815 + (uncompressed_size
- strm
.avail_out
));
8816 rc
= inflate (&strm
, Z_FINISH
);
8817 if (rc
!= Z_STREAM_END
)
8819 rc
= inflateReset (& strm
);
8821 rc
= inflateEnd (& strm
);
8823 || strm
.avail_out
!= 0)
8826 free (compressed_buffer
);
8827 *buffer
= uncompressed_buffer
;
8828 *size
= uncompressed_size
;
8832 free (uncompressed_buffer
);
8834 #endif /* HAVE_ZLIB_H */
8838 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8839 Elf_Internal_Shdr
* sec
, void * file
)
8841 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8843 int section_is_compressed
;
8845 /* If it is already loaded, do nothing. */
8846 if (section
->start
!= NULL
)
8849 section_is_compressed
= section
->name
== section
->compressed_name
;
8851 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8852 section
->address
= sec
->sh_addr
;
8853 section
->size
= sec
->sh_size
;
8854 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
8857 if (section
->start
== NULL
)
8860 if (section_is_compressed
)
8861 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8864 if (debug_displays
[debug
].relocate
)
8865 apply_relocations ((FILE *) file
, sec
, section
->start
);
8871 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8873 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8874 Elf_Internal_Shdr
* sec
;
8876 /* Locate the debug section. */
8877 sec
= find_section (section
->uncompressed_name
);
8879 section
->name
= section
->uncompressed_name
;
8882 sec
= find_section (section
->compressed_name
);
8884 section
->name
= section
->compressed_name
;
8889 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
8893 free_debug_section (enum dwarf_section_display_enum debug
)
8895 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8897 if (section
->start
== NULL
)
8900 free ((char *) section
->start
);
8901 section
->start
= NULL
;
8902 section
->address
= 0;
8907 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8909 char * name
= SECTION_NAME (section
);
8910 bfd_size_type length
;
8914 length
= section
->sh_size
;
8917 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8920 if (section
->sh_type
== SHT_NOBITS
)
8922 /* There is no point in dumping the contents of a debugging section
8923 which has the NOBITS type - the bits in the file will be random.
8924 This can happen when a file containing a .eh_frame section is
8925 stripped with the --only-keep-debug command line option. */
8926 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8930 if (const_strneq (name
, ".gnu.linkonce.wi."))
8931 name
= ".debug_info";
8933 /* See if we know how to display the contents of this section. */
8934 for (i
= 0; i
< max
; i
++)
8935 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8936 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8938 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8939 int secondary
= (section
!= find_section (name
));
8942 free_debug_section ((enum dwarf_section_display_enum
) i
);
8944 if (streq (sec
->uncompressed_name
, name
))
8945 sec
->name
= sec
->uncompressed_name
;
8947 sec
->name
= sec
->compressed_name
;
8948 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
8951 result
&= debug_displays
[i
].display (sec
, file
);
8953 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8954 free_debug_section ((enum dwarf_section_display_enum
) i
);
8962 printf (_("Unrecognized debug section: %s\n"), name
);
8969 /* Set DUMP_SECTS for all sections where dumps were requested
8970 based on section name. */
8973 initialise_dumps_byname (void)
8975 struct dump_list_entry
* cur
;
8977 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8982 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8983 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8985 request_dump_bynumber (i
, cur
->type
);
8990 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8996 process_section_contents (FILE * file
)
8998 Elf_Internal_Shdr
* section
;
9004 initialise_dumps_byname ();
9006 for (i
= 0, section
= section_headers
;
9007 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9010 #ifdef SUPPORT_DISASSEMBLY
9011 if (dump_sects
[i
] & DISASS_DUMP
)
9012 disassemble_section (section
, file
);
9014 if (dump_sects
[i
] & HEX_DUMP
)
9015 dump_section_as_bytes (section
, file
, FALSE
);
9017 if (dump_sects
[i
] & RELOC_DUMP
)
9018 dump_section_as_bytes (section
, file
, TRUE
);
9020 if (dump_sects
[i
] & STRING_DUMP
)
9021 dump_section_as_strings (section
, file
);
9023 if (dump_sects
[i
] & DEBUG_DUMP
)
9024 display_debug_section (section
, file
);
9027 /* Check to see if the user requested a
9028 dump of a section that does not exist. */
9029 while (i
++ < num_dump_sects
)
9031 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
9035 process_mips_fpe_exception (int mask
)
9040 if (mask
& OEX_FPU_INEX
)
9041 fputs ("INEX", stdout
), first
= 0;
9042 if (mask
& OEX_FPU_UFLO
)
9043 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9044 if (mask
& OEX_FPU_OFLO
)
9045 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9046 if (mask
& OEX_FPU_DIV0
)
9047 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9048 if (mask
& OEX_FPU_INVAL
)
9049 printf ("%sINVAL", first
? "" : "|");
9052 fputs ("0", stdout
);
9055 /* ARM EABI attributes section. */
9060 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9062 const char ** table
;
9063 } arm_attr_public_tag
;
9065 static const char * arm_attr_tag_CPU_arch
[] =
9066 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9067 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9068 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
9069 static const char * arm_attr_tag_THUMB_ISA_use
[] =
9070 {"No", "Thumb-1", "Thumb-2"};
9071 static const char * arm_attr_tag_VFP_arch
[] =
9072 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9073 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
9074 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
9075 static const char * arm_attr_tag_PCS_config
[] =
9076 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9077 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9078 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
9079 {"V6", "SB", "TLS", "Unused"};
9080 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
9081 {"Absolute", "PC-relative", "SB-relative", "None"};
9082 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
9083 {"Absolute", "PC-relative", "None"};
9084 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
9085 {"None", "direct", "GOT-indirect"};
9086 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
9087 {"None", "??? 1", "2", "??? 3", "4"};
9088 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
9089 static const char * arm_attr_tag_ABI_FP_denormal
[] =
9090 {"Unused", "Needed", "Sign only"};
9091 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
9092 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
9093 static const char * arm_attr_tag_ABI_FP_number_model
[] =
9094 {"Unused", "Finite", "RTABI", "IEEE 754"};
9095 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
9096 static const char * arm_attr_tag_ABI_align8_preserved
[] =
9097 {"No", "Yes, except leaf SP", "Yes"};
9098 static const char * arm_attr_tag_ABI_enum_size
[] =
9099 {"Unused", "small", "int", "forced to int"};
9100 static const char * arm_attr_tag_ABI_HardFP_use
[] =
9101 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9102 static const char * arm_attr_tag_ABI_VFP_args
[] =
9103 {"AAPCS", "VFP registers", "custom"};
9104 static const char * arm_attr_tag_ABI_WMMX_args
[] =
9105 {"AAPCS", "WMMX registers", "custom"};
9106 static const char * arm_attr_tag_ABI_optimization_goals
[] =
9107 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9108 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9109 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
9110 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9111 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9112 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
9113 static const char * arm_attr_tag_VFP_HP_extension
[] =
9114 {"Not Allowed", "Allowed"};
9115 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
9116 {"None", "IEEE 754", "Alternative Format"};
9117 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9118 static const char * arm_attr_tag_Virtualization_use
[] =
9119 {"Not Allowed", "Allowed"};
9120 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
9122 #define LOOKUP(id, name) \
9123 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9124 static arm_attr_public_tag arm_attr_public_tags
[] =
9126 {4, "CPU_raw_name", 1, NULL
},
9127 {5, "CPU_name", 1, NULL
},
9128 LOOKUP(6, CPU_arch
),
9129 {7, "CPU_arch_profile", 0, NULL
},
9130 LOOKUP(8, ARM_ISA_use
),
9131 LOOKUP(9, THUMB_ISA_use
),
9132 LOOKUP(10, VFP_arch
),
9133 LOOKUP(11, WMMX_arch
),
9134 LOOKUP(12, Advanced_SIMD_arch
),
9135 LOOKUP(13, PCS_config
),
9136 LOOKUP(14, ABI_PCS_R9_use
),
9137 LOOKUP(15, ABI_PCS_RW_data
),
9138 LOOKUP(16, ABI_PCS_RO_data
),
9139 LOOKUP(17, ABI_PCS_GOT_use
),
9140 LOOKUP(18, ABI_PCS_wchar_t
),
9141 LOOKUP(19, ABI_FP_rounding
),
9142 LOOKUP(20, ABI_FP_denormal
),
9143 LOOKUP(21, ABI_FP_exceptions
),
9144 LOOKUP(22, ABI_FP_user_exceptions
),
9145 LOOKUP(23, ABI_FP_number_model
),
9146 LOOKUP(24, ABI_align8_needed
),
9147 LOOKUP(25, ABI_align8_preserved
),
9148 LOOKUP(26, ABI_enum_size
),
9149 LOOKUP(27, ABI_HardFP_use
),
9150 LOOKUP(28, ABI_VFP_args
),
9151 LOOKUP(29, ABI_WMMX_args
),
9152 LOOKUP(30, ABI_optimization_goals
),
9153 LOOKUP(31, ABI_FP_optimization_goals
),
9154 {32, "compatibility", 0, NULL
},
9155 LOOKUP(34, CPU_unaligned_access
),
9156 LOOKUP(36, VFP_HP_extension
),
9157 LOOKUP(38, ABI_FP_16bit_format
),
9158 {64, "nodefaults", 0, NULL
},
9159 {65, "also_compatible_with", 0, NULL
},
9160 LOOKUP(66, T2EE_use
),
9161 {67, "conformance", 1, NULL
},
9162 LOOKUP(68, Virtualization_use
),
9163 LOOKUP(70, MPextension_use
)
9167 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9171 read_uleb128 (unsigned char * p
, unsigned int * plen
)
9185 val
|= ((unsigned int)c
& 0x7f) << shift
;
9194 static unsigned char *
9195 display_arm_attribute (unsigned char * p
)
9200 arm_attr_public_tag
* attr
;
9204 tag
= read_uleb128 (p
, &len
);
9207 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9209 if (arm_attr_public_tags
[i
].tag
== tag
)
9211 attr
= &arm_attr_public_tags
[i
];
9218 printf (" Tag_%s: ", attr
->name
);
9224 case 7: /* Tag_CPU_arch_profile. */
9225 val
= read_uleb128 (p
, &len
);
9229 case 0: printf ("None\n"); break;
9230 case 'A': printf ("Application\n"); break;
9231 case 'R': printf ("Realtime\n"); break;
9232 case 'M': printf ("Microcontroller\n"); break;
9233 default: printf ("??? (%d)\n", val
); break;
9237 case 32: /* Tag_compatibility. */
9238 val
= read_uleb128 (p
, &len
);
9240 printf ("flag = %d, vendor = %s\n", val
, p
);
9241 p
+= strlen ((char *) p
) + 1;
9244 case 64: /* Tag_nodefaults. */
9249 case 65: /* Tag_also_compatible_with. */
9250 val
= read_uleb128 (p
, &len
);
9252 if (val
== 6 /* Tag_CPU_arch. */)
9254 val
= read_uleb128 (p
, &len
);
9256 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
9257 printf ("??? (%d)\n", val
);
9259 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9263 while (*(p
++) != '\0' /* NUL terminator. */);
9277 assert (attr
->type
& 0x80);
9278 val
= read_uleb128 (p
, &len
);
9280 type
= attr
->type
& 0x7f;
9282 printf ("??? (%d)\n", val
);
9284 printf ("%s\n", attr
->table
[val
]);
9291 type
= 1; /* String. */
9293 type
= 2; /* uleb128. */
9294 printf (" Tag_unknown_%d: ", tag
);
9299 printf ("\"%s\"\n", p
);
9300 p
+= strlen ((char *) p
) + 1;
9304 val
= read_uleb128 (p
, &len
);
9306 printf ("%d (0x%x)\n", val
, val
);
9312 static unsigned char *
9313 display_gnu_attribute (unsigned char * p
,
9314 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9321 tag
= read_uleb128 (p
, &len
);
9324 /* Tag_compatibility is the only generic GNU attribute defined at
9328 val
= read_uleb128 (p
, &len
);
9330 printf ("flag = %d, vendor = %s\n", val
, p
);
9331 p
+= strlen ((char *) p
) + 1;
9335 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9336 return display_proc_gnu_attribute (p
, tag
);
9339 type
= 1; /* String. */
9341 type
= 2; /* uleb128. */
9342 printf (" Tag_unknown_%d: ", tag
);
9346 printf ("\"%s\"\n", p
);
9347 p
+= strlen ((char *) p
) + 1;
9351 val
= read_uleb128 (p
, &len
);
9353 printf ("%d (0x%x)\n", val
, val
);
9359 static unsigned char *
9360 display_power_gnu_attribute (unsigned char * p
, int tag
)
9366 if (tag
== Tag_GNU_Power_ABI_FP
)
9368 val
= read_uleb128 (p
, &len
);
9370 printf (" Tag_GNU_Power_ABI_FP: ");
9375 printf ("Hard or soft float\n");
9378 printf ("Hard float\n");
9381 printf ("Soft float\n");
9384 printf ("Single-precision hard float\n");
9387 printf ("??? (%d)\n", val
);
9393 if (tag
== Tag_GNU_Power_ABI_Vector
)
9395 val
= read_uleb128 (p
, &len
);
9397 printf (" Tag_GNU_Power_ABI_Vector: ");
9404 printf ("Generic\n");
9407 printf ("AltiVec\n");
9413 printf ("??? (%d)\n", val
);
9419 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9421 val
= read_uleb128 (p
, &len
);
9423 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9433 printf ("Memory\n");
9436 printf ("??? (%d)\n", val
);
9443 type
= 1; /* String. */
9445 type
= 2; /* uleb128. */
9446 printf (" Tag_unknown_%d: ", tag
);
9450 printf ("\"%s\"\n", p
);
9451 p
+= strlen ((char *) p
) + 1;
9455 val
= read_uleb128 (p
, &len
);
9457 printf ("%d (0x%x)\n", val
, val
);
9463 static unsigned char *
9464 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9470 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9472 val
= read_uleb128 (p
, &len
);
9474 printf (" Tag_GNU_MIPS_ABI_FP: ");
9479 printf ("Hard or soft float\n");
9482 printf ("Hard float (-mdouble-float)\n");
9485 printf ("Hard float (-msingle-float)\n");
9488 printf ("Soft float\n");
9491 printf ("64-bit float (-mips32r2 -mfp64)\n");
9494 printf ("??? (%d)\n", val
);
9501 type
= 1; /* String. */
9503 type
= 2; /* uleb128. */
9504 printf (" Tag_unknown_%d: ", tag
);
9508 printf ("\"%s\"\n", p
);
9509 p
+= strlen ((char *) p
) + 1;
9513 val
= read_uleb128 (p
, &len
);
9515 printf ("%d (0x%x)\n", val
, val
);
9522 process_attributes (FILE * file
,
9523 const char * public_name
,
9524 unsigned int proc_type
,
9525 unsigned char * (* display_pub_attribute
) (unsigned char *),
9526 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9528 Elf_Internal_Shdr
* sect
;
9529 unsigned char * contents
;
9531 unsigned char * end
;
9532 bfd_vma section_len
;
9536 /* Find the section header so that we get the size. */
9537 for (i
= 0, sect
= section_headers
;
9538 i
< elf_header
.e_shnum
;
9541 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9544 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
9545 sect
->sh_size
, _("attributes"));
9546 if (contents
== NULL
)
9552 len
= sect
->sh_size
- 1;
9558 bfd_boolean public_section
;
9559 bfd_boolean gnu_section
;
9561 section_len
= byte_get (p
, 4);
9564 if (section_len
> len
)
9566 printf (_("ERROR: Bad section length (%d > %d)\n"),
9567 (int) section_len
, (int) len
);
9572 printf ("Attribute Section: %s\n", p
);
9574 if (public_name
&& streq ((char *) p
, public_name
))
9575 public_section
= TRUE
;
9577 public_section
= FALSE
;
9579 if (streq ((char *) p
, "gnu"))
9582 gnu_section
= FALSE
;
9584 namelen
= strlen ((char *) p
) + 1;
9586 section_len
-= namelen
+ 4;
9588 while (section_len
> 0)
9594 size
= byte_get (p
, 4);
9595 if (size
> section_len
)
9597 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9598 (int) size
, (int) section_len
);
9602 section_len
-= size
;
9609 printf ("File Attributes\n");
9612 printf ("Section Attributes:");
9615 printf ("Symbol Attributes:");
9621 val
= read_uleb128 (p
, &j
);
9625 printf (" %d", val
);
9630 printf ("Unknown tag: %d\n", tag
);
9631 public_section
= FALSE
;
9638 p
= display_pub_attribute (p
);
9640 else if (gnu_section
)
9643 p
= display_gnu_attribute (p
,
9644 display_proc_gnu_attribute
);
9648 /* ??? Do something sensible, like dump hex. */
9649 printf (" Unknown section contexts\n");
9656 printf (_("Unknown format '%c'\n"), *p
);
9664 process_arm_specific (FILE * file
)
9666 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9667 display_arm_attribute
, NULL
);
9671 process_power_specific (FILE * file
)
9673 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9674 display_power_gnu_attribute
);
9677 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9678 Print the Address, Access and Initial fields of an entry at VMA ADDR
9679 and return the VMA of the next entry. */
9682 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9685 print_vma (addr
, LONG_HEX
);
9687 if (addr
< pltgot
+ 0xfff0)
9688 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9690 printf ("%10s", "");
9693 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9698 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9699 print_vma (entry
, LONG_HEX
);
9701 return addr
+ (is_32bit_elf
? 4 : 8);
9704 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9705 PLTGOT. Print the Address and Initial fields of an entry at VMA
9706 ADDR and return the VMA of the next entry. */
9709 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9712 print_vma (addr
, LONG_HEX
);
9715 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9720 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9721 print_vma (entry
, LONG_HEX
);
9723 return addr
+ (is_32bit_elf
? 4 : 8);
9727 process_mips_specific (FILE * file
)
9729 Elf_Internal_Dyn
* entry
;
9730 size_t liblist_offset
= 0;
9731 size_t liblistno
= 0;
9732 size_t conflictsno
= 0;
9733 size_t options_offset
= 0;
9734 size_t conflicts_offset
= 0;
9735 size_t pltrelsz
= 0;
9738 bfd_vma mips_pltgot
= 0;
9740 bfd_vma local_gotno
= 0;
9742 bfd_vma symtabno
= 0;
9744 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9745 display_mips_gnu_attribute
);
9747 /* We have a lot of special sections. Thanks SGI! */
9748 if (dynamic_section
== NULL
)
9749 /* No information available. */
9752 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9753 switch (entry
->d_tag
)
9755 case DT_MIPS_LIBLIST
:
9757 = offset_from_vma (file
, entry
->d_un
.d_val
,
9758 liblistno
* sizeof (Elf32_External_Lib
));
9760 case DT_MIPS_LIBLISTNO
:
9761 liblistno
= entry
->d_un
.d_val
;
9763 case DT_MIPS_OPTIONS
:
9764 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9766 case DT_MIPS_CONFLICT
:
9768 = offset_from_vma (file
, entry
->d_un
.d_val
,
9769 conflictsno
* sizeof (Elf32_External_Conflict
));
9771 case DT_MIPS_CONFLICTNO
:
9772 conflictsno
= entry
->d_un
.d_val
;
9775 pltgot
= entry
->d_un
.d_ptr
;
9777 case DT_MIPS_LOCAL_GOTNO
:
9778 local_gotno
= entry
->d_un
.d_val
;
9780 case DT_MIPS_GOTSYM
:
9781 gotsym
= entry
->d_un
.d_val
;
9783 case DT_MIPS_SYMTABNO
:
9784 symtabno
= entry
->d_un
.d_val
;
9786 case DT_MIPS_PLTGOT
:
9787 mips_pltgot
= entry
->d_un
.d_ptr
;
9790 pltrel
= entry
->d_un
.d_val
;
9793 pltrelsz
= entry
->d_un
.d_val
;
9796 jmprel
= entry
->d_un
.d_ptr
;
9802 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9804 Elf32_External_Lib
* elib
;
9807 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
9809 sizeof (Elf32_External_Lib
),
9813 printf ("\nSection '.liblist' contains %lu entries:\n",
9814 (unsigned long) liblistno
);
9815 fputs (" Library Time Stamp Checksum Version Flags\n",
9818 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9825 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9826 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9827 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9828 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9829 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9831 tmp
= gmtime (&atime
);
9832 snprintf (timebuf
, sizeof (timebuf
),
9833 "%04u-%02u-%02uT%02u:%02u:%02u",
9834 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9835 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9837 printf ("%3lu: ", (unsigned long) cnt
);
9838 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9839 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9841 printf ("<corrupt: %9ld>", liblist
.l_name
);
9842 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9845 if (liblist
.l_flags
== 0)
9856 { " EXACT_MATCH", LL_EXACT_MATCH
},
9857 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9858 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9859 { " EXPORTS", LL_EXPORTS
},
9860 { " DELAY_LOAD", LL_DELAY_LOAD
},
9861 { " DELTA", LL_DELTA
}
9863 int flags
= liblist
.l_flags
;
9866 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9867 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9869 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9870 flags
^= l_flags_vals
[fcnt
].bit
;
9873 printf (" %#x", (unsigned int) flags
);
9883 if (options_offset
!= 0)
9885 Elf_External_Options
* eopt
;
9886 Elf_Internal_Shdr
* sect
= section_headers
;
9887 Elf_Internal_Options
* iopt
;
9888 Elf_Internal_Options
* option
;
9892 /* Find the section header so that we get the size. */
9893 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9896 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
9897 sect
->sh_size
, _("options"));
9900 iopt
= (Elf_Internal_Options
*)
9901 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9904 error (_("Out of memory\n"));
9911 while (offset
< sect
->sh_size
)
9913 Elf_External_Options
* eoption
;
9915 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9917 option
->kind
= BYTE_GET (eoption
->kind
);
9918 option
->size
= BYTE_GET (eoption
->size
);
9919 option
->section
= BYTE_GET (eoption
->section
);
9920 option
->info
= BYTE_GET (eoption
->info
);
9922 offset
+= option
->size
;
9928 printf (_("\nSection '%s' contains %d entries:\n"),
9929 SECTION_NAME (sect
), cnt
);
9937 switch (option
->kind
)
9940 /* This shouldn't happen. */
9941 printf (" NULL %d %lx", option
->section
, option
->info
);
9944 printf (" REGINFO ");
9945 if (elf_header
.e_machine
== EM_MIPS
)
9948 Elf32_External_RegInfo
* ereg
;
9949 Elf32_RegInfo reginfo
;
9951 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9952 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9953 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9954 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9955 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9956 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9957 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9959 printf ("GPR %08lx GP 0x%lx\n",
9961 (unsigned long) reginfo
.ri_gp_value
);
9962 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9963 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9964 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9969 Elf64_External_RegInfo
* ereg
;
9970 Elf64_Internal_RegInfo reginfo
;
9972 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9973 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9974 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9975 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9976 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9977 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9978 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9980 printf ("GPR %08lx GP 0x",
9981 reginfo
.ri_gprmask
);
9982 printf_vma (reginfo
.ri_gp_value
);
9985 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9986 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9987 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9991 case ODK_EXCEPTIONS
:
9992 fputs (" EXCEPTIONS fpe_min(", stdout
);
9993 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9994 fputs (") fpe_max(", stdout
);
9995 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9996 fputs (")", stdout
);
9998 if (option
->info
& OEX_PAGE0
)
9999 fputs (" PAGE0", stdout
);
10000 if (option
->info
& OEX_SMM
)
10001 fputs (" SMM", stdout
);
10002 if (option
->info
& OEX_FPDBUG
)
10003 fputs (" FPDBUG", stdout
);
10004 if (option
->info
& OEX_DISMISS
)
10005 fputs (" DISMISS", stdout
);
10008 fputs (" PAD ", stdout
);
10009 if (option
->info
& OPAD_PREFIX
)
10010 fputs (" PREFIX", stdout
);
10011 if (option
->info
& OPAD_POSTFIX
)
10012 fputs (" POSTFIX", stdout
);
10013 if (option
->info
& OPAD_SYMBOL
)
10014 fputs (" SYMBOL", stdout
);
10017 fputs (" HWPATCH ", stdout
);
10018 if (option
->info
& OHW_R4KEOP
)
10019 fputs (" R4KEOP", stdout
);
10020 if (option
->info
& OHW_R8KPFETCH
)
10021 fputs (" R8KPFETCH", stdout
);
10022 if (option
->info
& OHW_R5KEOP
)
10023 fputs (" R5KEOP", stdout
);
10024 if (option
->info
& OHW_R5KCVTL
)
10025 fputs (" R5KCVTL", stdout
);
10028 fputs (" FILL ", stdout
);
10029 /* XXX Print content of info word? */
10032 fputs (" TAGS ", stdout
);
10033 /* XXX Print content of info word? */
10036 fputs (" HWAND ", stdout
);
10037 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10038 fputs (" R4KEOP_CHECKED", stdout
);
10039 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10040 fputs (" R4KEOP_CLEAN", stdout
);
10043 fputs (" HWOR ", stdout
);
10044 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10045 fputs (" R4KEOP_CHECKED", stdout
);
10046 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10047 fputs (" R4KEOP_CLEAN", stdout
);
10050 printf (" GP_GROUP %#06lx self-contained %#06lx",
10051 option
->info
& OGP_GROUP
,
10052 (option
->info
& OGP_SELF
) >> 16);
10055 printf (" IDENT %#06lx self-contained %#06lx",
10056 option
->info
& OGP_GROUP
,
10057 (option
->info
& OGP_SELF
) >> 16);
10060 /* This shouldn't happen. */
10061 printf (" %3d ??? %d %lx",
10062 option
->kind
, option
->section
, option
->info
);
10066 len
= sizeof (* eopt
);
10067 while (len
< option
->size
)
10068 if (((char *) option
)[len
] >= ' '
10069 && ((char *) option
)[len
] < 0x7f)
10070 printf ("%c", ((char *) option
)[len
++]);
10072 printf ("\\%03o", ((char *) option
)[len
++]);
10074 fputs ("\n", stdout
);
10082 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10084 Elf32_Conflict
* iconf
;
10087 if (dynamic_symbols
== NULL
)
10089 error (_("conflict list found without a dynamic symbol table\n"));
10093 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
10096 error (_("Out of memory\n"));
10102 Elf32_External_Conflict
* econf32
;
10104 econf32
= (Elf32_External_Conflict
*)
10105 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10106 sizeof (* econf32
), _("conflict"));
10110 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10111 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10117 Elf64_External_Conflict
* econf64
;
10119 econf64
= (Elf64_External_Conflict
*)
10120 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10121 sizeof (* econf64
), _("conflict"));
10125 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10126 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10131 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10132 (unsigned long) conflictsno
);
10133 puts (_(" Num: Index Value Name"));
10135 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10137 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10139 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10140 print_vma (psym
->st_value
, FULL_HEX
);
10142 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10143 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10145 printf ("<corrupt: %14ld>", psym
->st_name
);
10152 if (pltgot
!= 0 && local_gotno
!= 0)
10154 bfd_vma ent
, local_end
, global_end
;
10156 unsigned char * data
;
10160 addr_size
= (is_32bit_elf
? 4 : 8);
10161 local_end
= pltgot
+ local_gotno
* addr_size
;
10162 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10164 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10165 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10166 global_end
- pltgot
, 1, _("GOT"));
10167 printf (_("\nPrimary GOT:\n"));
10168 printf (_(" Canonical gp value: "));
10169 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10172 printf (_(" Reserved entries:\n"));
10173 printf (_(" %*s %10s %*s Purpose\n"),
10174 addr_size
* 2, "Address", "Access",
10175 addr_size
* 2, "Initial");
10176 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10177 printf (" Lazy resolver\n");
10179 && (byte_get (data
+ ent
- pltgot
, addr_size
)
10180 >> (addr_size
* 8 - 1)) != 0)
10182 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10183 printf (" Module pointer (GNU extension)\n");
10187 if (ent
< local_end
)
10189 printf (_(" Local entries:\n"));
10190 printf (_(" %*s %10s %*s\n"),
10191 addr_size
* 2, "Address", "Access",
10192 addr_size
* 2, "Initial");
10193 while (ent
< local_end
)
10195 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10201 if (gotsym
< symtabno
)
10205 printf (_(" Global entries:\n"));
10206 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10207 addr_size
* 2, "Address", "Access",
10208 addr_size
* 2, "Initial",
10209 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10210 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10211 for (i
= gotsym
; i
< symtabno
; i
++)
10213 Elf_Internal_Sym
* psym
;
10215 psym
= dynamic_symbols
+ i
;
10216 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10218 print_vma (psym
->st_value
, LONG_HEX
);
10219 printf (" %-7s %3s ",
10220 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10221 get_symbol_index_type (psym
->st_shndx
));
10222 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10223 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10225 printf ("<corrupt: %14ld>", psym
->st_name
);
10235 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10238 size_t offset
, rel_offset
;
10239 unsigned long count
, i
;
10240 unsigned char * data
;
10241 int addr_size
, sym_width
;
10242 Elf_Internal_Rela
* rels
;
10244 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10245 if (pltrel
== DT_RELA
)
10247 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10252 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10257 addr_size
= (is_32bit_elf
? 4 : 8);
10258 end
= mips_pltgot
+ (2 + count
) * addr_size
;
10260 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
10261 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
10263 printf (_("\nPLT GOT:\n\n"));
10264 printf (_(" Reserved entries:\n"));
10265 printf (_(" %*s %*s Purpose\n"),
10266 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10267 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10268 printf (" PLT lazy resolver\n");
10269 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10270 printf (" Module pointer\n");
10273 printf (_(" Entries:\n"));
10274 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10275 addr_size
* 2, "Address",
10276 addr_size
* 2, "Initial",
10277 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10278 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10279 for (i
= 0; i
< count
; i
++)
10281 Elf_Internal_Sym
* psym
;
10283 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10284 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
10286 print_vma (psym
->st_value
, LONG_HEX
);
10287 printf (" %-7s %3s ",
10288 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10289 get_symbol_index_type (psym
->st_shndx
));
10290 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10291 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10293 printf ("<corrupt: %14ld>", psym
->st_name
);
10307 process_gnu_liblist (FILE * file
)
10309 Elf_Internal_Shdr
* section
;
10310 Elf_Internal_Shdr
* string_sec
;
10311 Elf32_External_Lib
* elib
;
10313 size_t strtab_size
;
10320 for (i
= 0, section
= section_headers
;
10321 i
< elf_header
.e_shnum
;
10324 switch (section
->sh_type
)
10326 case SHT_GNU_LIBLIST
:
10327 if (section
->sh_link
>= elf_header
.e_shnum
)
10330 elib
= (Elf32_External_Lib
*)
10331 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10336 string_sec
= section_headers
+ section
->sh_link
;
10338 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10339 string_sec
->sh_size
,
10340 _("liblist string table"));
10341 strtab_size
= string_sec
->sh_size
;
10344 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10350 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10351 SECTION_NAME (section
),
10352 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10354 puts (" Library Time Stamp Checksum Version Flags");
10356 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10364 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10365 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10366 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10367 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10368 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10370 tmp
= gmtime (&atime
);
10371 snprintf (timebuf
, sizeof (timebuf
),
10372 "%04u-%02u-%02uT%02u:%02u:%02u",
10373 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10374 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10376 printf ("%3lu: ", (unsigned long) cnt
);
10378 printf ("%-20s", liblist
.l_name
< strtab_size
10379 ? strtab
+ liblist
.l_name
: "<corrupt>");
10381 printf ("%-20.20s", liblist
.l_name
< strtab_size
10382 ? strtab
+ liblist
.l_name
: "<corrupt>");
10383 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10384 liblist
.l_version
, liblist
.l_flags
);
10394 static const char *
10395 get_note_type (unsigned e_type
)
10397 static char buff
[64];
10399 if (elf_header
.e_type
== ET_CORE
)
10403 return _("NT_AUXV (auxiliary vector)");
10405 return _("NT_PRSTATUS (prstatus structure)");
10407 return _("NT_FPREGSET (floating point registers)");
10409 return _("NT_PRPSINFO (prpsinfo structure)");
10410 case NT_TASKSTRUCT
:
10411 return _("NT_TASKSTRUCT (task structure)");
10413 return _("NT_PRXFPREG (user_xfpregs structure)");
10415 return _("NT_PPC_VMX (ppc Altivec registers)");
10417 return _("NT_PPC_VSX (ppc VSX registers)");
10418 case NT_S390_HIGH_GPRS
:
10419 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
10421 return _("NT_PSTATUS (pstatus structure)");
10423 return _("NT_FPREGS (floating point registers)");
10425 return _("NT_PSINFO (psinfo structure)");
10427 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10429 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10430 case NT_WIN32PSTATUS
:
10431 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10439 return _("NT_VERSION (version)");
10441 return _("NT_ARCH (architecture)");
10446 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10450 static const char *
10451 get_gnu_elf_note_type (unsigned e_type
)
10453 static char buff
[64];
10457 case NT_GNU_ABI_TAG
:
10458 return _("NT_GNU_ABI_TAG (ABI version tag)");
10460 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10461 case NT_GNU_BUILD_ID
:
10462 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10463 case NT_GNU_GOLD_VERSION
:
10464 return _("NT_GNU_GOLD_VERSION (gold version)");
10469 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10473 static const char *
10474 get_netbsd_elfcore_note_type (unsigned e_type
)
10476 static char buff
[64];
10478 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10480 /* NetBSD core "procinfo" structure. */
10481 return _("NetBSD procinfo structure");
10484 /* As of Jan 2002 there are no other machine-independent notes
10485 defined for NetBSD core files. If the note type is less
10486 than the start of the machine-dependent note types, we don't
10489 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10491 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10495 switch (elf_header
.e_machine
)
10497 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10498 and PT_GETFPREGS == mach+2. */
10503 case EM_SPARC32PLUS
:
10507 case NT_NETBSDCORE_FIRSTMACH
+0:
10508 return _("PT_GETREGS (reg structure)");
10509 case NT_NETBSDCORE_FIRSTMACH
+2:
10510 return _("PT_GETFPREGS (fpreg structure)");
10516 /* On all other arch's, PT_GETREGS == mach+1 and
10517 PT_GETFPREGS == mach+3. */
10521 case NT_NETBSDCORE_FIRSTMACH
+1:
10522 return _("PT_GETREGS (reg structure)");
10523 case NT_NETBSDCORE_FIRSTMACH
+3:
10524 return _("PT_GETFPREGS (fpreg structure)");
10530 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10531 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10535 /* Note that by the ELF standard, the name field is already null byte
10536 terminated, and namesz includes the terminating null byte.
10537 I.E. the value of namesz for the name "FSF" is 4.
10539 If the value of namesz is zero, there is no name present. */
10541 process_note (Elf_Internal_Note
* pnote
)
10543 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10546 if (pnote
->namesz
== 0)
10547 /* If there is no note name, then use the default set of
10548 note type strings. */
10549 nt
= get_note_type (pnote
->type
);
10551 else if (const_strneq (pnote
->namedata
, "GNU"))
10552 /* GNU-specific object file notes. */
10553 nt
= get_gnu_elf_note_type (pnote
->type
);
10555 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10556 /* NetBSD-specific core file notes. */
10557 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10559 else if (strneq (pnote
->namedata
, "SPU/", 4))
10561 /* SPU-specific core file notes. */
10562 nt
= pnote
->namedata
+ 4;
10567 /* Don't recognize this note name; just use the default set of
10568 note type strings. */
10569 nt
= get_note_type (pnote
->type
);
10571 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10577 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10579 Elf_External_Note
* pnotes
;
10580 Elf_External_Note
* external
;
10586 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
10593 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10594 (unsigned long) offset
, (unsigned long) length
);
10595 printf (_(" Owner\t\tData size\tDescription\n"));
10597 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10599 Elf_External_Note
* next
;
10600 Elf_Internal_Note inote
;
10601 char * temp
= NULL
;
10603 inote
.type
= BYTE_GET (external
->type
);
10604 inote
.namesz
= BYTE_GET (external
->namesz
);
10605 inote
.namedata
= external
->name
;
10606 inote
.descsz
= BYTE_GET (external
->descsz
);
10607 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10608 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10610 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10612 if (((char *) next
) > (((char *) pnotes
) + length
))
10614 warn (_("corrupt note found at offset %lx into core notes\n"),
10615 (unsigned long) ((char *) external
- (char *) pnotes
));
10616 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10617 inote
.type
, inote
.namesz
, inote
.descsz
);
10623 /* Verify that name is null terminated. It appears that at least
10624 one version of Linux (RedHat 6.0) generates corefiles that don't
10625 comply with the ELF spec by failing to include the null byte in
10627 if (inote
.namedata
[inote
.namesz
] != '\0')
10629 temp
= (char *) malloc (inote
.namesz
+ 1);
10633 error (_("Out of memory\n"));
10638 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10639 temp
[inote
.namesz
] = 0;
10641 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10642 inote
.namedata
= temp
;
10645 res
&= process_note (& inote
);
10660 process_corefile_note_segments (FILE * file
)
10662 Elf_Internal_Phdr
* segment
;
10666 if (! get_program_headers (file
))
10669 for (i
= 0, segment
= program_headers
;
10670 i
< elf_header
.e_phnum
;
10673 if (segment
->p_type
== PT_NOTE
)
10674 res
&= process_corefile_note_segment (file
,
10675 (bfd_vma
) segment
->p_offset
,
10676 (bfd_vma
) segment
->p_filesz
);
10683 process_note_sections (FILE * file
)
10685 Elf_Internal_Shdr
* section
;
10689 for (i
= 0, section
= section_headers
;
10690 i
< elf_header
.e_shnum
;
10692 if (section
->sh_type
== SHT_NOTE
)
10693 res
&= process_corefile_note_segment (file
,
10694 (bfd_vma
) section
->sh_offset
,
10695 (bfd_vma
) section
->sh_size
);
10701 process_notes (FILE * file
)
10703 /* If we have not been asked to display the notes then do nothing. */
10707 if (elf_header
.e_type
!= ET_CORE
)
10708 return process_note_sections (file
);
10710 /* No program headers means no NOTE segment. */
10711 if (elf_header
.e_phnum
> 0)
10712 return process_corefile_note_segments (file
);
10714 printf (_("No note segments present in the core file.\n"));
10719 process_arch_specific (FILE * file
)
10724 switch (elf_header
.e_machine
)
10727 return process_arm_specific (file
);
10729 case EM_MIPS_RS3_LE
:
10730 return process_mips_specific (file
);
10733 return process_power_specific (file
);
10742 get_file_header (FILE * file
)
10744 /* Read in the identity array. */
10745 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10748 /* Determine how to read the rest of the header. */
10749 switch (elf_header
.e_ident
[EI_DATA
])
10751 default: /* fall through */
10752 case ELFDATANONE
: /* fall through */
10754 byte_get
= byte_get_little_endian
;
10755 byte_put
= byte_put_little_endian
;
10758 byte_get
= byte_get_big_endian
;
10759 byte_put
= byte_put_big_endian
;
10763 /* For now we only support 32 bit and 64 bit ELF files. */
10764 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10766 /* Read in the rest of the header. */
10769 Elf32_External_Ehdr ehdr32
;
10771 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10774 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10775 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10776 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10777 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10778 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10779 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10780 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10781 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10782 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10783 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10784 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10785 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10786 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10790 Elf64_External_Ehdr ehdr64
;
10792 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10793 we will not be able to cope with the 64bit data found in
10794 64 ELF files. Detect this now and abort before we start
10795 overwriting things. */
10796 if (sizeof (bfd_vma
) < 8)
10798 error (_("This instance of readelf has been built without support for a\n\
10799 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10803 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10806 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10807 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10808 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10809 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10810 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10811 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10812 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10813 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10814 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10815 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10816 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10817 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10818 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10821 if (elf_header
.e_shoff
)
10823 /* There may be some extensions in the first section header. Don't
10824 bomb if we can't read it. */
10826 get_32bit_section_headers (file
, 1);
10828 get_64bit_section_headers (file
, 1);
10834 /* Process one ELF object file according to the command line options.
10835 This file may actually be stored in an archive. The file is
10836 positioned at the start of the ELF object. */
10839 process_object (char * file_name
, FILE * file
)
10843 if (! get_file_header (file
))
10845 error (_("%s: Failed to read file header\n"), file_name
);
10849 /* Initialise per file variables. */
10850 for (i
= ARRAY_SIZE (version_info
); i
--;)
10851 version_info
[i
] = 0;
10853 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10854 dynamic_info
[i
] = 0;
10856 /* Process the file. */
10858 printf (_("\nFile: %s\n"), file_name
);
10860 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10861 Note we do this even if cmdline_dump_sects is empty because we
10862 must make sure that the dump_sets array is zeroed out before each
10863 object file is processed. */
10864 if (num_dump_sects
> num_cmdline_dump_sects
)
10865 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10867 if (num_cmdline_dump_sects
> 0)
10869 if (num_dump_sects
== 0)
10870 /* A sneaky way of allocating the dump_sects array. */
10871 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10873 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10874 memcpy (dump_sects
, cmdline_dump_sects
,
10875 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10878 if (! process_file_header ())
10881 if (! process_section_headers (file
))
10883 /* Without loaded section headers we cannot process lots of
10885 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10887 if (! do_using_dynamic
)
10888 do_syms
= do_dyn_syms
= do_reloc
= 0;
10891 if (! process_section_groups (file
))
10893 /* Without loaded section groups we cannot process unwind. */
10897 if (process_program_headers (file
))
10898 process_dynamic_section (file
);
10900 process_relocs (file
);
10902 process_unwind (file
);
10904 process_symbol_table (file
);
10906 process_syminfo (file
);
10908 process_version_sections (file
);
10910 process_section_contents (file
);
10912 process_notes (file
);
10914 process_gnu_liblist (file
);
10916 process_arch_specific (file
);
10918 if (program_headers
)
10920 free (program_headers
);
10921 program_headers
= NULL
;
10924 if (section_headers
)
10926 free (section_headers
);
10927 section_headers
= NULL
;
10932 free (string_table
);
10933 string_table
= NULL
;
10934 string_table_length
= 0;
10937 if (dynamic_strings
)
10939 free (dynamic_strings
);
10940 dynamic_strings
= NULL
;
10941 dynamic_strings_length
= 0;
10944 if (dynamic_symbols
)
10946 free (dynamic_symbols
);
10947 dynamic_symbols
= NULL
;
10948 num_dynamic_syms
= 0;
10951 if (dynamic_syminfo
)
10953 free (dynamic_syminfo
);
10954 dynamic_syminfo
= NULL
;
10957 if (section_headers_groups
)
10959 free (section_headers_groups
);
10960 section_headers_groups
= NULL
;
10963 if (section_groups
)
10965 struct group_list
* g
;
10966 struct group_list
* next
;
10968 for (i
= 0; i
< group_count
; i
++)
10970 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10977 free (section_groups
);
10978 section_groups
= NULL
;
10981 free_debug_memory ();
10986 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10987 to the path name of the thin archive itself if necessary. Always returns
10988 a pointer to malloc'ed memory. */
10991 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10993 char * member_file_name
;
10994 const char * base_name
= lbasename (file_name
);
10996 /* This is a proxy entry for a thin archive member.
10997 If the extended name table contains an absolute path
10998 name, or if the archive is in the current directory,
10999 use the path name as given. Otherwise, we need to
11000 find the member relative to the directory where the
11001 archive is located. */
11002 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
11004 member_file_name
= (char *) malloc (name_len
+ 1);
11005 if (member_file_name
== NULL
)
11007 error (_("Out of memory\n"));
11010 memcpy (member_file_name
, name
, name_len
);
11011 member_file_name
[name_len
] = '\0';
11015 /* Concatenate the path components of the archive file name
11016 to the relative path name from the extended name table. */
11017 size_t prefix_len
= base_name
- file_name
;
11018 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
11019 if (member_file_name
== NULL
)
11021 error (_("Out of memory\n"));
11024 memcpy (member_file_name
, file_name
, prefix_len
);
11025 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
11026 member_file_name
[prefix_len
+ name_len
] = '\0';
11028 return member_file_name
;
11031 /* Structure to hold information about an archive file. */
11033 struct archive_info
11035 char * file_name
; /* Archive file name. */
11036 FILE * file
; /* Open file descriptor. */
11037 unsigned long index_num
; /* Number of symbols in table. */
11038 unsigned long * index_array
; /* The array of member offsets. */
11039 char * sym_table
; /* The symbol table. */
11040 unsigned long sym_size
; /* Size of the symbol table. */
11041 char * longnames
; /* The long file names table. */
11042 unsigned long longnames_size
; /* Size of the long file names table. */
11043 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
11044 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
11045 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
11046 struct ar_hdr arhdr
; /* Current archive header. */
11049 /* Read the symbol table and long-name table from an archive. */
11052 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
11053 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
11056 unsigned long size
;
11058 arch
->file_name
= strdup (file_name
);
11060 arch
->index_num
= 0;
11061 arch
->index_array
= NULL
;
11062 arch
->sym_table
= NULL
;
11063 arch
->sym_size
= 0;
11064 arch
->longnames
= NULL
;
11065 arch
->longnames_size
= 0;
11066 arch
->nested_member_origin
= 0;
11067 arch
->is_thin_archive
= is_thin_archive
;
11068 arch
->next_arhdr_offset
= SARMAG
;
11070 /* Read the first archive member header. */
11071 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
11073 error (_("%s: failed to seek to first archive header\n"), file_name
);
11076 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11077 if (got
!= sizeof arch
->arhdr
)
11082 error (_("%s: failed to read archive header\n"), file_name
);
11086 /* See if this is the archive symbol table. */
11087 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
11088 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
11090 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11091 size
= size
+ (size
& 1);
11093 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
11098 /* A buffer used to hold numbers read in from an archive index.
11099 These are always 4 bytes long and stored in big-endian format. */
11100 #define SIZEOF_AR_INDEX_NUMBERS 4
11101 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
11102 unsigned char * index_buffer
;
11104 /* Check the size of the archive index. */
11105 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
11107 error (_("%s: the archive index is empty\n"), file_name
);
11111 /* Read the numer of entries in the archive index. */
11112 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
11113 if (got
!= sizeof (integer_buffer
))
11115 error (_("%s: failed to read archive index\n"), file_name
);
11118 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
11119 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11121 /* Read in the archive index. */
11122 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11124 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11125 file_name
, arch
->index_num
);
11128 index_buffer
= (unsigned char *)
11129 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11130 if (index_buffer
== NULL
)
11132 error (_("Out of memory whilst trying to read archive symbol index\n"));
11135 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11136 if (got
!= arch
->index_num
)
11138 free (index_buffer
);
11139 error (_("%s: failed to read archive index\n"), file_name
);
11142 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11144 /* Convert the index numbers into the host's numeric format. */
11145 arch
->index_array
= (long unsigned int *)
11146 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11147 if (arch
->index_array
== NULL
)
11149 free (index_buffer
);
11150 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11154 for (i
= 0; i
< arch
->index_num
; i
++)
11155 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11156 SIZEOF_AR_INDEX_NUMBERS
);
11157 free (index_buffer
);
11159 /* The remaining space in the header is taken up by the symbol table. */
11162 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11165 arch
->sym_table
= (char *) malloc (size
);
11166 arch
->sym_size
= size
;
11167 if (arch
->sym_table
== NULL
)
11169 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11172 got
= fread (arch
->sym_table
, 1, size
, file
);
11175 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11181 if (fseek (file
, size
, SEEK_CUR
) != 0)
11183 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11188 /* Read the next archive header. */
11189 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11190 if (got
!= sizeof arch
->arhdr
)
11194 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11198 else if (read_symbols
)
11199 printf (_("%s has no archive index\n"), file_name
);
11201 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11203 /* This is the archive string table holding long member names. */
11204 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11205 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11207 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11208 if (arch
->longnames
== NULL
)
11210 error (_("Out of memory reading long symbol names in archive\n"));
11214 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
11216 free (arch
->longnames
);
11217 arch
->longnames
= NULL
;
11218 error (_("%s: failed to read long symbol name string table\n"), file_name
);
11222 if ((arch
->longnames_size
& 1) != 0)
11229 /* Release the memory used for the archive information. */
11232 release_archive (struct archive_info
* arch
)
11234 if (arch
->file_name
!= NULL
)
11235 free (arch
->file_name
);
11236 if (arch
->index_array
!= NULL
)
11237 free (arch
->index_array
);
11238 if (arch
->sym_table
!= NULL
)
11239 free (arch
->sym_table
);
11240 if (arch
->longnames
!= NULL
)
11241 free (arch
->longnames
);
11244 /* Open and setup a nested archive, if not already open. */
11247 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
11249 FILE * member_file
;
11251 /* Have we already setup this archive? */
11252 if (nested_arch
->file_name
!= NULL
11253 && streq (nested_arch
->file_name
, member_file_name
))
11256 /* Close previous file and discard cached information. */
11257 if (nested_arch
->file
!= NULL
)
11258 fclose (nested_arch
->file
);
11259 release_archive (nested_arch
);
11261 member_file
= fopen (member_file_name
, "rb");
11262 if (member_file
== NULL
)
11264 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
11268 get_archive_member_name_at (struct archive_info
* arch
,
11269 unsigned long offset
,
11270 struct archive_info
* nested_arch
);
11272 /* Get the name of an archive member from the current archive header.
11273 For simple names, this will modify the ar_name field of the current
11274 archive header. For long names, it will return a pointer to the
11275 longnames table. For nested archives, it will open the nested archive
11276 and get the name recursively. NESTED_ARCH is a single-entry cache so
11277 we don't keep rereading the same information from a nested archive. */
11280 get_archive_member_name (struct archive_info
* arch
,
11281 struct archive_info
* nested_arch
)
11283 unsigned long j
, k
;
11285 if (arch
->arhdr
.ar_name
[0] == '/')
11287 /* We have a long name. */
11289 char * member_file_name
;
11290 char * member_name
;
11292 arch
->nested_member_origin
= 0;
11293 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11294 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11295 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11297 while ((j
< arch
->longnames_size
)
11298 && (arch
->longnames
[j
] != '\n')
11299 && (arch
->longnames
[j
] != '\0'))
11301 if (arch
->longnames
[j
-1] == '/')
11303 arch
->longnames
[j
] = '\0';
11305 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11306 return arch
->longnames
+ k
;
11308 /* This is a proxy for a member of a nested archive.
11309 Find the name of the member in that archive. */
11310 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11311 if (member_file_name
!= NULL
11312 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11313 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11315 free (member_file_name
);
11316 return member_name
;
11318 free (member_file_name
);
11320 /* Last resort: just return the name of the nested archive. */
11321 return arch
->longnames
+ k
;
11324 /* We have a normal (short) name. */
11326 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11328 arch
->arhdr
.ar_name
[j
] = '\0';
11329 return arch
->arhdr
.ar_name
;
11332 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11335 get_archive_member_name_at (struct archive_info
* arch
,
11336 unsigned long offset
,
11337 struct archive_info
* nested_arch
)
11341 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11343 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11346 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11347 if (got
!= sizeof arch
->arhdr
)
11349 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11352 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11354 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11358 return get_archive_member_name (arch
, nested_arch
);
11361 /* Construct a string showing the name of the archive member, qualified
11362 with the name of the containing archive file. For thin archives, we
11363 use square brackets to denote the indirection. For nested archives,
11364 we show the qualified name of the external member inside the square
11365 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11368 make_qualified_name (struct archive_info
* arch
,
11369 struct archive_info
* nested_arch
,
11370 char * member_name
)
11375 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11376 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11377 len
+= strlen (nested_arch
->file_name
) + 2;
11379 name
= (char *) malloc (len
);
11382 error (_("Out of memory\n"));
11386 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11387 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11388 else if (arch
->is_thin_archive
)
11389 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11391 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11396 /* Process an ELF archive.
11397 On entry the file is positioned just after the ARMAG string. */
11400 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11402 struct archive_info arch
;
11403 struct archive_info nested_arch
;
11405 size_t file_name_size
;
11410 /* The ARCH structure is used to hold information about this archive. */
11411 arch
.file_name
= NULL
;
11413 arch
.index_array
= NULL
;
11414 arch
.sym_table
= NULL
;
11415 arch
.longnames
= NULL
;
11417 /* The NESTED_ARCH structure is used as a single-item cache of information
11418 about a nested archive (when members of a thin archive reside within
11419 another regular archive file). */
11420 nested_arch
.file_name
= NULL
;
11421 nested_arch
.file
= NULL
;
11422 nested_arch
.index_array
= NULL
;
11423 nested_arch
.sym_table
= NULL
;
11424 nested_arch
.longnames
= NULL
;
11426 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11432 if (do_archive_index
)
11434 if (arch
.sym_table
== NULL
)
11435 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11439 unsigned long current_pos
;
11441 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11442 file_name
, arch
.index_num
, arch
.sym_size
);
11443 current_pos
= ftell (file
);
11445 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11447 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11449 char * member_name
;
11451 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11453 if (member_name
!= NULL
)
11455 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11457 if (qualified_name
!= NULL
)
11459 printf (_("Binary %s contains:\n"), qualified_name
);
11460 free (qualified_name
);
11465 if (l
>= arch
.sym_size
)
11467 error (_("%s: end of the symbol table reached before the end of the index\n"),
11471 printf ("\t%s\n", arch
.sym_table
+ l
);
11472 l
+= strlen (arch
.sym_table
+ l
) + 1;
11477 if (l
< arch
.sym_size
)
11478 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11481 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11483 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11489 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11490 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11491 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11492 && !do_section_groups
&& !do_dyn_syms
)
11494 ret
= 0; /* Archive index only. */
11499 file_name_size
= strlen (file_name
);
11506 char * qualified_name
;
11508 /* Read the next archive header. */
11509 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11511 error (_("%s: failed to seek to next archive header\n"), file_name
);
11514 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11515 if (got
!= sizeof arch
.arhdr
)
11519 error (_("%s: failed to read archive header\n"), file_name
);
11523 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11525 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11530 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11532 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11533 if (archive_file_size
& 01)
11534 ++archive_file_size
;
11536 name
= get_archive_member_name (&arch
, &nested_arch
);
11539 error (_("%s: bad archive file name\n"), file_name
);
11543 namelen
= strlen (name
);
11545 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11546 if (qualified_name
== NULL
)
11548 error (_("%s: bad archive file name\n"), file_name
);
11553 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11555 /* This is a proxy for an external member of a thin archive. */
11556 FILE * member_file
;
11557 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11558 if (member_file_name
== NULL
)
11564 member_file
= fopen (member_file_name
, "rb");
11565 if (member_file
== NULL
)
11567 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11568 free (member_file_name
);
11573 archive_file_offset
= arch
.nested_member_origin
;
11575 ret
|= process_object (qualified_name
, member_file
);
11577 fclose (member_file
);
11578 free (member_file_name
);
11580 else if (is_thin_archive
)
11582 /* This is a proxy for a member of a nested archive. */
11583 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11585 /* The nested archive file will have been opened and setup by
11586 get_archive_member_name. */
11587 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11589 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11594 ret
|= process_object (qualified_name
, nested_arch
.file
);
11598 archive_file_offset
= arch
.next_arhdr_offset
;
11599 arch
.next_arhdr_offset
+= archive_file_size
;
11601 ret
|= process_object (qualified_name
, file
);
11604 free (qualified_name
);
11608 if (nested_arch
.file
!= NULL
)
11609 fclose (nested_arch
.file
);
11610 release_archive (&nested_arch
);
11611 release_archive (&arch
);
11617 process_file (char * file_name
)
11620 struct stat statbuf
;
11621 char armag
[SARMAG
];
11624 if (stat (file_name
, &statbuf
) < 0)
11626 if (errno
== ENOENT
)
11627 error (_("'%s': No such file\n"), file_name
);
11629 error (_("Could not locate '%s'. System error message: %s\n"),
11630 file_name
, strerror (errno
));
11634 if (! S_ISREG (statbuf
.st_mode
))
11636 error (_("'%s' is not an ordinary file\n"), file_name
);
11640 file
= fopen (file_name
, "rb");
11643 error (_("Input file '%s' is not readable.\n"), file_name
);
11647 if (fread (armag
, SARMAG
, 1, file
) != 1)
11649 error (_("%s: Failed to read file's magic number\n"), file_name
);
11654 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11655 ret
= process_archive (file_name
, file
, FALSE
);
11656 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11657 ret
= process_archive (file_name
, file
, TRUE
);
11660 if (do_archive_index
)
11661 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11665 archive_file_size
= archive_file_offset
= 0;
11666 ret
= process_object (file_name
, file
);
11674 #ifdef SUPPORT_DISASSEMBLY
11675 /* Needed by the i386 disassembler. For extra credit, someone could
11676 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11680 print_address (unsigned int addr
, FILE * outfile
)
11682 fprintf (outfile
,"0x%8.8x", addr
);
11685 /* Needed by the i386 disassembler. */
11687 db_task_printsym (unsigned int addr
)
11689 print_address (addr
, stderr
);
11694 main (int argc
, char ** argv
)
11698 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11699 setlocale (LC_MESSAGES
, "");
11701 #if defined (HAVE_SETLOCALE)
11702 setlocale (LC_CTYPE
, "");
11704 bindtextdomain (PACKAGE
, LOCALEDIR
);
11705 textdomain (PACKAGE
);
11707 expandargv (&argc
, &argv
);
11709 parse_args (argc
, argv
);
11711 if (num_dump_sects
> 0)
11713 /* Make a copy of the dump_sects array. */
11714 cmdline_dump_sects
= (dump_type
*)
11715 malloc (num_dump_sects
* sizeof (* dump_sects
));
11716 if (cmdline_dump_sects
== NULL
)
11717 error (_("Out of memory allocating dump request table.\n"));
11720 memcpy (cmdline_dump_sects
, dump_sects
,
11721 num_dump_sects
* sizeof (* dump_sects
));
11722 num_cmdline_dump_sects
= num_dump_sects
;
11726 if (optind
< (argc
- 1))
11730 while (optind
< argc
)
11731 err
|= process_file (argv
[optind
++]);
11733 if (dump_sects
!= NULL
)
11735 if (cmdline_dump_sects
!= NULL
)
11736 free (cmdline_dump_sects
);