1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/fr30.h"
107 #include "elf/hppa.h"
108 #include "elf/i386.h"
109 #include "elf/i370.h"
110 #include "elf/i860.h"
111 #include "elf/i960.h"
112 #include "elf/ia64.h"
113 #include "elf/ip2k.h"
114 #include "elf/lm32.h"
115 #include "elf/iq2000.h"
116 #include "elf/m32c.h"
117 #include "elf/m32r.h"
118 #include "elf/m68k.h"
119 #include "elf/m68hc11.h"
120 #include "elf/mcore.h"
122 #include "elf/microblaze.h"
123 #include "elf/mips.h"
124 #include "elf/mmix.h"
125 #include "elf/mn10200.h"
126 #include "elf/mn10300.h"
128 #include "elf/msp430.h"
129 #include "elf/or32.h"
132 #include "elf/ppc64.h"
133 #include "elf/s390.h"
134 #include "elf/score.h"
136 #include "elf/sparc.h"
138 #include "elf/v850.h"
140 #include "elf/x86-64.h"
141 #include "elf/xstormy16.h"
142 #include "elf/xtensa.h"
147 #include "libiberty.h"
148 #include "safe-ctype.h"
149 #include "filenames.h"
151 char * program_name
= "readelf";
152 static long archive_file_offset
;
153 static unsigned long archive_file_size
;
154 static unsigned long dynamic_addr
;
155 static bfd_size_type dynamic_size
;
156 static unsigned int dynamic_nent
;
157 static char * dynamic_strings
;
158 static unsigned long dynamic_strings_length
;
159 static char * string_table
;
160 static unsigned long string_table_length
;
161 static unsigned long num_dynamic_syms
;
162 static Elf_Internal_Sym
* dynamic_symbols
;
163 static Elf_Internal_Syminfo
* dynamic_syminfo
;
164 static unsigned long dynamic_syminfo_offset
;
165 static unsigned int dynamic_syminfo_nent
;
166 static char program_interpreter
[PATH_MAX
];
167 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
168 static bfd_vma dynamic_info_DT_GNU_HASH
;
169 static bfd_vma version_info
[16];
170 static Elf_Internal_Ehdr elf_header
;
171 static Elf_Internal_Shdr
* section_headers
;
172 static Elf_Internal_Phdr
* program_headers
;
173 static Elf_Internal_Dyn
* dynamic_section
;
174 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
175 static int show_name
;
176 static int do_dynamic
;
179 static int do_sections
;
180 static int do_section_groups
;
181 static int do_section_details
;
182 static int do_segments
;
183 static int do_unwind
;
184 static int do_using_dynamic
;
185 static int do_header
;
187 static int do_version
;
188 static int do_histogram
;
189 static int do_debugging
;
192 static int do_archive_index
;
193 static int is_32bit_elf
;
197 struct group_list
* next
;
198 unsigned int section_index
;
203 struct group_list
* root
;
204 unsigned int group_index
;
207 static size_t group_count
;
208 static struct group
* section_groups
;
209 static struct group
** section_headers_groups
;
212 /* Flag bits indicating particular types of dump. */
213 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
214 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
215 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
216 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
217 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
219 typedef unsigned char dump_type
;
221 /* A linked list of the section names for which dumps were requested. */
222 struct dump_list_entry
226 struct dump_list_entry
* next
;
228 static struct dump_list_entry
* dump_sects_byname
;
230 /* A dynamic array of flags indicating for which sections a dump
231 has been requested via command line switches. */
232 static dump_type
* cmdline_dump_sects
= NULL
;
233 static unsigned int num_cmdline_dump_sects
= 0;
235 /* A dynamic array of flags indicating for which sections a dump of
236 some kind has been requested. It is reset on a per-object file
237 basis and then initialised from the cmdline_dump_sects array,
238 the results of interpreting the -w switch, and the
239 dump_sects_byname list. */
240 static dump_type
* dump_sects
= NULL
;
241 static unsigned int num_dump_sects
= 0;
244 /* How to print a vma value. */
245 typedef enum print_mode
257 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
261 #define SECTION_NAME(X) \
262 ((X) == NULL ? "<none>" \
263 : string_table == NULL ? "<no-name>" \
264 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
265 : string_table + (X)->sh_name))
267 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
269 #define BYTE_GET(field) byte_get (field, sizeof (field))
271 #define GET_ELF_SYMBOLS(file, section) \
272 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
273 : get_64bit_elf_symbols (file, section))
275 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
276 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
277 already been called and verified that the string exists. */
278 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
280 /* This is just a bit of syntatic sugar. */
281 #define streq(a,b) (strcmp ((a), (b)) == 0)
282 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
283 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
286 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
291 if (size
== 0 || nmemb
== 0)
294 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
296 error (_("Unable to seek to 0x%lx for %s\n"),
297 (unsigned long) archive_file_offset
+ offset
, reason
);
304 /* Check for overflow. */
305 if (nmemb
< (~(size_t) 0 - 1) / size
)
306 /* + 1 so that we can '\0' terminate invalid string table sections. */
307 mvar
= malloc (size
* nmemb
+ 1);
311 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
312 (unsigned long)(size
* nmemb
), reason
);
316 ((char *) mvar
)[size
* nmemb
] = '\0';
319 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
321 error (_("Unable to read in 0x%lx bytes of %s\n"),
322 (unsigned long)(size
* nmemb
), reason
);
332 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
337 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
338 field
[6] = ((value
>> 24) >> 24) & 0xff;
339 field
[5] = ((value
>> 24) >> 16) & 0xff;
340 field
[4] = ((value
>> 24) >> 8) & 0xff;
343 field
[3] = (value
>> 24) & 0xff;
346 field
[2] = (value
>> 16) & 0xff;
349 field
[1] = (value
>> 8) & 0xff;
352 field
[0] = value
& 0xff;
356 error (_("Unhandled data length: %d\n"), size
);
361 /* Print a VMA value. */
364 print_vma (bfd_vma vma
, print_mode mode
)
377 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
384 return printf ("%5" BFD_VMA_FMT
"d", vma
);
392 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
395 return printf ("%" BFD_VMA_FMT
"d", vma
);
398 return printf ("%" BFD_VMA_FMT
"u", vma
);
403 /* Display a symbol on stdout. Handles the display of non-printing characters.
405 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
406 truncating as necessary. If WIDTH is negative then format the string to be
407 exactly - WIDTH characters, truncating or padding as necessary.
409 Returns the number of emitted characters. */
412 print_symbol (int width
, const char * symbol
)
415 bfd_boolean extra_padding
= FALSE
;
416 unsigned int num_printed
= 0;
420 /* Set the width to a very large value. This simplifies the code below. */
425 /* Keep the width positive. This also helps. */
427 extra_padding
= TRUE
;
436 /* Look for non-printing symbols inside the symbol's name.
437 This test is triggered in particular by the names generated
438 by the assembler for local labels. */
439 while (ISPRINT (* c
))
449 printf ("%.*s", len
, symbol
);
455 if (* c
== 0 || width
== 0)
458 /* Now display the non-printing character, if
459 there is room left in which to dipslay it. */
465 printf ("^%c", *c
+ 0x40);
475 printf ("<0x%.2x>", *c
);
484 if (extra_padding
&& width
> 0)
486 /* Fill in the remaining spaces. */
487 printf ("%-*s", width
, " ");
495 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
500 field
[7] = value
& 0xff;
501 field
[6] = (value
>> 8) & 0xff;
502 field
[5] = (value
>> 16) & 0xff;
503 field
[4] = (value
>> 24) & 0xff;
508 field
[3] = value
& 0xff;
512 field
[2] = value
& 0xff;
516 field
[1] = value
& 0xff;
520 field
[0] = value
& 0xff;
524 error (_("Unhandled data length: %d\n"), size
);
529 /* Return a pointer to section NAME, or NULL if no such section exists. */
531 static Elf_Internal_Shdr
*
532 find_section (const char * name
)
536 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
537 if (streq (SECTION_NAME (section_headers
+ i
), name
))
538 return section_headers
+ i
;
543 /* Guess the relocation size commonly used by the specific machines. */
546 guess_is_rela (unsigned int e_machine
)
550 /* Targets that use REL relocations. */
566 /* Targets that use RELA relocations. */
570 case EM_ALTERA_NIOS2
:
590 case EM_LATTICEMICO32
:
598 case EM_CYGNUS_MN10200
:
600 case EM_CYGNUS_MN10300
:
623 case EM_MICROBLAZE_OLD
:
644 warn (_("Don't know about relocations on this machine architecture\n"));
650 slurp_rela_relocs (FILE * file
,
651 unsigned long rel_offset
,
652 unsigned long rel_size
,
653 Elf_Internal_Rela
** relasp
,
654 unsigned long * nrelasp
)
656 Elf_Internal_Rela
* relas
;
657 unsigned long nrelas
;
662 Elf32_External_Rela
* erelas
;
664 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
665 rel_size
, _("relocs"));
669 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
671 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
672 sizeof (Elf_Internal_Rela
));
677 error (_("out of memory parsing relocs\n"));
681 for (i
= 0; i
< nrelas
; i
++)
683 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
684 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
685 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
692 Elf64_External_Rela
* erelas
;
694 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
695 rel_size
, _("relocs"));
699 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
701 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
702 sizeof (Elf_Internal_Rela
));
707 error (_("out of memory parsing relocs\n"));
711 for (i
= 0; i
< nrelas
; i
++)
713 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
714 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
715 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
717 /* The #ifdef BFD64 below is to prevent a compile time
718 warning. We know that if we do not have a 64 bit data
719 type that we will never execute this code anyway. */
721 if (elf_header
.e_machine
== EM_MIPS
722 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
724 /* In little-endian objects, r_info isn't really a
725 64-bit little-endian value: it has a 32-bit
726 little-endian symbol index followed by four
727 individual byte fields. Reorder INFO
729 bfd_vma info
= relas
[i
].r_info
;
730 info
= (((info
& 0xffffffff) << 32)
731 | ((info
>> 56) & 0xff)
732 | ((info
>> 40) & 0xff00)
733 | ((info
>> 24) & 0xff0000)
734 | ((info
>> 8) & 0xff000000));
735 relas
[i
].r_info
= info
;
748 slurp_rel_relocs (FILE * file
,
749 unsigned long rel_offset
,
750 unsigned long rel_size
,
751 Elf_Internal_Rela
** relsp
,
752 unsigned long * nrelsp
)
754 Elf_Internal_Rela
* rels
;
760 Elf32_External_Rel
* erels
;
762 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
763 rel_size
, _("relocs"));
767 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
769 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
774 error (_("out of memory parsing relocs\n"));
778 for (i
= 0; i
< nrels
; i
++)
780 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
781 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
782 rels
[i
].r_addend
= 0;
789 Elf64_External_Rel
* erels
;
791 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
792 rel_size
, _("relocs"));
796 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
798 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
803 error (_("out of memory parsing relocs\n"));
807 for (i
= 0; i
< nrels
; i
++)
809 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
810 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
811 rels
[i
].r_addend
= 0;
813 /* The #ifdef BFD64 below is to prevent a compile time
814 warning. We know that if we do not have a 64 bit data
815 type that we will never execute this code anyway. */
817 if (elf_header
.e_machine
== EM_MIPS
818 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
820 /* In little-endian objects, r_info isn't really a
821 64-bit little-endian value: it has a 32-bit
822 little-endian symbol index followed by four
823 individual byte fields. Reorder INFO
825 bfd_vma info
= rels
[i
].r_info
;
826 info
= (((info
& 0xffffffff) << 32)
827 | ((info
>> 56) & 0xff)
828 | ((info
>> 40) & 0xff00)
829 | ((info
>> 24) & 0xff0000)
830 | ((info
>> 8) & 0xff000000));
831 rels
[i
].r_info
= info
;
843 /* Returns the reloc type extracted from the reloc info field. */
846 get_reloc_type (bfd_vma reloc_info
)
849 return ELF32_R_TYPE (reloc_info
);
851 switch (elf_header
.e_machine
)
854 /* Note: We assume that reloc_info has already been adjusted for us. */
855 return ELF64_MIPS_R_TYPE (reloc_info
);
858 return ELF64_R_TYPE_ID (reloc_info
);
861 return ELF64_R_TYPE (reloc_info
);
865 /* Return the symbol index extracted from the reloc info field. */
868 get_reloc_symindex (bfd_vma reloc_info
)
870 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
873 /* Display the contents of the relocation data found at the specified
877 dump_relocations (FILE * file
,
878 unsigned long rel_offset
,
879 unsigned long rel_size
,
880 Elf_Internal_Sym
* symtab
,
883 unsigned long strtablen
,
887 Elf_Internal_Rela
* rels
;
889 if (is_rela
== UNKNOWN
)
890 is_rela
= guess_is_rela (elf_header
.e_machine
);
894 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
899 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
908 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
910 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
915 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
917 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
925 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
927 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
932 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
934 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
938 for (i
= 0; i
< rel_size
; i
++)
943 bfd_vma symtab_index
;
946 offset
= rels
[i
].r_offset
;
947 info
= rels
[i
].r_info
;
949 type
= get_reloc_type (info
);
950 symtab_index
= get_reloc_symindex (info
);
954 printf ("%8.8lx %8.8lx ",
955 (unsigned long) offset
& 0xffffffff,
956 (unsigned long) info
& 0xffffffff);
960 #if BFD_HOST_64BIT_LONG
962 ? "%16.16lx %16.16lx "
963 : "%12.12lx %12.12lx ",
965 #elif BFD_HOST_64BIT_LONG_LONG
968 ? "%16.16llx %16.16llx "
969 : "%12.12llx %12.12llx ",
973 ? "%16.16I64x %16.16I64x "
974 : "%12.12I64x %12.12I64x ",
979 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
980 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
981 _bfd_int64_high (offset
),
982 _bfd_int64_low (offset
),
983 _bfd_int64_high (info
),
984 _bfd_int64_low (info
));
988 switch (elf_header
.e_machine
)
996 rtype
= elf_m32r_reloc_type (type
);
1001 rtype
= elf_i386_reloc_type (type
);
1006 rtype
= elf_m68hc11_reloc_type (type
);
1010 rtype
= elf_m68k_reloc_type (type
);
1014 rtype
= elf_i960_reloc_type (type
);
1019 rtype
= elf_avr_reloc_type (type
);
1022 case EM_OLD_SPARCV9
:
1023 case EM_SPARC32PLUS
:
1026 rtype
= elf_sparc_reloc_type (type
);
1030 rtype
= elf_spu_reloc_type (type
);
1034 case EM_CYGNUS_V850
:
1035 rtype
= v850_reloc_type (type
);
1039 case EM_CYGNUS_D10V
:
1040 rtype
= elf_d10v_reloc_type (type
);
1044 case EM_CYGNUS_D30V
:
1045 rtype
= elf_d30v_reloc_type (type
);
1049 rtype
= elf_dlx_reloc_type (type
);
1053 rtype
= elf_sh_reloc_type (type
);
1057 case EM_CYGNUS_MN10300
:
1058 rtype
= elf_mn10300_reloc_type (type
);
1062 case EM_CYGNUS_MN10200
:
1063 rtype
= elf_mn10200_reloc_type (type
);
1067 case EM_CYGNUS_FR30
:
1068 rtype
= elf_fr30_reloc_type (type
);
1072 rtype
= elf_frv_reloc_type (type
);
1076 rtype
= elf_mcore_reloc_type (type
);
1080 rtype
= elf_mmix_reloc_type (type
);
1085 rtype
= elf_msp430_reloc_type (type
);
1089 rtype
= elf_ppc_reloc_type (type
);
1093 rtype
= elf_ppc64_reloc_type (type
);
1097 case EM_MIPS_RS3_LE
:
1098 rtype
= elf_mips_reloc_type (type
);
1102 rtype
= elf_alpha_reloc_type (type
);
1106 rtype
= elf_arm_reloc_type (type
);
1110 rtype
= elf_arc_reloc_type (type
);
1114 rtype
= elf_hppa_reloc_type (type
);
1120 rtype
= elf_h8_reloc_type (type
);
1125 rtype
= elf_or32_reloc_type (type
);
1130 rtype
= elf_pj_reloc_type (type
);
1133 rtype
= elf_ia64_reloc_type (type
);
1137 rtype
= elf_cris_reloc_type (type
);
1141 rtype
= elf_i860_reloc_type (type
);
1146 rtype
= elf_x86_64_reloc_type (type
);
1150 rtype
= i370_reloc_type (type
);
1155 rtype
= elf_s390_reloc_type (type
);
1159 rtype
= elf_score_reloc_type (type
);
1163 rtype
= elf_xstormy16_reloc_type (type
);
1167 rtype
= elf_crx_reloc_type (type
);
1171 rtype
= elf_vax_reloc_type (type
);
1176 rtype
= elf_ip2k_reloc_type (type
);
1180 rtype
= elf_iq2000_reloc_type (type
);
1185 rtype
= elf_xtensa_reloc_type (type
);
1188 case EM_LATTICEMICO32
:
1189 rtype
= elf_lm32_reloc_type (type
);
1194 rtype
= elf_m32c_reloc_type (type
);
1198 rtype
= elf_mt_reloc_type (type
);
1202 rtype
= elf_bfin_reloc_type (type
);
1206 rtype
= elf_mep_reloc_type (type
);
1211 rtype
= elf_cr16_reloc_type (type
);
1215 case EM_MICROBLAZE_OLD
:
1216 rtype
= elf_microblaze_reloc_type (type
);
1221 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1223 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1225 if (elf_header
.e_machine
== EM_ALPHA
1227 && streq (rtype
, "R_ALPHA_LITUSE")
1230 switch (rels
[i
].r_addend
)
1232 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1233 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1234 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1235 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1236 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1237 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1238 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1239 default: rtype
= NULL
;
1242 printf (" (%s)", rtype
);
1246 printf (_("<unknown addend: %lx>"),
1247 (unsigned long) rels
[i
].r_addend
);
1250 else if (symtab_index
)
1252 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1253 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1256 Elf_Internal_Sym
* psym
;
1258 psym
= symtab
+ symtab_index
;
1262 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1266 unsigned int width
= is_32bit_elf
? 8 : 14;
1268 /* Relocations against GNU_IFUNC symbols do not use the value
1269 of the symbol as the address to relocate against. Instead
1270 they invoke the function named by the symbol and use its
1271 result as the address for relocation.
1273 To indicate this to the user, do not display the value of
1274 the symbol in the "Symbols's Value" field. Instead show
1275 its name followed by () as a hint that the symbol is
1279 || psym
->st_name
== 0
1280 || psym
->st_name
>= strtablen
)
1283 name
= strtab
+ psym
->st_name
;
1285 len
= print_symbol (width
, name
);
1286 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1290 print_vma (psym
->st_value
, LONG_HEX
);
1292 printf (is_32bit_elf
? " " : " ");
1295 if (psym
->st_name
== 0)
1297 const char * sec_name
= "<null>";
1300 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1302 if (psym
->st_shndx
< elf_header
.e_shnum
)
1304 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1305 else if (psym
->st_shndx
== SHN_ABS
)
1307 else if (psym
->st_shndx
== SHN_COMMON
)
1308 sec_name
= "COMMON";
1309 else if (elf_header
.e_machine
== EM_MIPS
1310 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1311 sec_name
= "SCOMMON";
1312 else if (elf_header
.e_machine
== EM_MIPS
1313 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1314 sec_name
= "SUNDEF";
1315 else if ((elf_header
.e_machine
== EM_X86_64
1316 || elf_header
.e_machine
== EM_L1OM
)
1317 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1318 sec_name
= "LARGE_COMMON";
1319 else if (elf_header
.e_machine
== EM_IA_64
1320 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1321 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1322 sec_name
= "ANSI_COM";
1323 else if (elf_header
.e_machine
== EM_IA_64
1324 && (elf_header
.e_ident
[EI_OSABI
]
1325 == ELFOSABI_OPENVMS
)
1326 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1327 sec_name
= "VMS_SYMVEC";
1330 sprintf (name_buf
, "<section 0x%x>",
1331 (unsigned int) psym
->st_shndx
);
1332 sec_name
= name_buf
;
1335 print_symbol (22, sec_name
);
1337 else if (strtab
== NULL
)
1338 printf (_("<string table index: %3ld>"), psym
->st_name
);
1339 else if (psym
->st_name
>= strtablen
)
1340 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1342 print_symbol (22, strtab
+ psym
->st_name
);
1346 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1349 printf (" - %lx", - offset
);
1351 printf (" + %lx", offset
);
1357 printf ("%*c", is_32bit_elf
?
1358 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1359 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1362 if (elf_header
.e_machine
== EM_SPARCV9
1364 && streq (rtype
, "R_SPARC_OLO10"))
1365 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1370 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1372 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1373 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1374 const char * rtype2
= elf_mips_reloc_type (type2
);
1375 const char * rtype3
= elf_mips_reloc_type (type3
);
1377 printf (" Type2: ");
1380 printf (_("unrecognized: %-7lx"),
1381 (unsigned long) type2
& 0xffffffff);
1383 printf ("%-17.17s", rtype2
);
1385 printf ("\n Type3: ");
1388 printf (_("unrecognized: %-7lx"),
1389 (unsigned long) type3
& 0xffffffff);
1391 printf ("%-17.17s", rtype3
);
1402 get_mips_dynamic_type (unsigned long type
)
1406 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1407 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1408 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1409 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1410 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1411 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1412 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1413 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1414 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1415 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1416 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1417 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1418 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1419 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1420 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1421 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1422 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1423 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1424 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1425 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1426 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1427 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1428 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1429 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1430 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1431 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1432 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1433 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1434 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1435 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1436 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1437 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1438 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1439 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1440 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1441 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1442 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1443 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1444 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1445 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1446 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1447 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1448 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1449 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1450 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1457 get_sparc64_dynamic_type (unsigned long type
)
1461 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1468 get_ppc_dynamic_type (unsigned long type
)
1472 case DT_PPC_GOT
: return "PPC_GOT";
1473 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1480 get_ppc64_dynamic_type (unsigned long type
)
1484 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1485 case DT_PPC64_OPD
: return "PPC64_OPD";
1486 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1487 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1494 get_parisc_dynamic_type (unsigned long type
)
1498 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1499 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1500 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1501 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1502 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1503 case DT_HP_PREINIT
: return "HP_PREINIT";
1504 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1505 case DT_HP_NEEDED
: return "HP_NEEDED";
1506 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1507 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1508 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1509 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1510 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1511 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1512 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1513 case DT_HP_FILTERED
: return "HP_FILTERED";
1514 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1515 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1516 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1517 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1518 case DT_PLT
: return "PLT";
1519 case DT_PLT_SIZE
: return "PLT_SIZE";
1520 case DT_DLT
: return "DLT";
1521 case DT_DLT_SIZE
: return "DLT_SIZE";
1528 get_ia64_dynamic_type (unsigned long type
)
1532 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1533 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1534 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1535 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1536 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1537 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1538 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1539 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1540 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1541 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1542 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1543 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1544 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1545 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1546 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1547 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1548 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1549 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1550 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1551 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1552 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1553 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1554 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1555 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1556 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1557 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1558 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1559 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1560 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1561 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1562 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1569 get_alpha_dynamic_type (unsigned long type
)
1573 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1580 get_score_dynamic_type (unsigned long type
)
1584 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1585 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1586 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1587 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1588 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1589 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1597 get_dynamic_type (unsigned long type
)
1599 static char buff
[64];
1603 case DT_NULL
: return "NULL";
1604 case DT_NEEDED
: return "NEEDED";
1605 case DT_PLTRELSZ
: return "PLTRELSZ";
1606 case DT_PLTGOT
: return "PLTGOT";
1607 case DT_HASH
: return "HASH";
1608 case DT_STRTAB
: return "STRTAB";
1609 case DT_SYMTAB
: return "SYMTAB";
1610 case DT_RELA
: return "RELA";
1611 case DT_RELASZ
: return "RELASZ";
1612 case DT_RELAENT
: return "RELAENT";
1613 case DT_STRSZ
: return "STRSZ";
1614 case DT_SYMENT
: return "SYMENT";
1615 case DT_INIT
: return "INIT";
1616 case DT_FINI
: return "FINI";
1617 case DT_SONAME
: return "SONAME";
1618 case DT_RPATH
: return "RPATH";
1619 case DT_SYMBOLIC
: return "SYMBOLIC";
1620 case DT_REL
: return "REL";
1621 case DT_RELSZ
: return "RELSZ";
1622 case DT_RELENT
: return "RELENT";
1623 case DT_PLTREL
: return "PLTREL";
1624 case DT_DEBUG
: return "DEBUG";
1625 case DT_TEXTREL
: return "TEXTREL";
1626 case DT_JMPREL
: return "JMPREL";
1627 case DT_BIND_NOW
: return "BIND_NOW";
1628 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1629 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1630 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1631 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1632 case DT_RUNPATH
: return "RUNPATH";
1633 case DT_FLAGS
: return "FLAGS";
1635 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1636 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1638 case DT_CHECKSUM
: return "CHECKSUM";
1639 case DT_PLTPADSZ
: return "PLTPADSZ";
1640 case DT_MOVEENT
: return "MOVEENT";
1641 case DT_MOVESZ
: return "MOVESZ";
1642 case DT_FEATURE
: return "FEATURE";
1643 case DT_POSFLAG_1
: return "POSFLAG_1";
1644 case DT_SYMINSZ
: return "SYMINSZ";
1645 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1647 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1648 case DT_CONFIG
: return "CONFIG";
1649 case DT_DEPAUDIT
: return "DEPAUDIT";
1650 case DT_AUDIT
: return "AUDIT";
1651 case DT_PLTPAD
: return "PLTPAD";
1652 case DT_MOVETAB
: return "MOVETAB";
1653 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1655 case DT_VERSYM
: return "VERSYM";
1657 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1658 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1659 case DT_RELACOUNT
: return "RELACOUNT";
1660 case DT_RELCOUNT
: return "RELCOUNT";
1661 case DT_FLAGS_1
: return "FLAGS_1";
1662 case DT_VERDEF
: return "VERDEF";
1663 case DT_VERDEFNUM
: return "VERDEFNUM";
1664 case DT_VERNEED
: return "VERNEED";
1665 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1667 case DT_AUXILIARY
: return "AUXILIARY";
1668 case DT_USED
: return "USED";
1669 case DT_FILTER
: return "FILTER";
1671 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1672 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1673 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1674 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1675 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1676 case DT_GNU_HASH
: return "GNU_HASH";
1679 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1681 const char * result
;
1683 switch (elf_header
.e_machine
)
1686 case EM_MIPS_RS3_LE
:
1687 result
= get_mips_dynamic_type (type
);
1690 result
= get_sparc64_dynamic_type (type
);
1693 result
= get_ppc_dynamic_type (type
);
1696 result
= get_ppc64_dynamic_type (type
);
1699 result
= get_ia64_dynamic_type (type
);
1702 result
= get_alpha_dynamic_type (type
);
1705 result
= get_score_dynamic_type (type
);
1715 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1717 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1718 || (elf_header
.e_machine
== EM_PARISC
1719 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1721 const char * result
;
1723 switch (elf_header
.e_machine
)
1726 result
= get_parisc_dynamic_type (type
);
1729 result
= get_ia64_dynamic_type (type
);
1739 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1743 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1750 get_file_type (unsigned e_type
)
1752 static char buff
[32];
1756 case ET_NONE
: return _("NONE (None)");
1757 case ET_REL
: return _("REL (Relocatable file)");
1758 case ET_EXEC
: return _("EXEC (Executable file)");
1759 case ET_DYN
: return _("DYN (Shared object file)");
1760 case ET_CORE
: return _("CORE (Core file)");
1763 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1764 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1765 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1766 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1768 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1774 get_machine_name (unsigned e_machine
)
1776 static char buff
[64]; /* XXX */
1780 case EM_NONE
: return _("None");
1781 case EM_M32
: return "WE32100";
1782 case EM_SPARC
: return "Sparc";
1783 case EM_SPU
: return "SPU";
1784 case EM_386
: return "Intel 80386";
1785 case EM_68K
: return "MC68000";
1786 case EM_88K
: return "MC88000";
1787 case EM_486
: return "Intel 80486";
1788 case EM_860
: return "Intel 80860";
1789 case EM_MIPS
: return "MIPS R3000";
1790 case EM_S370
: return "IBM System/370";
1791 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1792 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1793 case EM_PARISC
: return "HPPA";
1794 case EM_PPC_OLD
: return "Power PC (old)";
1795 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1796 case EM_960
: return "Intel 90860";
1797 case EM_PPC
: return "PowerPC";
1798 case EM_PPC64
: return "PowerPC64";
1799 case EM_V800
: return "NEC V800";
1800 case EM_FR20
: return "Fujitsu FR20";
1801 case EM_RH32
: return "TRW RH32";
1802 case EM_MCORE
: return "MCORE";
1803 case EM_ARM
: return "ARM";
1804 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1805 case EM_SH
: return "Renesas / SuperH SH";
1806 case EM_SPARCV9
: return "Sparc v9";
1807 case EM_TRICORE
: return "Siemens Tricore";
1808 case EM_ARC
: return "ARC";
1809 case EM_H8_300
: return "Renesas H8/300";
1810 case EM_H8_300H
: return "Renesas H8/300H";
1811 case EM_H8S
: return "Renesas H8S";
1812 case EM_H8_500
: return "Renesas H8/500";
1813 case EM_IA_64
: return "Intel IA-64";
1814 case EM_MIPS_X
: return "Stanford MIPS-X";
1815 case EM_COLDFIRE
: return "Motorola Coldfire";
1816 case EM_68HC12
: return "Motorola M68HC12";
1817 case EM_ALPHA
: return "Alpha";
1818 case EM_CYGNUS_D10V
:
1819 case EM_D10V
: return "d10v";
1820 case EM_CYGNUS_D30V
:
1821 case EM_D30V
: return "d30v";
1822 case EM_CYGNUS_M32R
:
1823 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1824 case EM_CYGNUS_V850
:
1825 case EM_V850
: return "NEC v850";
1826 case EM_CYGNUS_MN10300
:
1827 case EM_MN10300
: return "mn10300";
1828 case EM_CYGNUS_MN10200
:
1829 case EM_MN10200
: return "mn10200";
1830 case EM_CYGNUS_FR30
:
1831 case EM_FR30
: return "Fujitsu FR30";
1832 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1834 case EM_PJ
: return "picoJava";
1835 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1836 case EM_PCP
: return "Siemens PCP";
1837 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1838 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1839 case EM_STARCORE
: return "Motorola Star*Core processor";
1840 case EM_ME16
: return "Toyota ME16 processor";
1841 case EM_ST100
: return "STMicroelectronics ST100 processor";
1842 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1843 case EM_FX66
: return "Siemens FX66 microcontroller";
1844 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1845 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1846 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1847 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1848 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1849 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1850 case EM_SVX
: return "Silicon Graphics SVx";
1851 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1852 case EM_VAX
: return "Digital VAX";
1854 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1855 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1856 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1857 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1858 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1859 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1860 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1861 case EM_PRISM
: return "Vitesse Prism";
1862 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1863 case EM_L1OM
: return "Intel L1OM";
1865 case EM_S390
: return "IBM S/390";
1866 case EM_SCORE
: return "SUNPLUS S+Core";
1867 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1869 case EM_OR32
: return "OpenRISC";
1870 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1871 case EM_DLX
: return "OpenDLX";
1873 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1874 case EM_IQ2000
: return "Vitesse IQ2000";
1876 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1877 case EM_LATTICEMICO32
: return "Lattice Mico32";
1879 case EM_M32C
: return "Renesas M32c";
1880 case EM_MT
: return "Morpho Techologies MT processor";
1881 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1882 case EM_NIOS32
: return "Altera Nios";
1883 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1884 case EM_XC16X
: return "Infineon Technologies xc16x";
1885 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1887 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1888 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1889 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1891 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1897 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1902 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1903 e_flags
&= ~ EF_ARM_EABIMASK
;
1905 /* Handle "generic" ARM flags. */
1906 if (e_flags
& EF_ARM_RELEXEC
)
1908 strcat (buf
, ", relocatable executable");
1909 e_flags
&= ~ EF_ARM_RELEXEC
;
1912 if (e_flags
& EF_ARM_HASENTRY
)
1914 strcat (buf
, ", has entry point");
1915 e_flags
&= ~ EF_ARM_HASENTRY
;
1918 /* Now handle EABI specific flags. */
1922 strcat (buf
, ", <unrecognized EABI>");
1927 case EF_ARM_EABI_VER1
:
1928 strcat (buf
, ", Version1 EABI");
1933 /* Process flags one bit at a time. */
1934 flag
= e_flags
& - e_flags
;
1939 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1940 strcat (buf
, ", sorted symbol tables");
1950 case EF_ARM_EABI_VER2
:
1951 strcat (buf
, ", Version2 EABI");
1956 /* Process flags one bit at a time. */
1957 flag
= e_flags
& - e_flags
;
1962 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1963 strcat (buf
, ", sorted symbol tables");
1966 case EF_ARM_DYNSYMSUSESEGIDX
:
1967 strcat (buf
, ", dynamic symbols use segment index");
1970 case EF_ARM_MAPSYMSFIRST
:
1971 strcat (buf
, ", mapping symbols precede others");
1981 case EF_ARM_EABI_VER3
:
1982 strcat (buf
, ", Version3 EABI");
1985 case EF_ARM_EABI_VER4
:
1986 strcat (buf
, ", Version4 EABI");
1989 case EF_ARM_EABI_VER5
:
1990 strcat (buf
, ", Version5 EABI");
1996 /* Process flags one bit at a time. */
1997 flag
= e_flags
& - e_flags
;
2003 strcat (buf
, ", BE8");
2007 strcat (buf
, ", LE8");
2017 case EF_ARM_EABI_UNKNOWN
:
2018 strcat (buf
, ", GNU EABI");
2023 /* Process flags one bit at a time. */
2024 flag
= e_flags
& - e_flags
;
2029 case EF_ARM_INTERWORK
:
2030 strcat (buf
, ", interworking enabled");
2033 case EF_ARM_APCS_26
:
2034 strcat (buf
, ", uses APCS/26");
2037 case EF_ARM_APCS_FLOAT
:
2038 strcat (buf
, ", uses APCS/float");
2042 strcat (buf
, ", position independent");
2046 strcat (buf
, ", 8 bit structure alignment");
2049 case EF_ARM_NEW_ABI
:
2050 strcat (buf
, ", uses new ABI");
2053 case EF_ARM_OLD_ABI
:
2054 strcat (buf
, ", uses old ABI");
2057 case EF_ARM_SOFT_FLOAT
:
2058 strcat (buf
, ", software FP");
2061 case EF_ARM_VFP_FLOAT
:
2062 strcat (buf
, ", VFP");
2065 case EF_ARM_MAVERICK_FLOAT
:
2066 strcat (buf
, ", Maverick FP");
2077 strcat (buf
,", <unknown>");
2081 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2083 static char buf
[1024];
2095 decode_ARM_machine_flags (e_flags
, buf
);
2099 switch (e_flags
& EF_FRV_CPU_MASK
)
2101 case EF_FRV_CPU_GENERIC
:
2105 strcat (buf
, ", fr???");
2108 case EF_FRV_CPU_FR300
:
2109 strcat (buf
, ", fr300");
2112 case EF_FRV_CPU_FR400
:
2113 strcat (buf
, ", fr400");
2115 case EF_FRV_CPU_FR405
:
2116 strcat (buf
, ", fr405");
2119 case EF_FRV_CPU_FR450
:
2120 strcat (buf
, ", fr450");
2123 case EF_FRV_CPU_FR500
:
2124 strcat (buf
, ", fr500");
2126 case EF_FRV_CPU_FR550
:
2127 strcat (buf
, ", fr550");
2130 case EF_FRV_CPU_SIMPLE
:
2131 strcat (buf
, ", simple");
2133 case EF_FRV_CPU_TOMCAT
:
2134 strcat (buf
, ", tomcat");
2140 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2141 strcat (buf
, ", m68000");
2142 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2143 strcat (buf
, ", cpu32");
2144 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2145 strcat (buf
, ", fido_a");
2148 char const * isa
= _("unknown");
2149 char const * mac
= _("unknown mac");
2150 char const * additional
= NULL
;
2152 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2154 case EF_M68K_CF_ISA_A_NODIV
:
2156 additional
= ", nodiv";
2158 case EF_M68K_CF_ISA_A
:
2161 case EF_M68K_CF_ISA_A_PLUS
:
2164 case EF_M68K_CF_ISA_B_NOUSP
:
2166 additional
= ", nousp";
2168 case EF_M68K_CF_ISA_B
:
2172 strcat (buf
, ", cf, isa ");
2175 strcat (buf
, additional
);
2176 if (e_flags
& EF_M68K_CF_FLOAT
)
2177 strcat (buf
, ", float");
2178 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2183 case EF_M68K_CF_MAC
:
2186 case EF_M68K_CF_EMAC
:
2199 if (e_flags
& EF_PPC_EMB
)
2200 strcat (buf
, ", emb");
2202 if (e_flags
& EF_PPC_RELOCATABLE
)
2203 strcat (buf
, ", relocatable");
2205 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2206 strcat (buf
, ", relocatable-lib");
2210 case EM_CYGNUS_V850
:
2211 switch (e_flags
& EF_V850_ARCH
)
2214 strcat (buf
, ", v850e1");
2217 strcat (buf
, ", v850e");
2220 strcat (buf
, ", v850");
2223 strcat (buf
, ", unknown v850 architecture variant");
2229 case EM_CYGNUS_M32R
:
2230 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2231 strcat (buf
, ", m32r");
2235 case EM_MIPS_RS3_LE
:
2236 if (e_flags
& EF_MIPS_NOREORDER
)
2237 strcat (buf
, ", noreorder");
2239 if (e_flags
& EF_MIPS_PIC
)
2240 strcat (buf
, ", pic");
2242 if (e_flags
& EF_MIPS_CPIC
)
2243 strcat (buf
, ", cpic");
2245 if (e_flags
& EF_MIPS_UCODE
)
2246 strcat (buf
, ", ugen_reserved");
2248 if (e_flags
& EF_MIPS_ABI2
)
2249 strcat (buf
, ", abi2");
2251 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2252 strcat (buf
, ", odk first");
2254 if (e_flags
& EF_MIPS_32BITMODE
)
2255 strcat (buf
, ", 32bitmode");
2257 switch ((e_flags
& EF_MIPS_MACH
))
2259 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2260 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2261 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2262 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2263 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2264 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2265 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2266 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2267 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2268 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2269 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2270 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2271 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2272 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2274 /* We simply ignore the field in this case to avoid confusion:
2275 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2278 default: strcat (buf
, ", unknown CPU"); break;
2281 switch ((e_flags
& EF_MIPS_ABI
))
2283 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2284 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2285 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2286 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2288 /* We simply ignore the field in this case to avoid confusion:
2289 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2290 This means it is likely to be an o32 file, but not for
2293 default: strcat (buf
, ", unknown ABI"); break;
2296 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2297 strcat (buf
, ", mdmx");
2299 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2300 strcat (buf
, ", mips16");
2302 switch ((e_flags
& EF_MIPS_ARCH
))
2304 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2305 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2306 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2307 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2308 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2309 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2310 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2311 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2312 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2313 default: strcat (buf
, ", unknown ISA"); break;
2319 switch ((e_flags
& EF_SH_MACH_MASK
))
2321 case EF_SH1
: strcat (buf
, ", sh1"); break;
2322 case EF_SH2
: strcat (buf
, ", sh2"); break;
2323 case EF_SH3
: strcat (buf
, ", sh3"); break;
2324 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2325 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2326 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2327 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2328 case EF_SH4
: strcat (buf
, ", sh4"); break;
2329 case EF_SH5
: strcat (buf
, ", sh5"); break;
2330 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2331 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2332 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2333 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2334 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2335 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2336 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2337 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2338 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2339 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2340 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2341 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2342 default: strcat (buf
, ", unknown ISA"); break;
2348 if (e_flags
& EF_SPARC_32PLUS
)
2349 strcat (buf
, ", v8+");
2351 if (e_flags
& EF_SPARC_SUN_US1
)
2352 strcat (buf
, ", ultrasparcI");
2354 if (e_flags
& EF_SPARC_SUN_US3
)
2355 strcat (buf
, ", ultrasparcIII");
2357 if (e_flags
& EF_SPARC_HAL_R1
)
2358 strcat (buf
, ", halr1");
2360 if (e_flags
& EF_SPARC_LEDATA
)
2361 strcat (buf
, ", ledata");
2363 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2364 strcat (buf
, ", tso");
2366 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2367 strcat (buf
, ", pso");
2369 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2370 strcat (buf
, ", rmo");
2374 switch (e_flags
& EF_PARISC_ARCH
)
2376 case EFA_PARISC_1_0
:
2377 strcpy (buf
, ", PA-RISC 1.0");
2379 case EFA_PARISC_1_1
:
2380 strcpy (buf
, ", PA-RISC 1.1");
2382 case EFA_PARISC_2_0
:
2383 strcpy (buf
, ", PA-RISC 2.0");
2388 if (e_flags
& EF_PARISC_TRAPNIL
)
2389 strcat (buf
, ", trapnil");
2390 if (e_flags
& EF_PARISC_EXT
)
2391 strcat (buf
, ", ext");
2392 if (e_flags
& EF_PARISC_LSB
)
2393 strcat (buf
, ", lsb");
2394 if (e_flags
& EF_PARISC_WIDE
)
2395 strcat (buf
, ", wide");
2396 if (e_flags
& EF_PARISC_NO_KABP
)
2397 strcat (buf
, ", no kabp");
2398 if (e_flags
& EF_PARISC_LAZYSWAP
)
2399 strcat (buf
, ", lazyswap");
2404 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2405 strcat (buf
, ", new calling convention");
2407 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2408 strcat (buf
, ", gnu calling convention");
2412 if ((e_flags
& EF_IA_64_ABI64
))
2413 strcat (buf
, ", 64-bit");
2415 strcat (buf
, ", 32-bit");
2416 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2417 strcat (buf
, ", reduced fp model");
2418 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2419 strcat (buf
, ", no function descriptors, constant gp");
2420 else if ((e_flags
& EF_IA_64_CONS_GP
))
2421 strcat (buf
, ", constant gp");
2422 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2423 strcat (buf
, ", absolute");
2427 if ((e_flags
& EF_VAX_NONPIC
))
2428 strcat (buf
, ", non-PIC");
2429 if ((e_flags
& EF_VAX_DFLOAT
))
2430 strcat (buf
, ", D-Float");
2431 if ((e_flags
& EF_VAX_GFLOAT
))
2432 strcat (buf
, ", G-Float");
2441 get_osabi_name (unsigned int osabi
)
2443 static char buff
[32];
2447 case ELFOSABI_NONE
: return "UNIX - System V";
2448 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2449 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2450 case ELFOSABI_LINUX
: return "UNIX - Linux";
2451 case ELFOSABI_HURD
: return "GNU/Hurd";
2452 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2453 case ELFOSABI_AIX
: return "UNIX - AIX";
2454 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2455 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2456 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2457 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2458 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2459 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2460 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2461 case ELFOSABI_AROS
: return "AROS";
2462 case ELFOSABI_STANDALONE
: return _("Standalone App");
2463 case ELFOSABI_ARM
: return "ARM";
2465 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2471 get_arm_segment_type (unsigned long type
)
2485 get_mips_segment_type (unsigned long type
)
2489 case PT_MIPS_REGINFO
:
2491 case PT_MIPS_RTPROC
:
2493 case PT_MIPS_OPTIONS
:
2503 get_parisc_segment_type (unsigned long type
)
2507 case PT_HP_TLS
: return "HP_TLS";
2508 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2509 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2510 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2511 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2512 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2513 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2514 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2515 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2516 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2517 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2518 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2519 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2520 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2521 case PT_HP_STACK
: return "HP_STACK";
2522 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2523 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2524 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2525 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2534 get_ia64_segment_type (unsigned long type
)
2538 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2539 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2540 case PT_HP_TLS
: return "HP_TLS";
2541 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2542 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2543 case PT_IA_64_HP_STACK
: return "HP_STACK";
2552 get_segment_type (unsigned long p_type
)
2554 static char buff
[32];
2558 case PT_NULL
: return "NULL";
2559 case PT_LOAD
: return "LOAD";
2560 case PT_DYNAMIC
: return "DYNAMIC";
2561 case PT_INTERP
: return "INTERP";
2562 case PT_NOTE
: return "NOTE";
2563 case PT_SHLIB
: return "SHLIB";
2564 case PT_PHDR
: return "PHDR";
2565 case PT_TLS
: return "TLS";
2567 case PT_GNU_EH_FRAME
:
2568 return "GNU_EH_FRAME";
2569 case PT_GNU_STACK
: return "GNU_STACK";
2570 case PT_GNU_RELRO
: return "GNU_RELRO";
2573 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2575 const char * result
;
2577 switch (elf_header
.e_machine
)
2580 result
= get_arm_segment_type (p_type
);
2583 case EM_MIPS_RS3_LE
:
2584 result
= get_mips_segment_type (p_type
);
2587 result
= get_parisc_segment_type (p_type
);
2590 result
= get_ia64_segment_type (p_type
);
2600 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2602 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2604 const char * result
;
2606 switch (elf_header
.e_machine
)
2609 result
= get_parisc_segment_type (p_type
);
2612 result
= get_ia64_segment_type (p_type
);
2622 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2625 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2632 get_mips_section_type_name (unsigned int sh_type
)
2636 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2637 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2638 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2639 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2640 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2641 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2642 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2643 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2644 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2645 case SHT_MIPS_RELD
: return "MIPS_RELD";
2646 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2647 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2648 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2649 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2650 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2651 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2652 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2653 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2654 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2655 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2656 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2657 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2658 case SHT_MIPS_LINE
: return "MIPS_LINE";
2659 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2660 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2661 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2662 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2663 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2664 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2665 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2666 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2667 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2668 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2669 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2670 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2671 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2672 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2673 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2674 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2682 get_parisc_section_type_name (unsigned int sh_type
)
2686 case SHT_PARISC_EXT
: return "PARISC_EXT";
2687 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2688 case SHT_PARISC_DOC
: return "PARISC_DOC";
2689 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2690 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2691 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2692 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2700 get_ia64_section_type_name (unsigned int sh_type
)
2702 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2703 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2704 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2708 case SHT_IA_64_EXT
: return "IA_64_EXT";
2709 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2710 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2711 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2712 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2713 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2714 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2715 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2716 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2717 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2725 get_x86_64_section_type_name (unsigned int sh_type
)
2729 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2737 get_arm_section_type_name (unsigned int sh_type
)
2741 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2742 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2743 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2744 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2745 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2753 get_section_type_name (unsigned int sh_type
)
2755 static char buff
[32];
2759 case SHT_NULL
: return "NULL";
2760 case SHT_PROGBITS
: return "PROGBITS";
2761 case SHT_SYMTAB
: return "SYMTAB";
2762 case SHT_STRTAB
: return "STRTAB";
2763 case SHT_RELA
: return "RELA";
2764 case SHT_HASH
: return "HASH";
2765 case SHT_DYNAMIC
: return "DYNAMIC";
2766 case SHT_NOTE
: return "NOTE";
2767 case SHT_NOBITS
: return "NOBITS";
2768 case SHT_REL
: return "REL";
2769 case SHT_SHLIB
: return "SHLIB";
2770 case SHT_DYNSYM
: return "DYNSYM";
2771 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2772 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2773 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2774 case SHT_GNU_HASH
: return "GNU_HASH";
2775 case SHT_GROUP
: return "GROUP";
2776 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2777 case SHT_GNU_verdef
: return "VERDEF";
2778 case SHT_GNU_verneed
: return "VERNEED";
2779 case SHT_GNU_versym
: return "VERSYM";
2780 case 0x6ffffff0: return "VERSYM";
2781 case 0x6ffffffc: return "VERDEF";
2782 case 0x7ffffffd: return "AUXILIARY";
2783 case 0x7fffffff: return "FILTER";
2784 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2787 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2789 const char * result
;
2791 switch (elf_header
.e_machine
)
2794 case EM_MIPS_RS3_LE
:
2795 result
= get_mips_section_type_name (sh_type
);
2798 result
= get_parisc_section_type_name (sh_type
);
2801 result
= get_ia64_section_type_name (sh_type
);
2805 result
= get_x86_64_section_type_name (sh_type
);
2808 result
= get_arm_section_type_name (sh_type
);
2818 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2820 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2822 const char * result
;
2824 switch (elf_header
.e_machine
)
2827 result
= get_ia64_section_type_name (sh_type
);
2837 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2839 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2840 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2842 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2848 #define OPTION_DEBUG_DUMP 512
2850 static struct option options
[] =
2852 {"all", no_argument
, 0, 'a'},
2853 {"file-header", no_argument
, 0, 'h'},
2854 {"program-headers", no_argument
, 0, 'l'},
2855 {"headers", no_argument
, 0, 'e'},
2856 {"histogram", no_argument
, 0, 'I'},
2857 {"segments", no_argument
, 0, 'l'},
2858 {"sections", no_argument
, 0, 'S'},
2859 {"section-headers", no_argument
, 0, 'S'},
2860 {"section-groups", no_argument
, 0, 'g'},
2861 {"section-details", no_argument
, 0, 't'},
2862 {"full-section-name",no_argument
, 0, 'N'},
2863 {"symbols", no_argument
, 0, 's'},
2864 {"syms", no_argument
, 0, 's'},
2865 {"relocs", no_argument
, 0, 'r'},
2866 {"notes", no_argument
, 0, 'n'},
2867 {"dynamic", no_argument
, 0, 'd'},
2868 {"arch-specific", no_argument
, 0, 'A'},
2869 {"version-info", no_argument
, 0, 'V'},
2870 {"use-dynamic", no_argument
, 0, 'D'},
2871 {"unwind", no_argument
, 0, 'u'},
2872 {"archive-index", no_argument
, 0, 'c'},
2873 {"hex-dump", required_argument
, 0, 'x'},
2874 {"relocated-dump", required_argument
, 0, 'R'},
2875 {"string-dump", required_argument
, 0, 'p'},
2876 #ifdef SUPPORT_DISASSEMBLY
2877 {"instruction-dump", required_argument
, 0, 'i'},
2879 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2881 {"version", no_argument
, 0, 'v'},
2882 {"wide", no_argument
, 0, 'W'},
2883 {"help", no_argument
, 0, 'H'},
2884 {0, no_argument
, 0, 0}
2888 usage (FILE * stream
)
2890 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2891 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2892 fprintf (stream
, _(" Options are:\n\
2893 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2894 -h --file-header Display the ELF file header\n\
2895 -l --program-headers Display the program headers\n\
2896 --segments An alias for --program-headers\n\
2897 -S --section-headers Display the sections' header\n\
2898 --sections An alias for --section-headers\n\
2899 -g --section-groups Display the section groups\n\
2900 -t --section-details Display the section details\n\
2901 -e --headers Equivalent to: -h -l -S\n\
2902 -s --syms Display the symbol table\n\
2903 --symbols An alias for --syms\n\
2904 -n --notes Display the core notes (if present)\n\
2905 -r --relocs Display the relocations (if present)\n\
2906 -u --unwind Display the unwind info (if present)\n\
2907 -d --dynamic Display the dynamic section (if present)\n\
2908 -V --version-info Display the version sections (if present)\n\
2909 -A --arch-specific Display architecture specific information (if any).\n\
2910 -c --archive-index Display the symbol/file index in an archive\n\
2911 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2912 -x --hex-dump=<number|name>\n\
2913 Dump the contents of section <number|name> as bytes\n\
2914 -p --string-dump=<number|name>\n\
2915 Dump the contents of section <number|name> as strings\n\
2916 -R --relocated-dump=<number|name>\n\
2917 Dump the contents of section <number|name> as relocated bytes\n\
2918 -w[lLiaprmfFsoR] or\n\
2919 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2920 Display the contents of DWARF2 debug sections\n"));
2921 #ifdef SUPPORT_DISASSEMBLY
2922 fprintf (stream
, _("\
2923 -i --instruction-dump=<number|name>\n\
2924 Disassemble the contents of section <number|name>\n"));
2926 fprintf (stream
, _("\
2927 -I --histogram Display histogram of bucket list lengths\n\
2928 -W --wide Allow output width to exceed 80 characters\n\
2929 @<file> Read options from <file>\n\
2930 -H --help Display this information\n\
2931 -v --version Display the version number of readelf\n"));
2933 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2934 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2936 exit (stream
== stdout
? 0 : 1);
2939 /* Record the fact that the user wants the contents of section number
2940 SECTION to be displayed using the method(s) encoded as flags bits
2941 in TYPE. Note, TYPE can be zero if we are creating the array for
2945 request_dump_bynumber (unsigned int section
, dump_type type
)
2947 if (section
>= num_dump_sects
)
2949 dump_type
* new_dump_sects
;
2951 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
2952 sizeof (* dump_sects
));
2954 if (new_dump_sects
== NULL
)
2955 error (_("Out of memory allocating dump request table.\n"));
2958 /* Copy current flag settings. */
2959 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2963 dump_sects
= new_dump_sects
;
2964 num_dump_sects
= section
+ 1;
2969 dump_sects
[section
] |= type
;
2974 /* Request a dump by section name. */
2977 request_dump_byname (const char * section
, dump_type type
)
2979 struct dump_list_entry
* new_request
;
2981 new_request
= (struct dump_list_entry
*)
2982 malloc (sizeof (struct dump_list_entry
));
2984 error (_("Out of memory allocating dump request table.\n"));
2986 new_request
->name
= strdup (section
);
2987 if (!new_request
->name
)
2988 error (_("Out of memory allocating dump request table.\n"));
2990 new_request
->type
= type
;
2992 new_request
->next
= dump_sects_byname
;
2993 dump_sects_byname
= new_request
;
2997 request_dump (dump_type type
)
3003 section
= strtoul (optarg
, & cp
, 0);
3005 if (! *cp
&& section
>= 0)
3006 request_dump_bynumber (section
, type
);
3008 request_dump_byname (optarg
, type
);
3013 parse_args (int argc
, char ** argv
)
3020 while ((c
= getopt_long
3021 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3039 do_section_groups
++;
3047 do_section_groups
++;
3052 do_section_details
++;
3096 request_dump (HEX_DUMP
);
3099 request_dump (STRING_DUMP
);
3102 request_dump (RELOC_DUMP
);
3109 dwarf_select_sections_all ();
3114 dwarf_select_sections_by_letters (optarg
);
3117 case OPTION_DEBUG_DUMP
:
3124 dwarf_select_sections_by_names (optarg
);
3127 #ifdef SUPPORT_DISASSEMBLY
3129 request_dump (DISASS_DUMP
);
3133 print_version (program_name
);
3142 /* xgettext:c-format */
3143 error (_("Invalid option '-%c'\n"), c
);
3150 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3151 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3152 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3153 && !do_section_groups
&& !do_archive_index
)
3157 warn (_("Nothing to do.\n"));
3163 get_elf_class (unsigned int elf_class
)
3165 static char buff
[32];
3169 case ELFCLASSNONE
: return _("none");
3170 case ELFCLASS32
: return "ELF32";
3171 case ELFCLASS64
: return "ELF64";
3173 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3179 get_data_encoding (unsigned int encoding
)
3181 static char buff
[32];
3185 case ELFDATANONE
: return _("none");
3186 case ELFDATA2LSB
: return _("2's complement, little endian");
3187 case ELFDATA2MSB
: return _("2's complement, big endian");
3189 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3194 /* Decode the data held in 'elf_header'. */
3197 process_file_header (void)
3199 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3200 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3201 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3202 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3205 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3209 init_dwarf_regnames (elf_header
.e_machine
);
3215 printf (_("ELF Header:\n"));
3216 printf (_(" Magic: "));
3217 for (i
= 0; i
< EI_NIDENT
; i
++)
3218 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3220 printf (_(" Class: %s\n"),
3221 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3222 printf (_(" Data: %s\n"),
3223 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3224 printf (_(" Version: %d %s\n"),
3225 elf_header
.e_ident
[EI_VERSION
],
3226 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3228 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3231 printf (_(" OS/ABI: %s\n"),
3232 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3233 printf (_(" ABI Version: %d\n"),
3234 elf_header
.e_ident
[EI_ABIVERSION
]);
3235 printf (_(" Type: %s\n"),
3236 get_file_type (elf_header
.e_type
));
3237 printf (_(" Machine: %s\n"),
3238 get_machine_name (elf_header
.e_machine
));
3239 printf (_(" Version: 0x%lx\n"),
3240 (unsigned long) elf_header
.e_version
);
3242 printf (_(" Entry point address: "));
3243 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3244 printf (_("\n Start of program headers: "));
3245 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3246 printf (_(" (bytes into file)\n Start of section headers: "));
3247 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3248 printf (_(" (bytes into file)\n"));
3250 printf (_(" Flags: 0x%lx%s\n"),
3251 (unsigned long) elf_header
.e_flags
,
3252 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3253 printf (_(" Size of this header: %ld (bytes)\n"),
3254 (long) elf_header
.e_ehsize
);
3255 printf (_(" Size of program headers: %ld (bytes)\n"),
3256 (long) elf_header
.e_phentsize
);
3257 printf (_(" Number of program headers: %ld\n"),
3258 (long) elf_header
.e_phnum
);
3259 printf (_(" Size of section headers: %ld (bytes)\n"),
3260 (long) elf_header
.e_shentsize
);
3261 printf (_(" Number of section headers: %ld"),
3262 (long) elf_header
.e_shnum
);
3263 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3264 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3265 putc ('\n', stdout
);
3266 printf (_(" Section header string table index: %ld"),
3267 (long) elf_header
.e_shstrndx
);
3268 if (section_headers
!= NULL
3269 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3270 printf (" (%u)", section_headers
[0].sh_link
);
3271 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3272 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3273 printf (" <corrupt: out of range>");
3274 putc ('\n', stdout
);
3277 if (section_headers
!= NULL
)
3279 if (elf_header
.e_shnum
== SHN_UNDEF
)
3280 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3281 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3282 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3283 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3284 elf_header
.e_shstrndx
= SHN_UNDEF
;
3285 free (section_headers
);
3286 section_headers
= NULL
;
3294 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3296 Elf32_External_Phdr
* phdrs
;
3297 Elf32_External_Phdr
* external
;
3298 Elf_Internal_Phdr
* internal
;
3301 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3302 elf_header
.e_phentsize
,
3304 _("program headers"));
3308 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3309 i
< elf_header
.e_phnum
;
3310 i
++, internal
++, external
++)
3312 internal
->p_type
= BYTE_GET (external
->p_type
);
3313 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3314 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3315 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3316 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3317 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3318 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3319 internal
->p_align
= BYTE_GET (external
->p_align
);
3328 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3330 Elf64_External_Phdr
* phdrs
;
3331 Elf64_External_Phdr
* external
;
3332 Elf_Internal_Phdr
* internal
;
3335 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3336 elf_header
.e_phentsize
,
3338 _("program headers"));
3342 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3343 i
< elf_header
.e_phnum
;
3344 i
++, internal
++, external
++)
3346 internal
->p_type
= BYTE_GET (external
->p_type
);
3347 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3348 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3349 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3350 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3351 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3352 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3353 internal
->p_align
= BYTE_GET (external
->p_align
);
3361 /* Returns 1 if the program headers were read into `program_headers'. */
3364 get_program_headers (FILE * file
)
3366 Elf_Internal_Phdr
* phdrs
;
3368 /* Check cache of prior read. */
3369 if (program_headers
!= NULL
)
3372 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3373 sizeof (Elf_Internal_Phdr
));
3377 error (_("Out of memory\n"));
3382 ? get_32bit_program_headers (file
, phdrs
)
3383 : get_64bit_program_headers (file
, phdrs
))
3385 program_headers
= phdrs
;
3393 /* Returns 1 if the program headers were loaded. */
3396 process_program_headers (FILE * file
)
3398 Elf_Internal_Phdr
* segment
;
3401 if (elf_header
.e_phnum
== 0)
3404 printf (_("\nThere are no program headers in this file.\n"));
3408 if (do_segments
&& !do_header
)
3410 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3411 printf (_("Entry point "));
3412 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3413 printf (_("\nThere are %d program headers, starting at offset "),
3414 elf_header
.e_phnum
);
3415 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3419 if (! get_program_headers (file
))
3424 if (elf_header
.e_phnum
> 1)
3425 printf (_("\nProgram Headers:\n"));
3427 printf (_("\nProgram Headers:\n"));
3431 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3434 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3438 (_(" Type Offset VirtAddr PhysAddr\n"));
3440 (_(" FileSiz MemSiz Flags Align\n"));
3447 for (i
= 0, segment
= program_headers
;
3448 i
< elf_header
.e_phnum
;
3453 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3457 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3458 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3459 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3460 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3461 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3463 (segment
->p_flags
& PF_R
? 'R' : ' '),
3464 (segment
->p_flags
& PF_W
? 'W' : ' '),
3465 (segment
->p_flags
& PF_X
? 'E' : ' '));
3466 printf ("%#lx", (unsigned long) segment
->p_align
);
3470 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3471 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3474 print_vma (segment
->p_offset
, FULL_HEX
);
3478 print_vma (segment
->p_vaddr
, FULL_HEX
);
3480 print_vma (segment
->p_paddr
, FULL_HEX
);
3483 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3484 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3487 print_vma (segment
->p_filesz
, FULL_HEX
);
3491 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3492 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3495 print_vma (segment
->p_offset
, FULL_HEX
);
3499 (segment
->p_flags
& PF_R
? 'R' : ' '),
3500 (segment
->p_flags
& PF_W
? 'W' : ' '),
3501 (segment
->p_flags
& PF_X
? 'E' : ' '));
3503 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3504 printf ("%#lx", (unsigned long) segment
->p_align
);
3507 print_vma (segment
->p_align
, PREFIX_HEX
);
3512 print_vma (segment
->p_offset
, FULL_HEX
);
3514 print_vma (segment
->p_vaddr
, FULL_HEX
);
3516 print_vma (segment
->p_paddr
, FULL_HEX
);
3518 print_vma (segment
->p_filesz
, FULL_HEX
);
3520 print_vma (segment
->p_memsz
, FULL_HEX
);
3522 (segment
->p_flags
& PF_R
? 'R' : ' '),
3523 (segment
->p_flags
& PF_W
? 'W' : ' '),
3524 (segment
->p_flags
& PF_X
? 'E' : ' '));
3525 print_vma (segment
->p_align
, HEX
);
3529 switch (segment
->p_type
)
3533 error (_("more than one dynamic segment\n"));
3535 /* By default, assume that the .dynamic section is the first
3536 section in the DYNAMIC segment. */
3537 dynamic_addr
= segment
->p_offset
;
3538 dynamic_size
= segment
->p_filesz
;
3540 /* Try to locate the .dynamic section. If there is
3541 a section header table, we can easily locate it. */
3542 if (section_headers
!= NULL
)
3544 Elf_Internal_Shdr
* sec
;
3546 sec
= find_section (".dynamic");
3547 if (sec
== NULL
|| sec
->sh_size
== 0)
3549 error (_("no .dynamic section in the dynamic segment\n"));
3553 if (sec
->sh_type
== SHT_NOBITS
)
3559 dynamic_addr
= sec
->sh_offset
;
3560 dynamic_size
= sec
->sh_size
;
3562 if (dynamic_addr
< segment
->p_offset
3563 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3564 warn (_("the .dynamic section is not contained"
3565 " within the dynamic segment\n"));
3566 else if (dynamic_addr
> segment
->p_offset
)
3567 warn (_("the .dynamic section is not the first section"
3568 " in the dynamic segment.\n"));
3573 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3575 error (_("Unable to find program interpreter name\n"));
3579 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3581 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3582 error (_("Internal error: failed to create format string to display program interpreter\n"));
3584 program_interpreter
[0] = 0;
3585 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3586 error (_("Unable to read program interpreter name\n"));
3589 printf (_("\n [Requesting program interpreter: %s]"),
3590 program_interpreter
);
3596 putc ('\n', stdout
);
3599 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3601 printf (_("\n Section to Segment mapping:\n"));
3602 printf (_(" Segment Sections...\n"));
3604 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3607 Elf_Internal_Shdr
* section
;
3609 segment
= program_headers
+ i
;
3610 section
= section_headers
+ 1;
3612 printf (" %2.2d ", i
);
3614 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3616 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3617 printf ("%s ", SECTION_NAME (section
));
3628 /* Find the file offset corresponding to VMA by using the program headers. */
3631 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3633 Elf_Internal_Phdr
* seg
;
3635 if (! get_program_headers (file
))
3637 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3641 for (seg
= program_headers
;
3642 seg
< program_headers
+ elf_header
.e_phnum
;
3645 if (seg
->p_type
!= PT_LOAD
)
3648 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3649 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3650 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3653 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3654 (unsigned long) vma
);
3660 get_32bit_section_headers (FILE * file
, unsigned int num
)
3662 Elf32_External_Shdr
* shdrs
;
3663 Elf_Internal_Shdr
* internal
;
3666 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3667 elf_header
.e_shentsize
, num
,
3668 _("section headers"));
3672 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3673 sizeof (Elf_Internal_Shdr
));
3675 if (section_headers
== NULL
)
3677 error (_("Out of memory\n"));
3681 for (i
= 0, internal
= section_headers
;
3685 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3686 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3687 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3688 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3689 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3690 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3691 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3692 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3693 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3694 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3703 get_64bit_section_headers (FILE * file
, unsigned int num
)
3705 Elf64_External_Shdr
* shdrs
;
3706 Elf_Internal_Shdr
* internal
;
3709 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3710 elf_header
.e_shentsize
, num
,
3711 _("section headers"));
3715 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3716 sizeof (Elf_Internal_Shdr
));
3718 if (section_headers
== NULL
)
3720 error (_("Out of memory\n"));
3724 for (i
= 0, internal
= section_headers
;
3728 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3729 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3730 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3731 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3732 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3733 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3734 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3735 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3736 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3737 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3745 static Elf_Internal_Sym
*
3746 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3748 unsigned long number
;
3749 Elf32_External_Sym
* esyms
;
3750 Elf_External_Sym_Shndx
* shndx
;
3751 Elf_Internal_Sym
* isyms
;
3752 Elf_Internal_Sym
* psym
;
3755 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3756 section
->sh_size
, _("symbols"));
3761 if (symtab_shndx_hdr
!= NULL
3762 && (symtab_shndx_hdr
->sh_link
3763 == (unsigned long) (section
- section_headers
)))
3765 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3766 symtab_shndx_hdr
->sh_offset
,
3767 1, symtab_shndx_hdr
->sh_size
,
3776 number
= section
->sh_size
/ section
->sh_entsize
;
3777 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3781 error (_("Out of memory\n"));
3788 for (j
= 0, psym
= isyms
;
3792 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3793 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3794 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3795 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3796 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3798 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3799 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3800 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3801 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3802 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3812 static Elf_Internal_Sym
*
3813 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3815 unsigned long number
;
3816 Elf64_External_Sym
* esyms
;
3817 Elf_External_Sym_Shndx
* shndx
;
3818 Elf_Internal_Sym
* isyms
;
3819 Elf_Internal_Sym
* psym
;
3822 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3823 section
->sh_size
, _("symbols"));
3828 if (symtab_shndx_hdr
!= NULL
3829 && (symtab_shndx_hdr
->sh_link
3830 == (unsigned long) (section
- section_headers
)))
3832 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3833 symtab_shndx_hdr
->sh_offset
,
3834 1, symtab_shndx_hdr
->sh_size
,
3843 number
= section
->sh_size
/ section
->sh_entsize
;
3844 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3848 error (_("Out of memory\n"));
3855 for (j
= 0, psym
= isyms
;
3859 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3860 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3861 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3862 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3863 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3865 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3866 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3867 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3868 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3869 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3880 get_elf_section_flags (bfd_vma sh_flags
)
3882 static char buff
[1024];
3884 int field_size
= is_32bit_elf
? 8 : 16;
3885 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3886 bfd_vma os_flags
= 0;
3887 bfd_vma proc_flags
= 0;
3888 bfd_vma unknown_flags
= 0;
3896 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3897 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3898 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3899 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3900 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
3901 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
3902 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
3903 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
3904 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
3905 /* 9 */ { STRING_COMMA_LEN ("TLS") },
3906 /* IA-64 specific. */
3907 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
3908 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
3909 /* IA-64 OpenVMS specific. */
3910 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
3911 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
3912 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
3913 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
3914 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
3915 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
3916 /* SPARC specific. */
3917 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
3918 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
3921 if (do_section_details
)
3923 sprintf (buff
, "[%*.*lx]: ",
3924 field_size
, field_size
, (unsigned long) sh_flags
);
3925 p
+= field_size
+ 4;
3932 flag
= sh_flags
& - sh_flags
;
3935 if (do_section_details
)
3939 case SHF_WRITE
: index
= 0; break;
3940 case SHF_ALLOC
: index
= 1; break;
3941 case SHF_EXECINSTR
: index
= 2; break;
3942 case SHF_MERGE
: index
= 3; break;
3943 case SHF_STRINGS
: index
= 4; break;
3944 case SHF_INFO_LINK
: index
= 5; break;
3945 case SHF_LINK_ORDER
: index
= 6; break;
3946 case SHF_OS_NONCONFORMING
: index
= 7; break;
3947 case SHF_GROUP
: index
= 8; break;
3948 case SHF_TLS
: index
= 9; break;
3952 switch (elf_header
.e_machine
)
3955 if (flag
== SHF_IA_64_SHORT
)
3957 else if (flag
== SHF_IA_64_NORECOV
)
3960 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3963 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3964 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3965 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3966 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3967 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3968 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3977 case EM_OLD_SPARCV9
:
3978 case EM_SPARC32PLUS
:
3981 if (flag
== SHF_EXCLUDE
)
3983 else if (flag
== SHF_ORDERED
)
3993 if (p
!= buff
+ field_size
+ 4)
3995 if (size
< (10 + 2))
4002 size
-= flags
[index
].len
;
4003 p
= stpcpy (p
, flags
[index
].str
);
4005 else if (flag
& SHF_MASKOS
)
4007 else if (flag
& SHF_MASKPROC
)
4010 unknown_flags
|= flag
;
4016 case SHF_WRITE
: *p
= 'W'; break;
4017 case SHF_ALLOC
: *p
= 'A'; break;
4018 case SHF_EXECINSTR
: *p
= 'X'; break;
4019 case SHF_MERGE
: *p
= 'M'; break;
4020 case SHF_STRINGS
: *p
= 'S'; break;
4021 case SHF_INFO_LINK
: *p
= 'I'; break;
4022 case SHF_LINK_ORDER
: *p
= 'L'; break;
4023 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4024 case SHF_GROUP
: *p
= 'G'; break;
4025 case SHF_TLS
: *p
= 'T'; break;
4028 if ((elf_header
.e_machine
== EM_X86_64
4029 || elf_header
.e_machine
== EM_L1OM
)
4030 && flag
== SHF_X86_64_LARGE
)
4032 else if (flag
& SHF_MASKOS
)
4035 sh_flags
&= ~ SHF_MASKOS
;
4037 else if (flag
& SHF_MASKPROC
)
4040 sh_flags
&= ~ SHF_MASKPROC
;
4050 if (do_section_details
)
4054 size
-= 5 + field_size
;
4055 if (p
!= buff
+ field_size
+ 4)
4063 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4064 (unsigned long) os_flags
);
4065 p
+= 5 + field_size
;
4069 size
-= 7 + field_size
;
4070 if (p
!= buff
+ field_size
+ 4)
4078 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4079 (unsigned long) proc_flags
);
4080 p
+= 7 + field_size
;
4084 size
-= 10 + field_size
;
4085 if (p
!= buff
+ field_size
+ 4)
4093 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4094 (unsigned long) unknown_flags
);
4095 p
+= 10 + field_size
;
4104 process_section_headers (FILE * file
)
4106 Elf_Internal_Shdr
* section
;
4109 section_headers
= NULL
;
4111 if (elf_header
.e_shnum
== 0)
4114 printf (_("\nThere are no sections in this file.\n"));
4119 if (do_sections
&& !do_header
)
4120 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4121 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4125 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4128 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4131 /* Read in the string table, so that we have names to display. */
4132 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4133 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4135 section
= section_headers
+ elf_header
.e_shstrndx
;
4137 if (section
->sh_size
!= 0)
4139 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4140 1, section
->sh_size
,
4143 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4147 /* Scan the sections for the dynamic symbol table
4148 and dynamic string table and debug sections. */
4149 dynamic_symbols
= NULL
;
4150 dynamic_strings
= NULL
;
4151 dynamic_syminfo
= NULL
;
4152 symtab_shndx_hdr
= NULL
;
4154 eh_addr_size
= is_32bit_elf
? 4 : 8;
4155 switch (elf_header
.e_machine
)
4158 case EM_MIPS_RS3_LE
:
4159 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4160 FDE addresses. However, the ABI also has a semi-official ILP32
4161 variant for which the normal FDE address size rules apply.
4163 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4164 section, where XX is the size of longs in bits. Unfortunately,
4165 earlier compilers provided no way of distinguishing ILP32 objects
4166 from LP64 objects, so if there's any doubt, we should assume that
4167 the official LP64 form is being used. */
4168 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4169 && find_section (".gcc_compiled_long32") == NULL
)
4175 switch (elf_header
.e_flags
& EF_H8_MACH
)
4177 case E_H8_MACH_H8300
:
4178 case E_H8_MACH_H8300HN
:
4179 case E_H8_MACH_H8300SN
:
4180 case E_H8_MACH_H8300SXN
:
4183 case E_H8_MACH_H8300H
:
4184 case E_H8_MACH_H8300S
:
4185 case E_H8_MACH_H8300SX
:
4193 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4195 case EF_M32C_CPU_M16C
:
4202 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4205 size_t expected_entsize \
4206 = is_32bit_elf ? size32 : size64; \
4207 if (section->sh_entsize != expected_entsize) \
4208 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4209 i, (unsigned long int) section->sh_entsize, \
4210 (unsigned long int) expected_entsize); \
4211 section->sh_entsize = expected_entsize; \
4214 #define CHECK_ENTSIZE(section, i, type) \
4215 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4216 sizeof (Elf64_External_##type))
4218 for (i
= 0, section
= section_headers
;
4219 i
< elf_header
.e_shnum
;
4222 char * name
= SECTION_NAME (section
);
4224 if (section
->sh_type
== SHT_DYNSYM
)
4226 if (dynamic_symbols
!= NULL
)
4228 error (_("File contains multiple dynamic symbol tables\n"));
4232 CHECK_ENTSIZE (section
, i
, Sym
);
4233 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4234 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4236 else if (section
->sh_type
== SHT_STRTAB
4237 && streq (name
, ".dynstr"))
4239 if (dynamic_strings
!= NULL
)
4241 error (_("File contains multiple dynamic string tables\n"));
4245 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4246 1, section
->sh_size
,
4247 _("dynamic strings"));
4248 dynamic_strings_length
= section
->sh_size
;
4250 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4252 if (symtab_shndx_hdr
!= NULL
)
4254 error (_("File contains multiple symtab shndx tables\n"));
4257 symtab_shndx_hdr
= section
;
4259 else if (section
->sh_type
== SHT_SYMTAB
)
4260 CHECK_ENTSIZE (section
, i
, Sym
);
4261 else if (section
->sh_type
== SHT_GROUP
)
4262 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4263 else if (section
->sh_type
== SHT_REL
)
4264 CHECK_ENTSIZE (section
, i
, Rel
);
4265 else if (section
->sh_type
== SHT_RELA
)
4266 CHECK_ENTSIZE (section
, i
, Rela
);
4267 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4268 || do_debug_lines
|| do_debug_pubnames
4269 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4270 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4271 && (const_strneq (name
, ".debug_")
4272 || const_strneq (name
, ".zdebug_")))
4275 name
+= sizeof (".zdebug_") - 1;
4277 name
+= sizeof (".debug_") - 1;
4280 || (do_debug_info
&& streq (name
, "info"))
4281 || (do_debug_info
&& streq (name
, "types"))
4282 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4283 || (do_debug_lines
&& streq (name
, "line"))
4284 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4285 || (do_debug_aranges
&& streq (name
, "aranges"))
4286 || (do_debug_ranges
&& streq (name
, "ranges"))
4287 || (do_debug_frames
&& streq (name
, "frame"))
4288 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4289 || (do_debug_str
&& streq (name
, "str"))
4290 || (do_debug_loc
&& streq (name
, "loc"))
4292 request_dump_bynumber (i
, DEBUG_DUMP
);
4294 /* Linkonce section to be combined with .debug_info at link time. */
4295 else if ((do_debugging
|| do_debug_info
)
4296 && const_strneq (name
, ".gnu.linkonce.wi."))
4297 request_dump_bynumber (i
, DEBUG_DUMP
);
4298 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4299 request_dump_bynumber (i
, DEBUG_DUMP
);
4305 if (elf_header
.e_shnum
> 1)
4306 printf (_("\nSection Headers:\n"));
4308 printf (_("\nSection Header:\n"));
4312 if (do_section_details
)
4314 printf (_(" [Nr] Name\n"));
4315 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4319 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4323 if (do_section_details
)
4325 printf (_(" [Nr] Name\n"));
4326 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4330 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4334 if (do_section_details
)
4336 printf (_(" [Nr] Name\n"));
4337 printf (_(" Type Address Offset Link\n"));
4338 printf (_(" Size EntSize Info Align\n"));
4342 printf (_(" [Nr] Name Type Address Offset\n"));
4343 printf (_(" Size EntSize Flags Link Info Align\n"));
4347 if (do_section_details
)
4348 printf (_(" Flags\n"));
4350 for (i
= 0, section
= section_headers
;
4351 i
< elf_header
.e_shnum
;
4354 if (do_section_details
)
4356 printf (" [%2u] %s\n",
4358 SECTION_NAME (section
));
4359 if (is_32bit_elf
|| do_wide
)
4360 printf (" %-15.15s ",
4361 get_section_type_name (section
->sh_type
));
4364 printf ((do_wide
? " [%2u] %-17s %-15s "
4365 : " [%2u] %-17.17s %-15.15s "),
4367 SECTION_NAME (section
),
4368 get_section_type_name (section
->sh_type
));
4372 const char * link_too_big
= NULL
;
4374 print_vma (section
->sh_addr
, LONG_HEX
);
4376 printf ( " %6.6lx %6.6lx %2.2lx",
4377 (unsigned long) section
->sh_offset
,
4378 (unsigned long) section
->sh_size
,
4379 (unsigned long) section
->sh_entsize
);
4381 if (do_section_details
)
4382 fputs (" ", stdout
);
4384 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4386 if (section
->sh_link
>= elf_header
.e_shnum
)
4389 /* The sh_link value is out of range. Normally this indicates
4390 an error but it can have special values in Solaris binaries. */
4391 switch (elf_header
.e_machine
)
4396 case EM_OLD_SPARCV9
:
4397 case EM_SPARC32PLUS
:
4400 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4401 link_too_big
= "BEFORE";
4402 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4403 link_too_big
= "AFTER";
4410 if (do_section_details
)
4412 if (link_too_big
!= NULL
&& * link_too_big
)
4413 printf ("<%s> ", link_too_big
);
4415 printf ("%2u ", section
->sh_link
);
4416 printf ("%3u %2lu\n", section
->sh_info
,
4417 (unsigned long) section
->sh_addralign
);
4420 printf ("%2u %3u %2lu\n",
4423 (unsigned long) section
->sh_addralign
);
4425 if (link_too_big
&& ! * link_too_big
)
4426 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4427 i
, section
->sh_link
);
4431 print_vma (section
->sh_addr
, LONG_HEX
);
4433 if ((long) section
->sh_offset
== section
->sh_offset
)
4434 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4438 print_vma (section
->sh_offset
, LONG_HEX
);
4441 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4442 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4446 print_vma (section
->sh_size
, LONG_HEX
);
4449 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4450 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4454 print_vma (section
->sh_entsize
, LONG_HEX
);
4457 if (do_section_details
)
4458 fputs (" ", stdout
);
4460 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4462 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4464 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4465 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4468 print_vma (section
->sh_addralign
, DEC
);
4472 else if (do_section_details
)
4474 printf (" %-15.15s ",
4475 get_section_type_name (section
->sh_type
));
4476 print_vma (section
->sh_addr
, LONG_HEX
);
4477 if ((long) section
->sh_offset
== section
->sh_offset
)
4478 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4482 print_vma (section
->sh_offset
, LONG_HEX
);
4484 printf (" %u\n ", section
->sh_link
);
4485 print_vma (section
->sh_size
, LONG_HEX
);
4487 print_vma (section
->sh_entsize
, LONG_HEX
);
4489 printf (" %-16u %lu\n",
4491 (unsigned long) section
->sh_addralign
);
4496 print_vma (section
->sh_addr
, LONG_HEX
);
4497 if ((long) section
->sh_offset
== section
->sh_offset
)
4498 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4502 print_vma (section
->sh_offset
, LONG_HEX
);
4505 print_vma (section
->sh_size
, LONG_HEX
);
4507 print_vma (section
->sh_entsize
, LONG_HEX
);
4509 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4511 printf (" %2u %3u %lu\n",
4514 (unsigned long) section
->sh_addralign
);
4517 if (do_section_details
)
4518 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4521 if (!do_section_details
)
4522 printf (_("Key to Flags:\n\
4523 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4524 I (info), L (link order), G (group), x (unknown)\n\
4525 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4531 get_group_flags (unsigned int flags
)
4533 static char buff
[32];
4540 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4547 process_section_groups (FILE * file
)
4549 Elf_Internal_Shdr
* section
;
4551 struct group
* group
;
4552 Elf_Internal_Shdr
* symtab_sec
;
4553 Elf_Internal_Shdr
* strtab_sec
;
4554 Elf_Internal_Sym
* symtab
;
4558 /* Don't process section groups unless needed. */
4559 if (!do_unwind
&& !do_section_groups
)
4562 if (elf_header
.e_shnum
== 0)
4564 if (do_section_groups
)
4565 printf (_("\nThere are no sections in this file.\n"));
4570 if (section_headers
== NULL
)
4572 error (_("Section headers are not available!\n"));
4576 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4577 sizeof (struct group
*));
4579 if (section_headers_groups
== NULL
)
4581 error (_("Out of memory\n"));
4585 /* Scan the sections for the group section. */
4587 for (i
= 0, section
= section_headers
;
4588 i
< elf_header
.e_shnum
;
4590 if (section
->sh_type
== SHT_GROUP
)
4593 if (group_count
== 0)
4595 if (do_section_groups
)
4596 printf (_("\nThere are no section groups in this file.\n"));
4601 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4603 if (section_groups
== NULL
)
4605 error (_("Out of memory\n"));
4614 for (i
= 0, section
= section_headers
, group
= section_groups
;
4615 i
< elf_header
.e_shnum
;
4618 if (section
->sh_type
== SHT_GROUP
)
4620 char * name
= SECTION_NAME (section
);
4622 unsigned char * start
;
4623 unsigned char * indices
;
4624 unsigned int entry
, j
, size
;
4625 Elf_Internal_Shdr
* sec
;
4626 Elf_Internal_Sym
* sym
;
4628 /* Get the symbol table. */
4629 if (section
->sh_link
>= elf_header
.e_shnum
4630 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4633 error (_("Bad sh_link in group section `%s'\n"), name
);
4637 if (symtab_sec
!= sec
)
4642 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4645 sym
= symtab
+ section
->sh_info
;
4647 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4649 if (sym
->st_shndx
== 0
4650 || sym
->st_shndx
>= elf_header
.e_shnum
)
4652 error (_("Bad sh_info in group section `%s'\n"), name
);
4656 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4665 /* Get the string table. */
4666 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4675 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4680 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4681 1, strtab_sec
->sh_size
,
4683 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4685 group_name
= sym
->st_name
< strtab_size
4686 ? strtab
+ sym
->st_name
: "<corrupt>";
4689 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4690 1, section
->sh_size
,
4694 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4695 entry
= byte_get (indices
, 4);
4698 if (do_section_groups
)
4700 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4701 get_group_flags (entry
), i
, name
, group_name
, size
);
4703 printf (_(" [Index] Name\n"));
4706 group
->group_index
= i
;
4708 for (j
= 0; j
< size
; j
++)
4710 struct group_list
* g
;
4712 entry
= byte_get (indices
, 4);
4715 if (entry
>= elf_header
.e_shnum
)
4717 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4718 entry
, i
, elf_header
.e_shnum
- 1);
4722 if (section_headers_groups
[entry
] != NULL
)
4726 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4728 section_headers_groups
[entry
]->group_index
);
4733 /* Intel C/C++ compiler may put section 0 in a
4734 section group. We just warn it the first time
4735 and ignore it afterwards. */
4736 static int warned
= 0;
4739 error (_("section 0 in group section [%5u]\n"),
4740 section_headers_groups
[entry
]->group_index
);
4746 section_headers_groups
[entry
] = group
;
4748 if (do_section_groups
)
4750 sec
= section_headers
+ entry
;
4751 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4754 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
4755 g
->section_index
= entry
;
4756 g
->next
= group
->root
;
4780 } dynamic_relocations
[] =
4782 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4783 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4784 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4787 /* Process the reloc section. */
4790 process_relocs (FILE * file
)
4792 unsigned long rel_size
;
4793 unsigned long rel_offset
;
4799 if (do_using_dynamic
)
4803 int has_dynamic_reloc
;
4806 has_dynamic_reloc
= 0;
4808 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4810 is_rela
= dynamic_relocations
[i
].rela
;
4811 name
= dynamic_relocations
[i
].name
;
4812 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4813 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4815 has_dynamic_reloc
|= rel_size
;
4817 if (is_rela
== UNKNOWN
)
4819 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4820 switch (dynamic_info
[DT_PLTREL
])
4834 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4835 name
, rel_offset
, rel_size
);
4837 dump_relocations (file
,
4838 offset_from_vma (file
, rel_offset
, rel_size
),
4840 dynamic_symbols
, num_dynamic_syms
,
4841 dynamic_strings
, dynamic_strings_length
, is_rela
);
4845 if (! has_dynamic_reloc
)
4846 printf (_("\nThere are no dynamic relocations in this file.\n"));
4850 Elf_Internal_Shdr
* section
;
4854 for (i
= 0, section
= section_headers
;
4855 i
< elf_header
.e_shnum
;
4858 if ( section
->sh_type
!= SHT_RELA
4859 && section
->sh_type
!= SHT_REL
)
4862 rel_offset
= section
->sh_offset
;
4863 rel_size
= section
->sh_size
;
4867 Elf_Internal_Shdr
* strsec
;
4870 printf (_("\nRelocation section "));
4872 if (string_table
== NULL
)
4873 printf ("%d", section
->sh_name
);
4875 printf (_("'%s'"), SECTION_NAME (section
));
4877 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4878 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4880 is_rela
= section
->sh_type
== SHT_RELA
;
4882 if (section
->sh_link
!= 0
4883 && section
->sh_link
< elf_header
.e_shnum
)
4885 Elf_Internal_Shdr
* symsec
;
4886 Elf_Internal_Sym
* symtab
;
4887 unsigned long nsyms
;
4888 unsigned long strtablen
= 0;
4889 char * strtab
= NULL
;
4891 symsec
= section_headers
+ section
->sh_link
;
4892 if (symsec
->sh_type
!= SHT_SYMTAB
4893 && symsec
->sh_type
!= SHT_DYNSYM
)
4896 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4897 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4902 if (symsec
->sh_link
!= 0
4903 && symsec
->sh_link
< elf_header
.e_shnum
)
4905 strsec
= section_headers
+ symsec
->sh_link
;
4907 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4910 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4913 dump_relocations (file
, rel_offset
, rel_size
,
4914 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4920 dump_relocations (file
, rel_offset
, rel_size
,
4921 NULL
, 0, NULL
, 0, is_rela
);
4928 printf (_("\nThere are no relocations in this file.\n"));
4934 /* Process the unwind section. */
4936 #include "unwind-ia64.h"
4938 /* An absolute address consists of a section and an offset. If the
4939 section is NULL, the offset itself is the address, otherwise, the
4940 address equals to LOAD_ADDRESS(section) + offset. */
4944 unsigned short section
;
4948 #define ABSADDR(a) \
4950 ? section_headers [(a).section].sh_addr + (a).offset \
4953 struct ia64_unw_table_entry
4955 struct absaddr start
;
4957 struct absaddr info
;
4960 struct ia64_unw_aux_info
4963 struct ia64_unw_table_entry
*table
; /* Unwind table. */
4964 unsigned long table_len
; /* Length of unwind table. */
4965 unsigned char * info
; /* Unwind info. */
4966 unsigned long info_size
; /* Size of unwind info. */
4967 bfd_vma info_addr
; /* starting address of unwind info. */
4968 bfd_vma seg_base
; /* Starting address of segment. */
4969 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4970 unsigned long nsyms
; /* Number of symbols. */
4971 char * strtab
; /* The string table. */
4972 unsigned long strtab_size
; /* Size of string table. */
4976 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4977 unsigned long nsyms
,
4978 const char * strtab
,
4979 unsigned long strtab_size
,
4980 struct absaddr addr
,
4981 const char ** symname
,
4984 bfd_vma dist
= 0x100000;
4985 Elf_Internal_Sym
* sym
;
4986 Elf_Internal_Sym
* best
= NULL
;
4989 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4991 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4992 && sym
->st_name
!= 0
4993 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4994 && addr
.offset
>= sym
->st_value
4995 && addr
.offset
- sym
->st_value
< dist
)
4998 dist
= addr
.offset
- sym
->st_value
;
5005 *symname
= (best
->st_name
>= strtab_size
5006 ? "<corrupt>" : strtab
+ best
->st_name
);
5011 *offset
= addr
.offset
;
5015 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5017 struct ia64_unw_table_entry
* tp
;
5020 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5024 const unsigned char * dp
;
5025 const unsigned char * head
;
5026 const char * procname
;
5028 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5029 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5031 fputs ("\n<", stdout
);
5035 fputs (procname
, stdout
);
5038 printf ("+%lx", (unsigned long) offset
);
5041 fputs (">: [", stdout
);
5042 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5043 fputc ('-', stdout
);
5044 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5045 printf ("], info at +0x%lx\n",
5046 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5048 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5049 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5051 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5052 (unsigned) UNW_VER (stamp
),
5053 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5054 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5055 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5056 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5058 if (UNW_VER (stamp
) != 1)
5060 printf ("\tUnknown version.\n");
5065 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5066 dp
= unw_decode (dp
, in_body
, & in_body
);
5071 slurp_ia64_unwind_table (FILE * file
,
5072 struct ia64_unw_aux_info
* aux
,
5073 Elf_Internal_Shdr
* sec
)
5075 unsigned long size
, nrelas
, i
;
5076 Elf_Internal_Phdr
* seg
;
5077 struct ia64_unw_table_entry
* tep
;
5078 Elf_Internal_Shdr
* relsec
;
5079 Elf_Internal_Rela
* rela
;
5080 Elf_Internal_Rela
* rp
;
5081 unsigned char * table
;
5083 Elf_Internal_Sym
* sym
;
5084 const char * relname
;
5086 /* First, find the starting address of the segment that includes
5089 if (elf_header
.e_phnum
)
5091 if (! get_program_headers (file
))
5094 for (seg
= program_headers
;
5095 seg
< program_headers
+ elf_header
.e_phnum
;
5098 if (seg
->p_type
!= PT_LOAD
)
5101 if (sec
->sh_addr
>= seg
->p_vaddr
5102 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5104 aux
->seg_base
= seg
->p_vaddr
;
5110 /* Second, build the unwind table from the contents of the unwind section: */
5111 size
= sec
->sh_size
;
5112 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5117 aux
->table
= (struct ia64_unw_table_entry
*)
5118 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5120 for (tp
= table
; tp
< table
+ size
; ++tep
)
5122 tep
->start
.section
= SHN_UNDEF
;
5123 tep
->end
.section
= SHN_UNDEF
;
5124 tep
->info
.section
= SHN_UNDEF
;
5125 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5126 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5127 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5128 tep
->start
.offset
+= aux
->seg_base
;
5129 tep
->end
.offset
+= aux
->seg_base
;
5130 tep
->info
.offset
+= aux
->seg_base
;
5134 /* Third, apply any relocations to the unwind table: */
5135 for (relsec
= section_headers
;
5136 relsec
< section_headers
+ elf_header
.e_shnum
;
5139 if (relsec
->sh_type
!= SHT_RELA
5140 || relsec
->sh_info
>= elf_header
.e_shnum
5141 || section_headers
+ relsec
->sh_info
!= sec
)
5144 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5148 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5150 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5151 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5153 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5155 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5159 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5161 switch (rp
->r_offset
/eh_addr_size
% 3)
5164 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5165 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5168 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5169 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5172 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5173 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5183 aux
->table_len
= size
/ (3 * eh_addr_size
);
5188 ia64_process_unwind (FILE * file
)
5190 Elf_Internal_Shdr
* sec
;
5191 Elf_Internal_Shdr
* unwsec
= NULL
;
5192 Elf_Internal_Shdr
* strsec
;
5193 unsigned long i
, unwcount
= 0, unwstart
= 0;
5194 struct ia64_unw_aux_info aux
;
5196 memset (& aux
, 0, sizeof (aux
));
5198 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5200 if (sec
->sh_type
== SHT_SYMTAB
5201 && sec
->sh_link
< elf_header
.e_shnum
)
5203 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5204 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5206 strsec
= section_headers
+ sec
->sh_link
;
5207 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5210 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5212 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5217 printf (_("\nThere are no unwind sections in this file.\n"));
5219 while (unwcount
-- > 0)
5224 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5225 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5226 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5233 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5235 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5237 /* We need to find which section group it is in. */
5238 struct group_list
* g
= section_headers_groups
[i
]->root
;
5240 for (; g
!= NULL
; g
= g
->next
)
5242 sec
= section_headers
+ g
->section_index
;
5244 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5249 i
= elf_header
.e_shnum
;
5251 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5253 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5254 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5255 suffix
= SECTION_NAME (unwsec
) + len
;
5256 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5258 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5259 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5264 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5265 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5266 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5267 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5269 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5270 suffix
= SECTION_NAME (unwsec
) + len
;
5271 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5273 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5274 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5278 if (i
== elf_header
.e_shnum
)
5280 printf (_("\nCould not find unwind info section for "));
5282 if (string_table
== NULL
)
5283 printf ("%d", unwsec
->sh_name
);
5285 printf (_("'%s'"), SECTION_NAME (unwsec
));
5289 aux
.info_size
= sec
->sh_size
;
5290 aux
.info_addr
= sec
->sh_addr
;
5291 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5295 printf (_("\nUnwind section "));
5297 if (string_table
== NULL
)
5298 printf ("%d", unwsec
->sh_name
);
5300 printf (_("'%s'"), SECTION_NAME (unwsec
));
5302 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5303 (unsigned long) unwsec
->sh_offset
,
5304 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5306 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5308 if (aux
.table_len
> 0)
5309 dump_ia64_unwind (& aux
);
5312 free ((char *) aux
.table
);
5314 free ((char *) aux
.info
);
5323 free ((char *) aux
.strtab
);
5328 struct hppa_unw_table_entry
5330 struct absaddr start
;
5332 unsigned int Cannot_unwind
:1; /* 0 */
5333 unsigned int Millicode
:1; /* 1 */
5334 unsigned int Millicode_save_sr0
:1; /* 2 */
5335 unsigned int Region_description
:2; /* 3..4 */
5336 unsigned int reserved1
:1; /* 5 */
5337 unsigned int Entry_SR
:1; /* 6 */
5338 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5339 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5340 unsigned int Args_stored
:1; /* 16 */
5341 unsigned int Variable_Frame
:1; /* 17 */
5342 unsigned int Separate_Package_Body
:1; /* 18 */
5343 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5344 unsigned int Stack_Overflow_Check
:1; /* 20 */
5345 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5346 unsigned int Ada_Region
:1; /* 22 */
5347 unsigned int cxx_info
:1; /* 23 */
5348 unsigned int cxx_try_catch
:1; /* 24 */
5349 unsigned int sched_entry_seq
:1; /* 25 */
5350 unsigned int reserved2
:1; /* 26 */
5351 unsigned int Save_SP
:1; /* 27 */
5352 unsigned int Save_RP
:1; /* 28 */
5353 unsigned int Save_MRP_in_frame
:1; /* 29 */
5354 unsigned int extn_ptr_defined
:1; /* 30 */
5355 unsigned int Cleanup_defined
:1; /* 31 */
5357 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5358 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5359 unsigned int Large_frame
:1; /* 2 */
5360 unsigned int Pseudo_SP_Set
:1; /* 3 */
5361 unsigned int reserved4
:1; /* 4 */
5362 unsigned int Total_frame_size
:27; /* 5..31 */
5365 struct hppa_unw_aux_info
5367 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5368 unsigned long table_len
; /* Length of unwind table. */
5369 bfd_vma seg_base
; /* Starting address of segment. */
5370 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5371 unsigned long nsyms
; /* Number of symbols. */
5372 char * strtab
; /* The string table. */
5373 unsigned long strtab_size
; /* Size of string table. */
5377 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5379 struct hppa_unw_table_entry
* tp
;
5381 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5384 const char * procname
;
5386 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5387 aux
->strtab_size
, tp
->start
, &procname
,
5390 fputs ("\n<", stdout
);
5394 fputs (procname
, stdout
);
5397 printf ("+%lx", (unsigned long) offset
);
5400 fputs (">: [", stdout
);
5401 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5402 fputc ('-', stdout
);
5403 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5406 #define PF(_m) if (tp->_m) printf (#_m " ");
5407 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5410 PF(Millicode_save_sr0
);
5411 /* PV(Region_description); */
5417 PF(Separate_Package_Body
);
5418 PF(Frame_Extension_Millicode
);
5419 PF(Stack_Overflow_Check
);
5420 PF(Two_Instruction_SP_Increment
);
5424 PF(sched_entry_seq
);
5427 PF(Save_MRP_in_frame
);
5428 PF(extn_ptr_defined
);
5429 PF(Cleanup_defined
);
5430 PF(MPE_XL_interrupt_marker
);
5431 PF(HP_UX_interrupt_marker
);
5434 PV(Total_frame_size
);
5443 slurp_hppa_unwind_table (FILE * file
,
5444 struct hppa_unw_aux_info
* aux
,
5445 Elf_Internal_Shdr
* sec
)
5447 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5448 Elf_Internal_Phdr
* seg
;
5449 struct hppa_unw_table_entry
* tep
;
5450 Elf_Internal_Shdr
* relsec
;
5451 Elf_Internal_Rela
* rela
;
5452 Elf_Internal_Rela
* rp
;
5453 unsigned char * table
;
5455 Elf_Internal_Sym
* sym
;
5456 const char * relname
;
5458 /* First, find the starting address of the segment that includes
5461 if (elf_header
.e_phnum
)
5463 if (! get_program_headers (file
))
5466 for (seg
= program_headers
;
5467 seg
< program_headers
+ elf_header
.e_phnum
;
5470 if (seg
->p_type
!= PT_LOAD
)
5473 if (sec
->sh_addr
>= seg
->p_vaddr
5474 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5476 aux
->seg_base
= seg
->p_vaddr
;
5482 /* Second, build the unwind table from the contents of the unwind
5484 size
= sec
->sh_size
;
5485 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5491 nentries
= size
/ unw_ent_size
;
5492 size
= unw_ent_size
* nentries
;
5494 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5495 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5497 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5499 unsigned int tmp1
, tmp2
;
5501 tep
->start
.section
= SHN_UNDEF
;
5502 tep
->end
.section
= SHN_UNDEF
;
5504 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5505 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5506 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5507 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5509 tep
->start
.offset
+= aux
->seg_base
;
5510 tep
->end
.offset
+= aux
->seg_base
;
5512 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5513 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5514 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5515 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5516 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5517 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5518 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5519 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5520 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5521 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5522 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5523 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5524 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5525 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5526 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5527 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5528 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5529 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5530 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5531 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5532 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5533 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5534 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5535 tep
->Cleanup_defined
= tmp1
& 0x1;
5537 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5538 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5539 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5540 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5541 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5542 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5546 /* Third, apply any relocations to the unwind table. */
5547 for (relsec
= section_headers
;
5548 relsec
< section_headers
+ elf_header
.e_shnum
;
5551 if (relsec
->sh_type
!= SHT_RELA
5552 || relsec
->sh_info
>= elf_header
.e_shnum
5553 || section_headers
+ relsec
->sh_info
!= sec
)
5556 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5560 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5562 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5563 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5565 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5566 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5568 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5572 i
= rp
->r_offset
/ unw_ent_size
;
5574 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5577 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5578 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5581 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5582 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5592 aux
->table_len
= nentries
;
5598 hppa_process_unwind (FILE * file
)
5600 struct hppa_unw_aux_info aux
;
5601 Elf_Internal_Shdr
* unwsec
= NULL
;
5602 Elf_Internal_Shdr
* strsec
;
5603 Elf_Internal_Shdr
* sec
;
5606 memset (& aux
, 0, sizeof (aux
));
5608 if (string_table
== NULL
)
5611 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5613 if (sec
->sh_type
== SHT_SYMTAB
5614 && sec
->sh_link
< elf_header
.e_shnum
)
5616 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5617 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5619 strsec
= section_headers
+ sec
->sh_link
;
5620 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5623 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5625 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5630 printf (_("\nThere are no unwind sections in this file.\n"));
5632 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5634 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5636 printf (_("\nUnwind section "));
5637 printf (_("'%s'"), SECTION_NAME (sec
));
5639 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5640 (unsigned long) sec
->sh_offset
,
5641 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5643 slurp_hppa_unwind_table (file
, &aux
, sec
);
5644 if (aux
.table_len
> 0)
5645 dump_hppa_unwind (&aux
);
5648 free ((char *) aux
.table
);
5656 free ((char *) aux
.strtab
);
5662 process_unwind (FILE * file
)
5664 struct unwind_handler
5667 int (* handler
)(FILE *);
5670 { EM_IA_64
, ia64_process_unwind
},
5671 { EM_PARISC
, hppa_process_unwind
},
5679 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5680 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5681 return handlers
[i
].handler (file
);
5683 printf (_("\nThere are no unwind sections in this file.\n"));
5688 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5690 switch (entry
->d_tag
)
5693 if (entry
->d_un
.d_val
== 0)
5697 static const char * opts
[] =
5699 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5700 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5701 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5702 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5707 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5708 if (entry
->d_un
.d_val
& (1 << cnt
))
5710 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5717 case DT_MIPS_IVERSION
:
5718 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5719 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5721 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5724 case DT_MIPS_TIME_STAMP
:
5729 time_t time
= entry
->d_un
.d_val
;
5730 tmp
= gmtime (&time
);
5731 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5732 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5733 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5734 printf ("Time Stamp: %s\n", timebuf
);
5738 case DT_MIPS_RLD_VERSION
:
5739 case DT_MIPS_LOCAL_GOTNO
:
5740 case DT_MIPS_CONFLICTNO
:
5741 case DT_MIPS_LIBLISTNO
:
5742 case DT_MIPS_SYMTABNO
:
5743 case DT_MIPS_UNREFEXTNO
:
5744 case DT_MIPS_HIPAGENO
:
5745 case DT_MIPS_DELTA_CLASS_NO
:
5746 case DT_MIPS_DELTA_INSTANCE_NO
:
5747 case DT_MIPS_DELTA_RELOC_NO
:
5748 case DT_MIPS_DELTA_SYM_NO
:
5749 case DT_MIPS_DELTA_CLASSSYM_NO
:
5750 case DT_MIPS_COMPACT_SIZE
:
5751 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5755 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5761 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5763 switch (entry
->d_tag
)
5765 case DT_HP_DLD_FLAGS
:
5774 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5775 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5776 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5777 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5778 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5779 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5780 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5781 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5782 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5783 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5784 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5785 { DT_HP_GST
, "HP_GST" },
5786 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5787 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5788 { DT_HP_NODELETE
, "HP_NODELETE" },
5789 { DT_HP_GROUP
, "HP_GROUP" },
5790 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5794 bfd_vma val
= entry
->d_un
.d_val
;
5796 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5797 if (val
& flags
[cnt
].bit
)
5801 fputs (flags
[cnt
].str
, stdout
);
5803 val
^= flags
[cnt
].bit
;
5806 if (val
!= 0 || first
)
5810 print_vma (val
, HEX
);
5816 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5823 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5825 switch (entry
->d_tag
)
5827 case DT_IA_64_PLT_RESERVE
:
5828 /* First 3 slots reserved. */
5829 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5831 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5835 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5842 get_32bit_dynamic_section (FILE * file
)
5844 Elf32_External_Dyn
* edyn
;
5845 Elf32_External_Dyn
* ext
;
5846 Elf_Internal_Dyn
* entry
;
5848 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5849 dynamic_size
, _("dynamic section"));
5853 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5854 might not have the luxury of section headers. Look for the DT_NULL
5855 terminator to determine the number of entries. */
5856 for (ext
= edyn
, dynamic_nent
= 0;
5857 (char *) ext
< (char *) edyn
+ dynamic_size
;
5861 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5865 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5867 if (dynamic_section
== NULL
)
5869 error (_("Out of memory\n"));
5874 for (ext
= edyn
, entry
= dynamic_section
;
5875 entry
< dynamic_section
+ dynamic_nent
;
5878 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5879 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5888 get_64bit_dynamic_section (FILE * file
)
5890 Elf64_External_Dyn
* edyn
;
5891 Elf64_External_Dyn
* ext
;
5892 Elf_Internal_Dyn
* entry
;
5894 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5895 dynamic_size
, _("dynamic section"));
5899 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5900 might not have the luxury of section headers. Look for the DT_NULL
5901 terminator to determine the number of entries. */
5902 for (ext
= edyn
, dynamic_nent
= 0;
5903 (char *) ext
< (char *) edyn
+ dynamic_size
;
5907 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5911 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5913 if (dynamic_section
== NULL
)
5915 error (_("Out of memory\n"));
5920 for (ext
= edyn
, entry
= dynamic_section
;
5921 entry
< dynamic_section
+ dynamic_nent
;
5924 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5925 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5934 print_dynamic_flags (bfd_vma flags
)
5942 flag
= flags
& - flags
;
5952 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5953 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5954 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5955 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5956 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5957 default: fputs ("unknown", stdout
); break;
5963 /* Parse and display the contents of the dynamic section. */
5966 process_dynamic_section (FILE * file
)
5968 Elf_Internal_Dyn
* entry
;
5970 if (dynamic_size
== 0)
5973 printf (_("\nThere is no dynamic section in this file.\n"));
5980 if (! get_32bit_dynamic_section (file
))
5983 else if (! get_64bit_dynamic_section (file
))
5986 /* Find the appropriate symbol table. */
5987 if (dynamic_symbols
== NULL
)
5989 for (entry
= dynamic_section
;
5990 entry
< dynamic_section
+ dynamic_nent
;
5993 Elf_Internal_Shdr section
;
5995 if (entry
->d_tag
!= DT_SYMTAB
)
5998 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6000 /* Since we do not know how big the symbol table is,
6001 we default to reading in the entire file (!) and
6002 processing that. This is overkill, I know, but it
6004 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6006 if (archive_file_offset
!= 0)
6007 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6010 if (fseek (file
, 0, SEEK_END
))
6011 error (_("Unable to seek to end of file!\n"));
6013 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6017 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6019 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6021 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6022 if (num_dynamic_syms
< 1)
6024 error (_("Unable to determine the number of symbols to load\n"));
6028 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6032 /* Similarly find a string table. */
6033 if (dynamic_strings
== NULL
)
6035 for (entry
= dynamic_section
;
6036 entry
< dynamic_section
+ dynamic_nent
;
6039 unsigned long offset
;
6042 if (entry
->d_tag
!= DT_STRTAB
)
6045 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6047 /* Since we do not know how big the string table is,
6048 we default to reading in the entire file (!) and
6049 processing that. This is overkill, I know, but it
6052 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6054 if (archive_file_offset
!= 0)
6055 str_tab_len
= archive_file_size
- offset
;
6058 if (fseek (file
, 0, SEEK_END
))
6059 error (_("Unable to seek to end of file\n"));
6060 str_tab_len
= ftell (file
) - offset
;
6063 if (str_tab_len
< 1)
6066 (_("Unable to determine the length of the dynamic string table\n"));
6070 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6072 _("dynamic string table"));
6073 dynamic_strings_length
= str_tab_len
;
6078 /* And find the syminfo section if available. */
6079 if (dynamic_syminfo
== NULL
)
6081 unsigned long syminsz
= 0;
6083 for (entry
= dynamic_section
;
6084 entry
< dynamic_section
+ dynamic_nent
;
6087 if (entry
->d_tag
== DT_SYMINENT
)
6089 /* Note: these braces are necessary to avoid a syntax
6090 error from the SunOS4 C compiler. */
6091 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6093 else if (entry
->d_tag
== DT_SYMINSZ
)
6094 syminsz
= entry
->d_un
.d_val
;
6095 else if (entry
->d_tag
== DT_SYMINFO
)
6096 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6100 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6102 Elf_External_Syminfo
* extsyminfo
;
6103 Elf_External_Syminfo
* extsym
;
6104 Elf_Internal_Syminfo
* syminfo
;
6106 /* There is a syminfo section. Read the data. */
6107 extsyminfo
= (Elf_External_Syminfo
*)
6108 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6109 _("symbol information"));
6113 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6114 if (dynamic_syminfo
== NULL
)
6116 error (_("Out of memory\n"));
6120 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6121 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6122 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6123 ++syminfo
, ++extsym
)
6125 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6126 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6133 if (do_dynamic
&& dynamic_addr
)
6134 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6135 dynamic_addr
, dynamic_nent
);
6137 printf (_(" Tag Type Name/Value\n"));
6139 for (entry
= dynamic_section
;
6140 entry
< dynamic_section
+ dynamic_nent
;
6148 print_vma (entry
->d_tag
, FULL_HEX
);
6149 dtype
= get_dynamic_type (entry
->d_tag
);
6150 printf (" (%s)%*s", dtype
,
6151 ((is_32bit_elf
? 27 : 19)
6152 - (int) strlen (dtype
)),
6156 switch (entry
->d_tag
)
6160 print_dynamic_flags (entry
->d_un
.d_val
);
6170 switch (entry
->d_tag
)
6173 printf (_("Auxiliary library"));
6177 printf (_("Filter library"));
6181 printf (_("Configuration file"));
6185 printf (_("Dependency audit library"));
6189 printf (_("Audit library"));
6193 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6194 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6198 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6207 printf (_("Flags:"));
6209 if (entry
->d_un
.d_val
== 0)
6210 printf (_(" None\n"));
6213 unsigned long int val
= entry
->d_un
.d_val
;
6215 if (val
& DTF_1_PARINIT
)
6217 printf (" PARINIT");
6218 val
^= DTF_1_PARINIT
;
6220 if (val
& DTF_1_CONFEXP
)
6222 printf (" CONFEXP");
6223 val
^= DTF_1_CONFEXP
;
6226 printf (" %lx", val
);
6235 printf (_("Flags:"));
6237 if (entry
->d_un
.d_val
== 0)
6238 printf (_(" None\n"));
6241 unsigned long int val
= entry
->d_un
.d_val
;
6243 if (val
& DF_P1_LAZYLOAD
)
6245 printf (" LAZYLOAD");
6246 val
^= DF_P1_LAZYLOAD
;
6248 if (val
& DF_P1_GROUPPERM
)
6250 printf (" GROUPPERM");
6251 val
^= DF_P1_GROUPPERM
;
6254 printf (" %lx", val
);
6263 printf (_("Flags:"));
6264 if (entry
->d_un
.d_val
== 0)
6265 printf (_(" None\n"));
6268 unsigned long int val
= entry
->d_un
.d_val
;
6275 if (val
& DF_1_GLOBAL
)
6280 if (val
& DF_1_GROUP
)
6285 if (val
& DF_1_NODELETE
)
6287 printf (" NODELETE");
6288 val
^= DF_1_NODELETE
;
6290 if (val
& DF_1_LOADFLTR
)
6292 printf (" LOADFLTR");
6293 val
^= DF_1_LOADFLTR
;
6295 if (val
& DF_1_INITFIRST
)
6297 printf (" INITFIRST");
6298 val
^= DF_1_INITFIRST
;
6300 if (val
& DF_1_NOOPEN
)
6305 if (val
& DF_1_ORIGIN
)
6310 if (val
& DF_1_DIRECT
)
6315 if (val
& DF_1_TRANS
)
6320 if (val
& DF_1_INTERPOSE
)
6322 printf (" INTERPOSE");
6323 val
^= DF_1_INTERPOSE
;
6325 if (val
& DF_1_NODEFLIB
)
6327 printf (" NODEFLIB");
6328 val
^= DF_1_NODEFLIB
;
6330 if (val
& DF_1_NODUMP
)
6335 if (val
& DF_1_CONLFAT
)
6337 printf (" CONLFAT");
6338 val
^= DF_1_CONLFAT
;
6341 printf (" %lx", val
);
6348 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6350 puts (get_dynamic_type (entry
->d_un
.d_val
));
6370 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6376 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6377 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6383 switch (entry
->d_tag
)
6386 printf (_("Shared library: [%s]"), name
);
6388 if (streq (name
, program_interpreter
))
6389 printf (_(" program interpreter"));
6393 printf (_("Library soname: [%s]"), name
);
6397 printf (_("Library rpath: [%s]"), name
);
6401 printf (_("Library runpath: [%s]"), name
);
6405 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6410 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6423 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6427 case DT_INIT_ARRAYSZ
:
6428 case DT_FINI_ARRAYSZ
:
6429 case DT_GNU_CONFLICTSZ
:
6430 case DT_GNU_LIBLISTSZ
:
6433 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6434 printf (" (bytes)\n");
6444 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6457 if (entry
->d_tag
== DT_USED
6458 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6460 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6464 printf (_("Not needed object: [%s]\n"), name
);
6469 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6475 /* The value of this entry is ignored. */
6480 case DT_GNU_PRELINKED
:
6484 time_t time
= entry
->d_un
.d_val
;
6486 tmp
= gmtime (&time
);
6487 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6488 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6489 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6495 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6498 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6504 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6505 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6510 switch (elf_header
.e_machine
)
6513 case EM_MIPS_RS3_LE
:
6514 dynamic_section_mips_val (entry
);
6517 dynamic_section_parisc_val (entry
);
6520 dynamic_section_ia64_val (entry
);
6523 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6535 get_ver_flags (unsigned int flags
)
6537 static char buff
[32];
6544 if (flags
& VER_FLG_BASE
)
6545 strcat (buff
, "BASE ");
6547 if (flags
& VER_FLG_WEAK
)
6549 if (flags
& VER_FLG_BASE
)
6550 strcat (buff
, "| ");
6552 strcat (buff
, "WEAK ");
6555 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6556 strcat (buff
, "| <unknown>");
6561 /* Display the contents of the version sections. */
6564 process_version_sections (FILE * file
)
6566 Elf_Internal_Shdr
* section
;
6573 for (i
= 0, section
= section_headers
;
6574 i
< elf_header
.e_shnum
;
6577 switch (section
->sh_type
)
6579 case SHT_GNU_verdef
:
6581 Elf_External_Verdef
* edefs
;
6589 (_("\nVersion definition section '%s' contains %u entries:\n"),
6590 SECTION_NAME (section
), section
->sh_info
);
6592 printf (_(" Addr: 0x"));
6593 printf_vma (section
->sh_addr
);
6594 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6595 (unsigned long) section
->sh_offset
, section
->sh_link
,
6596 section
->sh_link
< elf_header
.e_shnum
6597 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6600 edefs
= (Elf_External_Verdef
*)
6601 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
6602 _("version definition section"));
6603 endbuf
= (char *) edefs
+ section
->sh_size
;
6607 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6610 Elf_External_Verdef
* edef
;
6611 Elf_Internal_Verdef ent
;
6612 Elf_External_Verdaux
* eaux
;
6613 Elf_Internal_Verdaux aux
;
6617 vstart
= ((char *) edefs
) + idx
;
6618 if (vstart
+ sizeof (*edef
) > endbuf
)
6621 edef
= (Elf_External_Verdef
*) vstart
;
6623 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6624 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6625 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6626 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6627 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6628 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6629 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6631 printf (_(" %#06x: Rev: %d Flags: %s"),
6632 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6634 printf (_(" Index: %d Cnt: %d "),
6635 ent
.vd_ndx
, ent
.vd_cnt
);
6637 vstart
+= ent
.vd_aux
;
6639 eaux
= (Elf_External_Verdaux
*) vstart
;
6641 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6642 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6644 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6645 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6647 printf (_("Name index: %ld\n"), aux
.vda_name
);
6649 isum
= idx
+ ent
.vd_aux
;
6651 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6653 isum
+= aux
.vda_next
;
6654 vstart
+= aux
.vda_next
;
6656 eaux
= (Elf_External_Verdaux
*) vstart
;
6657 if (vstart
+ sizeof (*eaux
) > endbuf
)
6660 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6661 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6663 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6664 printf (_(" %#06x: Parent %d: %s\n"),
6665 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6667 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6668 isum
, j
, aux
.vda_name
);
6671 printf (_(" Version def aux past end of section\n"));
6675 if (cnt
< section
->sh_info
)
6676 printf (_(" Version definition past end of section\n"));
6682 case SHT_GNU_verneed
:
6684 Elf_External_Verneed
* eneed
;
6691 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6692 SECTION_NAME (section
), section
->sh_info
);
6694 printf (_(" Addr: 0x"));
6695 printf_vma (section
->sh_addr
);
6696 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6697 (unsigned long) section
->sh_offset
, section
->sh_link
,
6698 section
->sh_link
< elf_header
.e_shnum
6699 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6702 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
6703 section
->sh_offset
, 1,
6705 _("version need section"));
6706 endbuf
= (char *) eneed
+ section
->sh_size
;
6710 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6712 Elf_External_Verneed
* entry
;
6713 Elf_Internal_Verneed ent
;
6718 vstart
= ((char *) eneed
) + idx
;
6719 if (vstart
+ sizeof (*entry
) > endbuf
)
6722 entry
= (Elf_External_Verneed
*) vstart
;
6724 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6725 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6726 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6727 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6728 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6730 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6732 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6733 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6735 printf (_(" File: %lx"), ent
.vn_file
);
6737 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6739 vstart
+= ent
.vn_aux
;
6741 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6743 Elf_External_Vernaux
* eaux
;
6744 Elf_Internal_Vernaux aux
;
6746 if (vstart
+ sizeof (*eaux
) > endbuf
)
6748 eaux
= (Elf_External_Vernaux
*) vstart
;
6750 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6751 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6752 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6753 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6754 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6756 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6757 printf (_(" %#06x: Name: %s"),
6758 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6760 printf (_(" %#06x: Name index: %lx"),
6761 isum
, aux
.vna_name
);
6763 printf (_(" Flags: %s Version: %d\n"),
6764 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6766 isum
+= aux
.vna_next
;
6767 vstart
+= aux
.vna_next
;
6770 printf (_(" Version need aux past end of section\n"));
6774 if (cnt
< section
->sh_info
)
6775 printf (_(" Version need past end of section\n"));
6781 case SHT_GNU_versym
:
6783 Elf_Internal_Shdr
* link_section
;
6786 unsigned char * edata
;
6787 unsigned short * data
;
6789 Elf_Internal_Sym
* symbols
;
6790 Elf_Internal_Shdr
* string_sec
;
6793 if (section
->sh_link
>= elf_header
.e_shnum
)
6796 link_section
= section_headers
+ section
->sh_link
;
6797 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6799 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6804 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6806 string_sec
= section_headers
+ link_section
->sh_link
;
6808 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6809 string_sec
->sh_size
,
6810 _("version string table"));
6814 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6815 SECTION_NAME (section
), total
);
6817 printf (_(" Addr: "));
6818 printf_vma (section
->sh_addr
);
6819 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6820 (unsigned long) section
->sh_offset
, section
->sh_link
,
6821 SECTION_NAME (link_section
));
6823 off
= offset_from_vma (file
,
6824 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6825 total
* sizeof (short));
6826 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
6828 _("version symbol data"));
6835 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
6837 for (cnt
= total
; cnt
--;)
6838 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6843 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6846 int check_def
, check_need
;
6849 printf (" %03x:", cnt
);
6851 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6852 switch (data
[cnt
+ j
])
6855 fputs (_(" 0 (*local*) "), stdout
);
6859 fputs (_(" 1 (*global*) "), stdout
);
6863 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
6864 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
6868 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6869 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6872 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6879 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6881 Elf_Internal_Verneed ivn
;
6882 unsigned long offset
;
6884 offset
= offset_from_vma
6885 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6886 sizeof (Elf_External_Verneed
));
6890 Elf_Internal_Vernaux ivna
;
6891 Elf_External_Verneed evn
;
6892 Elf_External_Vernaux evna
;
6893 unsigned long a_off
;
6895 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6898 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6899 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6901 a_off
= offset
+ ivn
.vn_aux
;
6905 get_data (&evna
, file
, a_off
, sizeof (evna
),
6906 1, _("version need aux (2)"));
6908 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6909 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6911 a_off
+= ivna
.vna_next
;
6913 while (ivna
.vna_other
!= data
[cnt
+ j
]
6914 && ivna
.vna_next
!= 0);
6916 if (ivna
.vna_other
== data
[cnt
+ j
])
6918 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6920 if (ivna
.vna_name
>= string_sec
->sh_size
)
6921 name
= _("*invalid*");
6923 name
= strtab
+ ivna
.vna_name
;
6924 nn
+= printf ("(%s%-*s",
6926 12 - (int) strlen (name
),
6932 offset
+= ivn
.vn_next
;
6934 while (ivn
.vn_next
);
6937 if (check_def
&& data
[cnt
+ j
] != 0x8001
6938 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6940 Elf_Internal_Verdef ivd
;
6941 Elf_External_Verdef evd
;
6942 unsigned long offset
;
6944 offset
= offset_from_vma
6945 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6950 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6953 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6954 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6956 offset
+= ivd
.vd_next
;
6958 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
6959 && ivd
.vd_next
!= 0);
6961 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
6963 Elf_External_Verdaux evda
;
6964 Elf_Internal_Verdaux ivda
;
6966 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6968 get_data (&evda
, file
,
6969 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6971 _("version def aux"));
6973 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6975 if (ivda
.vda_name
>= string_sec
->sh_size
)
6976 name
= _("*invalid*");
6978 name
= strtab
+ ivda
.vda_name
;
6979 nn
+= printf ("(%s%-*s",
6981 12 - (int) strlen (name
),
6987 printf ("%*c", 18 - nn
, ' ');
7005 printf (_("\nNo version information found in this file.\n"));
7011 get_symbol_binding (unsigned int binding
)
7013 static char buff
[32];
7017 case STB_LOCAL
: return "LOCAL";
7018 case STB_GLOBAL
: return "GLOBAL";
7019 case STB_WEAK
: return "WEAK";
7021 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7022 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7024 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7026 if (binding
== STB_GNU_UNIQUE
7027 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7028 /* GNU/Linux is still using the default value 0. */
7029 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7031 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7034 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7040 get_symbol_type (unsigned int type
)
7042 static char buff
[32];
7046 case STT_NOTYPE
: return "NOTYPE";
7047 case STT_OBJECT
: return "OBJECT";
7048 case STT_FUNC
: return "FUNC";
7049 case STT_SECTION
: return "SECTION";
7050 case STT_FILE
: return "FILE";
7051 case STT_COMMON
: return "COMMON";
7052 case STT_TLS
: return "TLS";
7053 case STT_RELC
: return "RELC";
7054 case STT_SRELC
: return "SRELC";
7056 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7058 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7059 return "THUMB_FUNC";
7061 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7064 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7065 return "PARISC_MILLI";
7067 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7069 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7071 if (elf_header
.e_machine
== EM_PARISC
)
7073 if (type
== STT_HP_OPAQUE
)
7075 if (type
== STT_HP_STUB
)
7079 if (type
== STT_GNU_IFUNC
7080 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7081 /* GNU/Linux is still using the default value 0. */
7082 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7085 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7088 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7094 get_symbol_visibility (unsigned int visibility
)
7098 case STV_DEFAULT
: return "DEFAULT";
7099 case STV_INTERNAL
: return "INTERNAL";
7100 case STV_HIDDEN
: return "HIDDEN";
7101 case STV_PROTECTED
: return "PROTECTED";
7107 get_mips_symbol_other (unsigned int other
)
7111 case STO_OPTIONAL
: return "OPTIONAL";
7112 case STO_MIPS16
: return "MIPS16";
7113 case STO_MIPS_PLT
: return "MIPS PLT";
7114 case STO_MIPS_PIC
: return "MIPS PIC";
7115 default: return NULL
;
7120 get_symbol_other (unsigned int other
)
7122 const char * result
= NULL
;
7123 static char buff
[32];
7128 switch (elf_header
.e_machine
)
7131 result
= get_mips_symbol_other (other
);
7139 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7144 get_symbol_index_type (unsigned int type
)
7146 static char buff
[32];
7150 case SHN_UNDEF
: return "UND";
7151 case SHN_ABS
: return "ABS";
7152 case SHN_COMMON
: return "COM";
7154 if (type
== SHN_IA_64_ANSI_COMMON
7155 && elf_header
.e_machine
== EM_IA_64
7156 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7158 else if ((elf_header
.e_machine
== EM_X86_64
7159 || elf_header
.e_machine
== EM_L1OM
)
7160 && type
== SHN_X86_64_LCOMMON
)
7162 else if (type
== SHN_MIPS_SCOMMON
7163 && elf_header
.e_machine
== EM_MIPS
)
7165 else if (type
== SHN_MIPS_SUNDEFINED
7166 && elf_header
.e_machine
== EM_MIPS
)
7168 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7169 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7170 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7171 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7172 else if (type
>= SHN_LORESERVE
)
7173 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7175 sprintf (buff
, "%3d", type
);
7183 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7185 unsigned char * e_data
;
7188 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
7192 error (_("Out of memory\n"));
7196 if (fread (e_data
, ent_size
, number
, file
) != number
)
7198 error (_("Unable to read in dynamic data\n"));
7202 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
7206 error (_("Out of memory\n"));
7212 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7220 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7222 Elf_Internal_Sym
* psym
;
7225 psym
= dynamic_symbols
+ si
;
7227 n
= print_vma (si
, DEC_5
);
7229 fputs (" " + n
, stdout
);
7230 printf (" %3lu: ", hn
);
7231 print_vma (psym
->st_value
, LONG_HEX
);
7233 print_vma (psym
->st_size
, DEC_5
);
7235 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7236 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7237 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7238 /* Check to see if any other bits in the st_other field are set.
7239 Note - displaying this information disrupts the layout of the
7240 table being generated, but for the moment this case is very
7242 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7243 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7244 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7245 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7246 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7248 printf (" <corrupt: %14ld>", psym
->st_name
);
7252 /* Dump the symbol table. */
7254 process_symbol_table (FILE * file
)
7256 Elf_Internal_Shdr
* section
;
7257 bfd_vma nbuckets
= 0;
7258 bfd_vma nchains
= 0;
7259 bfd_vma
* buckets
= NULL
;
7260 bfd_vma
* chains
= NULL
;
7261 bfd_vma ngnubuckets
= 0;
7262 bfd_vma
* gnubuckets
= NULL
;
7263 bfd_vma
* gnuchains
= NULL
;
7264 bfd_vma gnusymidx
= 0;
7266 if (! do_syms
&& !do_histogram
)
7269 if (dynamic_info
[DT_HASH
]
7271 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7273 unsigned char nb
[8];
7274 unsigned char nc
[8];
7275 int hash_ent_size
= 4;
7277 if ((elf_header
.e_machine
== EM_ALPHA
7278 || elf_header
.e_machine
== EM_S390
7279 || elf_header
.e_machine
== EM_S390_OLD
)
7280 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7284 (archive_file_offset
7285 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7286 sizeof nb
+ sizeof nc
)),
7289 error (_("Unable to seek to start of dynamic information\n"));
7293 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7295 error (_("Failed to read in number of buckets\n"));
7299 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7301 error (_("Failed to read in number of chains\n"));
7305 nbuckets
= byte_get (nb
, hash_ent_size
);
7306 nchains
= byte_get (nc
, hash_ent_size
);
7308 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7309 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7312 if (buckets
== NULL
|| chains
== NULL
)
7314 if (do_using_dynamic
)
7325 if (dynamic_info_DT_GNU_HASH
7327 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7329 unsigned char nb
[16];
7330 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7331 bfd_vma buckets_vma
;
7334 (archive_file_offset
7335 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7339 error (_("Unable to seek to start of dynamic information\n"));
7343 if (fread (nb
, 16, 1, file
) != 1)
7345 error (_("Failed to read in number of buckets\n"));
7349 ngnubuckets
= byte_get (nb
, 4);
7350 gnusymidx
= byte_get (nb
+ 4, 4);
7351 bitmaskwords
= byte_get (nb
+ 8, 4);
7352 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7354 buckets_vma
+= bitmaskwords
* 4;
7356 buckets_vma
+= bitmaskwords
* 8;
7359 (archive_file_offset
7360 + offset_from_vma (file
, buckets_vma
, 4)),
7363 error (_("Unable to seek to start of dynamic information\n"));
7367 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7369 if (gnubuckets
== NULL
)
7372 for (i
= 0; i
< ngnubuckets
; i
++)
7373 if (gnubuckets
[i
] != 0)
7375 if (gnubuckets
[i
] < gnusymidx
)
7378 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7379 maxchain
= gnubuckets
[i
];
7382 if (maxchain
== 0xffffffff)
7385 maxchain
-= gnusymidx
;
7388 (archive_file_offset
7389 + offset_from_vma (file
, buckets_vma
7390 + 4 * (ngnubuckets
+ maxchain
), 4)),
7393 error (_("Unable to seek to start of dynamic information\n"));
7399 if (fread (nb
, 4, 1, file
) != 1)
7401 error (_("Failed to determine last chain length\n"));
7405 if (maxchain
+ 1 == 0)
7410 while ((byte_get (nb
, 4) & 1) == 0);
7413 (archive_file_offset
7414 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7417 error (_("Unable to seek to start of dynamic information\n"));
7421 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7424 if (gnuchains
== NULL
)
7429 if (do_using_dynamic
)
7434 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7437 && dynamic_strings
!= NULL
)
7441 if (dynamic_info
[DT_HASH
])
7445 printf (_("\nSymbol table for image:\n"));
7447 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7449 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7451 for (hn
= 0; hn
< nbuckets
; hn
++)
7456 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7457 print_dynamic_symbol (si
, hn
);
7461 if (dynamic_info_DT_GNU_HASH
)
7463 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7465 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7467 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7469 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7470 if (gnubuckets
[hn
] != 0)
7472 bfd_vma si
= gnubuckets
[hn
];
7473 bfd_vma off
= si
- gnusymidx
;
7477 print_dynamic_symbol (si
, hn
);
7480 while ((gnuchains
[off
++] & 1) == 0);
7484 else if (do_syms
&& !do_using_dynamic
)
7488 for (i
= 0, section
= section_headers
;
7489 i
< elf_header
.e_shnum
;
7493 char * strtab
= NULL
;
7494 unsigned long int strtab_size
= 0;
7495 Elf_Internal_Sym
* symtab
;
7496 Elf_Internal_Sym
* psym
;
7498 if ( section
->sh_type
!= SHT_SYMTAB
7499 && section
->sh_type
!= SHT_DYNSYM
)
7502 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7503 SECTION_NAME (section
),
7504 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7506 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7508 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7510 symtab
= GET_ELF_SYMBOLS (file
, section
);
7514 if (section
->sh_link
== elf_header
.e_shstrndx
)
7516 strtab
= string_table
;
7517 strtab_size
= string_table_length
;
7519 else if (section
->sh_link
< elf_header
.e_shnum
)
7521 Elf_Internal_Shdr
* string_sec
;
7523 string_sec
= section_headers
+ section
->sh_link
;
7525 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
7526 1, string_sec
->sh_size
,
7528 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7531 for (si
= 0, psym
= symtab
;
7532 si
< section
->sh_size
/ section
->sh_entsize
;
7535 printf ("%6d: ", si
);
7536 print_vma (psym
->st_value
, LONG_HEX
);
7538 print_vma (psym
->st_size
, DEC_5
);
7539 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7540 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7541 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7542 /* Check to see if any other bits in the st_other field are set.
7543 Note - displaying this information disrupts the layout of the
7544 table being generated, but for the moment this case is very rare. */
7545 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7546 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7547 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7548 print_symbol (25, psym
->st_name
< strtab_size
7549 ? strtab
+ psym
->st_name
: "<corrupt>");
7551 if (section
->sh_type
== SHT_DYNSYM
&&
7552 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7554 unsigned char data
[2];
7555 unsigned short vers_data
;
7556 unsigned long offset
;
7560 offset
= offset_from_vma
7561 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7562 sizeof data
+ si
* sizeof (vers_data
));
7564 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7565 sizeof (data
), 1, _("version data"));
7567 vers_data
= byte_get (data
, 2);
7569 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7570 && section_headers
[psym
->st_shndx
].sh_type
7573 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7575 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
7577 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7578 && (is_nobits
|| ! check_def
))
7580 Elf_External_Verneed evn
;
7581 Elf_Internal_Verneed ivn
;
7582 Elf_Internal_Vernaux ivna
;
7584 /* We must test both. */
7585 offset
= offset_from_vma
7586 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7591 unsigned long vna_off
;
7593 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7596 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7597 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7599 vna_off
= offset
+ ivn
.vn_aux
;
7603 Elf_External_Vernaux evna
;
7605 get_data (&evna
, file
, vna_off
,
7607 _("version need aux (3)"));
7609 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7610 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7611 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7613 vna_off
+= ivna
.vna_next
;
7615 while (ivna
.vna_other
!= vers_data
7616 && ivna
.vna_next
!= 0);
7618 if (ivna
.vna_other
== vers_data
)
7621 offset
+= ivn
.vn_next
;
7623 while (ivn
.vn_next
!= 0);
7625 if (ivna
.vna_other
== vers_data
)
7628 ivna
.vna_name
< strtab_size
7629 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7633 else if (! is_nobits
)
7634 error (_("bad dynamic symbol\n"));
7641 if (vers_data
!= 0x8001
7642 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7644 Elf_Internal_Verdef ivd
;
7645 Elf_Internal_Verdaux ivda
;
7646 Elf_External_Verdaux evda
;
7647 unsigned long offset
;
7649 offset
= offset_from_vma
7651 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7652 sizeof (Elf_External_Verdef
));
7656 Elf_External_Verdef evd
;
7658 get_data (&evd
, file
, offset
, sizeof (evd
),
7659 1, _("version def"));
7661 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7662 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7663 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7665 offset
+= ivd
.vd_next
;
7667 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
7668 && ivd
.vd_next
!= 0);
7670 offset
-= ivd
.vd_next
;
7671 offset
+= ivd
.vd_aux
;
7673 get_data (&evda
, file
, offset
, sizeof (evda
),
7674 1, _("version def aux"));
7676 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7678 if (psym
->st_name
!= ivda
.vda_name
)
7679 printf ((vers_data
& VERSYM_HIDDEN
)
7681 ivda
.vda_name
< strtab_size
7682 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7692 if (strtab
!= string_table
)
7698 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7700 if (do_histogram
&& buckets
!= NULL
)
7702 unsigned long * lengths
;
7703 unsigned long * counts
;
7706 unsigned long maxlength
= 0;
7707 unsigned long nzero_counts
= 0;
7708 unsigned long nsyms
= 0;
7710 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7711 (unsigned long) nbuckets
);
7712 printf (_(" Length Number %% of total Coverage\n"));
7714 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
7715 if (lengths
== NULL
)
7717 error (_("Out of memory\n"));
7720 for (hn
= 0; hn
< nbuckets
; ++hn
)
7722 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7725 if (maxlength
< ++lengths
[hn
])
7730 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7733 error (_("Out of memory\n"));
7737 for (hn
= 0; hn
< nbuckets
; ++hn
)
7738 ++counts
[lengths
[hn
]];
7743 printf (" 0 %-10lu (%5.1f%%)\n",
7744 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7745 for (i
= 1; i
<= maxlength
; ++i
)
7747 nzero_counts
+= counts
[i
] * i
;
7748 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7749 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7750 (nzero_counts
* 100.0) / nsyms
);
7758 if (buckets
!= NULL
)
7764 if (do_histogram
&& gnubuckets
!= NULL
)
7766 unsigned long * lengths
;
7767 unsigned long * counts
;
7769 unsigned long maxlength
= 0;
7770 unsigned long nzero_counts
= 0;
7771 unsigned long nsyms
= 0;
7773 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
7774 if (lengths
== NULL
)
7776 error (_("Out of memory\n"));
7780 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7781 (unsigned long) ngnubuckets
);
7782 printf (_(" Length Number %% of total Coverage\n"));
7784 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7785 if (gnubuckets
[hn
] != 0)
7787 bfd_vma off
, length
= 1;
7789 for (off
= gnubuckets
[hn
] - gnusymidx
;
7790 (gnuchains
[off
] & 1) == 0; ++off
)
7792 lengths
[hn
] = length
;
7793 if (length
> maxlength
)
7798 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7801 error (_("Out of memory\n"));
7805 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7806 ++counts
[lengths
[hn
]];
7808 if (ngnubuckets
> 0)
7811 printf (" 0 %-10lu (%5.1f%%)\n",
7812 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7813 for (j
= 1; j
<= maxlength
; ++j
)
7815 nzero_counts
+= counts
[j
] * j
;
7816 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7817 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7818 (nzero_counts
* 100.0) / nsyms
);
7832 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7836 if (dynamic_syminfo
== NULL
7838 /* No syminfo, this is ok. */
7841 /* There better should be a dynamic symbol section. */
7842 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7846 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7847 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7849 printf (_(" Num: Name BoundTo Flags\n"));
7850 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7852 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7854 printf ("%4d: ", i
);
7855 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7856 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7858 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7861 switch (dynamic_syminfo
[i
].si_boundto
)
7863 case SYMINFO_BT_SELF
:
7864 fputs ("SELF ", stdout
);
7866 case SYMINFO_BT_PARENT
:
7867 fputs ("PARENT ", stdout
);
7870 if (dynamic_syminfo
[i
].si_boundto
> 0
7871 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7872 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7874 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7878 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7882 if (flags
& SYMINFO_FLG_DIRECT
)
7884 if (flags
& SYMINFO_FLG_PASSTHRU
)
7885 printf (" PASSTHRU");
7886 if (flags
& SYMINFO_FLG_COPY
)
7888 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7889 printf (" LAZYLOAD");
7897 /* Check to see if the given reloc needs to be handled in a target specific
7898 manner. If so then process the reloc and return TRUE otherwise return
7902 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
7903 unsigned char * start
,
7904 Elf_Internal_Sym
* symtab
)
7906 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
7908 switch (elf_header
.e_machine
)
7911 case EM_CYGNUS_MN10300
:
7913 static Elf_Internal_Sym
* saved_sym
= NULL
;
7917 case 34: /* R_MN10300_ALIGN */
7919 case 33: /* R_MN10300_SYM_DIFF */
7920 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
7922 case 1: /* R_MN10300_32 */
7923 case 2: /* R_MN10300_16 */
7924 if (saved_sym
!= NULL
)
7928 value
= reloc
->r_addend
7929 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
7930 - saved_sym
->st_value
);
7932 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
7939 if (saved_sym
!= NULL
)
7940 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
7950 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7951 DWARF debug sections. This is a target specific test. Note - we do not
7952 go through the whole including-target-headers-multiple-times route, (as
7953 we have already done with <elf/h8.h>) because this would become very
7954 messy and even then this function would have to contain target specific
7955 information (the names of the relocs instead of their numeric values).
7956 FIXME: This is not the correct way to solve this problem. The proper way
7957 is to have target specific reloc sizing and typing functions created by
7958 the reloc-macros.h header, in the same way that it already creates the
7959 reloc naming functions. */
7962 is_32bit_abs_reloc (unsigned int reloc_type
)
7964 switch (elf_header
.e_machine
)
7968 return reloc_type
== 1; /* R_386_32. */
7970 return reloc_type
== 1; /* R_68K_32. */
7972 return reloc_type
== 1; /* R_860_32. */
7974 return reloc_type
== 1; /* XXX Is this right ? */
7976 return reloc_type
== 1; /* R_ARC_32. */
7978 return reloc_type
== 2; /* R_ARM_ABS32 */
7981 return reloc_type
== 1;
7983 return reloc_type
== 0x12; /* R_byte4_data. */
7985 return reloc_type
== 3; /* R_CRIS_32. */
7988 return reloc_type
== 3; /* R_CR16_NUM32. */
7990 return reloc_type
== 15; /* R_CRX_NUM32. */
7992 return reloc_type
== 1;
7993 case EM_CYGNUS_D10V
:
7995 return reloc_type
== 6; /* R_D10V_32. */
7996 case EM_CYGNUS_D30V
:
7998 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8000 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8001 case EM_CYGNUS_FR30
:
8003 return reloc_type
== 3; /* R_FR30_32. */
8007 return reloc_type
== 1; /* R_H8_DIR32. */
8009 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8012 return reloc_type
== 2; /* R_IP2K_32. */
8014 return reloc_type
== 2; /* R_IQ2000_32. */
8015 case EM_LATTICEMICO32
:
8016 return reloc_type
== 3; /* R_LM32_32. */
8019 return reloc_type
== 3; /* R_M32C_32. */
8021 return reloc_type
== 34; /* R_M32R_32_RELA. */
8023 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8025 return reloc_type
== 4; /* R_MEP_32. */
8027 return reloc_type
== 2; /* R_MIPS_32. */
8029 return reloc_type
== 4; /* R_MMIX_32. */
8030 case EM_CYGNUS_MN10200
:
8032 return reloc_type
== 1; /* R_MN10200_32. */
8033 case EM_CYGNUS_MN10300
:
8035 return reloc_type
== 1; /* R_MN10300_32. */
8038 return reloc_type
== 1; /* R_MSP43_32. */
8040 return reloc_type
== 2; /* R_MT_32. */
8041 case EM_ALTERA_NIOS2
:
8043 return reloc_type
== 1; /* R_NIOS_32. */
8046 return reloc_type
== 1; /* R_OR32_32. */
8048 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8049 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8052 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8054 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8056 return reloc_type
== 1; /* R_PPC_ADDR32. */
8058 return reloc_type
== 1; /* R_I370_ADDR31. */
8061 return reloc_type
== 4; /* R_S390_32. */
8063 return reloc_type
== 8; /* R_SCORE_ABS32. */
8065 return reloc_type
== 1; /* R_SH_DIR32. */
8066 case EM_SPARC32PLUS
:
8069 return reloc_type
== 3 /* R_SPARC_32. */
8070 || reloc_type
== 23; /* R_SPARC_UA32. */
8072 return reloc_type
== 6; /* R_SPU_ADDR32 */
8073 case EM_CYGNUS_V850
:
8075 return reloc_type
== 6; /* R_V850_ABS32. */
8077 return reloc_type
== 1; /* R_VAX_32. */
8080 return reloc_type
== 10; /* R_X86_64_32. */
8082 return reloc_type
== 1; /* R_XSTROMY16_32. */
8085 return reloc_type
== 1; /* R_XTENSA_32. */
8088 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8089 elf_header
.e_machine
);
8094 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8095 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8098 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8100 switch (elf_header
.e_machine
)
8104 return reloc_type
== 2; /* R_386_PC32. */
8106 return reloc_type
== 4; /* R_68K_PC32. */
8108 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8110 return reloc_type
== 3; /* R_ARM_REL32 */
8112 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8114 return reloc_type
== 26; /* R_PPC_REL32. */
8116 return reloc_type
== 26; /* R_PPC64_REL32. */
8119 return reloc_type
== 5; /* R_390_PC32. */
8121 return reloc_type
== 2; /* R_SH_REL32. */
8122 case EM_SPARC32PLUS
:
8125 return reloc_type
== 6; /* R_SPARC_DISP32. */
8127 return reloc_type
== 13; /* R_SPU_REL32. */
8130 return reloc_type
== 2; /* R_X86_64_PC32. */
8133 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8135 /* Do not abort or issue an error message here. Not all targets use
8136 pc-relative 32-bit relocs in their DWARF debug information and we
8137 have already tested for target coverage in is_32bit_abs_reloc. A
8138 more helpful warning message will be generated by apply_relocations
8139 anyway, so just return. */
8144 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8145 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8148 is_64bit_abs_reloc (unsigned int reloc_type
)
8150 switch (elf_header
.e_machine
)
8153 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8155 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8157 return reloc_type
== 80; /* R_PARISC_DIR64. */
8159 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8160 case EM_SPARC32PLUS
:
8163 return reloc_type
== 54; /* R_SPARC_UA64. */
8166 return reloc_type
== 1; /* R_X86_64_64. */
8169 return reloc_type
== 22; /* R_S390_64 */
8171 return reloc_type
== 18; /* R_MIPS_64 */
8177 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8178 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8181 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8183 switch (elf_header
.e_machine
)
8186 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8188 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8190 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8192 return reloc_type
== 44; /* R_PPC64_REL64 */
8193 case EM_SPARC32PLUS
:
8196 return reloc_type
== 46; /* R_SPARC_DISP64 */
8199 return reloc_type
== 24; /* R_X86_64_PC64 */
8202 return reloc_type
== 23; /* R_S390_PC64 */
8208 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8209 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8212 is_24bit_abs_reloc (unsigned int reloc_type
)
8214 switch (elf_header
.e_machine
)
8216 case EM_CYGNUS_MN10200
:
8218 return reloc_type
== 4; /* R_MN10200_24. */
8224 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8225 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8228 is_16bit_abs_reloc (unsigned int reloc_type
)
8230 switch (elf_header
.e_machine
)
8234 return reloc_type
== 4; /* R_AVR_16. */
8235 case EM_CYGNUS_D10V
:
8237 return reloc_type
== 3; /* R_D10V_16. */
8241 return reloc_type
== R_H8_DIR16
;
8244 return reloc_type
== 1; /* R_IP2K_16. */
8247 return reloc_type
== 1; /* R_M32C_16 */
8250 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8251 case EM_ALTERA_NIOS2
:
8253 return reloc_type
== 9; /* R_NIOS_16. */
8259 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8260 relocation entries (possibly formerly used for SHT_GROUP sections). */
8263 is_none_reloc (unsigned int reloc_type
)
8265 switch (elf_header
.e_machine
)
8267 case EM_68K
: /* R_68K_NONE. */
8268 case EM_386
: /* R_386_NONE. */
8269 case EM_SPARC32PLUS
:
8271 case EM_SPARC
: /* R_SPARC_NONE. */
8272 case EM_MIPS
: /* R_MIPS_NONE. */
8273 case EM_PARISC
: /* R_PARISC_NONE. */
8274 case EM_ALPHA
: /* R_ALPHA_NONE. */
8275 case EM_PPC
: /* R_PPC_NONE. */
8276 case EM_PPC64
: /* R_PPC64_NONE. */
8277 case EM_ARM
: /* R_ARM_NONE. */
8278 case EM_IA_64
: /* R_IA64_NONE. */
8279 case EM_SH
: /* R_SH_NONE. */
8281 case EM_S390
: /* R_390_NONE. */
8282 case EM_CRIS
: /* R_CRIS_NONE. */
8283 case EM_X86_64
: /* R_X86_64_NONE. */
8284 case EM_L1OM
: /* R_X86_64_NONE. */
8285 case EM_MN10300
: /* R_MN10300_NONE. */
8286 case EM_M32R
: /* R_M32R_NONE. */
8287 return reloc_type
== 0;
8290 return (reloc_type
== 0 /* R_XTENSA_NONE. */
8291 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
8292 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
8293 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
8298 /* Apply relocations to a section.
8299 Note: So far support has been added only for those relocations
8300 which can be found in debug sections.
8301 FIXME: Add support for more relocations ? */
8304 apply_relocations (void * file
,
8305 Elf_Internal_Shdr
* section
,
8306 unsigned char * start
)
8308 Elf_Internal_Shdr
* relsec
;
8309 unsigned char * end
= start
+ section
->sh_size
;
8311 if (elf_header
.e_type
!= ET_REL
)
8314 /* Find the reloc section associated with the section. */
8315 for (relsec
= section_headers
;
8316 relsec
< section_headers
+ elf_header
.e_shnum
;
8319 bfd_boolean is_rela
;
8320 unsigned long num_relocs
;
8321 Elf_Internal_Rela
* relocs
;
8322 Elf_Internal_Rela
* rp
;
8323 Elf_Internal_Shdr
* symsec
;
8324 Elf_Internal_Sym
* symtab
;
8325 Elf_Internal_Sym
* sym
;
8327 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8328 || relsec
->sh_info
>= elf_header
.e_shnum
8329 || section_headers
+ relsec
->sh_info
!= section
8330 || relsec
->sh_size
== 0
8331 || relsec
->sh_link
>= elf_header
.e_shnum
)
8334 is_rela
= relsec
->sh_type
== SHT_RELA
;
8338 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
8339 relsec
->sh_size
, & relocs
, & num_relocs
))
8344 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
8345 relsec
->sh_size
, & relocs
, & num_relocs
))
8349 /* SH uses RELA but uses in place value instead of the addend field. */
8350 if (elf_header
.e_machine
== EM_SH
)
8353 symsec
= section_headers
+ relsec
->sh_link
;
8354 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
8356 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8359 unsigned int reloc_type
;
8360 unsigned int reloc_size
;
8361 unsigned char * loc
;
8363 reloc_type
= get_reloc_type (rp
->r_info
);
8365 if (target_specific_reloc_handling (rp
, start
, symtab
))
8367 else if (is_none_reloc (reloc_type
))
8369 else if (is_32bit_abs_reloc (reloc_type
)
8370 || is_32bit_pcrel_reloc (reloc_type
))
8372 else if (is_64bit_abs_reloc (reloc_type
)
8373 || is_64bit_pcrel_reloc (reloc_type
))
8375 else if (is_24bit_abs_reloc (reloc_type
))
8377 else if (is_16bit_abs_reloc (reloc_type
))
8381 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8382 reloc_type
, SECTION_NAME (section
));
8386 loc
= start
+ rp
->r_offset
;
8387 if ((loc
+ reloc_size
) > end
)
8389 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8390 (unsigned long) rp
->r_offset
,
8391 SECTION_NAME (section
));
8395 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8397 /* If the reloc has a symbol associated with it,
8398 make sure that it is of an appropriate type.
8400 Relocations against symbols without type can happen.
8401 Gcc -feliminate-dwarf2-dups may generate symbols
8402 without type for debug info.
8404 Icc generates relocations against function symbols
8405 instead of local labels.
8407 Relocations against object symbols can happen, eg when
8408 referencing a global array. For an example of this see
8409 the _clz.o binary in libgcc.a. */
8411 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8413 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8414 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8415 (long int)(rp
- relocs
),
8416 SECTION_NAME (relsec
));
8422 addend
+= rp
->r_addend
;
8423 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8425 || (elf_header
.e_machine
== EM_XTENSA
8427 || ((elf_header
.e_machine
== EM_PJ
8428 || elf_header
.e_machine
== EM_PJ_OLD
)
8429 && reloc_type
== 1))
8430 addend
+= byte_get (loc
, reloc_size
);
8432 if (is_32bit_pcrel_reloc (reloc_type
)
8433 || is_64bit_pcrel_reloc (reloc_type
))
8435 /* On HPPA, all pc-relative relocations are biased by 8. */
8436 if (elf_header
.e_machine
== EM_PARISC
)
8438 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8442 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8451 #ifdef SUPPORT_DISASSEMBLY
8453 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8455 printf (_("\nAssembly dump of section %s\n"),
8456 SECTION_NAME (section
));
8458 /* XXX -- to be done --- XXX */
8464 /* Reads in the contents of SECTION from FILE, returning a pointer
8465 to a malloc'ed buffer or NULL if something went wrong. */
8468 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8470 bfd_size_type num_bytes
;
8472 num_bytes
= section
->sh_size
;
8474 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8476 printf (_("\nSection '%s' has no data to dump.\n"),
8477 SECTION_NAME (section
));
8481 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8482 _("section contents"));
8487 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8489 Elf_Internal_Shdr
* relsec
;
8490 bfd_size_type num_bytes
;
8495 char * name
= SECTION_NAME (section
);
8496 bfd_boolean some_strings_shown
;
8498 start
= get_section_contents (section
, file
);
8502 printf (_("\nString dump of section '%s':\n"), name
);
8504 /* If the section being dumped has relocations against it the user might
8505 be expecting these relocations to have been applied. Check for this
8506 case and issue a warning message in order to avoid confusion.
8507 FIXME: Maybe we ought to have an option that dumps a section with
8509 for (relsec
= section_headers
;
8510 relsec
< section_headers
+ elf_header
.e_shnum
;
8513 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8514 || relsec
->sh_info
>= elf_header
.e_shnum
8515 || section_headers
+ relsec
->sh_info
!= section
8516 || relsec
->sh_size
== 0
8517 || relsec
->sh_link
>= elf_header
.e_shnum
)
8520 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8524 num_bytes
= section
->sh_size
;
8525 addr
= section
->sh_addr
;
8527 end
= start
+ num_bytes
;
8528 some_strings_shown
= FALSE
;
8532 while (!ISPRINT (* data
))
8539 printf (" [%6tx] %s\n", data
- start
, data
);
8541 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8543 data
+= strlen (data
);
8544 some_strings_shown
= TRUE
;
8548 if (! some_strings_shown
)
8549 printf (_(" No strings found in this section."));
8557 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8559 bfd_boolean relocate
)
8561 Elf_Internal_Shdr
* relsec
;
8562 bfd_size_type bytes
;
8564 unsigned char * data
;
8565 unsigned char * start
;
8567 start
= (unsigned char *) get_section_contents (section
, file
);
8571 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8575 apply_relocations (file
, section
, start
);
8579 /* If the section being dumped has relocations against it the user might
8580 be expecting these relocations to have been applied. Check for this
8581 case and issue a warning message in order to avoid confusion.
8582 FIXME: Maybe we ought to have an option that dumps a section with
8584 for (relsec
= section_headers
;
8585 relsec
< section_headers
+ elf_header
.e_shnum
;
8588 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8589 || relsec
->sh_info
>= elf_header
.e_shnum
8590 || section_headers
+ relsec
->sh_info
!= section
8591 || relsec
->sh_size
== 0
8592 || relsec
->sh_link
>= elf_header
.e_shnum
)
8595 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8600 addr
= section
->sh_addr
;
8601 bytes
= section
->sh_size
;
8610 lbytes
= (bytes
> 16 ? 16 : bytes
);
8612 printf (" 0x%8.8lx ", (unsigned long) addr
);
8614 for (j
= 0; j
< 16; j
++)
8617 printf ("%2.2x", data
[j
]);
8625 for (j
= 0; j
< lbytes
; j
++)
8628 if (k
>= ' ' && k
< 0x7f)
8646 /* Uncompresses a section that was compressed using zlib, in place.
8647 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8650 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8653 /* These are just to quiet gcc. */
8658 dwarf_size_type compressed_size
= *size
;
8659 unsigned char * compressed_buffer
= *buffer
;
8660 dwarf_size_type uncompressed_size
;
8661 unsigned char * uncompressed_buffer
;
8664 dwarf_size_type header_size
= 12;
8666 /* Read the zlib header. In this case, it should be "ZLIB" followed
8667 by the uncompressed section size, 8 bytes in big-endian order. */
8668 if (compressed_size
< header_size
8669 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8672 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8673 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8674 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8675 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8676 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8677 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8678 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8679 uncompressed_size
+= compressed_buffer
[11];
8681 /* It is possible the section consists of several compressed
8682 buffers concatenated together, so we uncompress in a loop. */
8686 strm
.avail_in
= compressed_size
- header_size
;
8687 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8688 strm
.avail_out
= uncompressed_size
;
8689 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
8691 rc
= inflateInit (& strm
);
8692 while (strm
.avail_in
> 0)
8696 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8697 + (uncompressed_size
- strm
.avail_out
));
8698 rc
= inflate (&strm
, Z_FINISH
);
8699 if (rc
!= Z_STREAM_END
)
8701 rc
= inflateReset (& strm
);
8703 rc
= inflateEnd (& strm
);
8705 || strm
.avail_out
!= 0)
8708 free (compressed_buffer
);
8709 *buffer
= uncompressed_buffer
;
8710 *size
= uncompressed_size
;
8714 free (uncompressed_buffer
);
8716 #endif /* HAVE_ZLIB_H */
8720 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8721 Elf_Internal_Shdr
* sec
, void * file
)
8723 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8725 int section_is_compressed
;
8727 /* If it is already loaded, do nothing. */
8728 if (section
->start
!= NULL
)
8731 section_is_compressed
= section
->name
== section
->compressed_name
;
8733 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8734 section
->address
= sec
->sh_addr
;
8735 section
->size
= sec
->sh_size
;
8736 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
8739 if (section
->start
== NULL
)
8742 if (section_is_compressed
)
8743 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8746 if (debug_displays
[debug
].relocate
)
8747 apply_relocations ((FILE *) file
, sec
, section
->start
);
8753 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8755 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8756 Elf_Internal_Shdr
* sec
;
8758 /* Locate the debug section. */
8759 sec
= find_section (section
->uncompressed_name
);
8761 section
->name
= section
->uncompressed_name
;
8764 sec
= find_section (section
->compressed_name
);
8766 section
->name
= section
->compressed_name
;
8771 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
8775 free_debug_section (enum dwarf_section_display_enum debug
)
8777 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8779 if (section
->start
== NULL
)
8782 free ((char *) section
->start
);
8783 section
->start
= NULL
;
8784 section
->address
= 0;
8789 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8791 char * name
= SECTION_NAME (section
);
8792 bfd_size_type length
;
8796 length
= section
->sh_size
;
8799 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8802 if (section
->sh_type
== SHT_NOBITS
)
8804 /* There is no point in dumping the contents of a debugging section
8805 which has the NOBITS type - the bits in the file will be random.
8806 This can happen when a file containing a .eh_frame section is
8807 stripped with the --only-keep-debug command line option. */
8808 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8812 if (const_strneq (name
, ".gnu.linkonce.wi."))
8813 name
= ".debug_info";
8815 /* See if we know how to display the contents of this section. */
8816 for (i
= 0; i
< max
; i
++)
8817 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8818 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8820 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8821 int secondary
= (section
!= find_section (name
));
8824 free_debug_section ((enum dwarf_section_display_enum
) i
);
8826 if (streq (sec
->uncompressed_name
, name
))
8827 sec
->name
= sec
->uncompressed_name
;
8829 sec
->name
= sec
->compressed_name
;
8830 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
8833 result
&= debug_displays
[i
].display (sec
, file
);
8835 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8836 free_debug_section ((enum dwarf_section_display_enum
) i
);
8844 printf (_("Unrecognized debug section: %s\n"), name
);
8851 /* Set DUMP_SECTS for all sections where dumps were requested
8852 based on section name. */
8855 initialise_dumps_byname (void)
8857 struct dump_list_entry
* cur
;
8859 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8864 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8865 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8867 request_dump_bynumber (i
, cur
->type
);
8872 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8878 process_section_contents (FILE * file
)
8880 Elf_Internal_Shdr
* section
;
8886 initialise_dumps_byname ();
8888 for (i
= 0, section
= section_headers
;
8889 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8892 #ifdef SUPPORT_DISASSEMBLY
8893 if (dump_sects
[i
] & DISASS_DUMP
)
8894 disassemble_section (section
, file
);
8896 if (dump_sects
[i
] & HEX_DUMP
)
8897 dump_section_as_bytes (section
, file
, FALSE
);
8899 if (dump_sects
[i
] & RELOC_DUMP
)
8900 dump_section_as_bytes (section
, file
, TRUE
);
8902 if (dump_sects
[i
] & STRING_DUMP
)
8903 dump_section_as_strings (section
, file
);
8905 if (dump_sects
[i
] & DEBUG_DUMP
)
8906 display_debug_section (section
, file
);
8909 /* Check to see if the user requested a
8910 dump of a section that does not exist. */
8911 while (i
++ < num_dump_sects
)
8913 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8917 process_mips_fpe_exception (int mask
)
8922 if (mask
& OEX_FPU_INEX
)
8923 fputs ("INEX", stdout
), first
= 0;
8924 if (mask
& OEX_FPU_UFLO
)
8925 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8926 if (mask
& OEX_FPU_OFLO
)
8927 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8928 if (mask
& OEX_FPU_DIV0
)
8929 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8930 if (mask
& OEX_FPU_INVAL
)
8931 printf ("%sINVAL", first
? "" : "|");
8934 fputs ("0", stdout
);
8937 /* ARM EABI attributes section. */
8942 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8944 const char ** table
;
8945 } arm_attr_public_tag
;
8947 static const char * arm_attr_tag_CPU_arch
[] =
8948 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8949 "v6K", "v7", "v6-M", "v6S-M"};
8950 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8951 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8952 {"No", "Thumb-1", "Thumb-2"};
8953 static const char * arm_attr_tag_VFP_arch
[] =
8954 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8955 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8956 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8957 static const char * arm_attr_tag_PCS_config
[] =
8958 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8959 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8960 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8961 {"V6", "SB", "TLS", "Unused"};
8962 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8963 {"Absolute", "PC-relative", "SB-relative", "None"};
8964 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8965 {"Absolute", "PC-relative", "None"};
8966 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8967 {"None", "direct", "GOT-indirect"};
8968 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8969 {"None", "??? 1", "2", "??? 3", "4"};
8970 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8971 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8972 {"Unused", "Needed", "Sign only"};
8973 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8974 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8975 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8976 {"Unused", "Finite", "RTABI", "IEEE 754"};
8977 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8978 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8979 {"No", "Yes, except leaf SP", "Yes"};
8980 static const char * arm_attr_tag_ABI_enum_size
[] =
8981 {"Unused", "small", "int", "forced to int"};
8982 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8983 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8984 static const char * arm_attr_tag_ABI_VFP_args
[] =
8985 {"AAPCS", "VFP registers", "custom"};
8986 static const char * arm_attr_tag_ABI_WMMX_args
[] =
8987 {"AAPCS", "WMMX registers", "custom"};
8988 static const char * arm_attr_tag_ABI_optimization_goals
[] =
8989 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8990 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8991 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
8992 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8993 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8994 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8995 static const char * arm_attr_tag_VFP_HP_extension
[] =
8996 {"Not Allowed", "Allowed"};
8997 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
8998 {"None", "IEEE 754", "Alternative Format"};
8999 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9000 static const char * arm_attr_tag_Virtualization_use
[] =
9001 {"Not Allowed", "Allowed"};
9002 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
9004 #define LOOKUP(id, name) \
9005 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9006 static arm_attr_public_tag arm_attr_public_tags
[] =
9008 {4, "CPU_raw_name", 1, NULL
},
9009 {5, "CPU_name", 1, NULL
},
9010 LOOKUP(6, CPU_arch
),
9011 {7, "CPU_arch_profile", 0, NULL
},
9012 LOOKUP(8, ARM_ISA_use
),
9013 LOOKUP(9, THUMB_ISA_use
),
9014 LOOKUP(10, VFP_arch
),
9015 LOOKUP(11, WMMX_arch
),
9016 LOOKUP(12, Advanced_SIMD_arch
),
9017 LOOKUP(13, PCS_config
),
9018 LOOKUP(14, ABI_PCS_R9_use
),
9019 LOOKUP(15, ABI_PCS_RW_data
),
9020 LOOKUP(16, ABI_PCS_RO_data
),
9021 LOOKUP(17, ABI_PCS_GOT_use
),
9022 LOOKUP(18, ABI_PCS_wchar_t
),
9023 LOOKUP(19, ABI_FP_rounding
),
9024 LOOKUP(20, ABI_FP_denormal
),
9025 LOOKUP(21, ABI_FP_exceptions
),
9026 LOOKUP(22, ABI_FP_user_exceptions
),
9027 LOOKUP(23, ABI_FP_number_model
),
9028 LOOKUP(24, ABI_align8_needed
),
9029 LOOKUP(25, ABI_align8_preserved
),
9030 LOOKUP(26, ABI_enum_size
),
9031 LOOKUP(27, ABI_HardFP_use
),
9032 LOOKUP(28, ABI_VFP_args
),
9033 LOOKUP(29, ABI_WMMX_args
),
9034 LOOKUP(30, ABI_optimization_goals
),
9035 LOOKUP(31, ABI_FP_optimization_goals
),
9036 {32, "compatibility", 0, NULL
},
9037 LOOKUP(34, CPU_unaligned_access
),
9038 LOOKUP(36, VFP_HP_extension
),
9039 LOOKUP(38, ABI_FP_16bit_format
),
9040 {64, "nodefaults", 0, NULL
},
9041 {65, "also_compatible_with", 0, NULL
},
9042 LOOKUP(66, T2EE_use
),
9043 {67, "conformance", 1, NULL
},
9044 LOOKUP(68, Virtualization_use
),
9045 LOOKUP(70, MPextension_use
)
9049 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9053 read_uleb128 (unsigned char * p
, unsigned int * plen
)
9067 val
|= ((unsigned int)c
& 0x7f) << shift
;
9076 static unsigned char *
9077 display_arm_attribute (unsigned char * p
)
9082 arm_attr_public_tag
* attr
;
9086 tag
= read_uleb128 (p
, &len
);
9089 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9091 if (arm_attr_public_tags
[i
].tag
== tag
)
9093 attr
= &arm_attr_public_tags
[i
];
9100 printf (" Tag_%s: ", attr
->name
);
9106 case 7: /* Tag_CPU_arch_profile. */
9107 val
= read_uleb128 (p
, &len
);
9111 case 0: printf ("None\n"); break;
9112 case 'A': printf ("Application\n"); break;
9113 case 'R': printf ("Realtime\n"); break;
9114 case 'M': printf ("Microcontroller\n"); break;
9115 default: printf ("??? (%d)\n", val
); break;
9119 case 32: /* Tag_compatibility. */
9120 val
= read_uleb128 (p
, &len
);
9122 printf ("flag = %d, vendor = %s\n", val
, p
);
9123 p
+= strlen ((char *) p
) + 1;
9126 case 64: /* Tag_nodefaults. */
9131 case 65: /* Tag_also_compatible_with. */
9132 val
= read_uleb128 (p
, &len
);
9134 if (val
== 6 /* Tag_CPU_arch. */)
9136 val
= read_uleb128 (p
, &len
);
9138 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
9139 printf ("??? (%d)\n", val
);
9141 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9145 while (*(p
++) != '\0' /* NUL terminator. */);
9159 assert (attr
->type
& 0x80);
9160 val
= read_uleb128 (p
, &len
);
9162 type
= attr
->type
& 0x7f;
9164 printf ("??? (%d)\n", val
);
9166 printf ("%s\n", attr
->table
[val
]);
9173 type
= 1; /* String. */
9175 type
= 2; /* uleb128. */
9176 printf (" Tag_unknown_%d: ", tag
);
9181 printf ("\"%s\"\n", p
);
9182 p
+= strlen ((char *) p
) + 1;
9186 val
= read_uleb128 (p
, &len
);
9188 printf ("%d (0x%x)\n", val
, val
);
9194 static unsigned char *
9195 display_gnu_attribute (unsigned char * p
,
9196 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9203 tag
= read_uleb128 (p
, &len
);
9206 /* Tag_compatibility is the only generic GNU attribute defined at
9210 val
= read_uleb128 (p
, &len
);
9212 printf ("flag = %d, vendor = %s\n", val
, p
);
9213 p
+= strlen ((char *) p
) + 1;
9217 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9218 return display_proc_gnu_attribute (p
, tag
);
9221 type
= 1; /* String. */
9223 type
= 2; /* uleb128. */
9224 printf (" Tag_unknown_%d: ", tag
);
9228 printf ("\"%s\"\n", p
);
9229 p
+= strlen ((char *) p
) + 1;
9233 val
= read_uleb128 (p
, &len
);
9235 printf ("%d (0x%x)\n", val
, val
);
9241 static unsigned char *
9242 display_power_gnu_attribute (unsigned char * p
, int tag
)
9248 if (tag
== Tag_GNU_Power_ABI_FP
)
9250 val
= read_uleb128 (p
, &len
);
9252 printf (" Tag_GNU_Power_ABI_FP: ");
9257 printf ("Hard or soft float\n");
9260 printf ("Hard float\n");
9263 printf ("Soft float\n");
9266 printf ("Single-precision hard float\n");
9269 printf ("??? (%d)\n", val
);
9275 if (tag
== Tag_GNU_Power_ABI_Vector
)
9277 val
= read_uleb128 (p
, &len
);
9279 printf (" Tag_GNU_Power_ABI_Vector: ");
9286 printf ("Generic\n");
9289 printf ("AltiVec\n");
9295 printf ("??? (%d)\n", val
);
9301 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9303 val
= read_uleb128 (p
, &len
);
9305 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9315 printf ("Memory\n");
9318 printf ("??? (%d)\n", val
);
9325 type
= 1; /* String. */
9327 type
= 2; /* uleb128. */
9328 printf (" Tag_unknown_%d: ", tag
);
9332 printf ("\"%s\"\n", p
);
9333 p
+= strlen ((char *) p
) + 1;
9337 val
= read_uleb128 (p
, &len
);
9339 printf ("%d (0x%x)\n", val
, val
);
9345 static unsigned char *
9346 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9352 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9354 val
= read_uleb128 (p
, &len
);
9356 printf (" Tag_GNU_MIPS_ABI_FP: ");
9361 printf ("Hard or soft float\n");
9364 printf ("Hard float (-mdouble-float)\n");
9367 printf ("Hard float (-msingle-float)\n");
9370 printf ("Soft float\n");
9373 printf ("64-bit float (-mips32r2 -mfp64)\n");
9376 printf ("??? (%d)\n", val
);
9383 type
= 1; /* String. */
9385 type
= 2; /* uleb128. */
9386 printf (" Tag_unknown_%d: ", tag
);
9390 printf ("\"%s\"\n", p
);
9391 p
+= strlen ((char *) p
) + 1;
9395 val
= read_uleb128 (p
, &len
);
9397 printf ("%d (0x%x)\n", val
, val
);
9404 process_attributes (FILE * file
,
9405 const char * public_name
,
9406 unsigned int proc_type
,
9407 unsigned char * (* display_pub_attribute
) (unsigned char *),
9408 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9410 Elf_Internal_Shdr
* sect
;
9411 unsigned char * contents
;
9413 unsigned char * end
;
9414 bfd_vma section_len
;
9418 /* Find the section header so that we get the size. */
9419 for (i
= 0, sect
= section_headers
;
9420 i
< elf_header
.e_shnum
;
9423 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9426 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
9427 sect
->sh_size
, _("attributes"));
9428 if (contents
== NULL
)
9434 len
= sect
->sh_size
- 1;
9440 bfd_boolean public_section
;
9441 bfd_boolean gnu_section
;
9443 section_len
= byte_get (p
, 4);
9446 if (section_len
> len
)
9448 printf (_("ERROR: Bad section length (%d > %d)\n"),
9449 (int) section_len
, (int) len
);
9454 printf ("Attribute Section: %s\n", p
);
9456 if (public_name
&& streq ((char *) p
, public_name
))
9457 public_section
= TRUE
;
9459 public_section
= FALSE
;
9461 if (streq ((char *) p
, "gnu"))
9464 gnu_section
= FALSE
;
9466 namelen
= strlen ((char *) p
) + 1;
9468 section_len
-= namelen
+ 4;
9470 while (section_len
> 0)
9476 size
= byte_get (p
, 4);
9477 if (size
> section_len
)
9479 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9480 (int) size
, (int) section_len
);
9484 section_len
-= size
;
9491 printf ("File Attributes\n");
9494 printf ("Section Attributes:");
9497 printf ("Symbol Attributes:");
9503 val
= read_uleb128 (p
, &i
);
9507 printf (" %d", val
);
9512 printf ("Unknown tag: %d\n", tag
);
9513 public_section
= FALSE
;
9520 p
= display_pub_attribute (p
);
9522 else if (gnu_section
)
9525 p
= display_gnu_attribute (p
,
9526 display_proc_gnu_attribute
);
9530 /* ??? Do something sensible, like dump hex. */
9531 printf (" Unknown section contexts\n");
9538 printf (_("Unknown format '%c'\n"), *p
);
9546 process_arm_specific (FILE * file
)
9548 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9549 display_arm_attribute
, NULL
);
9553 process_power_specific (FILE * file
)
9555 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9556 display_power_gnu_attribute
);
9559 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9560 Print the Address, Access and Initial fields of an entry at VMA ADDR
9561 and return the VMA of the next entry. */
9564 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9567 print_vma (addr
, LONG_HEX
);
9569 if (addr
< pltgot
+ 0xfff0)
9570 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9572 printf ("%10s", "");
9575 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9580 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9581 print_vma (entry
, LONG_HEX
);
9583 return addr
+ (is_32bit_elf
? 4 : 8);
9586 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9587 PLTGOT. Print the Address and Initial fields of an entry at VMA
9588 ADDR and return the VMA of the next entry. */
9591 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9594 print_vma (addr
, LONG_HEX
);
9597 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9602 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9603 print_vma (entry
, LONG_HEX
);
9605 return addr
+ (is_32bit_elf
? 4 : 8);
9609 process_mips_specific (FILE * file
)
9611 Elf_Internal_Dyn
* entry
;
9612 size_t liblist_offset
= 0;
9613 size_t liblistno
= 0;
9614 size_t conflictsno
= 0;
9615 size_t options_offset
= 0;
9616 size_t conflicts_offset
= 0;
9617 size_t pltrelsz
= 0;
9620 bfd_vma mips_pltgot
= 0;
9622 bfd_vma local_gotno
= 0;
9624 bfd_vma symtabno
= 0;
9626 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9627 display_mips_gnu_attribute
);
9629 /* We have a lot of special sections. Thanks SGI! */
9630 if (dynamic_section
== NULL
)
9631 /* No information available. */
9634 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9635 switch (entry
->d_tag
)
9637 case DT_MIPS_LIBLIST
:
9639 = offset_from_vma (file
, entry
->d_un
.d_val
,
9640 liblistno
* sizeof (Elf32_External_Lib
));
9642 case DT_MIPS_LIBLISTNO
:
9643 liblistno
= entry
->d_un
.d_val
;
9645 case DT_MIPS_OPTIONS
:
9646 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9648 case DT_MIPS_CONFLICT
:
9650 = offset_from_vma (file
, entry
->d_un
.d_val
,
9651 conflictsno
* sizeof (Elf32_External_Conflict
));
9653 case DT_MIPS_CONFLICTNO
:
9654 conflictsno
= entry
->d_un
.d_val
;
9657 pltgot
= entry
->d_un
.d_ptr
;
9659 case DT_MIPS_LOCAL_GOTNO
:
9660 local_gotno
= entry
->d_un
.d_val
;
9662 case DT_MIPS_GOTSYM
:
9663 gotsym
= entry
->d_un
.d_val
;
9665 case DT_MIPS_SYMTABNO
:
9666 symtabno
= entry
->d_un
.d_val
;
9668 case DT_MIPS_PLTGOT
:
9669 mips_pltgot
= entry
->d_un
.d_ptr
;
9672 pltrel
= entry
->d_un
.d_val
;
9675 pltrelsz
= entry
->d_un
.d_val
;
9678 jmprel
= entry
->d_un
.d_ptr
;
9684 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9686 Elf32_External_Lib
* elib
;
9689 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
9691 sizeof (Elf32_External_Lib
),
9695 printf ("\nSection '.liblist' contains %lu entries:\n",
9696 (unsigned long) liblistno
);
9697 fputs (" Library Time Stamp Checksum Version Flags\n",
9700 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9707 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9708 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9709 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9710 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9711 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9713 tmp
= gmtime (&time
);
9714 snprintf (timebuf
, sizeof (timebuf
),
9715 "%04u-%02u-%02uT%02u:%02u:%02u",
9716 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9717 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9719 printf ("%3lu: ", (unsigned long) cnt
);
9720 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9721 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9723 printf ("<corrupt: %9ld>", liblist
.l_name
);
9724 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9727 if (liblist
.l_flags
== 0)
9738 { " EXACT_MATCH", LL_EXACT_MATCH
},
9739 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9740 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9741 { " EXPORTS", LL_EXPORTS
},
9742 { " DELAY_LOAD", LL_DELAY_LOAD
},
9743 { " DELTA", LL_DELTA
}
9745 int flags
= liblist
.l_flags
;
9748 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9749 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9751 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9752 flags
^= l_flags_vals
[fcnt
].bit
;
9755 printf (" %#x", (unsigned int) flags
);
9765 if (options_offset
!= 0)
9767 Elf_External_Options
* eopt
;
9768 Elf_Internal_Shdr
* sect
= section_headers
;
9769 Elf_Internal_Options
* iopt
;
9770 Elf_Internal_Options
* option
;
9774 /* Find the section header so that we get the size. */
9775 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9778 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
9779 sect
->sh_size
, _("options"));
9782 iopt
= (Elf_Internal_Options
*)
9783 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9786 error (_("Out of memory\n"));
9793 while (offset
< sect
->sh_size
)
9795 Elf_External_Options
* eoption
;
9797 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9799 option
->kind
= BYTE_GET (eoption
->kind
);
9800 option
->size
= BYTE_GET (eoption
->size
);
9801 option
->section
= BYTE_GET (eoption
->section
);
9802 option
->info
= BYTE_GET (eoption
->info
);
9804 offset
+= option
->size
;
9810 printf (_("\nSection '%s' contains %d entries:\n"),
9811 SECTION_NAME (sect
), cnt
);
9819 switch (option
->kind
)
9822 /* This shouldn't happen. */
9823 printf (" NULL %d %lx", option
->section
, option
->info
);
9826 printf (" REGINFO ");
9827 if (elf_header
.e_machine
== EM_MIPS
)
9830 Elf32_External_RegInfo
* ereg
;
9831 Elf32_RegInfo reginfo
;
9833 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9834 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9835 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9836 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9837 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9838 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9839 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9841 printf ("GPR %08lx GP 0x%lx\n",
9843 (unsigned long) reginfo
.ri_gp_value
);
9844 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9845 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9846 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9851 Elf64_External_RegInfo
* ereg
;
9852 Elf64_Internal_RegInfo reginfo
;
9854 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9855 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9856 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9857 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9858 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9859 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9860 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9862 printf ("GPR %08lx GP 0x",
9863 reginfo
.ri_gprmask
);
9864 printf_vma (reginfo
.ri_gp_value
);
9867 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9868 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9869 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9873 case ODK_EXCEPTIONS
:
9874 fputs (" EXCEPTIONS fpe_min(", stdout
);
9875 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9876 fputs (") fpe_max(", stdout
);
9877 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9878 fputs (")", stdout
);
9880 if (option
->info
& OEX_PAGE0
)
9881 fputs (" PAGE0", stdout
);
9882 if (option
->info
& OEX_SMM
)
9883 fputs (" SMM", stdout
);
9884 if (option
->info
& OEX_FPDBUG
)
9885 fputs (" FPDBUG", stdout
);
9886 if (option
->info
& OEX_DISMISS
)
9887 fputs (" DISMISS", stdout
);
9890 fputs (" PAD ", stdout
);
9891 if (option
->info
& OPAD_PREFIX
)
9892 fputs (" PREFIX", stdout
);
9893 if (option
->info
& OPAD_POSTFIX
)
9894 fputs (" POSTFIX", stdout
);
9895 if (option
->info
& OPAD_SYMBOL
)
9896 fputs (" SYMBOL", stdout
);
9899 fputs (" HWPATCH ", stdout
);
9900 if (option
->info
& OHW_R4KEOP
)
9901 fputs (" R4KEOP", stdout
);
9902 if (option
->info
& OHW_R8KPFETCH
)
9903 fputs (" R8KPFETCH", stdout
);
9904 if (option
->info
& OHW_R5KEOP
)
9905 fputs (" R5KEOP", stdout
);
9906 if (option
->info
& OHW_R5KCVTL
)
9907 fputs (" R5KCVTL", stdout
);
9910 fputs (" FILL ", stdout
);
9911 /* XXX Print content of info word? */
9914 fputs (" TAGS ", stdout
);
9915 /* XXX Print content of info word? */
9918 fputs (" HWAND ", stdout
);
9919 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9920 fputs (" R4KEOP_CHECKED", stdout
);
9921 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9922 fputs (" R4KEOP_CLEAN", stdout
);
9925 fputs (" HWOR ", stdout
);
9926 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9927 fputs (" R4KEOP_CHECKED", stdout
);
9928 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9929 fputs (" R4KEOP_CLEAN", stdout
);
9932 printf (" GP_GROUP %#06lx self-contained %#06lx",
9933 option
->info
& OGP_GROUP
,
9934 (option
->info
& OGP_SELF
) >> 16);
9937 printf (" IDENT %#06lx self-contained %#06lx",
9938 option
->info
& OGP_GROUP
,
9939 (option
->info
& OGP_SELF
) >> 16);
9942 /* This shouldn't happen. */
9943 printf (" %3d ??? %d %lx",
9944 option
->kind
, option
->section
, option
->info
);
9948 len
= sizeof (* eopt
);
9949 while (len
< option
->size
)
9950 if (((char *) option
)[len
] >= ' '
9951 && ((char *) option
)[len
] < 0x7f)
9952 printf ("%c", ((char *) option
)[len
++]);
9954 printf ("\\%03o", ((char *) option
)[len
++]);
9956 fputs ("\n", stdout
);
9964 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9966 Elf32_Conflict
* iconf
;
9969 if (dynamic_symbols
== NULL
)
9971 error (_("conflict list found without a dynamic symbol table\n"));
9975 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
9978 error (_("Out of memory\n"));
9984 Elf32_External_Conflict
* econf32
;
9986 econf32
= (Elf32_External_Conflict
*)
9987 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
9988 sizeof (* econf32
), _("conflict"));
9992 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9993 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9999 Elf64_External_Conflict
* econf64
;
10001 econf64
= (Elf64_External_Conflict
*)
10002 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10003 sizeof (* econf64
), _("conflict"));
10007 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10008 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10013 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10014 (unsigned long) conflictsno
);
10015 puts (_(" Num: Index Value Name"));
10017 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10019 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10021 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10022 print_vma (psym
->st_value
, FULL_HEX
);
10024 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10025 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10027 printf ("<corrupt: %14ld>", psym
->st_name
);
10034 if (pltgot
!= 0 && local_gotno
!= 0)
10036 bfd_vma entry
, local_end
, global_end
;
10038 unsigned char * data
;
10042 addr_size
= (is_32bit_elf
? 4 : 8);
10043 local_end
= pltgot
+ local_gotno
* addr_size
;
10044 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10046 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10047 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10048 global_end
- pltgot
, 1, _("GOT"));
10049 printf (_("\nPrimary GOT:\n"));
10050 printf (_(" Canonical gp value: "));
10051 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10054 printf (_(" Reserved entries:\n"));
10055 printf (_(" %*s %10s %*s Purpose\n"),
10056 addr_size
* 2, "Address", "Access",
10057 addr_size
* 2, "Initial");
10058 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10059 printf (" Lazy resolver\n");
10061 && (byte_get (data
+ entry
- pltgot
, addr_size
)
10062 >> (addr_size
* 8 - 1)) != 0)
10064 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10065 printf (" Module pointer (GNU extension)\n");
10069 if (entry
< local_end
)
10071 printf (_(" Local entries:\n"));
10072 printf (_(" %*s %10s %*s\n"),
10073 addr_size
* 2, "Address", "Access",
10074 addr_size
* 2, "Initial");
10075 while (entry
< local_end
)
10077 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10083 if (gotsym
< symtabno
)
10087 printf (_(" Global entries:\n"));
10088 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10089 addr_size
* 2, "Address", "Access",
10090 addr_size
* 2, "Initial",
10091 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10092 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10093 for (i
= gotsym
; i
< symtabno
; i
++)
10095 Elf_Internal_Sym
* psym
;
10097 psym
= dynamic_symbols
+ i
;
10098 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10100 print_vma (psym
->st_value
, LONG_HEX
);
10101 printf (" %-7s %3s ",
10102 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10103 get_symbol_index_type (psym
->st_shndx
));
10104 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10105 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10107 printf ("<corrupt: %14ld>", psym
->st_name
);
10117 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10119 bfd_vma entry
, end
;
10120 size_t offset
, rel_offset
;
10121 unsigned long count
, i
;
10122 unsigned char * data
;
10123 int addr_size
, sym_width
;
10124 Elf_Internal_Rela
* rels
;
10126 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10127 if (pltrel
== DT_RELA
)
10129 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10134 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10138 entry
= mips_pltgot
;
10139 addr_size
= (is_32bit_elf
? 4 : 8);
10140 end
= mips_pltgot
+ (2 + count
) * addr_size
;
10142 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
10143 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
10145 printf (_("\nPLT GOT:\n\n"));
10146 printf (_(" Reserved entries:\n"));
10147 printf (_(" %*s %*s Purpose\n"),
10148 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10149 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10150 printf (" PLT lazy resolver\n");
10151 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10152 printf (" Module pointer\n");
10155 printf (_(" Entries:\n"));
10156 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10157 addr_size
* 2, "Address",
10158 addr_size
* 2, "Initial",
10159 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10160 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10161 for (i
= 0; i
< count
; i
++)
10163 Elf_Internal_Sym
* psym
;
10165 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10166 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10168 print_vma (psym
->st_value
, LONG_HEX
);
10169 printf (" %-7s %3s ",
10170 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10171 get_symbol_index_type (psym
->st_shndx
));
10172 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10173 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10175 printf ("<corrupt: %14ld>", psym
->st_name
);
10189 process_gnu_liblist (FILE * file
)
10191 Elf_Internal_Shdr
* section
;
10192 Elf_Internal_Shdr
* string_sec
;
10193 Elf32_External_Lib
* elib
;
10195 size_t strtab_size
;
10202 for (i
= 0, section
= section_headers
;
10203 i
< elf_header
.e_shnum
;
10206 switch (section
->sh_type
)
10208 case SHT_GNU_LIBLIST
:
10209 if (section
->sh_link
>= elf_header
.e_shnum
)
10212 elib
= (Elf32_External_Lib
*)
10213 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10218 string_sec
= section_headers
+ section
->sh_link
;
10220 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10221 string_sec
->sh_size
,
10222 _("liblist string table"));
10223 strtab_size
= string_sec
->sh_size
;
10226 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10232 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10233 SECTION_NAME (section
),
10234 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10236 puts (" Library Time Stamp Checksum Version Flags");
10238 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10246 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10247 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10248 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10249 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10250 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10252 tmp
= gmtime (&time
);
10253 snprintf (timebuf
, sizeof (timebuf
),
10254 "%04u-%02u-%02uT%02u:%02u:%02u",
10255 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10256 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10258 printf ("%3lu: ", (unsigned long) cnt
);
10260 printf ("%-20s", liblist
.l_name
< strtab_size
10261 ? strtab
+ liblist
.l_name
: "<corrupt>");
10263 printf ("%-20.20s", liblist
.l_name
< strtab_size
10264 ? strtab
+ liblist
.l_name
: "<corrupt>");
10265 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10266 liblist
.l_version
, liblist
.l_flags
);
10276 static const char *
10277 get_note_type (unsigned e_type
)
10279 static char buff
[64];
10281 if (elf_header
.e_type
== ET_CORE
)
10285 return _("NT_AUXV (auxiliary vector)");
10287 return _("NT_PRSTATUS (prstatus structure)");
10289 return _("NT_FPREGSET (floating point registers)");
10291 return _("NT_PRPSINFO (prpsinfo structure)");
10292 case NT_TASKSTRUCT
:
10293 return _("NT_TASKSTRUCT (task structure)");
10295 return _("NT_PRXFPREG (user_xfpregs structure)");
10297 return _("NT_PPC_VMX (ppc Altivec registers)");
10299 return _("NT_PPC_VSX (ppc VSX registers)");
10301 return _("NT_PSTATUS (pstatus structure)");
10303 return _("NT_FPREGS (floating point registers)");
10305 return _("NT_PSINFO (psinfo structure)");
10307 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10309 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10310 case NT_WIN32PSTATUS
:
10311 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10319 return _("NT_VERSION (version)");
10321 return _("NT_ARCH (architecture)");
10326 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10330 static const char *
10331 get_gnu_elf_note_type (unsigned e_type
)
10333 static char buff
[64];
10337 case NT_GNU_ABI_TAG
:
10338 return _("NT_GNU_ABI_TAG (ABI version tag)");
10340 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10341 case NT_GNU_BUILD_ID
:
10342 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10343 case NT_GNU_GOLD_VERSION
:
10344 return _("NT_GNU_GOLD_VERSION (gold version)");
10349 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10353 static const char *
10354 get_netbsd_elfcore_note_type (unsigned e_type
)
10356 static char buff
[64];
10358 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10360 /* NetBSD core "procinfo" structure. */
10361 return _("NetBSD procinfo structure");
10364 /* As of Jan 2002 there are no other machine-independent notes
10365 defined for NetBSD core files. If the note type is less
10366 than the start of the machine-dependent note types, we don't
10369 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10371 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10375 switch (elf_header
.e_machine
)
10377 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10378 and PT_GETFPREGS == mach+2. */
10383 case EM_SPARC32PLUS
:
10387 case NT_NETBSDCORE_FIRSTMACH
+0:
10388 return _("PT_GETREGS (reg structure)");
10389 case NT_NETBSDCORE_FIRSTMACH
+2:
10390 return _("PT_GETFPREGS (fpreg structure)");
10396 /* On all other arch's, PT_GETREGS == mach+1 and
10397 PT_GETFPREGS == mach+3. */
10401 case NT_NETBSDCORE_FIRSTMACH
+1:
10402 return _("PT_GETREGS (reg structure)");
10403 case NT_NETBSDCORE_FIRSTMACH
+3:
10404 return _("PT_GETFPREGS (fpreg structure)");
10410 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10411 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10415 /* Note that by the ELF standard, the name field is already null byte
10416 terminated, and namesz includes the terminating null byte.
10417 I.E. the value of namesz for the name "FSF" is 4.
10419 If the value of namesz is zero, there is no name present. */
10421 process_note (Elf_Internal_Note
* pnote
)
10423 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10426 if (pnote
->namesz
== 0)
10427 /* If there is no note name, then use the default set of
10428 note type strings. */
10429 nt
= get_note_type (pnote
->type
);
10431 else if (const_strneq (pnote
->namedata
, "GNU"))
10432 /* GNU-specific object file notes. */
10433 nt
= get_gnu_elf_note_type (pnote
->type
);
10435 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10436 /* NetBSD-specific core file notes. */
10437 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10439 else if (strneq (pnote
->namedata
, "SPU/", 4))
10441 /* SPU-specific core file notes. */
10442 nt
= pnote
->namedata
+ 4;
10447 /* Don't recognize this note name; just use the default set of
10448 note type strings. */
10449 nt
= get_note_type (pnote
->type
);
10451 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10457 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10459 Elf_External_Note
* pnotes
;
10460 Elf_External_Note
* external
;
10466 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
10473 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10474 (unsigned long) offset
, (unsigned long) length
);
10475 printf (_(" Owner\t\tData size\tDescription\n"));
10477 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10479 Elf_External_Note
* next
;
10480 Elf_Internal_Note inote
;
10481 char * temp
= NULL
;
10483 inote
.type
= BYTE_GET (external
->type
);
10484 inote
.namesz
= BYTE_GET (external
->namesz
);
10485 inote
.namedata
= external
->name
;
10486 inote
.descsz
= BYTE_GET (external
->descsz
);
10487 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10488 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10490 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10492 if (((char *) next
) > (((char *) pnotes
) + length
))
10494 warn (_("corrupt note found at offset %lx into core notes\n"),
10495 (unsigned long) ((char *) external
- (char *) pnotes
));
10496 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10497 inote
.type
, inote
.namesz
, inote
.descsz
);
10503 /* Verify that name is null terminated. It appears that at least
10504 one version of Linux (RedHat 6.0) generates corefiles that don't
10505 comply with the ELF spec by failing to include the null byte in
10507 if (inote
.namedata
[inote
.namesz
] != '\0')
10509 temp
= (char *) malloc (inote
.namesz
+ 1);
10513 error (_("Out of memory\n"));
10518 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10519 temp
[inote
.namesz
] = 0;
10521 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10522 inote
.namedata
= temp
;
10525 res
&= process_note (& inote
);
10540 process_corefile_note_segments (FILE * file
)
10542 Elf_Internal_Phdr
* segment
;
10546 if (! get_program_headers (file
))
10549 for (i
= 0, segment
= program_headers
;
10550 i
< elf_header
.e_phnum
;
10553 if (segment
->p_type
== PT_NOTE
)
10554 res
&= process_corefile_note_segment (file
,
10555 (bfd_vma
) segment
->p_offset
,
10556 (bfd_vma
) segment
->p_filesz
);
10563 process_note_sections (FILE * file
)
10565 Elf_Internal_Shdr
* section
;
10569 for (i
= 0, section
= section_headers
;
10570 i
< elf_header
.e_shnum
;
10572 if (section
->sh_type
== SHT_NOTE
)
10573 res
&= process_corefile_note_segment (file
,
10574 (bfd_vma
) section
->sh_offset
,
10575 (bfd_vma
) section
->sh_size
);
10581 process_notes (FILE * file
)
10583 /* If we have not been asked to display the notes then do nothing. */
10587 if (elf_header
.e_type
!= ET_CORE
)
10588 return process_note_sections (file
);
10590 /* No program headers means no NOTE segment. */
10591 if (elf_header
.e_phnum
> 0)
10592 return process_corefile_note_segments (file
);
10594 printf (_("No note segments present in the core file.\n"));
10599 process_arch_specific (FILE * file
)
10604 switch (elf_header
.e_machine
)
10607 return process_arm_specific (file
);
10609 case EM_MIPS_RS3_LE
:
10610 return process_mips_specific (file
);
10613 return process_power_specific (file
);
10622 get_file_header (FILE * file
)
10624 /* Read in the identity array. */
10625 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10628 /* Determine how to read the rest of the header. */
10629 switch (elf_header
.e_ident
[EI_DATA
])
10631 default: /* fall through */
10632 case ELFDATANONE
: /* fall through */
10634 byte_get
= byte_get_little_endian
;
10635 byte_put
= byte_put_little_endian
;
10638 byte_get
= byte_get_big_endian
;
10639 byte_put
= byte_put_big_endian
;
10643 /* For now we only support 32 bit and 64 bit ELF files. */
10644 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10646 /* Read in the rest of the header. */
10649 Elf32_External_Ehdr ehdr32
;
10651 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10654 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10655 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10656 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10657 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10658 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10659 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10660 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10661 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10662 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10663 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10664 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10665 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10666 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10670 Elf64_External_Ehdr ehdr64
;
10672 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10673 we will not be able to cope with the 64bit data found in
10674 64 ELF files. Detect this now and abort before we start
10675 overwriting things. */
10676 if (sizeof (bfd_vma
) < 8)
10678 error (_("This instance of readelf has been built without support for a\n\
10679 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10683 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10686 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10687 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10688 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10689 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10690 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10691 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10692 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10693 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10694 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10695 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10696 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10697 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10698 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10701 if (elf_header
.e_shoff
)
10703 /* There may be some extensions in the first section header. Don't
10704 bomb if we can't read it. */
10706 get_32bit_section_headers (file
, 1);
10708 get_64bit_section_headers (file
, 1);
10714 /* Process one ELF object file according to the command line options.
10715 This file may actually be stored in an archive. The file is
10716 positioned at the start of the ELF object. */
10719 process_object (char * file_name
, FILE * file
)
10723 if (! get_file_header (file
))
10725 error (_("%s: Failed to read file header\n"), file_name
);
10729 /* Initialise per file variables. */
10730 for (i
= ARRAY_SIZE (version_info
); i
--;)
10731 version_info
[i
] = 0;
10733 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10734 dynamic_info
[i
] = 0;
10736 /* Process the file. */
10738 printf (_("\nFile: %s\n"), file_name
);
10740 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10741 Note we do this even if cmdline_dump_sects is empty because we
10742 must make sure that the dump_sets array is zeroed out before each
10743 object file is processed. */
10744 if (num_dump_sects
> num_cmdline_dump_sects
)
10745 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10747 if (num_cmdline_dump_sects
> 0)
10749 if (num_dump_sects
== 0)
10750 /* A sneaky way of allocating the dump_sects array. */
10751 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10753 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10754 memcpy (dump_sects
, cmdline_dump_sects
,
10755 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10758 if (! process_file_header ())
10761 if (! process_section_headers (file
))
10763 /* Without loaded section headers we cannot process lots of
10765 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10767 if (! do_using_dynamic
)
10768 do_syms
= do_reloc
= 0;
10771 if (! process_section_groups (file
))
10773 /* Without loaded section groups we cannot process unwind. */
10777 if (process_program_headers (file
))
10778 process_dynamic_section (file
);
10780 process_relocs (file
);
10782 process_unwind (file
);
10784 process_symbol_table (file
);
10786 process_syminfo (file
);
10788 process_version_sections (file
);
10790 process_section_contents (file
);
10792 process_notes (file
);
10794 process_gnu_liblist (file
);
10796 process_arch_specific (file
);
10798 if (program_headers
)
10800 free (program_headers
);
10801 program_headers
= NULL
;
10804 if (section_headers
)
10806 free (section_headers
);
10807 section_headers
= NULL
;
10812 free (string_table
);
10813 string_table
= NULL
;
10814 string_table_length
= 0;
10817 if (dynamic_strings
)
10819 free (dynamic_strings
);
10820 dynamic_strings
= NULL
;
10821 dynamic_strings_length
= 0;
10824 if (dynamic_symbols
)
10826 free (dynamic_symbols
);
10827 dynamic_symbols
= NULL
;
10828 num_dynamic_syms
= 0;
10831 if (dynamic_syminfo
)
10833 free (dynamic_syminfo
);
10834 dynamic_syminfo
= NULL
;
10837 if (section_headers_groups
)
10839 free (section_headers_groups
);
10840 section_headers_groups
= NULL
;
10843 if (section_groups
)
10845 struct group_list
* g
;
10846 struct group_list
* next
;
10848 for (i
= 0; i
< group_count
; i
++)
10850 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10857 free (section_groups
);
10858 section_groups
= NULL
;
10861 free_debug_memory ();
10866 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10867 to the path name of the thin archive itself if necessary. Always returns
10868 a pointer to malloc'ed memory. */
10871 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10873 char * member_file_name
;
10874 const char * base_name
= lbasename (file_name
);
10876 /* This is a proxy entry for a thin archive member.
10877 If the extended name table contains an absolute path
10878 name, or if the archive is in the current directory,
10879 use the path name as given. Otherwise, we need to
10880 find the member relative to the directory where the
10881 archive is located. */
10882 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10884 member_file_name
= (char *) malloc (name_len
+ 1);
10885 if (member_file_name
== NULL
)
10887 error (_("Out of memory\n"));
10890 memcpy (member_file_name
, name
, name_len
);
10891 member_file_name
[name_len
] = '\0';
10895 /* Concatenate the path components of the archive file name
10896 to the relative path name from the extended name table. */
10897 size_t prefix_len
= base_name
- file_name
;
10898 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
10899 if (member_file_name
== NULL
)
10901 error (_("Out of memory\n"));
10904 memcpy (member_file_name
, file_name
, prefix_len
);
10905 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10906 member_file_name
[prefix_len
+ name_len
] = '\0';
10908 return member_file_name
;
10911 /* Structure to hold information about an archive file. */
10913 struct archive_info
10915 char * file_name
; /* Archive file name. */
10916 FILE * file
; /* Open file descriptor. */
10917 unsigned long index_num
; /* Number of symbols in table. */
10918 unsigned long * index_array
; /* The array of member offsets. */
10919 char * sym_table
; /* The symbol table. */
10920 unsigned long sym_size
; /* Size of the symbol table. */
10921 char * longnames
; /* The long file names table. */
10922 unsigned long longnames_size
; /* Size of the long file names table. */
10923 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10924 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10925 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10926 struct ar_hdr arhdr
; /* Current archive header. */
10929 /* Read the symbol table and long-name table from an archive. */
10932 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10933 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10936 unsigned long size
;
10938 arch
->file_name
= strdup (file_name
);
10940 arch
->index_num
= 0;
10941 arch
->index_array
= NULL
;
10942 arch
->sym_table
= NULL
;
10943 arch
->sym_size
= 0;
10944 arch
->longnames
= NULL
;
10945 arch
->longnames_size
= 0;
10946 arch
->nested_member_origin
= 0;
10947 arch
->is_thin_archive
= is_thin_archive
;
10948 arch
->next_arhdr_offset
= SARMAG
;
10950 /* Read the first archive member header. */
10951 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10953 error (_("%s: failed to seek to first archive header\n"), file_name
);
10956 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10957 if (got
!= sizeof arch
->arhdr
)
10962 error (_("%s: failed to read archive header\n"), file_name
);
10966 /* See if this is the archive symbol table. */
10967 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10968 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10970 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10971 size
= size
+ (size
& 1);
10973 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10978 /* A buffer used to hold numbers read in from an archive index.
10979 These are always 4 bytes long and stored in big-endian format. */
10980 #define SIZEOF_AR_INDEX_NUMBERS 4
10981 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10982 unsigned char * index_buffer
;
10984 /* Check the size of the archive index. */
10985 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10987 error (_("%s: the archive index is empty\n"), file_name
);
10991 /* Read the numer of entries in the archive index. */
10992 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10993 if (got
!= sizeof (integer_buffer
))
10995 error (_("%s: failed to read archive index\n"), file_name
);
10998 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10999 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11001 /* Read in the archive index. */
11002 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11004 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11005 file_name
, arch
->index_num
);
11008 index_buffer
= (unsigned char *)
11009 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11010 if (index_buffer
== NULL
)
11012 error (_("Out of memory whilst trying to read archive symbol index\n"));
11015 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11016 if (got
!= arch
->index_num
)
11018 free (index_buffer
);
11019 error (_("%s: failed to read archive index\n"), file_name
);
11022 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11024 /* Convert the index numbers into the host's numeric format. */
11025 arch
->index_array
= (long unsigned int *)
11026 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11027 if (arch
->index_array
== NULL
)
11029 free (index_buffer
);
11030 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11034 for (i
= 0; i
< arch
->index_num
; i
++)
11035 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11036 SIZEOF_AR_INDEX_NUMBERS
);
11037 free (index_buffer
);
11039 /* The remaining space in the header is taken up by the symbol table. */
11042 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11045 arch
->sym_table
= (char *) malloc (size
);
11046 arch
->sym_size
= size
;
11047 if (arch
->sym_table
== NULL
)
11049 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11052 got
= fread (arch
->sym_table
, 1, size
, file
);
11055 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11061 if (fseek (file
, size
, SEEK_CUR
) != 0)
11063 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11068 /* Read the next archive header. */
11069 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11070 if (got
!= sizeof arch
->arhdr
)
11074 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11078 else if (read_symbols
)
11079 printf (_("%s has no archive index\n"), file_name
);
11081 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11083 /* This is the archive string table holding long member names. */
11084 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11085 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11087 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11088 if (arch
->longnames
== NULL
)
11090 error (_("Out of memory reading long symbol names in archive\n"));
11094 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
11096 free (arch
->longnames
);
11097 arch
->longnames
= NULL
;
11098 error (_("%s: failed to read long symbol name string table\n"), file_name
);
11102 if ((arch
->longnames_size
& 1) != 0)
11109 /* Release the memory used for the archive information. */
11112 release_archive (struct archive_info
* arch
)
11114 if (arch
->file_name
!= NULL
)
11115 free (arch
->file_name
);
11116 if (arch
->index_array
!= NULL
)
11117 free (arch
->index_array
);
11118 if (arch
->sym_table
!= NULL
)
11119 free (arch
->sym_table
);
11120 if (arch
->longnames
!= NULL
)
11121 free (arch
->longnames
);
11124 /* Open and setup a nested archive, if not already open. */
11127 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
11129 FILE * member_file
;
11131 /* Have we already setup this archive? */
11132 if (nested_arch
->file_name
!= NULL
11133 && streq (nested_arch
->file_name
, member_file_name
))
11136 /* Close previous file and discard cached information. */
11137 if (nested_arch
->file
!= NULL
)
11138 fclose (nested_arch
->file
);
11139 release_archive (nested_arch
);
11141 member_file
= fopen (member_file_name
, "rb");
11142 if (member_file
== NULL
)
11144 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
11148 get_archive_member_name_at (struct archive_info
* arch
,
11149 unsigned long offset
,
11150 struct archive_info
* nested_arch
);
11152 /* Get the name of an archive member from the current archive header.
11153 For simple names, this will modify the ar_name field of the current
11154 archive header. For long names, it will return a pointer to the
11155 longnames table. For nested archives, it will open the nested archive
11156 and get the name recursively. NESTED_ARCH is a single-entry cache so
11157 we don't keep rereading the same information from a nested archive. */
11160 get_archive_member_name (struct archive_info
* arch
,
11161 struct archive_info
* nested_arch
)
11163 unsigned long j
, k
;
11165 if (arch
->arhdr
.ar_name
[0] == '/')
11167 /* We have a long name. */
11169 char * member_file_name
;
11170 char * member_name
;
11172 arch
->nested_member_origin
= 0;
11173 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11174 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11175 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11177 while ((j
< arch
->longnames_size
)
11178 && (arch
->longnames
[j
] != '\n')
11179 && (arch
->longnames
[j
] != '\0'))
11181 if (arch
->longnames
[j
-1] == '/')
11183 arch
->longnames
[j
] = '\0';
11185 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11186 return arch
->longnames
+ k
;
11188 /* This is a proxy for a member of a nested archive.
11189 Find the name of the member in that archive. */
11190 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11191 if (member_file_name
!= NULL
11192 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11193 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11195 free (member_file_name
);
11196 return member_name
;
11198 free (member_file_name
);
11200 /* Last resort: just return the name of the nested archive. */
11201 return arch
->longnames
+ k
;
11204 /* We have a normal (short) name. */
11206 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11208 arch
->arhdr
.ar_name
[j
] = '\0';
11209 return arch
->arhdr
.ar_name
;
11212 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11215 get_archive_member_name_at (struct archive_info
* arch
,
11216 unsigned long offset
,
11217 struct archive_info
* nested_arch
)
11221 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11223 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11226 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11227 if (got
!= sizeof arch
->arhdr
)
11229 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11232 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11234 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11238 return get_archive_member_name (arch
, nested_arch
);
11241 /* Construct a string showing the name of the archive member, qualified
11242 with the name of the containing archive file. For thin archives, we
11243 use square brackets to denote the indirection. For nested archives,
11244 we show the qualified name of the external member inside the square
11245 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11248 make_qualified_name (struct archive_info
* arch
,
11249 struct archive_info
* nested_arch
,
11250 char * member_name
)
11255 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11256 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11257 len
+= strlen (nested_arch
->file_name
) + 2;
11259 name
= (char *) malloc (len
);
11262 error (_("Out of memory\n"));
11266 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11267 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11268 else if (arch
->is_thin_archive
)
11269 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11271 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11276 /* Process an ELF archive.
11277 On entry the file is positioned just after the ARMAG string. */
11280 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11282 struct archive_info arch
;
11283 struct archive_info nested_arch
;
11285 size_t file_name_size
;
11290 /* The ARCH structure is used to hold information about this archive. */
11291 arch
.file_name
= NULL
;
11293 arch
.index_array
= NULL
;
11294 arch
.sym_table
= NULL
;
11295 arch
.longnames
= NULL
;
11297 /* The NESTED_ARCH structure is used as a single-item cache of information
11298 about a nested archive (when members of a thin archive reside within
11299 another regular archive file). */
11300 nested_arch
.file_name
= NULL
;
11301 nested_arch
.file
= NULL
;
11302 nested_arch
.index_array
= NULL
;
11303 nested_arch
.sym_table
= NULL
;
11304 nested_arch
.longnames
= NULL
;
11306 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11312 if (do_archive_index
)
11314 if (arch
.sym_table
== NULL
)
11315 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11319 unsigned long current_pos
;
11321 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11322 file_name
, arch
.index_num
, arch
.sym_size
);
11323 current_pos
= ftell (file
);
11325 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11327 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11329 char * member_name
;
11331 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11333 if (member_name
!= NULL
)
11335 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11337 if (qualified_name
!= NULL
)
11339 printf (_("Binary %s contains:\n"), qualified_name
);
11340 free (qualified_name
);
11345 if (l
>= arch
.sym_size
)
11347 error (_("%s: end of the symbol table reached before the end of the index\n"),
11351 printf ("\t%s\n", arch
.sym_table
+ l
);
11352 l
+= strlen (arch
.sym_table
+ l
) + 1;
11357 if (l
< arch
.sym_size
)
11358 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11361 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11363 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11369 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11370 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11371 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11372 && !do_section_groups
)
11374 ret
= 0; /* Archive index only. */
11379 file_name_size
= strlen (file_name
);
11386 char * qualified_name
;
11388 /* Read the next archive header. */
11389 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11391 error (_("%s: failed to seek to next archive header\n"), file_name
);
11394 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11395 if (got
!= sizeof arch
.arhdr
)
11399 error (_("%s: failed to read archive header\n"), file_name
);
11403 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11405 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11410 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11412 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11413 if (archive_file_size
& 01)
11414 ++archive_file_size
;
11416 name
= get_archive_member_name (&arch
, &nested_arch
);
11419 error (_("%s: bad archive file name\n"), file_name
);
11423 namelen
= strlen (name
);
11425 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11426 if (qualified_name
== NULL
)
11428 error (_("%s: bad archive file name\n"), file_name
);
11433 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11435 /* This is a proxy for an external member of a thin archive. */
11436 FILE * member_file
;
11437 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11438 if (member_file_name
== NULL
)
11444 member_file
= fopen (member_file_name
, "rb");
11445 if (member_file
== NULL
)
11447 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11448 free (member_file_name
);
11453 archive_file_offset
= arch
.nested_member_origin
;
11455 ret
|= process_object (qualified_name
, member_file
);
11457 fclose (member_file
);
11458 free (member_file_name
);
11460 else if (is_thin_archive
)
11462 /* This is a proxy for a member of a nested archive. */
11463 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11465 /* The nested archive file will have been opened and setup by
11466 get_archive_member_name. */
11467 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11469 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11474 ret
|= process_object (qualified_name
, nested_arch
.file
);
11478 archive_file_offset
= arch
.next_arhdr_offset
;
11479 arch
.next_arhdr_offset
+= archive_file_size
;
11481 ret
|= process_object (qualified_name
, file
);
11484 free (qualified_name
);
11488 if (nested_arch
.file
!= NULL
)
11489 fclose (nested_arch
.file
);
11490 release_archive (&nested_arch
);
11491 release_archive (&arch
);
11497 process_file (char * file_name
)
11500 struct stat statbuf
;
11501 char armag
[SARMAG
];
11504 if (stat (file_name
, &statbuf
) < 0)
11506 if (errno
== ENOENT
)
11507 error (_("'%s': No such file\n"), file_name
);
11509 error (_("Could not locate '%s'. System error message: %s\n"),
11510 file_name
, strerror (errno
));
11514 if (! S_ISREG (statbuf
.st_mode
))
11516 error (_("'%s' is not an ordinary file\n"), file_name
);
11520 file
= fopen (file_name
, "rb");
11523 error (_("Input file '%s' is not readable.\n"), file_name
);
11527 if (fread (armag
, SARMAG
, 1, file
) != 1)
11529 error (_("%s: Failed to read file's magic number\n"), file_name
);
11534 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11535 ret
= process_archive (file_name
, file
, FALSE
);
11536 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11537 ret
= process_archive (file_name
, file
, TRUE
);
11540 if (do_archive_index
)
11541 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11545 archive_file_size
= archive_file_offset
= 0;
11546 ret
= process_object (file_name
, file
);
11554 #ifdef SUPPORT_DISASSEMBLY
11555 /* Needed by the i386 disassembler. For extra credit, someone could
11556 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11560 print_address (unsigned int addr
, FILE * outfile
)
11562 fprintf (outfile
,"0x%8.8x", addr
);
11565 /* Needed by the i386 disassembler. */
11567 db_task_printsym (unsigned int addr
)
11569 print_address (addr
, stderr
);
11574 main (int argc
, char ** argv
)
11578 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11579 setlocale (LC_MESSAGES
, "");
11581 #if defined (HAVE_SETLOCALE)
11582 setlocale (LC_CTYPE
, "");
11584 bindtextdomain (PACKAGE
, LOCALEDIR
);
11585 textdomain (PACKAGE
);
11587 expandargv (&argc
, &argv
);
11589 parse_args (argc
, argv
);
11591 if (num_dump_sects
> 0)
11593 /* Make a copy of the dump_sects array. */
11594 cmdline_dump_sects
= (dump_type
*)
11595 malloc (num_dump_sects
* sizeof (* dump_sects
));
11596 if (cmdline_dump_sects
== NULL
)
11597 error (_("Out of memory allocating dump request table.\n"));
11600 memcpy (cmdline_dump_sects
, dump_sects
,
11601 num_dump_sects
* sizeof (* dump_sects
));
11602 num_cmdline_dump_sects
= num_dump_sects
;
11606 if (optind
< (argc
- 1))
11610 while (optind
< argc
)
11611 err
|= process_file (argv
[optind
++]);
11613 if (dump_sects
!= NULL
)
11615 if (cmdline_dump_sects
!= NULL
)
11616 free (cmdline_dump_sects
);