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";
153 static long archive_file_offset
;
154 static unsigned long archive_file_size
;
155 static unsigned long dynamic_addr
;
156 static bfd_size_type dynamic_size
;
157 static unsigned int dynamic_nent
;
158 static char * dynamic_strings
;
159 static unsigned long dynamic_strings_length
;
160 static char * string_table
;
161 static unsigned long string_table_length
;
162 static unsigned long num_dynamic_syms
;
163 static Elf_Internal_Sym
* dynamic_symbols
;
164 static Elf_Internal_Syminfo
* dynamic_syminfo
;
165 static unsigned long dynamic_syminfo_offset
;
166 static unsigned int dynamic_syminfo_nent
;
167 static char program_interpreter
[PATH_MAX
];
168 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
169 static bfd_vma dynamic_info_DT_GNU_HASH
;
170 static bfd_vma version_info
[16];
171 static Elf_Internal_Ehdr elf_header
;
172 static Elf_Internal_Shdr
* section_headers
;
173 static Elf_Internal_Phdr
* program_headers
;
174 static Elf_Internal_Dyn
* dynamic_section
;
175 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
176 static int show_name
;
177 static int do_dynamic
;
180 static int do_sections
;
181 static int do_section_groups
;
182 static int do_section_details
;
183 static int do_segments
;
184 static int do_unwind
;
185 static int do_using_dynamic
;
186 static int do_header
;
188 static int do_version
;
189 static int do_histogram
;
190 static int do_debugging
;
193 static int do_archive_index
;
194 static int is_32bit_elf
;
198 struct group_list
* next
;
199 unsigned int section_index
;
204 struct group_list
* root
;
205 unsigned int group_index
;
208 static size_t group_count
;
209 static struct group
* section_groups
;
210 static struct group
** section_headers_groups
;
213 /* Flag bits indicating particular types of dump. */
214 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
215 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
216 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
217 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
218 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
220 typedef unsigned char dump_type
;
222 /* A linked list of the section names for which dumps were requested. */
223 struct dump_list_entry
227 struct dump_list_entry
* next
;
229 static struct dump_list_entry
* dump_sects_byname
;
231 /* A dynamic array of flags indicating for which sections a dump
232 has been requested via command line switches. */
233 static dump_type
* cmdline_dump_sects
= NULL
;
234 static unsigned int num_cmdline_dump_sects
= 0;
236 /* A dynamic array of flags indicating for which sections a dump of
237 some kind has been requested. It is reset on a per-object file
238 basis and then initialised from the cmdline_dump_sects array,
239 the results of interpreting the -w switch, and the
240 dump_sects_byname list. */
241 static dump_type
* dump_sects
= NULL
;
242 static unsigned int num_dump_sects
= 0;
245 /* How to print a vma value. */
246 typedef enum print_mode
258 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
262 #define SECTION_NAME(X) \
263 ((X) == NULL ? "<none>" \
264 : string_table == NULL ? "<no-name>" \
265 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
266 : string_table + (X)->sh_name))
268 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
270 #define BYTE_GET(field) byte_get (field, sizeof (field))
272 #define GET_ELF_SYMBOLS(file, section) \
273 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
274 : get_64bit_elf_symbols (file, section))
276 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
277 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
278 already been called and verified that the string exists. */
279 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
281 /* This is just a bit of syntatic sugar. */
282 #define streq(a,b) (strcmp ((a), (b)) == 0)
283 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
284 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
287 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
292 if (size
== 0 || nmemb
== 0)
295 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
297 error (_("Unable to seek to 0x%lx for %s\n"),
298 (unsigned long) archive_file_offset
+ offset
, reason
);
305 /* Check for overflow. */
306 if (nmemb
< (~(size_t) 0 - 1) / size
)
307 /* + 1 so that we can '\0' terminate invalid string table sections. */
308 mvar
= malloc (size
* nmemb
+ 1);
312 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
313 (unsigned long)(size
* nmemb
), reason
);
317 ((char *) mvar
)[size
* nmemb
] = '\0';
320 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
322 error (_("Unable to read in 0x%lx bytes of %s\n"),
323 (unsigned long)(size
* nmemb
), reason
);
333 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
338 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
339 field
[6] = ((value
>> 24) >> 24) & 0xff;
340 field
[5] = ((value
>> 24) >> 16) & 0xff;
341 field
[4] = ((value
>> 24) >> 8) & 0xff;
344 field
[3] = (value
>> 24) & 0xff;
345 field
[2] = (value
>> 16) & 0xff;
348 field
[1] = (value
>> 8) & 0xff;
351 field
[0] = value
& 0xff;
355 error (_("Unhandled data length: %d\n"), size
);
360 /* Print a VMA value. */
363 print_vma (bfd_vma vma
, print_mode mode
)
376 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
383 return printf ("%5" BFD_VMA_FMT
"d", vma
);
391 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
394 return printf ("%" BFD_VMA_FMT
"d", vma
);
397 return printf ("%" BFD_VMA_FMT
"u", vma
);
402 /* Display a symbol on stdout. Handles the display of non-printing characters.
404 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
405 truncating as necessary. If WIDTH is negative then format the string to be
406 exactly - WIDTH characters, truncating or padding as necessary.
408 Returns the number of emitted characters. */
411 print_symbol (int width
, const char * symbol
)
414 bfd_boolean extra_padding
= FALSE
;
415 unsigned int num_printed
= 0;
419 /* Set the width to a very large value. This simplifies the code below. */
424 /* Keep the width positive. This also helps. */
426 extra_padding
= TRUE
;
435 /* Look for non-printing symbols inside the symbol's name.
436 This test is triggered in particular by the names generated
437 by the assembler for local labels. */
438 while (ISPRINT (* c
))
448 printf ("%.*s", len
, symbol
);
454 if (* c
== 0 || width
== 0)
457 /* Now display the non-printing character, if
458 there is room left in which to dipslay it. */
464 printf ("^%c", *c
+ 0x40);
474 printf ("<0x%.2x>", *c
);
483 if (extra_padding
&& width
> 0)
485 /* Fill in the remaining spaces. */
486 printf ("%-*s", width
, " ");
494 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
499 field
[7] = value
& 0xff;
500 field
[6] = (value
>> 8) & 0xff;
501 field
[5] = (value
>> 16) & 0xff;
502 field
[4] = (value
>> 24) & 0xff;
507 field
[3] = value
& 0xff;
508 field
[2] = (value
>> 8) & 0xff;
512 field
[1] = value
& 0xff;
516 field
[0] = value
& 0xff;
520 error (_("Unhandled data length: %d\n"), size
);
525 /* Return a pointer to section NAME, or NULL if no such section exists. */
527 static Elf_Internal_Shdr
*
528 find_section (const char * name
)
532 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
533 if (streq (SECTION_NAME (section_headers
+ i
), name
))
534 return section_headers
+ i
;
539 /* Guess the relocation size commonly used by the specific machines. */
542 guess_is_rela (unsigned int e_machine
)
546 /* Targets that use REL relocations. */
562 /* Targets that use RELA relocations. */
566 case EM_ALTERA_NIOS2
:
586 case EM_LATTICEMICO32
:
594 case EM_CYGNUS_MN10200
:
596 case EM_CYGNUS_MN10300
:
619 case EM_MICROBLAZE_OLD
:
640 warn (_("Don't know about relocations on this machine architecture\n"));
646 slurp_rela_relocs (FILE * file
,
647 unsigned long rel_offset
,
648 unsigned long rel_size
,
649 Elf_Internal_Rela
** relasp
,
650 unsigned long * nrelasp
)
652 Elf_Internal_Rela
* relas
;
653 unsigned long nrelas
;
658 Elf32_External_Rela
* erelas
;
660 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
664 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
666 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
671 error (_("out of memory parsing relocs\n"));
675 for (i
= 0; i
< nrelas
; i
++)
677 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
678 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
679 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
686 Elf64_External_Rela
* erelas
;
688 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
692 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
694 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
699 error (_("out of memory parsing relocs\n"));
703 for (i
= 0; i
< nrelas
; i
++)
705 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
706 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
707 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
709 /* The #ifdef BFD64 below is to prevent a compile time
710 warning. We know that if we do not have a 64 bit data
711 type that we will never execute this code anyway. */
713 if (elf_header
.e_machine
== EM_MIPS
714 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
716 /* In little-endian objects, r_info isn't really a
717 64-bit little-endian value: it has a 32-bit
718 little-endian symbol index followed by four
719 individual byte fields. Reorder INFO
721 bfd_vma info
= relas
[i
].r_info
;
722 info
= (((info
& 0xffffffff) << 32)
723 | ((info
>> 56) & 0xff)
724 | ((info
>> 40) & 0xff00)
725 | ((info
>> 24) & 0xff0000)
726 | ((info
>> 8) & 0xff000000));
727 relas
[i
].r_info
= info
;
740 slurp_rel_relocs (FILE * file
,
741 unsigned long rel_offset
,
742 unsigned long rel_size
,
743 Elf_Internal_Rela
** relsp
,
744 unsigned long * nrelsp
)
746 Elf_Internal_Rela
* rels
;
752 Elf32_External_Rel
* erels
;
754 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
758 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
760 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
765 error (_("out of memory parsing relocs\n"));
769 for (i
= 0; i
< nrels
; i
++)
771 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
772 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
773 rels
[i
].r_addend
= 0;
780 Elf64_External_Rel
* erels
;
782 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
786 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
788 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
793 error (_("out of memory parsing relocs\n"));
797 for (i
= 0; i
< nrels
; i
++)
799 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
800 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
801 rels
[i
].r_addend
= 0;
803 /* The #ifdef BFD64 below is to prevent a compile time
804 warning. We know that if we do not have a 64 bit data
805 type that we will never execute this code anyway. */
807 if (elf_header
.e_machine
== EM_MIPS
808 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
810 /* In little-endian objects, r_info isn't really a
811 64-bit little-endian value: it has a 32-bit
812 little-endian symbol index followed by four
813 individual byte fields. Reorder INFO
815 bfd_vma info
= rels
[i
].r_info
;
816 info
= (((info
& 0xffffffff) << 32)
817 | ((info
>> 56) & 0xff)
818 | ((info
>> 40) & 0xff00)
819 | ((info
>> 24) & 0xff0000)
820 | ((info
>> 8) & 0xff000000));
821 rels
[i
].r_info
= info
;
833 /* Returns the reloc type extracted from the reloc info field. */
836 get_reloc_type (bfd_vma reloc_info
)
839 return ELF32_R_TYPE (reloc_info
);
841 switch (elf_header
.e_machine
)
844 /* Note: We assume that reloc_info has already been adjusted for us. */
845 return ELF64_MIPS_R_TYPE (reloc_info
);
848 return ELF64_R_TYPE_ID (reloc_info
);
851 return ELF64_R_TYPE (reloc_info
);
855 /* Return the symbol index extracted from the reloc info field. */
858 get_reloc_symindex (bfd_vma reloc_info
)
860 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
863 /* Display the contents of the relocation data found at the specified
867 dump_relocations (FILE * file
,
868 unsigned long rel_offset
,
869 unsigned long rel_size
,
870 Elf_Internal_Sym
* symtab
,
873 unsigned long strtablen
,
877 Elf_Internal_Rela
* rels
;
879 if (is_rela
== UNKNOWN
)
880 is_rela
= guess_is_rela (elf_header
.e_machine
);
884 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
889 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
898 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
900 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
905 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
907 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
915 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
917 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
922 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
924 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
928 for (i
= 0; i
< rel_size
; i
++)
933 bfd_vma symtab_index
;
936 offset
= rels
[i
].r_offset
;
937 info
= rels
[i
].r_info
;
939 type
= get_reloc_type (info
);
940 symtab_index
= get_reloc_symindex (info
);
944 printf ("%8.8lx %8.8lx ",
945 (unsigned long) offset
& 0xffffffff,
946 (unsigned long) info
& 0xffffffff);
950 #if BFD_HOST_64BIT_LONG
952 ? "%16.16lx %16.16lx "
953 : "%12.12lx %12.12lx ",
955 #elif BFD_HOST_64BIT_LONG_LONG
958 ? "%16.16llx %16.16llx "
959 : "%12.12llx %12.12llx ",
963 ? "%16.16I64x %16.16I64x "
964 : "%12.12I64x %12.12I64x ",
969 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
970 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
971 _bfd_int64_high (offset
),
972 _bfd_int64_low (offset
),
973 _bfd_int64_high (info
),
974 _bfd_int64_low (info
));
978 switch (elf_header
.e_machine
)
986 rtype
= elf_m32r_reloc_type (type
);
991 rtype
= elf_i386_reloc_type (type
);
996 rtype
= elf_m68hc11_reloc_type (type
);
1000 rtype
= elf_m68k_reloc_type (type
);
1004 rtype
= elf_i960_reloc_type (type
);
1009 rtype
= elf_avr_reloc_type (type
);
1012 case EM_OLD_SPARCV9
:
1013 case EM_SPARC32PLUS
:
1016 rtype
= elf_sparc_reloc_type (type
);
1020 rtype
= elf_spu_reloc_type (type
);
1024 case EM_CYGNUS_V850
:
1025 rtype
= v850_reloc_type (type
);
1029 case EM_CYGNUS_D10V
:
1030 rtype
= elf_d10v_reloc_type (type
);
1034 case EM_CYGNUS_D30V
:
1035 rtype
= elf_d30v_reloc_type (type
);
1039 rtype
= elf_dlx_reloc_type (type
);
1043 rtype
= elf_sh_reloc_type (type
);
1047 case EM_CYGNUS_MN10300
:
1048 rtype
= elf_mn10300_reloc_type (type
);
1052 case EM_CYGNUS_MN10200
:
1053 rtype
= elf_mn10200_reloc_type (type
);
1057 case EM_CYGNUS_FR30
:
1058 rtype
= elf_fr30_reloc_type (type
);
1062 rtype
= elf_frv_reloc_type (type
);
1066 rtype
= elf_mcore_reloc_type (type
);
1070 rtype
= elf_mmix_reloc_type (type
);
1075 rtype
= elf_msp430_reloc_type (type
);
1079 rtype
= elf_ppc_reloc_type (type
);
1083 rtype
= elf_ppc64_reloc_type (type
);
1087 case EM_MIPS_RS3_LE
:
1088 rtype
= elf_mips_reloc_type (type
);
1092 rtype
= elf_alpha_reloc_type (type
);
1096 rtype
= elf_arm_reloc_type (type
);
1100 rtype
= elf_arc_reloc_type (type
);
1104 rtype
= elf_hppa_reloc_type (type
);
1110 rtype
= elf_h8_reloc_type (type
);
1115 rtype
= elf_or32_reloc_type (type
);
1120 rtype
= elf_pj_reloc_type (type
);
1123 rtype
= elf_ia64_reloc_type (type
);
1127 rtype
= elf_cris_reloc_type (type
);
1131 rtype
= elf_i860_reloc_type (type
);
1136 rtype
= elf_x86_64_reloc_type (type
);
1140 rtype
= i370_reloc_type (type
);
1145 rtype
= elf_s390_reloc_type (type
);
1149 rtype
= elf_score_reloc_type (type
);
1153 rtype
= elf_xstormy16_reloc_type (type
);
1157 rtype
= elf_crx_reloc_type (type
);
1161 rtype
= elf_vax_reloc_type (type
);
1166 rtype
= elf_ip2k_reloc_type (type
);
1170 rtype
= elf_iq2000_reloc_type (type
);
1175 rtype
= elf_xtensa_reloc_type (type
);
1178 case EM_LATTICEMICO32
:
1179 rtype
= elf_lm32_reloc_type (type
);
1184 rtype
= elf_m32c_reloc_type (type
);
1188 rtype
= elf_mt_reloc_type (type
);
1192 rtype
= elf_bfin_reloc_type (type
);
1196 rtype
= elf_mep_reloc_type (type
);
1201 rtype
= elf_cr16_reloc_type (type
);
1205 case EM_MICROBLAZE_OLD
:
1206 rtype
= elf_microblaze_reloc_type (type
);
1211 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1213 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1215 if (elf_header
.e_machine
== EM_ALPHA
1217 && streq (rtype
, "R_ALPHA_LITUSE")
1220 switch (rels
[i
].r_addend
)
1222 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1223 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1224 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1225 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1226 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1227 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1228 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1229 default: rtype
= NULL
;
1232 printf (" (%s)", rtype
);
1236 printf (_("<unknown addend: %lx>"),
1237 (unsigned long) rels
[i
].r_addend
);
1240 else if (symtab_index
)
1242 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1243 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1246 Elf_Internal_Sym
* psym
;
1248 psym
= symtab
+ symtab_index
;
1252 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1256 unsigned int width
= is_32bit_elf
? 8 : 14;
1258 /* Relocations against GNU_IFUNC symbols do not use the value
1259 of the symbol as the address to relocate against. Instead
1260 they invoke the function named by the symbol and use its
1261 result as the address for relocation.
1263 To indicate this to the user, do not display the value of
1264 the symbol in the "Symbols's Value" field. Instead show
1265 its name followed by () as a hint that the symbol is
1269 || psym
->st_name
== 0
1270 || psym
->st_name
>= strtablen
)
1273 name
= strtab
+ psym
->st_name
;
1275 len
= print_symbol (width
, name
);
1276 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1280 print_vma (psym
->st_value
, LONG_HEX
);
1282 printf (is_32bit_elf
? " " : " ");
1285 if (psym
->st_name
== 0)
1287 const char * sec_name
= "<null>";
1290 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1292 if (psym
->st_shndx
< elf_header
.e_shnum
)
1294 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1295 else if (psym
->st_shndx
== SHN_ABS
)
1297 else if (psym
->st_shndx
== SHN_COMMON
)
1298 sec_name
= "COMMON";
1299 else if (elf_header
.e_machine
== EM_MIPS
1300 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1301 sec_name
= "SCOMMON";
1302 else if (elf_header
.e_machine
== EM_MIPS
1303 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1304 sec_name
= "SUNDEF";
1305 else if ((elf_header
.e_machine
== EM_X86_64
1306 || elf_header
.e_machine
== EM_L1OM
)
1307 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1308 sec_name
= "LARGE_COMMON";
1309 else if (elf_header
.e_machine
== EM_IA_64
1310 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1311 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1312 sec_name
= "ANSI_COM";
1313 else if (elf_header
.e_machine
== EM_IA_64
1314 && (elf_header
.e_ident
[EI_OSABI
]
1315 == ELFOSABI_OPENVMS
)
1316 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1317 sec_name
= "VMS_SYMVEC";
1320 sprintf (name_buf
, "<section 0x%x>",
1321 (unsigned int) psym
->st_shndx
);
1322 sec_name
= name_buf
;
1325 print_symbol (22, sec_name
);
1327 else if (strtab
== NULL
)
1328 printf (_("<string table index: %3ld>"), psym
->st_name
);
1329 else if (psym
->st_name
>= strtablen
)
1330 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1332 print_symbol (22, strtab
+ psym
->st_name
);
1336 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1339 printf (" - %lx", - offset
);
1341 printf (" + %lx", offset
);
1347 printf ("%*c", is_32bit_elf
?
1348 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1349 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1352 if (elf_header
.e_machine
== EM_SPARCV9
1354 && streq (rtype
, "R_SPARC_OLO10"))
1355 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1360 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1362 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1363 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1364 const char * rtype2
= elf_mips_reloc_type (type2
);
1365 const char * rtype3
= elf_mips_reloc_type (type3
);
1367 printf (" Type2: ");
1370 printf (_("unrecognized: %-7lx"),
1371 (unsigned long) type2
& 0xffffffff);
1373 printf ("%-17.17s", rtype2
);
1375 printf ("\n Type3: ");
1378 printf (_("unrecognized: %-7lx"),
1379 (unsigned long) type3
& 0xffffffff);
1381 printf ("%-17.17s", rtype3
);
1392 get_mips_dynamic_type (unsigned long type
)
1396 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1397 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1398 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1399 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1400 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1401 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1402 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1403 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1404 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1405 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1406 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1407 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1408 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1409 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1410 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1411 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1412 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1413 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1414 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1415 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1416 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1417 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1418 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1419 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1420 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1421 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1422 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1423 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1424 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1425 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1426 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1427 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1428 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1429 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1430 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1431 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1432 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1433 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1434 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1435 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1436 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1437 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1438 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1439 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1440 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1447 get_sparc64_dynamic_type (unsigned long type
)
1451 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1458 get_ppc_dynamic_type (unsigned long type
)
1462 case DT_PPC_GOT
: return "PPC_GOT";
1469 get_ppc64_dynamic_type (unsigned long type
)
1473 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1474 case DT_PPC64_OPD
: return "PPC64_OPD";
1475 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1482 get_parisc_dynamic_type (unsigned long type
)
1486 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1487 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1488 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1489 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1490 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1491 case DT_HP_PREINIT
: return "HP_PREINIT";
1492 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1493 case DT_HP_NEEDED
: return "HP_NEEDED";
1494 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1495 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1496 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1497 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1498 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1499 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1500 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1501 case DT_HP_FILTERED
: return "HP_FILTERED";
1502 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1503 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1504 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1505 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1506 case DT_PLT
: return "PLT";
1507 case DT_PLT_SIZE
: return "PLT_SIZE";
1508 case DT_DLT
: return "DLT";
1509 case DT_DLT_SIZE
: return "DLT_SIZE";
1516 get_ia64_dynamic_type (unsigned long type
)
1520 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1521 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1522 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1523 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1524 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1525 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1526 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1527 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1528 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1529 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1530 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1531 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1532 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1533 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1534 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1535 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1536 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1537 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1538 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1539 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1540 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1541 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1542 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1543 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1544 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1545 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1546 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1547 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1548 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1549 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1550 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1557 get_alpha_dynamic_type (unsigned long type
)
1561 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1568 get_score_dynamic_type (unsigned long type
)
1572 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1573 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1574 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1575 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1576 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1577 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1585 get_dynamic_type (unsigned long type
)
1587 static char buff
[64];
1591 case DT_NULL
: return "NULL";
1592 case DT_NEEDED
: return "NEEDED";
1593 case DT_PLTRELSZ
: return "PLTRELSZ";
1594 case DT_PLTGOT
: return "PLTGOT";
1595 case DT_HASH
: return "HASH";
1596 case DT_STRTAB
: return "STRTAB";
1597 case DT_SYMTAB
: return "SYMTAB";
1598 case DT_RELA
: return "RELA";
1599 case DT_RELASZ
: return "RELASZ";
1600 case DT_RELAENT
: return "RELAENT";
1601 case DT_STRSZ
: return "STRSZ";
1602 case DT_SYMENT
: return "SYMENT";
1603 case DT_INIT
: return "INIT";
1604 case DT_FINI
: return "FINI";
1605 case DT_SONAME
: return "SONAME";
1606 case DT_RPATH
: return "RPATH";
1607 case DT_SYMBOLIC
: return "SYMBOLIC";
1608 case DT_REL
: return "REL";
1609 case DT_RELSZ
: return "RELSZ";
1610 case DT_RELENT
: return "RELENT";
1611 case DT_PLTREL
: return "PLTREL";
1612 case DT_DEBUG
: return "DEBUG";
1613 case DT_TEXTREL
: return "TEXTREL";
1614 case DT_JMPREL
: return "JMPREL";
1615 case DT_BIND_NOW
: return "BIND_NOW";
1616 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1617 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1618 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1619 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1620 case DT_RUNPATH
: return "RUNPATH";
1621 case DT_FLAGS
: return "FLAGS";
1623 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1624 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1626 case DT_CHECKSUM
: return "CHECKSUM";
1627 case DT_PLTPADSZ
: return "PLTPADSZ";
1628 case DT_MOVEENT
: return "MOVEENT";
1629 case DT_MOVESZ
: return "MOVESZ";
1630 case DT_FEATURE
: return "FEATURE";
1631 case DT_POSFLAG_1
: return "POSFLAG_1";
1632 case DT_SYMINSZ
: return "SYMINSZ";
1633 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1635 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1636 case DT_CONFIG
: return "CONFIG";
1637 case DT_DEPAUDIT
: return "DEPAUDIT";
1638 case DT_AUDIT
: return "AUDIT";
1639 case DT_PLTPAD
: return "PLTPAD";
1640 case DT_MOVETAB
: return "MOVETAB";
1641 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1643 case DT_VERSYM
: return "VERSYM";
1645 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1646 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1647 case DT_RELACOUNT
: return "RELACOUNT";
1648 case DT_RELCOUNT
: return "RELCOUNT";
1649 case DT_FLAGS_1
: return "FLAGS_1";
1650 case DT_VERDEF
: return "VERDEF";
1651 case DT_VERDEFNUM
: return "VERDEFNUM";
1652 case DT_VERNEED
: return "VERNEED";
1653 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1655 case DT_AUXILIARY
: return "AUXILIARY";
1656 case DT_USED
: return "USED";
1657 case DT_FILTER
: return "FILTER";
1659 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1660 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1661 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1662 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1663 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1664 case DT_GNU_HASH
: return "GNU_HASH";
1667 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1669 const char * result
;
1671 switch (elf_header
.e_machine
)
1674 case EM_MIPS_RS3_LE
:
1675 result
= get_mips_dynamic_type (type
);
1678 result
= get_sparc64_dynamic_type (type
);
1681 result
= get_ppc_dynamic_type (type
);
1684 result
= get_ppc64_dynamic_type (type
);
1687 result
= get_ia64_dynamic_type (type
);
1690 result
= get_alpha_dynamic_type (type
);
1693 result
= get_score_dynamic_type (type
);
1703 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1705 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1706 || (elf_header
.e_machine
== EM_PARISC
1707 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1709 const char * result
;
1711 switch (elf_header
.e_machine
)
1714 result
= get_parisc_dynamic_type (type
);
1717 result
= get_ia64_dynamic_type (type
);
1727 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1731 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1738 get_file_type (unsigned e_type
)
1740 static char buff
[32];
1744 case ET_NONE
: return _("NONE (None)");
1745 case ET_REL
: return _("REL (Relocatable file)");
1746 case ET_EXEC
: return _("EXEC (Executable file)");
1747 case ET_DYN
: return _("DYN (Shared object file)");
1748 case ET_CORE
: return _("CORE (Core file)");
1751 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1752 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1753 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1754 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1756 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1762 get_machine_name (unsigned e_machine
)
1764 static char buff
[64]; /* XXX */
1768 case EM_NONE
: return _("None");
1769 case EM_M32
: return "WE32100";
1770 case EM_SPARC
: return "Sparc";
1771 case EM_SPU
: return "SPU";
1772 case EM_386
: return "Intel 80386";
1773 case EM_68K
: return "MC68000";
1774 case EM_88K
: return "MC88000";
1775 case EM_486
: return "Intel 80486";
1776 case EM_860
: return "Intel 80860";
1777 case EM_MIPS
: return "MIPS R3000";
1778 case EM_S370
: return "IBM System/370";
1779 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1780 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1781 case EM_PARISC
: return "HPPA";
1782 case EM_PPC_OLD
: return "Power PC (old)";
1783 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1784 case EM_960
: return "Intel 90860";
1785 case EM_PPC
: return "PowerPC";
1786 case EM_PPC64
: return "PowerPC64";
1787 case EM_V800
: return "NEC V800";
1788 case EM_FR20
: return "Fujitsu FR20";
1789 case EM_RH32
: return "TRW RH32";
1790 case EM_MCORE
: return "MCORE";
1791 case EM_ARM
: return "ARM";
1792 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1793 case EM_SH
: return "Renesas / SuperH SH";
1794 case EM_SPARCV9
: return "Sparc v9";
1795 case EM_TRICORE
: return "Siemens Tricore";
1796 case EM_ARC
: return "ARC";
1797 case EM_H8_300
: return "Renesas H8/300";
1798 case EM_H8_300H
: return "Renesas H8/300H";
1799 case EM_H8S
: return "Renesas H8S";
1800 case EM_H8_500
: return "Renesas H8/500";
1801 case EM_IA_64
: return "Intel IA-64";
1802 case EM_MIPS_X
: return "Stanford MIPS-X";
1803 case EM_COLDFIRE
: return "Motorola Coldfire";
1804 case EM_68HC12
: return "Motorola M68HC12";
1805 case EM_ALPHA
: return "Alpha";
1806 case EM_CYGNUS_D10V
:
1807 case EM_D10V
: return "d10v";
1808 case EM_CYGNUS_D30V
:
1809 case EM_D30V
: return "d30v";
1810 case EM_CYGNUS_M32R
:
1811 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1812 case EM_CYGNUS_V850
:
1813 case EM_V850
: return "NEC v850";
1814 case EM_CYGNUS_MN10300
:
1815 case EM_MN10300
: return "mn10300";
1816 case EM_CYGNUS_MN10200
:
1817 case EM_MN10200
: return "mn10200";
1818 case EM_CYGNUS_FR30
:
1819 case EM_FR30
: return "Fujitsu FR30";
1820 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1822 case EM_PJ
: return "picoJava";
1823 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1824 case EM_PCP
: return "Siemens PCP";
1825 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1826 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1827 case EM_STARCORE
: return "Motorola Star*Core processor";
1828 case EM_ME16
: return "Toyota ME16 processor";
1829 case EM_ST100
: return "STMicroelectronics ST100 processor";
1830 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1831 case EM_FX66
: return "Siemens FX66 microcontroller";
1832 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1833 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1834 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1835 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1836 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1837 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1838 case EM_SVX
: return "Silicon Graphics SVx";
1839 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1840 case EM_VAX
: return "Digital VAX";
1842 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1843 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1844 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1845 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1846 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1847 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1848 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1849 case EM_PRISM
: return "Vitesse Prism";
1850 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1851 case EM_L1OM
: return "Intel L1OM";
1853 case EM_S390
: return "IBM S/390";
1854 case EM_SCORE
: return "SUNPLUS S+Core";
1855 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1857 case EM_OR32
: return "OpenRISC";
1858 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1859 case EM_DLX
: return "OpenDLX";
1861 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1862 case EM_IQ2000
: return "Vitesse IQ2000";
1864 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1865 case EM_LATTICEMICO32
: return "Lattice Mico32";
1867 case EM_M32C
: return "Renesas M32c";
1868 case EM_MT
: return "Morpho Techologies MT processor";
1869 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1870 case EM_NIOS32
: return "Altera Nios";
1871 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1872 case EM_XC16X
: return "Infineon Technologies xc16x";
1873 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1875 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1876 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1877 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1879 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1885 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1890 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1891 e_flags
&= ~ EF_ARM_EABIMASK
;
1893 /* Handle "generic" ARM flags. */
1894 if (e_flags
& EF_ARM_RELEXEC
)
1896 strcat (buf
, ", relocatable executable");
1897 e_flags
&= ~ EF_ARM_RELEXEC
;
1900 if (e_flags
& EF_ARM_HASENTRY
)
1902 strcat (buf
, ", has entry point");
1903 e_flags
&= ~ EF_ARM_HASENTRY
;
1906 /* Now handle EABI specific flags. */
1910 strcat (buf
, ", <unrecognized EABI>");
1915 case EF_ARM_EABI_VER1
:
1916 strcat (buf
, ", Version1 EABI");
1921 /* Process flags one bit at a time. */
1922 flag
= e_flags
& - e_flags
;
1927 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1928 strcat (buf
, ", sorted symbol tables");
1938 case EF_ARM_EABI_VER2
:
1939 strcat (buf
, ", Version2 EABI");
1944 /* Process flags one bit at a time. */
1945 flag
= e_flags
& - e_flags
;
1950 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1951 strcat (buf
, ", sorted symbol tables");
1954 case EF_ARM_DYNSYMSUSESEGIDX
:
1955 strcat (buf
, ", dynamic symbols use segment index");
1958 case EF_ARM_MAPSYMSFIRST
:
1959 strcat (buf
, ", mapping symbols precede others");
1969 case EF_ARM_EABI_VER3
:
1970 strcat (buf
, ", Version3 EABI");
1973 case EF_ARM_EABI_VER4
:
1974 strcat (buf
, ", Version4 EABI");
1977 case EF_ARM_EABI_VER5
:
1978 strcat (buf
, ", Version5 EABI");
1984 /* Process flags one bit at a time. */
1985 flag
= e_flags
& - e_flags
;
1991 strcat (buf
, ", BE8");
1995 strcat (buf
, ", LE8");
2005 case EF_ARM_EABI_UNKNOWN
:
2006 strcat (buf
, ", GNU EABI");
2011 /* Process flags one bit at a time. */
2012 flag
= e_flags
& - e_flags
;
2017 case EF_ARM_INTERWORK
:
2018 strcat (buf
, ", interworking enabled");
2021 case EF_ARM_APCS_26
:
2022 strcat (buf
, ", uses APCS/26");
2025 case EF_ARM_APCS_FLOAT
:
2026 strcat (buf
, ", uses APCS/float");
2030 strcat (buf
, ", position independent");
2034 strcat (buf
, ", 8 bit structure alignment");
2037 case EF_ARM_NEW_ABI
:
2038 strcat (buf
, ", uses new ABI");
2041 case EF_ARM_OLD_ABI
:
2042 strcat (buf
, ", uses old ABI");
2045 case EF_ARM_SOFT_FLOAT
:
2046 strcat (buf
, ", software FP");
2049 case EF_ARM_VFP_FLOAT
:
2050 strcat (buf
, ", VFP");
2053 case EF_ARM_MAVERICK_FLOAT
:
2054 strcat (buf
, ", Maverick FP");
2065 strcat (buf
,", <unknown>");
2069 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2071 static char buf
[1024];
2083 decode_ARM_machine_flags (e_flags
, buf
);
2087 switch (e_flags
& EF_FRV_CPU_MASK
)
2089 case EF_FRV_CPU_GENERIC
:
2093 strcat (buf
, ", fr???");
2096 case EF_FRV_CPU_FR300
:
2097 strcat (buf
, ", fr300");
2100 case EF_FRV_CPU_FR400
:
2101 strcat (buf
, ", fr400");
2103 case EF_FRV_CPU_FR405
:
2104 strcat (buf
, ", fr405");
2107 case EF_FRV_CPU_FR450
:
2108 strcat (buf
, ", fr450");
2111 case EF_FRV_CPU_FR500
:
2112 strcat (buf
, ", fr500");
2114 case EF_FRV_CPU_FR550
:
2115 strcat (buf
, ", fr550");
2118 case EF_FRV_CPU_SIMPLE
:
2119 strcat (buf
, ", simple");
2121 case EF_FRV_CPU_TOMCAT
:
2122 strcat (buf
, ", tomcat");
2128 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2129 strcat (buf
, ", m68000");
2130 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2131 strcat (buf
, ", cpu32");
2132 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2133 strcat (buf
, ", fido_a");
2136 char const * isa
= _("unknown");
2137 char const * mac
= _("unknown mac");
2138 char const * additional
= NULL
;
2140 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2142 case EF_M68K_CF_ISA_A_NODIV
:
2144 additional
= ", nodiv";
2146 case EF_M68K_CF_ISA_A
:
2149 case EF_M68K_CF_ISA_A_PLUS
:
2152 case EF_M68K_CF_ISA_B_NOUSP
:
2154 additional
= ", nousp";
2156 case EF_M68K_CF_ISA_B
:
2160 strcat (buf
, ", cf, isa ");
2163 strcat (buf
, additional
);
2164 if (e_flags
& EF_M68K_CF_FLOAT
)
2165 strcat (buf
, ", float");
2166 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2171 case EF_M68K_CF_MAC
:
2174 case EF_M68K_CF_EMAC
:
2187 if (e_flags
& EF_PPC_EMB
)
2188 strcat (buf
, ", emb");
2190 if (e_flags
& EF_PPC_RELOCATABLE
)
2191 strcat (buf
, ", relocatable");
2193 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2194 strcat (buf
, ", relocatable-lib");
2198 case EM_CYGNUS_V850
:
2199 switch (e_flags
& EF_V850_ARCH
)
2202 strcat (buf
, ", v850e1");
2205 strcat (buf
, ", v850e");
2208 strcat (buf
, ", v850");
2211 strcat (buf
, ", unknown v850 architecture variant");
2217 case EM_CYGNUS_M32R
:
2218 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2219 strcat (buf
, ", m32r");
2223 case EM_MIPS_RS3_LE
:
2224 if (e_flags
& EF_MIPS_NOREORDER
)
2225 strcat (buf
, ", noreorder");
2227 if (e_flags
& EF_MIPS_PIC
)
2228 strcat (buf
, ", pic");
2230 if (e_flags
& EF_MIPS_CPIC
)
2231 strcat (buf
, ", cpic");
2233 if (e_flags
& EF_MIPS_UCODE
)
2234 strcat (buf
, ", ugen_reserved");
2236 if (e_flags
& EF_MIPS_ABI2
)
2237 strcat (buf
, ", abi2");
2239 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2240 strcat (buf
, ", odk first");
2242 if (e_flags
& EF_MIPS_32BITMODE
)
2243 strcat (buf
, ", 32bitmode");
2245 switch ((e_flags
& EF_MIPS_MACH
))
2247 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2248 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2249 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2250 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2251 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2252 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2253 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2254 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2255 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2256 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2257 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2258 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2259 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2260 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2262 /* We simply ignore the field in this case to avoid confusion:
2263 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2266 default: strcat (buf
, ", unknown CPU"); break;
2269 switch ((e_flags
& EF_MIPS_ABI
))
2271 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2272 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2273 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2274 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2276 /* We simply ignore the field in this case to avoid confusion:
2277 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2278 This means it is likely to be an o32 file, but not for
2281 default: strcat (buf
, ", unknown ABI"); break;
2284 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2285 strcat (buf
, ", mdmx");
2287 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2288 strcat (buf
, ", mips16");
2290 switch ((e_flags
& EF_MIPS_ARCH
))
2292 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2293 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2294 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2295 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2296 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2297 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2298 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2299 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2300 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2301 default: strcat (buf
, ", unknown ISA"); break;
2307 switch ((e_flags
& EF_SH_MACH_MASK
))
2309 case EF_SH1
: strcat (buf
, ", sh1"); break;
2310 case EF_SH2
: strcat (buf
, ", sh2"); break;
2311 case EF_SH3
: strcat (buf
, ", sh3"); break;
2312 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2313 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2314 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2315 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2316 case EF_SH4
: strcat (buf
, ", sh4"); break;
2317 case EF_SH5
: strcat (buf
, ", sh5"); break;
2318 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2319 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2320 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2321 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2322 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2323 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2324 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2325 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2326 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2327 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2328 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2329 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2330 default: strcat (buf
, ", unknown ISA"); break;
2336 if (e_flags
& EF_SPARC_32PLUS
)
2337 strcat (buf
, ", v8+");
2339 if (e_flags
& EF_SPARC_SUN_US1
)
2340 strcat (buf
, ", ultrasparcI");
2342 if (e_flags
& EF_SPARC_SUN_US3
)
2343 strcat (buf
, ", ultrasparcIII");
2345 if (e_flags
& EF_SPARC_HAL_R1
)
2346 strcat (buf
, ", halr1");
2348 if (e_flags
& EF_SPARC_LEDATA
)
2349 strcat (buf
, ", ledata");
2351 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2352 strcat (buf
, ", tso");
2354 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2355 strcat (buf
, ", pso");
2357 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2358 strcat (buf
, ", rmo");
2362 switch (e_flags
& EF_PARISC_ARCH
)
2364 case EFA_PARISC_1_0
:
2365 strcpy (buf
, ", PA-RISC 1.0");
2367 case EFA_PARISC_1_1
:
2368 strcpy (buf
, ", PA-RISC 1.1");
2370 case EFA_PARISC_2_0
:
2371 strcpy (buf
, ", PA-RISC 2.0");
2376 if (e_flags
& EF_PARISC_TRAPNIL
)
2377 strcat (buf
, ", trapnil");
2378 if (e_flags
& EF_PARISC_EXT
)
2379 strcat (buf
, ", ext");
2380 if (e_flags
& EF_PARISC_LSB
)
2381 strcat (buf
, ", lsb");
2382 if (e_flags
& EF_PARISC_WIDE
)
2383 strcat (buf
, ", wide");
2384 if (e_flags
& EF_PARISC_NO_KABP
)
2385 strcat (buf
, ", no kabp");
2386 if (e_flags
& EF_PARISC_LAZYSWAP
)
2387 strcat (buf
, ", lazyswap");
2392 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2393 strcat (buf
, ", new calling convention");
2395 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2396 strcat (buf
, ", gnu calling convention");
2400 if ((e_flags
& EF_IA_64_ABI64
))
2401 strcat (buf
, ", 64-bit");
2403 strcat (buf
, ", 32-bit");
2404 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2405 strcat (buf
, ", reduced fp model");
2406 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2407 strcat (buf
, ", no function descriptors, constant gp");
2408 else if ((e_flags
& EF_IA_64_CONS_GP
))
2409 strcat (buf
, ", constant gp");
2410 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2411 strcat (buf
, ", absolute");
2415 if ((e_flags
& EF_VAX_NONPIC
))
2416 strcat (buf
, ", non-PIC");
2417 if ((e_flags
& EF_VAX_DFLOAT
))
2418 strcat (buf
, ", D-Float");
2419 if ((e_flags
& EF_VAX_GFLOAT
))
2420 strcat (buf
, ", G-Float");
2429 get_osabi_name (unsigned int osabi
)
2431 static char buff
[32];
2435 case ELFOSABI_NONE
: return "UNIX - System V";
2436 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2437 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2438 case ELFOSABI_LINUX
: return "UNIX - Linux";
2439 case ELFOSABI_HURD
: return "GNU/Hurd";
2440 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2441 case ELFOSABI_AIX
: return "UNIX - AIX";
2442 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2443 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2444 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2445 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2446 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2447 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2448 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2449 case ELFOSABI_AROS
: return "AROS";
2450 case ELFOSABI_STANDALONE
: return _("Standalone App");
2451 case ELFOSABI_ARM
: return "ARM";
2453 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2459 get_arm_segment_type (unsigned long type
)
2473 get_mips_segment_type (unsigned long type
)
2477 case PT_MIPS_REGINFO
:
2479 case PT_MIPS_RTPROC
:
2481 case PT_MIPS_OPTIONS
:
2491 get_parisc_segment_type (unsigned long type
)
2495 case PT_HP_TLS
: return "HP_TLS";
2496 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2497 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2498 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2499 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2500 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2501 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2502 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2503 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2504 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2505 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2506 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2507 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2508 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2509 case PT_HP_STACK
: return "HP_STACK";
2510 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2511 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2512 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2513 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2522 get_ia64_segment_type (unsigned long type
)
2526 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2527 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2528 case PT_HP_TLS
: return "HP_TLS";
2529 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2530 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2531 case PT_IA_64_HP_STACK
: return "HP_STACK";
2540 get_segment_type (unsigned long p_type
)
2542 static char buff
[32];
2546 case PT_NULL
: return "NULL";
2547 case PT_LOAD
: return "LOAD";
2548 case PT_DYNAMIC
: return "DYNAMIC";
2549 case PT_INTERP
: return "INTERP";
2550 case PT_NOTE
: return "NOTE";
2551 case PT_SHLIB
: return "SHLIB";
2552 case PT_PHDR
: return "PHDR";
2553 case PT_TLS
: return "TLS";
2555 case PT_GNU_EH_FRAME
:
2556 return "GNU_EH_FRAME";
2557 case PT_GNU_STACK
: return "GNU_STACK";
2558 case PT_GNU_RELRO
: return "GNU_RELRO";
2561 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2563 const char * result
;
2565 switch (elf_header
.e_machine
)
2568 result
= get_arm_segment_type (p_type
);
2571 case EM_MIPS_RS3_LE
:
2572 result
= get_mips_segment_type (p_type
);
2575 result
= get_parisc_segment_type (p_type
);
2578 result
= get_ia64_segment_type (p_type
);
2588 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2590 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2592 const char * result
;
2594 switch (elf_header
.e_machine
)
2597 result
= get_parisc_segment_type (p_type
);
2600 result
= get_ia64_segment_type (p_type
);
2610 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2613 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2620 get_mips_section_type_name (unsigned int sh_type
)
2624 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2625 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2626 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2627 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2628 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2629 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2630 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2631 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2632 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2633 case SHT_MIPS_RELD
: return "MIPS_RELD";
2634 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2635 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2636 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2637 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2638 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2639 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2640 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2641 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2642 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2643 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2644 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2645 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2646 case SHT_MIPS_LINE
: return "MIPS_LINE";
2647 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2648 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2649 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2650 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2651 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2652 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2653 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2654 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2655 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2656 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2657 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2658 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2659 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2660 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2661 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2662 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2670 get_parisc_section_type_name (unsigned int sh_type
)
2674 case SHT_PARISC_EXT
: return "PARISC_EXT";
2675 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2676 case SHT_PARISC_DOC
: return "PARISC_DOC";
2677 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2678 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2679 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2680 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2688 get_ia64_section_type_name (unsigned int sh_type
)
2690 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2691 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2692 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2696 case SHT_IA_64_EXT
: return "IA_64_EXT";
2697 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2698 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2699 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2700 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2701 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2702 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2703 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2704 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2705 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2713 get_x86_64_section_type_name (unsigned int sh_type
)
2717 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2725 get_arm_section_type_name (unsigned int sh_type
)
2731 case SHT_ARM_PREEMPTMAP
:
2732 return "ARM_PREEMPTMAP";
2733 case SHT_ARM_ATTRIBUTES
:
2734 return "ARM_ATTRIBUTES";
2742 get_section_type_name (unsigned int sh_type
)
2744 static char buff
[32];
2748 case SHT_NULL
: return "NULL";
2749 case SHT_PROGBITS
: return "PROGBITS";
2750 case SHT_SYMTAB
: return "SYMTAB";
2751 case SHT_STRTAB
: return "STRTAB";
2752 case SHT_RELA
: return "RELA";
2753 case SHT_HASH
: return "HASH";
2754 case SHT_DYNAMIC
: return "DYNAMIC";
2755 case SHT_NOTE
: return "NOTE";
2756 case SHT_NOBITS
: return "NOBITS";
2757 case SHT_REL
: return "REL";
2758 case SHT_SHLIB
: return "SHLIB";
2759 case SHT_DYNSYM
: return "DYNSYM";
2760 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2761 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2762 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2763 case SHT_GNU_HASH
: return "GNU_HASH";
2764 case SHT_GROUP
: return "GROUP";
2765 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2766 case SHT_GNU_verdef
: return "VERDEF";
2767 case SHT_GNU_verneed
: return "VERNEED";
2768 case SHT_GNU_versym
: return "VERSYM";
2769 case 0x6ffffff0: return "VERSYM";
2770 case 0x6ffffffc: return "VERDEF";
2771 case 0x7ffffffd: return "AUXILIARY";
2772 case 0x7fffffff: return "FILTER";
2773 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2776 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2778 const char * result
;
2780 switch (elf_header
.e_machine
)
2783 case EM_MIPS_RS3_LE
:
2784 result
= get_mips_section_type_name (sh_type
);
2787 result
= get_parisc_section_type_name (sh_type
);
2790 result
= get_ia64_section_type_name (sh_type
);
2794 result
= get_x86_64_section_type_name (sh_type
);
2797 result
= get_arm_section_type_name (sh_type
);
2807 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2809 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2811 const char * result
;
2813 switch (elf_header
.e_machine
)
2816 result
= get_ia64_section_type_name (sh_type
);
2826 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2828 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2829 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2831 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2837 #define OPTION_DEBUG_DUMP 512
2839 static struct option options
[] =
2841 {"all", no_argument
, 0, 'a'},
2842 {"file-header", no_argument
, 0, 'h'},
2843 {"program-headers", no_argument
, 0, 'l'},
2844 {"headers", no_argument
, 0, 'e'},
2845 {"histogram", no_argument
, 0, 'I'},
2846 {"segments", no_argument
, 0, 'l'},
2847 {"sections", no_argument
, 0, 'S'},
2848 {"section-headers", no_argument
, 0, 'S'},
2849 {"section-groups", no_argument
, 0, 'g'},
2850 {"section-details", no_argument
, 0, 't'},
2851 {"full-section-name",no_argument
, 0, 'N'},
2852 {"symbols", no_argument
, 0, 's'},
2853 {"syms", no_argument
, 0, 's'},
2854 {"relocs", no_argument
, 0, 'r'},
2855 {"notes", no_argument
, 0, 'n'},
2856 {"dynamic", no_argument
, 0, 'd'},
2857 {"arch-specific", no_argument
, 0, 'A'},
2858 {"version-info", no_argument
, 0, 'V'},
2859 {"use-dynamic", no_argument
, 0, 'D'},
2860 {"unwind", no_argument
, 0, 'u'},
2861 {"archive-index", no_argument
, 0, 'c'},
2862 {"hex-dump", required_argument
, 0, 'x'},
2863 {"relocated-dump", required_argument
, 0, 'R'},
2864 {"string-dump", required_argument
, 0, 'p'},
2865 #ifdef SUPPORT_DISASSEMBLY
2866 {"instruction-dump", required_argument
, 0, 'i'},
2868 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2870 {"version", no_argument
, 0, 'v'},
2871 {"wide", no_argument
, 0, 'W'},
2872 {"help", no_argument
, 0, 'H'},
2873 {0, no_argument
, 0, 0}
2877 usage (FILE * stream
)
2879 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2880 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2881 fprintf (stream
, _(" Options are:\n\
2882 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2883 -h --file-header Display the ELF file header\n\
2884 -l --program-headers Display the program headers\n\
2885 --segments An alias for --program-headers\n\
2886 -S --section-headers Display the sections' header\n\
2887 --sections An alias for --section-headers\n\
2888 -g --section-groups Display the section groups\n\
2889 -t --section-details Display the section details\n\
2890 -e --headers Equivalent to: -h -l -S\n\
2891 -s --syms Display the symbol table\n\
2892 --symbols An alias for --syms\n\
2893 -n --notes Display the core notes (if present)\n\
2894 -r --relocs Display the relocations (if present)\n\
2895 -u --unwind Display the unwind info (if present)\n\
2896 -d --dynamic Display the dynamic section (if present)\n\
2897 -V --version-info Display the version sections (if present)\n\
2898 -A --arch-specific Display architecture specific information (if any).\n\
2899 -c --archive-index Display the symbol/file index in an archive\n\
2900 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2901 -x --hex-dump=<number|name>\n\
2902 Dump the contents of section <number|name> as bytes\n\
2903 -p --string-dump=<number|name>\n\
2904 Dump the contents of section <number|name> as strings\n\
2905 -R --relocated-dump=<number|name>\n\
2906 Dump the contents of section <number|name> as relocated bytes\n\
2907 -w[lLiaprmfFsoR] or\n\
2908 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2909 Display the contents of DWARF2 debug sections\n"));
2910 #ifdef SUPPORT_DISASSEMBLY
2911 fprintf (stream
, _("\
2912 -i --instruction-dump=<number|name>\n\
2913 Disassemble the contents of section <number|name>\n"));
2915 fprintf (stream
, _("\
2916 -I --histogram Display histogram of bucket list lengths\n\
2917 -W --wide Allow output width to exceed 80 characters\n\
2918 @<file> Read options from <file>\n\
2919 -H --help Display this information\n\
2920 -v --version Display the version number of readelf\n"));
2922 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2923 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2925 exit (stream
== stdout
? 0 : 1);
2928 /* Record the fact that the user wants the contents of section number
2929 SECTION to be displayed using the method(s) encoded as flags bits
2930 in TYPE. Note, TYPE can be zero if we are creating the array for
2934 request_dump_bynumber (unsigned int section
, dump_type type
)
2936 if (section
>= num_dump_sects
)
2938 dump_type
* new_dump_sects
;
2940 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2942 if (new_dump_sects
== NULL
)
2943 error (_("Out of memory allocating dump request table.\n"));
2946 /* Copy current flag settings. */
2947 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2951 dump_sects
= new_dump_sects
;
2952 num_dump_sects
= section
+ 1;
2957 dump_sects
[section
] |= type
;
2962 /* Request a dump by section name. */
2965 request_dump_byname (const char * section
, dump_type type
)
2967 struct dump_list_entry
* new_request
;
2969 new_request
= malloc (sizeof (struct dump_list_entry
));
2971 error (_("Out of memory allocating dump request table.\n"));
2973 new_request
->name
= strdup (section
);
2974 if (!new_request
->name
)
2975 error (_("Out of memory allocating dump request table.\n"));
2977 new_request
->type
= type
;
2979 new_request
->next
= dump_sects_byname
;
2980 dump_sects_byname
= new_request
;
2984 request_dump (dump_type type
)
2990 section
= strtoul (optarg
, & cp
, 0);
2992 if (! *cp
&& section
>= 0)
2993 request_dump_bynumber (section
, type
);
2995 request_dump_byname (optarg
, type
);
3000 parse_args (int argc
, char ** argv
)
3007 while ((c
= getopt_long
3008 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3026 do_section_groups
++;
3034 do_section_groups
++;
3039 do_section_details
++;
3083 request_dump (HEX_DUMP
);
3086 request_dump (STRING_DUMP
);
3089 request_dump (RELOC_DUMP
);
3096 dwarf_select_sections_all ();
3101 dwarf_select_sections_by_letters (optarg
);
3104 case OPTION_DEBUG_DUMP
:
3111 dwarf_select_sections_by_names (optarg
);
3114 #ifdef SUPPORT_DISASSEMBLY
3116 request_dump (DISASS_DUMP
);
3120 print_version (program_name
);
3129 /* xgettext:c-format */
3130 error (_("Invalid option '-%c'\n"), c
);
3137 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3138 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3139 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3140 && !do_section_groups
&& !do_archive_index
)
3144 warn (_("Nothing to do.\n"));
3150 get_elf_class (unsigned int elf_class
)
3152 static char buff
[32];
3156 case ELFCLASSNONE
: return _("none");
3157 case ELFCLASS32
: return "ELF32";
3158 case ELFCLASS64
: return "ELF64";
3160 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3166 get_data_encoding (unsigned int encoding
)
3168 static char buff
[32];
3172 case ELFDATANONE
: return _("none");
3173 case ELFDATA2LSB
: return _("2's complement, little endian");
3174 case ELFDATA2MSB
: return _("2's complement, big endian");
3176 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3181 /* Decode the data held in 'elf_header'. */
3184 process_file_header (void)
3186 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3187 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3188 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3189 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3192 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3196 init_dwarf_regnames (elf_header
.e_machine
);
3202 printf (_("ELF Header:\n"));
3203 printf (_(" Magic: "));
3204 for (i
= 0; i
< EI_NIDENT
; i
++)
3205 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3207 printf (_(" Class: %s\n"),
3208 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3209 printf (_(" Data: %s\n"),
3210 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3211 printf (_(" Version: %d %s\n"),
3212 elf_header
.e_ident
[EI_VERSION
],
3213 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3215 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3218 printf (_(" OS/ABI: %s\n"),
3219 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3220 printf (_(" ABI Version: %d\n"),
3221 elf_header
.e_ident
[EI_ABIVERSION
]);
3222 printf (_(" Type: %s\n"),
3223 get_file_type (elf_header
.e_type
));
3224 printf (_(" Machine: %s\n"),
3225 get_machine_name (elf_header
.e_machine
));
3226 printf (_(" Version: 0x%lx\n"),
3227 (unsigned long) elf_header
.e_version
);
3229 printf (_(" Entry point address: "));
3230 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3231 printf (_("\n Start of program headers: "));
3232 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3233 printf (_(" (bytes into file)\n Start of section headers: "));
3234 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3235 printf (_(" (bytes into file)\n"));
3237 printf (_(" Flags: 0x%lx%s\n"),
3238 (unsigned long) elf_header
.e_flags
,
3239 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3240 printf (_(" Size of this header: %ld (bytes)\n"),
3241 (long) elf_header
.e_ehsize
);
3242 printf (_(" Size of program headers: %ld (bytes)\n"),
3243 (long) elf_header
.e_phentsize
);
3244 printf (_(" Number of program headers: %ld\n"),
3245 (long) elf_header
.e_phnum
);
3246 printf (_(" Size of section headers: %ld (bytes)\n"),
3247 (long) elf_header
.e_shentsize
);
3248 printf (_(" Number of section headers: %ld"),
3249 (long) elf_header
.e_shnum
);
3250 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3251 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3252 putc ('\n', stdout
);
3253 printf (_(" Section header string table index: %ld"),
3254 (long) elf_header
.e_shstrndx
);
3255 if (section_headers
!= NULL
3256 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3257 printf (" (%u)", section_headers
[0].sh_link
);
3258 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3259 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3260 printf (" <corrupt: out of range>");
3261 putc ('\n', stdout
);
3264 if (section_headers
!= NULL
)
3266 if (elf_header
.e_shnum
== SHN_UNDEF
)
3267 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3268 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3269 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3270 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3271 elf_header
.e_shstrndx
= SHN_UNDEF
;
3272 free (section_headers
);
3273 section_headers
= NULL
;
3281 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3283 Elf32_External_Phdr
* phdrs
;
3284 Elf32_External_Phdr
* external
;
3285 Elf_Internal_Phdr
* internal
;
3288 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3289 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3290 _("program headers"));
3294 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3295 i
< elf_header
.e_phnum
;
3296 i
++, internal
++, external
++)
3298 internal
->p_type
= BYTE_GET (external
->p_type
);
3299 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3300 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3301 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3302 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3303 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3304 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3305 internal
->p_align
= BYTE_GET (external
->p_align
);
3314 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3316 Elf64_External_Phdr
* phdrs
;
3317 Elf64_External_Phdr
* external
;
3318 Elf_Internal_Phdr
* internal
;
3321 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3322 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3323 _("program headers"));
3327 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3328 i
< elf_header
.e_phnum
;
3329 i
++, internal
++, external
++)
3331 internal
->p_type
= BYTE_GET (external
->p_type
);
3332 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3333 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3334 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3335 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3336 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3337 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3338 internal
->p_align
= BYTE_GET (external
->p_align
);
3346 /* Returns 1 if the program headers were read into `program_headers'. */
3349 get_program_headers (FILE * file
)
3351 Elf_Internal_Phdr
* phdrs
;
3353 /* Check cache of prior read. */
3354 if (program_headers
!= NULL
)
3357 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3361 error (_("Out of memory\n"));
3366 ? get_32bit_program_headers (file
, phdrs
)
3367 : get_64bit_program_headers (file
, phdrs
))
3369 program_headers
= phdrs
;
3377 /* Returns 1 if the program headers were loaded. */
3380 process_program_headers (FILE * file
)
3382 Elf_Internal_Phdr
* segment
;
3385 if (elf_header
.e_phnum
== 0)
3388 printf (_("\nThere are no program headers in this file.\n"));
3392 if (do_segments
&& !do_header
)
3394 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3395 printf (_("Entry point "));
3396 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3397 printf (_("\nThere are %d program headers, starting at offset "),
3398 elf_header
.e_phnum
);
3399 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3403 if (! get_program_headers (file
))
3408 if (elf_header
.e_phnum
> 1)
3409 printf (_("\nProgram Headers:\n"));
3411 printf (_("\nProgram Headers:\n"));
3415 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3418 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3422 (_(" Type Offset VirtAddr PhysAddr\n"));
3424 (_(" FileSiz MemSiz Flags Align\n"));
3431 for (i
= 0, segment
= program_headers
;
3432 i
< elf_header
.e_phnum
;
3437 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3441 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3442 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3443 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3444 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3445 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3447 (segment
->p_flags
& PF_R
? 'R' : ' '),
3448 (segment
->p_flags
& PF_W
? 'W' : ' '),
3449 (segment
->p_flags
& PF_X
? 'E' : ' '));
3450 printf ("%#lx", (unsigned long) segment
->p_align
);
3454 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3455 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3458 print_vma (segment
->p_offset
, FULL_HEX
);
3462 print_vma (segment
->p_vaddr
, FULL_HEX
);
3464 print_vma (segment
->p_paddr
, FULL_HEX
);
3467 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3468 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3471 print_vma (segment
->p_filesz
, FULL_HEX
);
3475 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3476 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3479 print_vma (segment
->p_offset
, FULL_HEX
);
3483 (segment
->p_flags
& PF_R
? 'R' : ' '),
3484 (segment
->p_flags
& PF_W
? 'W' : ' '),
3485 (segment
->p_flags
& PF_X
? 'E' : ' '));
3487 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3488 printf ("%#lx", (unsigned long) segment
->p_align
);
3491 print_vma (segment
->p_align
, PREFIX_HEX
);
3496 print_vma (segment
->p_offset
, FULL_HEX
);
3498 print_vma (segment
->p_vaddr
, FULL_HEX
);
3500 print_vma (segment
->p_paddr
, FULL_HEX
);
3502 print_vma (segment
->p_filesz
, FULL_HEX
);
3504 print_vma (segment
->p_memsz
, FULL_HEX
);
3506 (segment
->p_flags
& PF_R
? 'R' : ' '),
3507 (segment
->p_flags
& PF_W
? 'W' : ' '),
3508 (segment
->p_flags
& PF_X
? 'E' : ' '));
3509 print_vma (segment
->p_align
, HEX
);
3513 switch (segment
->p_type
)
3517 error (_("more than one dynamic segment\n"));
3519 /* By default, assume that the .dynamic section is the first
3520 section in the DYNAMIC segment. */
3521 dynamic_addr
= segment
->p_offset
;
3522 dynamic_size
= segment
->p_filesz
;
3524 /* Try to locate the .dynamic section. If there is
3525 a section header table, we can easily locate it. */
3526 if (section_headers
!= NULL
)
3528 Elf_Internal_Shdr
* sec
;
3530 sec
= find_section (".dynamic");
3531 if (sec
== NULL
|| sec
->sh_size
== 0)
3533 error (_("no .dynamic section in the dynamic segment\n"));
3537 if (sec
->sh_type
== SHT_NOBITS
)
3543 dynamic_addr
= sec
->sh_offset
;
3544 dynamic_size
= sec
->sh_size
;
3546 if (dynamic_addr
< segment
->p_offset
3547 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3548 warn (_("the .dynamic section is not contained"
3549 " within the dynamic segment\n"));
3550 else if (dynamic_addr
> segment
->p_offset
)
3551 warn (_("the .dynamic section is not the first section"
3552 " in the dynamic segment.\n"));
3557 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3559 error (_("Unable to find program interpreter name\n"));
3563 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3565 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3566 error (_("Internal error: failed to create format string to display program interpreter\n"));
3568 program_interpreter
[0] = 0;
3569 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3570 error (_("Unable to read program interpreter name\n"));
3573 printf (_("\n [Requesting program interpreter: %s]"),
3574 program_interpreter
);
3580 putc ('\n', stdout
);
3583 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3585 printf (_("\n Section to Segment mapping:\n"));
3586 printf (_(" Segment Sections...\n"));
3588 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3591 Elf_Internal_Shdr
* section
;
3593 segment
= program_headers
+ i
;
3594 section
= section_headers
+ 1;
3596 printf (" %2.2d ", i
);
3598 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3600 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3601 printf ("%s ", SECTION_NAME (section
));
3612 /* Find the file offset corresponding to VMA by using the program headers. */
3615 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3617 Elf_Internal_Phdr
* seg
;
3619 if (! get_program_headers (file
))
3621 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3625 for (seg
= program_headers
;
3626 seg
< program_headers
+ elf_header
.e_phnum
;
3629 if (seg
->p_type
!= PT_LOAD
)
3632 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3633 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3634 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3637 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3638 (unsigned long) vma
);
3644 get_32bit_section_headers (FILE * file
, unsigned int num
)
3646 Elf32_External_Shdr
* shdrs
;
3647 Elf_Internal_Shdr
* internal
;
3650 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3651 elf_header
.e_shentsize
, num
, _("section headers"));
3655 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3657 if (section_headers
== NULL
)
3659 error (_("Out of memory\n"));
3663 for (i
= 0, internal
= section_headers
;
3667 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3668 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3669 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3670 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3671 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3672 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3673 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3674 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3675 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3676 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3685 get_64bit_section_headers (FILE * file
, unsigned int num
)
3687 Elf64_External_Shdr
* shdrs
;
3688 Elf_Internal_Shdr
* internal
;
3691 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3692 elf_header
.e_shentsize
, num
, _("section headers"));
3696 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3698 if (section_headers
== NULL
)
3700 error (_("Out of memory\n"));
3704 for (i
= 0, internal
= section_headers
;
3708 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3709 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3710 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3711 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3712 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3713 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3714 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3715 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3716 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3717 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3725 static Elf_Internal_Sym
*
3726 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3728 unsigned long number
;
3729 Elf32_External_Sym
* esyms
;
3730 Elf_External_Sym_Shndx
* shndx
;
3731 Elf_Internal_Sym
* isyms
;
3732 Elf_Internal_Sym
* psym
;
3735 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3741 if (symtab_shndx_hdr
!= NULL
3742 && (symtab_shndx_hdr
->sh_link
3743 == (unsigned long) (section
- section_headers
)))
3745 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3746 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3754 number
= section
->sh_size
/ section
->sh_entsize
;
3755 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3759 error (_("Out of memory\n"));
3766 for (j
= 0, psym
= isyms
;
3770 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3771 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3772 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3773 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3774 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3776 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3777 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3778 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3779 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3780 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3790 static Elf_Internal_Sym
*
3791 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3793 unsigned long number
;
3794 Elf64_External_Sym
* esyms
;
3795 Elf_External_Sym_Shndx
* shndx
;
3796 Elf_Internal_Sym
* isyms
;
3797 Elf_Internal_Sym
* psym
;
3800 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3806 if (symtab_shndx_hdr
!= NULL
3807 && (symtab_shndx_hdr
->sh_link
3808 == (unsigned long) (section
- section_headers
)))
3810 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3811 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3819 number
= section
->sh_size
/ section
->sh_entsize
;
3820 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3824 error (_("Out of memory\n"));
3831 for (j
= 0, psym
= isyms
;
3835 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3836 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3837 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3838 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3839 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3841 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3842 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3843 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3844 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3845 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3856 get_elf_section_flags (bfd_vma sh_flags
)
3858 static char buff
[1024];
3860 int field_size
= is_32bit_elf
? 8 : 16;
3861 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3862 bfd_vma os_flags
= 0;
3863 bfd_vma proc_flags
= 0;
3864 bfd_vma unknown_flags
= 0;
3878 { "LINK ORDER", 10 },
3879 { "OS NONCONF", 10 },
3882 /* IA-64 specific. */
3885 /* IA-64 OpenVMS specific. */
3886 { "VMS_GLOBAL", 10 },
3887 { "VMS_OVERLAID", 12 },
3888 { "VMS_SHARED", 10 },
3889 { "VMS_VECTOR", 10 },
3890 { "VMS_ALLOC_64BIT", 15 },
3891 { "VMS_PROTECTED", 13}
3894 if (do_section_details
)
3896 sprintf (buff
, "[%*.*lx]: ",
3897 field_size
, field_size
, (unsigned long) sh_flags
);
3898 p
+= field_size
+ 4;
3905 flag
= sh_flags
& - sh_flags
;
3908 if (do_section_details
)
3912 case SHF_WRITE
: index
= 0; break;
3913 case SHF_ALLOC
: index
= 1; break;
3914 case SHF_EXECINSTR
: index
= 2; break;
3915 case SHF_MERGE
: index
= 3; break;
3916 case SHF_STRINGS
: index
= 4; break;
3917 case SHF_INFO_LINK
: index
= 5; break;
3918 case SHF_LINK_ORDER
: index
= 6; break;
3919 case SHF_OS_NONCONFORMING
: index
= 7; break;
3920 case SHF_GROUP
: index
= 8; break;
3921 case SHF_TLS
: index
= 9; break;
3925 if (elf_header
.e_machine
== EM_IA_64
)
3927 if (flag
== SHF_IA_64_SHORT
)
3929 else if (flag
== SHF_IA_64_NORECOV
)
3932 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3935 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3936 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3937 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3938 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3939 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3940 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3950 if (p
!= buff
+ field_size
+ 4)
3952 if (size
< (10 + 2))
3959 size
-= flags
[index
].len
;
3960 p
= stpcpy (p
, flags
[index
].str
);
3962 else if (flag
& SHF_MASKOS
)
3964 else if (flag
& SHF_MASKPROC
)
3967 unknown_flags
|= flag
;
3973 case SHF_WRITE
: *p
= 'W'; break;
3974 case SHF_ALLOC
: *p
= 'A'; break;
3975 case SHF_EXECINSTR
: *p
= 'X'; break;
3976 case SHF_MERGE
: *p
= 'M'; break;
3977 case SHF_STRINGS
: *p
= 'S'; break;
3978 case SHF_INFO_LINK
: *p
= 'I'; break;
3979 case SHF_LINK_ORDER
: *p
= 'L'; break;
3980 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3981 case SHF_GROUP
: *p
= 'G'; break;
3982 case SHF_TLS
: *p
= 'T'; break;
3985 if ((elf_header
.e_machine
== EM_X86_64
3986 || elf_header
.e_machine
== EM_L1OM
)
3987 && flag
== SHF_X86_64_LARGE
)
3989 else if (flag
& SHF_MASKOS
)
3992 sh_flags
&= ~ SHF_MASKOS
;
3994 else if (flag
& SHF_MASKPROC
)
3997 sh_flags
&= ~ SHF_MASKPROC
;
4007 if (do_section_details
)
4011 size
-= 5 + field_size
;
4012 if (p
!= buff
+ field_size
+ 4)
4020 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4021 (unsigned long) os_flags
);
4022 p
+= 5 + field_size
;
4026 size
-= 7 + field_size
;
4027 if (p
!= buff
+ field_size
+ 4)
4035 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4036 (unsigned long) proc_flags
);
4037 p
+= 7 + field_size
;
4041 size
-= 10 + field_size
;
4042 if (p
!= buff
+ field_size
+ 4)
4050 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4051 (unsigned long) unknown_flags
);
4052 p
+= 10 + field_size
;
4061 process_section_headers (FILE * file
)
4063 Elf_Internal_Shdr
* section
;
4066 section_headers
= NULL
;
4068 if (elf_header
.e_shnum
== 0)
4071 printf (_("\nThere are no sections in this file.\n"));
4076 if (do_sections
&& !do_header
)
4077 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4078 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4082 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4085 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4088 /* Read in the string table, so that we have names to display. */
4089 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4090 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4092 section
= section_headers
+ elf_header
.e_shstrndx
;
4094 if (section
->sh_size
!= 0)
4096 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4097 1, section
->sh_size
, _("string table"));
4099 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4103 /* Scan the sections for the dynamic symbol table
4104 and dynamic string table and debug sections. */
4105 dynamic_symbols
= NULL
;
4106 dynamic_strings
= NULL
;
4107 dynamic_syminfo
= NULL
;
4108 symtab_shndx_hdr
= NULL
;
4110 eh_addr_size
= is_32bit_elf
? 4 : 8;
4111 switch (elf_header
.e_machine
)
4114 case EM_MIPS_RS3_LE
:
4115 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4116 FDE addresses. However, the ABI also has a semi-official ILP32
4117 variant for which the normal FDE address size rules apply.
4119 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4120 section, where XX is the size of longs in bits. Unfortunately,
4121 earlier compilers provided no way of distinguishing ILP32 objects
4122 from LP64 objects, so if there's any doubt, we should assume that
4123 the official LP64 form is being used. */
4124 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4125 && find_section (".gcc_compiled_long32") == NULL
)
4131 switch (elf_header
.e_flags
& EF_H8_MACH
)
4133 case E_H8_MACH_H8300
:
4134 case E_H8_MACH_H8300HN
:
4135 case E_H8_MACH_H8300SN
:
4136 case E_H8_MACH_H8300SXN
:
4139 case E_H8_MACH_H8300H
:
4140 case E_H8_MACH_H8300S
:
4141 case E_H8_MACH_H8300SX
:
4149 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4151 case EF_M32C_CPU_M16C
:
4158 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4161 size_t expected_entsize \
4162 = is_32bit_elf ? size32 : size64; \
4163 if (section->sh_entsize != expected_entsize) \
4164 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4165 i, (unsigned long int) section->sh_entsize, \
4166 (unsigned long int) expected_entsize); \
4167 section->sh_entsize = expected_entsize; \
4170 #define CHECK_ENTSIZE(section, i, type) \
4171 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4172 sizeof (Elf64_External_##type))
4174 for (i
= 0, section
= section_headers
;
4175 i
< elf_header
.e_shnum
;
4178 char * name
= SECTION_NAME (section
);
4180 if (section
->sh_type
== SHT_DYNSYM
)
4182 if (dynamic_symbols
!= NULL
)
4184 error (_("File contains multiple dynamic symbol tables\n"));
4188 CHECK_ENTSIZE (section
, i
, Sym
);
4189 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4190 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4192 else if (section
->sh_type
== SHT_STRTAB
4193 && streq (name
, ".dynstr"))
4195 if (dynamic_strings
!= NULL
)
4197 error (_("File contains multiple dynamic string tables\n"));
4201 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4202 1, section
->sh_size
, _("dynamic strings"));
4203 dynamic_strings_length
= section
->sh_size
;
4205 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4207 if (symtab_shndx_hdr
!= NULL
)
4209 error (_("File contains multiple symtab shndx tables\n"));
4212 symtab_shndx_hdr
= section
;
4214 else if (section
->sh_type
== SHT_SYMTAB
)
4215 CHECK_ENTSIZE (section
, i
, Sym
);
4216 else if (section
->sh_type
== SHT_GROUP
)
4217 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4218 else if (section
->sh_type
== SHT_REL
)
4219 CHECK_ENTSIZE (section
, i
, Rel
);
4220 else if (section
->sh_type
== SHT_RELA
)
4221 CHECK_ENTSIZE (section
, i
, Rela
);
4222 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4223 || do_debug_lines
|| do_debug_pubnames
4224 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4225 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4226 && (const_strneq (name
, ".debug_")
4227 || const_strneq (name
, ".zdebug_")))
4230 name
+= sizeof (".zdebug_") - 1;
4232 name
+= sizeof (".debug_") - 1;
4235 || (do_debug_info
&& streq (name
, "info"))
4236 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4237 || (do_debug_lines
&& streq (name
, "line"))
4238 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4239 || (do_debug_aranges
&& streq (name
, "aranges"))
4240 || (do_debug_ranges
&& streq (name
, "ranges"))
4241 || (do_debug_frames
&& streq (name
, "frame"))
4242 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4243 || (do_debug_str
&& streq (name
, "str"))
4244 || (do_debug_loc
&& streq (name
, "loc"))
4246 request_dump_bynumber (i
, DEBUG_DUMP
);
4248 /* Linkonce section to be combined with .debug_info at link time. */
4249 else if ((do_debugging
|| do_debug_info
)
4250 && const_strneq (name
, ".gnu.linkonce.wi."))
4251 request_dump_bynumber (i
, DEBUG_DUMP
);
4252 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4253 request_dump_bynumber (i
, DEBUG_DUMP
);
4259 if (elf_header
.e_shnum
> 1)
4260 printf (_("\nSection Headers:\n"));
4262 printf (_("\nSection Header:\n"));
4266 if (do_section_details
)
4268 printf (_(" [Nr] Name\n"));
4269 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4273 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4277 if (do_section_details
)
4279 printf (_(" [Nr] Name\n"));
4280 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4284 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4288 if (do_section_details
)
4290 printf (_(" [Nr] Name\n"));
4291 printf (_(" Type Address Offset Link\n"));
4292 printf (_(" Size EntSize Info Align\n"));
4296 printf (_(" [Nr] Name Type Address Offset\n"));
4297 printf (_(" Size EntSize Flags Link Info Align\n"));
4301 if (do_section_details
)
4302 printf (_(" Flags\n"));
4304 for (i
= 0, section
= section_headers
;
4305 i
< elf_header
.e_shnum
;
4308 if (do_section_details
)
4310 printf (" [%2u] %s\n",
4312 SECTION_NAME (section
));
4313 if (is_32bit_elf
|| do_wide
)
4314 printf (" %-15.15s ",
4315 get_section_type_name (section
->sh_type
));
4318 printf ((do_wide
? " [%2u] %-17s %-15s "
4319 : " [%2u] %-17.17s %-15.15s "),
4321 SECTION_NAME (section
),
4322 get_section_type_name (section
->sh_type
));
4326 print_vma (section
->sh_addr
, LONG_HEX
);
4328 printf ( " %6.6lx %6.6lx %2.2lx",
4329 (unsigned long) section
->sh_offset
,
4330 (unsigned long) section
->sh_size
,
4331 (unsigned long) section
->sh_entsize
);
4333 if (do_section_details
)
4334 fputs (" ", stdout
);
4336 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4338 printf ("%2u %3u %2lu\n",
4341 (unsigned long) section
->sh_addralign
);
4345 print_vma (section
->sh_addr
, LONG_HEX
);
4347 if ((long) section
->sh_offset
== section
->sh_offset
)
4348 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4352 print_vma (section
->sh_offset
, LONG_HEX
);
4355 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4356 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4360 print_vma (section
->sh_size
, LONG_HEX
);
4363 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4364 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4368 print_vma (section
->sh_entsize
, LONG_HEX
);
4371 if (do_section_details
)
4372 fputs (" ", stdout
);
4374 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4376 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4378 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4379 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4382 print_vma (section
->sh_addralign
, DEC
);
4386 else if (do_section_details
)
4388 printf (" %-15.15s ",
4389 get_section_type_name (section
->sh_type
));
4390 print_vma (section
->sh_addr
, LONG_HEX
);
4391 if ((long) section
->sh_offset
== section
->sh_offset
)
4392 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4396 print_vma (section
->sh_offset
, LONG_HEX
);
4398 printf (" %u\n ", section
->sh_link
);
4399 print_vma (section
->sh_size
, LONG_HEX
);
4401 print_vma (section
->sh_entsize
, LONG_HEX
);
4403 printf (" %-16u %lu\n",
4405 (unsigned long) section
->sh_addralign
);
4410 print_vma (section
->sh_addr
, LONG_HEX
);
4411 if ((long) section
->sh_offset
== section
->sh_offset
)
4412 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4416 print_vma (section
->sh_offset
, LONG_HEX
);
4419 print_vma (section
->sh_size
, LONG_HEX
);
4421 print_vma (section
->sh_entsize
, LONG_HEX
);
4423 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4425 printf (" %2u %3u %lu\n",
4428 (unsigned long) section
->sh_addralign
);
4431 if (do_section_details
)
4432 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4435 if (!do_section_details
)
4436 printf (_("Key to Flags:\n\
4437 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4438 I (info), L (link order), G (group), x (unknown)\n\
4439 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4445 get_group_flags (unsigned int flags
)
4447 static char buff
[32];
4454 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4461 process_section_groups (FILE * file
)
4463 Elf_Internal_Shdr
* section
;
4465 struct group
* group
;
4466 Elf_Internal_Shdr
* symtab_sec
;
4467 Elf_Internal_Shdr
* strtab_sec
;
4468 Elf_Internal_Sym
* symtab
;
4472 /* Don't process section groups unless needed. */
4473 if (!do_unwind
&& !do_section_groups
)
4476 if (elf_header
.e_shnum
== 0)
4478 if (do_section_groups
)
4479 printf (_("\nThere are no sections in this file.\n"));
4484 if (section_headers
== NULL
)
4486 error (_("Section headers are not available!\n"));
4490 section_headers_groups
= calloc (elf_header
.e_shnum
,
4491 sizeof (struct group
*));
4493 if (section_headers_groups
== NULL
)
4495 error (_("Out of memory\n"));
4499 /* Scan the sections for the group section. */
4501 for (i
= 0, section
= section_headers
;
4502 i
< elf_header
.e_shnum
;
4504 if (section
->sh_type
== SHT_GROUP
)
4507 if (group_count
== 0)
4509 if (do_section_groups
)
4510 printf (_("\nThere are no section groups in this file.\n"));
4515 section_groups
= calloc (group_count
, sizeof (struct group
));
4517 if (section_groups
== NULL
)
4519 error (_("Out of memory\n"));
4528 for (i
= 0, section
= section_headers
, group
= section_groups
;
4529 i
< elf_header
.e_shnum
;
4532 if (section
->sh_type
== SHT_GROUP
)
4534 char * name
= SECTION_NAME (section
);
4536 unsigned char * start
;
4537 unsigned char * indices
;
4538 unsigned int entry
, j
, size
;
4539 Elf_Internal_Shdr
* sec
;
4540 Elf_Internal_Sym
* sym
;
4542 /* Get the symbol table. */
4543 if (section
->sh_link
>= elf_header
.e_shnum
4544 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4547 error (_("Bad sh_link in group section `%s'\n"), name
);
4551 if (symtab_sec
!= sec
)
4556 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4559 sym
= symtab
+ section
->sh_info
;
4561 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4563 if (sym
->st_shndx
== 0
4564 || sym
->st_shndx
>= elf_header
.e_shnum
)
4566 error (_("Bad sh_info in group section `%s'\n"), name
);
4570 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4579 /* Get the string table. */
4580 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4589 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4594 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4595 1, strtab_sec
->sh_size
,
4597 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4599 group_name
= sym
->st_name
< strtab_size
4600 ? strtab
+ sym
->st_name
: "<corrupt>";
4603 start
= get_data (NULL
, file
, section
->sh_offset
,
4604 1, section
->sh_size
, _("section data"));
4607 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4608 entry
= byte_get (indices
, 4);
4611 if (do_section_groups
)
4613 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4614 get_group_flags (entry
), i
, name
, group_name
, size
);
4616 printf (_(" [Index] Name\n"));
4619 group
->group_index
= i
;
4621 for (j
= 0; j
< size
; j
++)
4623 struct group_list
* g
;
4625 entry
= byte_get (indices
, 4);
4628 if (entry
>= elf_header
.e_shnum
)
4630 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4631 entry
, i
, elf_header
.e_shnum
- 1);
4635 if (section_headers_groups
[entry
] != NULL
)
4639 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4641 section_headers_groups
[entry
]->group_index
);
4646 /* Intel C/C++ compiler may put section 0 in a
4647 section group. We just warn it the first time
4648 and ignore it afterwards. */
4649 static int warned
= 0;
4652 error (_("section 0 in group section [%5u]\n"),
4653 section_headers_groups
[entry
]->group_index
);
4659 section_headers_groups
[entry
] = group
;
4661 if (do_section_groups
)
4663 sec
= section_headers
+ entry
;
4664 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4667 g
= xmalloc (sizeof (struct group_list
));
4668 g
->section_index
= entry
;
4669 g
->next
= group
->root
;
4693 } dynamic_relocations
[] =
4695 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4696 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4697 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4700 /* Process the reloc section. */
4703 process_relocs (FILE * file
)
4705 unsigned long rel_size
;
4706 unsigned long rel_offset
;
4712 if (do_using_dynamic
)
4716 int has_dynamic_reloc
;
4719 has_dynamic_reloc
= 0;
4721 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4723 is_rela
= dynamic_relocations
[i
].rela
;
4724 name
= dynamic_relocations
[i
].name
;
4725 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4726 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4728 has_dynamic_reloc
|= rel_size
;
4730 if (is_rela
== UNKNOWN
)
4732 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4733 switch (dynamic_info
[DT_PLTREL
])
4747 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4748 name
, rel_offset
, rel_size
);
4750 dump_relocations (file
,
4751 offset_from_vma (file
, rel_offset
, rel_size
),
4753 dynamic_symbols
, num_dynamic_syms
,
4754 dynamic_strings
, dynamic_strings_length
, is_rela
);
4758 if (! has_dynamic_reloc
)
4759 printf (_("\nThere are no dynamic relocations in this file.\n"));
4763 Elf_Internal_Shdr
* section
;
4767 for (i
= 0, section
= section_headers
;
4768 i
< elf_header
.e_shnum
;
4771 if ( section
->sh_type
!= SHT_RELA
4772 && section
->sh_type
!= SHT_REL
)
4775 rel_offset
= section
->sh_offset
;
4776 rel_size
= section
->sh_size
;
4780 Elf_Internal_Shdr
* strsec
;
4783 printf (_("\nRelocation section "));
4785 if (string_table
== NULL
)
4786 printf ("%d", section
->sh_name
);
4788 printf (_("'%s'"), SECTION_NAME (section
));
4790 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4791 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4793 is_rela
= section
->sh_type
== SHT_RELA
;
4795 if (section
->sh_link
!= 0
4796 && section
->sh_link
< elf_header
.e_shnum
)
4798 Elf_Internal_Shdr
* symsec
;
4799 Elf_Internal_Sym
* symtab
;
4800 unsigned long nsyms
;
4801 unsigned long strtablen
= 0;
4802 char * strtab
= NULL
;
4804 symsec
= section_headers
+ section
->sh_link
;
4805 if (symsec
->sh_type
!= SHT_SYMTAB
4806 && symsec
->sh_type
!= SHT_DYNSYM
)
4809 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4810 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4815 if (symsec
->sh_link
!= 0
4816 && symsec
->sh_link
< elf_header
.e_shnum
)
4818 strsec
= section_headers
+ symsec
->sh_link
;
4820 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4823 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4826 dump_relocations (file
, rel_offset
, rel_size
,
4827 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4833 dump_relocations (file
, rel_offset
, rel_size
,
4834 NULL
, 0, NULL
, 0, is_rela
);
4841 printf (_("\nThere are no relocations in this file.\n"));
4847 /* Process the unwind section. */
4849 #include "unwind-ia64.h"
4851 /* An absolute address consists of a section and an offset. If the
4852 section is NULL, the offset itself is the address, otherwise, the
4853 address equals to LOAD_ADDRESS(section) + offset. */
4857 unsigned short section
;
4861 #define ABSADDR(a) \
4863 ? section_headers [(a).section].sh_addr + (a).offset \
4866 struct ia64_unw_aux_info
4868 struct ia64_unw_table_entry
4870 struct absaddr start
;
4872 struct absaddr info
;
4874 *table
; /* Unwind table. */
4875 unsigned long table_len
; /* Length of unwind table. */
4876 unsigned char * info
; /* Unwind info. */
4877 unsigned long info_size
; /* Size of unwind info. */
4878 bfd_vma info_addr
; /* starting address of unwind info. */
4879 bfd_vma seg_base
; /* Starting address of segment. */
4880 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4881 unsigned long nsyms
; /* Number of symbols. */
4882 char * strtab
; /* The string table. */
4883 unsigned long strtab_size
; /* Size of string table. */
4887 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4888 unsigned long nsyms
,
4889 const char * strtab
,
4890 unsigned long strtab_size
,
4891 struct absaddr addr
,
4892 const char ** symname
,
4895 bfd_vma dist
= 0x100000;
4896 Elf_Internal_Sym
* sym
;
4897 Elf_Internal_Sym
* best
= NULL
;
4900 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4902 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4903 && sym
->st_name
!= 0
4904 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4905 && addr
.offset
>= sym
->st_value
4906 && addr
.offset
- sym
->st_value
< dist
)
4909 dist
= addr
.offset
- sym
->st_value
;
4916 *symname
= (best
->st_name
>= strtab_size
4917 ? "<corrupt>" : strtab
+ best
->st_name
);
4922 *offset
= addr
.offset
;
4926 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
4928 struct ia64_unw_table_entry
* tp
;
4931 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4935 const unsigned char * dp
;
4936 const unsigned char * head
;
4937 const char * procname
;
4939 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4940 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4942 fputs ("\n<", stdout
);
4946 fputs (procname
, stdout
);
4949 printf ("+%lx", (unsigned long) offset
);
4952 fputs (">: [", stdout
);
4953 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4954 fputc ('-', stdout
);
4955 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4956 printf ("], info at +0x%lx\n",
4957 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4959 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4960 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4962 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4963 (unsigned) UNW_VER (stamp
),
4964 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4965 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4966 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4967 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4969 if (UNW_VER (stamp
) != 1)
4971 printf ("\tUnknown version.\n");
4976 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4977 dp
= unw_decode (dp
, in_body
, & in_body
);
4982 slurp_ia64_unwind_table (FILE * file
,
4983 struct ia64_unw_aux_info
* aux
,
4984 Elf_Internal_Shdr
* sec
)
4986 unsigned long size
, nrelas
, i
;
4987 Elf_Internal_Phdr
* seg
;
4988 struct ia64_unw_table_entry
* tep
;
4989 Elf_Internal_Shdr
* relsec
;
4990 Elf_Internal_Rela
* rela
;
4991 Elf_Internal_Rela
* rp
;
4992 unsigned char * table
;
4994 Elf_Internal_Sym
* sym
;
4995 const char * relname
;
4997 /* First, find the starting address of the segment that includes
5000 if (elf_header
.e_phnum
)
5002 if (! get_program_headers (file
))
5005 for (seg
= program_headers
;
5006 seg
< program_headers
+ elf_header
.e_phnum
;
5009 if (seg
->p_type
!= PT_LOAD
)
5012 if (sec
->sh_addr
>= seg
->p_vaddr
5013 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5015 aux
->seg_base
= seg
->p_vaddr
;
5021 /* Second, build the unwind table from the contents of the unwind section: */
5022 size
= sec
->sh_size
;
5023 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5027 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5029 for (tp
= table
; tp
< table
+ size
; ++tep
)
5031 tep
->start
.section
= SHN_UNDEF
;
5032 tep
->end
.section
= SHN_UNDEF
;
5033 tep
->info
.section
= SHN_UNDEF
;
5034 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5035 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5036 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5037 tep
->start
.offset
+= aux
->seg_base
;
5038 tep
->end
.offset
+= aux
->seg_base
;
5039 tep
->info
.offset
+= aux
->seg_base
;
5043 /* Third, apply any relocations to the unwind table: */
5044 for (relsec
= section_headers
;
5045 relsec
< section_headers
+ elf_header
.e_shnum
;
5048 if (relsec
->sh_type
!= SHT_RELA
5049 || relsec
->sh_info
>= elf_header
.e_shnum
5050 || section_headers
+ relsec
->sh_info
!= sec
)
5053 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5057 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5059 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5060 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5062 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5064 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5068 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5070 switch (rp
->r_offset
/eh_addr_size
% 3)
5073 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5074 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5077 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5078 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5081 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5082 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5092 aux
->table_len
= size
/ (3 * eh_addr_size
);
5097 ia64_process_unwind (FILE * file
)
5099 Elf_Internal_Shdr
* sec
;
5100 Elf_Internal_Shdr
* unwsec
= NULL
;
5101 Elf_Internal_Shdr
* strsec
;
5102 unsigned long i
, unwcount
= 0, unwstart
= 0;
5103 struct ia64_unw_aux_info aux
;
5105 memset (& aux
, 0, sizeof (aux
));
5107 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5109 if (sec
->sh_type
== SHT_SYMTAB
5110 && sec
->sh_link
< elf_header
.e_shnum
)
5112 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5113 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5115 strsec
= section_headers
+ sec
->sh_link
;
5116 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5117 1, strsec
->sh_size
, _("string table"));
5118 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5120 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5125 printf (_("\nThere are no unwind sections in this file.\n"));
5127 while (unwcount
-- > 0)
5132 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5133 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5134 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5141 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5143 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5145 /* We need to find which section group it is in. */
5146 struct group_list
* g
= section_headers_groups
[i
]->root
;
5148 for (; g
!= NULL
; g
= g
->next
)
5150 sec
= section_headers
+ g
->section_index
;
5152 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5157 i
= elf_header
.e_shnum
;
5159 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5161 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5162 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5163 suffix
= SECTION_NAME (unwsec
) + len
;
5164 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5166 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5167 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5172 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5173 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5174 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5175 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5177 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5178 suffix
= SECTION_NAME (unwsec
) + len
;
5179 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5181 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5182 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5186 if (i
== elf_header
.e_shnum
)
5188 printf (_("\nCould not find unwind info section for "));
5190 if (string_table
== NULL
)
5191 printf ("%d", unwsec
->sh_name
);
5193 printf (_("'%s'"), SECTION_NAME (unwsec
));
5197 aux
.info_size
= sec
->sh_size
;
5198 aux
.info_addr
= sec
->sh_addr
;
5199 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5202 printf (_("\nUnwind section "));
5204 if (string_table
== NULL
)
5205 printf ("%d", unwsec
->sh_name
);
5207 printf (_("'%s'"), SECTION_NAME (unwsec
));
5209 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5210 (unsigned long) unwsec
->sh_offset
,
5211 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5213 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5215 if (aux
.table_len
> 0)
5216 dump_ia64_unwind (& aux
);
5219 free ((char *) aux
.table
);
5221 free ((char *) aux
.info
);
5230 free ((char *) aux
.strtab
);
5235 struct hppa_unw_aux_info
5237 struct hppa_unw_table_entry
5239 struct absaddr start
;
5241 unsigned int Cannot_unwind
:1; /* 0 */
5242 unsigned int Millicode
:1; /* 1 */
5243 unsigned int Millicode_save_sr0
:1; /* 2 */
5244 unsigned int Region_description
:2; /* 3..4 */
5245 unsigned int reserved1
:1; /* 5 */
5246 unsigned int Entry_SR
:1; /* 6 */
5247 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5248 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5249 unsigned int Args_stored
:1; /* 16 */
5250 unsigned int Variable_Frame
:1; /* 17 */
5251 unsigned int Separate_Package_Body
:1; /* 18 */
5252 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5253 unsigned int Stack_Overflow_Check
:1; /* 20 */
5254 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5255 unsigned int Ada_Region
:1; /* 22 */
5256 unsigned int cxx_info
:1; /* 23 */
5257 unsigned int cxx_try_catch
:1; /* 24 */
5258 unsigned int sched_entry_seq
:1; /* 25 */
5259 unsigned int reserved2
:1; /* 26 */
5260 unsigned int Save_SP
:1; /* 27 */
5261 unsigned int Save_RP
:1; /* 28 */
5262 unsigned int Save_MRP_in_frame
:1; /* 29 */
5263 unsigned int extn_ptr_defined
:1; /* 30 */
5264 unsigned int Cleanup_defined
:1; /* 31 */
5266 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5267 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5268 unsigned int Large_frame
:1; /* 2 */
5269 unsigned int Pseudo_SP_Set
:1; /* 3 */
5270 unsigned int reserved4
:1; /* 4 */
5271 unsigned int Total_frame_size
:27; /* 5..31 */
5273 *table
; /* Unwind table. */
5274 unsigned long table_len
; /* Length of unwind table. */
5275 bfd_vma seg_base
; /* Starting address of segment. */
5276 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5277 unsigned long nsyms
; /* Number of symbols. */
5278 char * strtab
; /* The string table. */
5279 unsigned long strtab_size
; /* Size of string table. */
5283 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5285 struct hppa_unw_table_entry
* tp
;
5287 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5290 const char * procname
;
5292 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5293 aux
->strtab_size
, tp
->start
, &procname
,
5296 fputs ("\n<", stdout
);
5300 fputs (procname
, stdout
);
5303 printf ("+%lx", (unsigned long) offset
);
5306 fputs (">: [", stdout
);
5307 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5308 fputc ('-', stdout
);
5309 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5312 #define PF(_m) if (tp->_m) printf (#_m " ");
5313 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5316 PF(Millicode_save_sr0
);
5317 /* PV(Region_description); */
5323 PF(Separate_Package_Body
);
5324 PF(Frame_Extension_Millicode
);
5325 PF(Stack_Overflow_Check
);
5326 PF(Two_Instruction_SP_Increment
);
5330 PF(sched_entry_seq
);
5333 PF(Save_MRP_in_frame
);
5334 PF(extn_ptr_defined
);
5335 PF(Cleanup_defined
);
5336 PF(MPE_XL_interrupt_marker
);
5337 PF(HP_UX_interrupt_marker
);
5340 PV(Total_frame_size
);
5349 slurp_hppa_unwind_table (FILE * file
,
5350 struct hppa_unw_aux_info
* aux
,
5351 Elf_Internal_Shdr
* sec
)
5353 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5354 Elf_Internal_Phdr
* seg
;
5355 struct hppa_unw_table_entry
* tep
;
5356 Elf_Internal_Shdr
* relsec
;
5357 Elf_Internal_Rela
* rela
;
5358 Elf_Internal_Rela
* rp
;
5359 unsigned char * table
;
5361 Elf_Internal_Sym
* sym
;
5362 const char * relname
;
5364 /* First, find the starting address of the segment that includes
5367 if (elf_header
.e_phnum
)
5369 if (! get_program_headers (file
))
5372 for (seg
= program_headers
;
5373 seg
< program_headers
+ elf_header
.e_phnum
;
5376 if (seg
->p_type
!= PT_LOAD
)
5379 if (sec
->sh_addr
>= seg
->p_vaddr
5380 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5382 aux
->seg_base
= seg
->p_vaddr
;
5388 /* Second, build the unwind table from the contents of the unwind
5390 size
= sec
->sh_size
;
5391 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5396 nentries
= size
/ unw_ent_size
;
5397 size
= unw_ent_size
* nentries
;
5399 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5401 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5403 unsigned int tmp1
, tmp2
;
5405 tep
->start
.section
= SHN_UNDEF
;
5406 tep
->end
.section
= SHN_UNDEF
;
5408 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5409 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5410 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5411 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5413 tep
->start
.offset
+= aux
->seg_base
;
5414 tep
->end
.offset
+= aux
->seg_base
;
5416 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5417 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5418 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5419 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5420 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5421 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5422 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5423 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5424 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5425 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5426 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5427 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5428 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5429 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5430 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5431 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5432 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5433 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5434 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5435 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5436 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5437 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5438 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5439 tep
->Cleanup_defined
= tmp1
& 0x1;
5441 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5442 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5443 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5444 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5445 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5446 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5450 /* Third, apply any relocations to the unwind table. */
5451 for (relsec
= section_headers
;
5452 relsec
< section_headers
+ elf_header
.e_shnum
;
5455 if (relsec
->sh_type
!= SHT_RELA
5456 || relsec
->sh_info
>= elf_header
.e_shnum
5457 || section_headers
+ relsec
->sh_info
!= sec
)
5460 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5464 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5466 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5467 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5469 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5470 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5472 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5476 i
= rp
->r_offset
/ unw_ent_size
;
5478 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5481 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5482 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5485 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5486 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5496 aux
->table_len
= nentries
;
5502 hppa_process_unwind (FILE * file
)
5504 struct hppa_unw_aux_info aux
;
5505 Elf_Internal_Shdr
* unwsec
= NULL
;
5506 Elf_Internal_Shdr
* strsec
;
5507 Elf_Internal_Shdr
* sec
;
5510 memset (& aux
, 0, sizeof (aux
));
5512 if (string_table
== NULL
)
5515 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5517 if (sec
->sh_type
== SHT_SYMTAB
5518 && sec
->sh_link
< elf_header
.e_shnum
)
5520 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5521 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5523 strsec
= section_headers
+ sec
->sh_link
;
5524 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5525 1, strsec
->sh_size
, _("string table"));
5526 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5528 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5533 printf (_("\nThere are no unwind sections in this file.\n"));
5535 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5537 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5539 printf (_("\nUnwind section "));
5540 printf (_("'%s'"), SECTION_NAME (sec
));
5542 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5543 (unsigned long) sec
->sh_offset
,
5544 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5546 slurp_hppa_unwind_table (file
, &aux
, sec
);
5547 if (aux
.table_len
> 0)
5548 dump_hppa_unwind (&aux
);
5551 free ((char *) aux
.table
);
5559 free ((char *) aux
.strtab
);
5565 process_unwind (FILE * file
)
5567 struct unwind_handler
5570 int (* handler
)(FILE *);
5573 { EM_IA_64
, ia64_process_unwind
},
5574 { EM_PARISC
, hppa_process_unwind
},
5582 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5583 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5584 return handlers
[i
].handler (file
);
5586 printf (_("\nThere are no unwind sections in this file.\n"));
5591 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5593 switch (entry
->d_tag
)
5596 if (entry
->d_un
.d_val
== 0)
5600 static const char * opts
[] =
5602 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5603 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5604 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5605 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5610 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5611 if (entry
->d_un
.d_val
& (1 << cnt
))
5613 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5620 case DT_MIPS_IVERSION
:
5621 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5622 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5624 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5627 case DT_MIPS_TIME_STAMP
:
5632 time_t time
= entry
->d_un
.d_val
;
5633 tmp
= gmtime (&time
);
5634 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5635 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5636 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5637 printf ("Time Stamp: %s\n", timebuf
);
5641 case DT_MIPS_RLD_VERSION
:
5642 case DT_MIPS_LOCAL_GOTNO
:
5643 case DT_MIPS_CONFLICTNO
:
5644 case DT_MIPS_LIBLISTNO
:
5645 case DT_MIPS_SYMTABNO
:
5646 case DT_MIPS_UNREFEXTNO
:
5647 case DT_MIPS_HIPAGENO
:
5648 case DT_MIPS_DELTA_CLASS_NO
:
5649 case DT_MIPS_DELTA_INSTANCE_NO
:
5650 case DT_MIPS_DELTA_RELOC_NO
:
5651 case DT_MIPS_DELTA_SYM_NO
:
5652 case DT_MIPS_DELTA_CLASSSYM_NO
:
5653 case DT_MIPS_COMPACT_SIZE
:
5654 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5658 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5664 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5666 switch (entry
->d_tag
)
5668 case DT_HP_DLD_FLAGS
:
5677 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5678 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5679 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5680 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5681 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5682 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5683 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5684 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5685 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5686 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5687 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5688 { DT_HP_GST
, "HP_GST" },
5689 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5690 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5691 { DT_HP_NODELETE
, "HP_NODELETE" },
5692 { DT_HP_GROUP
, "HP_GROUP" },
5693 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5697 bfd_vma val
= entry
->d_un
.d_val
;
5699 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5700 if (val
& flags
[cnt
].bit
)
5704 fputs (flags
[cnt
].str
, stdout
);
5706 val
^= flags
[cnt
].bit
;
5709 if (val
!= 0 || first
)
5713 print_vma (val
, HEX
);
5719 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5726 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5728 switch (entry
->d_tag
)
5730 case DT_IA_64_PLT_RESERVE
:
5731 /* First 3 slots reserved. */
5732 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5734 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5738 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5745 get_32bit_dynamic_section (FILE * file
)
5747 Elf32_External_Dyn
* edyn
;
5748 Elf32_External_Dyn
* ext
;
5749 Elf_Internal_Dyn
* entry
;
5751 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5752 _("dynamic section"));
5756 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5757 might not have the luxury of section headers. Look for the DT_NULL
5758 terminator to determine the number of entries. */
5759 for (ext
= edyn
, dynamic_nent
= 0;
5760 (char *) ext
< (char *) edyn
+ dynamic_size
;
5764 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5768 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5769 if (dynamic_section
== NULL
)
5771 error (_("Out of memory\n"));
5776 for (ext
= edyn
, entry
= dynamic_section
;
5777 entry
< dynamic_section
+ dynamic_nent
;
5780 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5781 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5790 get_64bit_dynamic_section (FILE * file
)
5792 Elf64_External_Dyn
* edyn
;
5793 Elf64_External_Dyn
* ext
;
5794 Elf_Internal_Dyn
* entry
;
5796 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5797 _("dynamic section"));
5801 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5802 might not have the luxury of section headers. Look for the DT_NULL
5803 terminator to determine the number of entries. */
5804 for (ext
= edyn
, dynamic_nent
= 0;
5805 (char *) ext
< (char *) edyn
+ dynamic_size
;
5809 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5813 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5814 if (dynamic_section
== NULL
)
5816 error (_("Out of memory\n"));
5821 for (ext
= edyn
, entry
= dynamic_section
;
5822 entry
< dynamic_section
+ dynamic_nent
;
5825 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5826 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5835 print_dynamic_flags (bfd_vma flags
)
5843 flag
= flags
& - flags
;
5853 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5854 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5855 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5856 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5857 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5858 default: fputs ("unknown", stdout
); break;
5864 /* Parse and display the contents of the dynamic section. */
5867 process_dynamic_section (FILE * file
)
5869 Elf_Internal_Dyn
* entry
;
5871 if (dynamic_size
== 0)
5874 printf (_("\nThere is no dynamic section in this file.\n"));
5881 if (! get_32bit_dynamic_section (file
))
5884 else if (! get_64bit_dynamic_section (file
))
5887 /* Find the appropriate symbol table. */
5888 if (dynamic_symbols
== NULL
)
5890 for (entry
= dynamic_section
;
5891 entry
< dynamic_section
+ dynamic_nent
;
5894 Elf_Internal_Shdr section
;
5896 if (entry
->d_tag
!= DT_SYMTAB
)
5899 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5901 /* Since we do not know how big the symbol table is,
5902 we default to reading in the entire file (!) and
5903 processing that. This is overkill, I know, but it
5905 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5907 if (archive_file_offset
!= 0)
5908 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5911 if (fseek (file
, 0, SEEK_END
))
5912 error (_("Unable to seek to end of file!\n"));
5914 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5918 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5920 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5922 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5923 if (num_dynamic_syms
< 1)
5925 error (_("Unable to determine the number of symbols to load\n"));
5929 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5933 /* Similarly find a string table. */
5934 if (dynamic_strings
== NULL
)
5936 for (entry
= dynamic_section
;
5937 entry
< dynamic_section
+ dynamic_nent
;
5940 unsigned long offset
;
5943 if (entry
->d_tag
!= DT_STRTAB
)
5946 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5948 /* Since we do not know how big the string table is,
5949 we default to reading in the entire file (!) and
5950 processing that. This is overkill, I know, but it
5953 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5955 if (archive_file_offset
!= 0)
5956 str_tab_len
= archive_file_size
- offset
;
5959 if (fseek (file
, 0, SEEK_END
))
5960 error (_("Unable to seek to end of file\n"));
5961 str_tab_len
= ftell (file
) - offset
;
5964 if (str_tab_len
< 1)
5967 (_("Unable to determine the length of the dynamic string table\n"));
5971 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5972 _("dynamic string table"));
5973 dynamic_strings_length
= str_tab_len
;
5978 /* And find the syminfo section if available. */
5979 if (dynamic_syminfo
== NULL
)
5981 unsigned long syminsz
= 0;
5983 for (entry
= dynamic_section
;
5984 entry
< dynamic_section
+ dynamic_nent
;
5987 if (entry
->d_tag
== DT_SYMINENT
)
5989 /* Note: these braces are necessary to avoid a syntax
5990 error from the SunOS4 C compiler. */
5991 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5993 else if (entry
->d_tag
== DT_SYMINSZ
)
5994 syminsz
= entry
->d_un
.d_val
;
5995 else if (entry
->d_tag
== DT_SYMINFO
)
5996 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6000 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6002 Elf_External_Syminfo
* extsyminfo
;
6003 Elf_External_Syminfo
* extsym
;
6004 Elf_Internal_Syminfo
* syminfo
;
6006 /* There is a syminfo section. Read the data. */
6007 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
6008 syminsz
, _("symbol information"));
6012 dynamic_syminfo
= malloc (syminsz
);
6013 if (dynamic_syminfo
== NULL
)
6015 error (_("Out of memory\n"));
6019 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6020 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6021 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6022 ++syminfo
, ++extsym
)
6024 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6025 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6032 if (do_dynamic
&& dynamic_addr
)
6033 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6034 dynamic_addr
, dynamic_nent
);
6036 printf (_(" Tag Type Name/Value\n"));
6038 for (entry
= dynamic_section
;
6039 entry
< dynamic_section
+ dynamic_nent
;
6047 print_vma (entry
->d_tag
, FULL_HEX
);
6048 dtype
= get_dynamic_type (entry
->d_tag
);
6049 printf (" (%s)%*s", dtype
,
6050 ((is_32bit_elf
? 27 : 19)
6051 - (int) strlen (dtype
)),
6055 switch (entry
->d_tag
)
6059 print_dynamic_flags (entry
->d_un
.d_val
);
6069 switch (entry
->d_tag
)
6072 printf (_("Auxiliary library"));
6076 printf (_("Filter library"));
6080 printf (_("Configuration file"));
6084 printf (_("Dependency audit library"));
6088 printf (_("Audit library"));
6092 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6093 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6097 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6106 printf (_("Flags:"));
6108 if (entry
->d_un
.d_val
== 0)
6109 printf (_(" None\n"));
6112 unsigned long int val
= entry
->d_un
.d_val
;
6114 if (val
& DTF_1_PARINIT
)
6116 printf (" PARINIT");
6117 val
^= DTF_1_PARINIT
;
6119 if (val
& DTF_1_CONFEXP
)
6121 printf (" CONFEXP");
6122 val
^= DTF_1_CONFEXP
;
6125 printf (" %lx", val
);
6134 printf (_("Flags:"));
6136 if (entry
->d_un
.d_val
== 0)
6137 printf (_(" None\n"));
6140 unsigned long int val
= entry
->d_un
.d_val
;
6142 if (val
& DF_P1_LAZYLOAD
)
6144 printf (" LAZYLOAD");
6145 val
^= DF_P1_LAZYLOAD
;
6147 if (val
& DF_P1_GROUPPERM
)
6149 printf (" GROUPPERM");
6150 val
^= DF_P1_GROUPPERM
;
6153 printf (" %lx", val
);
6162 printf (_("Flags:"));
6163 if (entry
->d_un
.d_val
== 0)
6164 printf (_(" None\n"));
6167 unsigned long int val
= entry
->d_un
.d_val
;
6174 if (val
& DF_1_GLOBAL
)
6179 if (val
& DF_1_GROUP
)
6184 if (val
& DF_1_NODELETE
)
6186 printf (" NODELETE");
6187 val
^= DF_1_NODELETE
;
6189 if (val
& DF_1_LOADFLTR
)
6191 printf (" LOADFLTR");
6192 val
^= DF_1_LOADFLTR
;
6194 if (val
& DF_1_INITFIRST
)
6196 printf (" INITFIRST");
6197 val
^= DF_1_INITFIRST
;
6199 if (val
& DF_1_NOOPEN
)
6204 if (val
& DF_1_ORIGIN
)
6209 if (val
& DF_1_DIRECT
)
6214 if (val
& DF_1_TRANS
)
6219 if (val
& DF_1_INTERPOSE
)
6221 printf (" INTERPOSE");
6222 val
^= DF_1_INTERPOSE
;
6224 if (val
& DF_1_NODEFLIB
)
6226 printf (" NODEFLIB");
6227 val
^= DF_1_NODEFLIB
;
6229 if (val
& DF_1_NODUMP
)
6234 if (val
& DF_1_CONLFAT
)
6236 printf (" CONLFAT");
6237 val
^= DF_1_CONLFAT
;
6240 printf (" %lx", val
);
6247 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6249 puts (get_dynamic_type (entry
->d_un
.d_val
));
6269 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6275 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6276 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6282 switch (entry
->d_tag
)
6285 printf (_("Shared library: [%s]"), name
);
6287 if (streq (name
, program_interpreter
))
6288 printf (_(" program interpreter"));
6292 printf (_("Library soname: [%s]"), name
);
6296 printf (_("Library rpath: [%s]"), name
);
6300 printf (_("Library runpath: [%s]"), name
);
6304 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6309 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6322 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6326 case DT_INIT_ARRAYSZ
:
6327 case DT_FINI_ARRAYSZ
:
6328 case DT_GNU_CONFLICTSZ
:
6329 case DT_GNU_LIBLISTSZ
:
6332 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6333 printf (" (bytes)\n");
6343 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6356 if (entry
->d_tag
== DT_USED
6357 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6359 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6363 printf (_("Not needed object: [%s]\n"), name
);
6368 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6374 /* The value of this entry is ignored. */
6379 case DT_GNU_PRELINKED
:
6383 time_t time
= entry
->d_un
.d_val
;
6385 tmp
= gmtime (&time
);
6386 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6387 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6388 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6394 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6397 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6403 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6404 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6409 switch (elf_header
.e_machine
)
6412 case EM_MIPS_RS3_LE
:
6413 dynamic_section_mips_val (entry
);
6416 dynamic_section_parisc_val (entry
);
6419 dynamic_section_ia64_val (entry
);
6422 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6434 get_ver_flags (unsigned int flags
)
6436 static char buff
[32];
6443 if (flags
& VER_FLG_BASE
)
6444 strcat (buff
, "BASE ");
6446 if (flags
& VER_FLG_WEAK
)
6448 if (flags
& VER_FLG_BASE
)
6449 strcat (buff
, "| ");
6451 strcat (buff
, "WEAK ");
6454 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6455 strcat (buff
, "| <unknown>");
6460 /* Display the contents of the version sections. */
6463 process_version_sections (FILE * file
)
6465 Elf_Internal_Shdr
* section
;
6472 for (i
= 0, section
= section_headers
;
6473 i
< elf_header
.e_shnum
;
6476 switch (section
->sh_type
)
6478 case SHT_GNU_verdef
:
6480 Elf_External_Verdef
* edefs
;
6488 (_("\nVersion definition section '%s' contains %u entries:\n"),
6489 SECTION_NAME (section
), section
->sh_info
);
6491 printf (_(" Addr: 0x"));
6492 printf_vma (section
->sh_addr
);
6493 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6494 (unsigned long) section
->sh_offset
, section
->sh_link
,
6495 section
->sh_link
< elf_header
.e_shnum
6496 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6499 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6501 _("version definition section"));
6502 endbuf
= (char *) edefs
+ section
->sh_size
;
6506 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6509 Elf_External_Verdef
* edef
;
6510 Elf_Internal_Verdef ent
;
6511 Elf_External_Verdaux
* eaux
;
6512 Elf_Internal_Verdaux aux
;
6516 vstart
= ((char *) edefs
) + idx
;
6517 if (vstart
+ sizeof (*edef
) > endbuf
)
6520 edef
= (Elf_External_Verdef
*) vstart
;
6522 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6523 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6524 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6525 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6526 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6527 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6528 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6530 printf (_(" %#06x: Rev: %d Flags: %s"),
6531 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6533 printf (_(" Index: %d Cnt: %d "),
6534 ent
.vd_ndx
, ent
.vd_cnt
);
6536 vstart
+= ent
.vd_aux
;
6538 eaux
= (Elf_External_Verdaux
*) vstart
;
6540 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6541 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6543 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6544 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6546 printf (_("Name index: %ld\n"), aux
.vda_name
);
6548 isum
= idx
+ ent
.vd_aux
;
6550 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6552 isum
+= aux
.vda_next
;
6553 vstart
+= aux
.vda_next
;
6555 eaux
= (Elf_External_Verdaux
*) vstart
;
6556 if (vstart
+ sizeof (*eaux
) > endbuf
)
6559 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6560 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6562 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6563 printf (_(" %#06x: Parent %d: %s\n"),
6564 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6566 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6567 isum
, j
, aux
.vda_name
);
6570 printf (_(" Version def aux past end of section\n"));
6574 if (cnt
< section
->sh_info
)
6575 printf (_(" Version definition past end of section\n"));
6581 case SHT_GNU_verneed
:
6583 Elf_External_Verneed
* eneed
;
6590 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6591 SECTION_NAME (section
), section
->sh_info
);
6593 printf (_(" Addr: 0x"));
6594 printf_vma (section
->sh_addr
);
6595 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6596 (unsigned long) section
->sh_offset
, section
->sh_link
,
6597 section
->sh_link
< elf_header
.e_shnum
6598 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6601 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6603 _("version need section"));
6604 endbuf
= (char *) eneed
+ section
->sh_size
;
6608 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6610 Elf_External_Verneed
* entry
;
6611 Elf_Internal_Verneed ent
;
6616 vstart
= ((char *) eneed
) + idx
;
6617 if (vstart
+ sizeof (*entry
) > endbuf
)
6620 entry
= (Elf_External_Verneed
*) vstart
;
6622 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6623 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6624 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6625 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6626 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6628 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6630 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6631 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6633 printf (_(" File: %lx"), ent
.vn_file
);
6635 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6637 vstart
+= ent
.vn_aux
;
6639 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6641 Elf_External_Vernaux
* eaux
;
6642 Elf_Internal_Vernaux aux
;
6644 if (vstart
+ sizeof (*eaux
) > endbuf
)
6646 eaux
= (Elf_External_Vernaux
*) vstart
;
6648 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6649 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6650 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6651 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6652 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6654 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6655 printf (_(" %#06x: Name: %s"),
6656 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6658 printf (_(" %#06x: Name index: %lx"),
6659 isum
, aux
.vna_name
);
6661 printf (_(" Flags: %s Version: %d\n"),
6662 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6664 isum
+= aux
.vna_next
;
6665 vstart
+= aux
.vna_next
;
6668 printf (_(" Version need aux past end of section\n"));
6672 if (cnt
< section
->sh_info
)
6673 printf (_(" Version need past end of section\n"));
6679 case SHT_GNU_versym
:
6681 Elf_Internal_Shdr
* link_section
;
6684 unsigned char * edata
;
6685 unsigned short * data
;
6687 Elf_Internal_Sym
* symbols
;
6688 Elf_Internal_Shdr
* string_sec
;
6691 if (section
->sh_link
>= elf_header
.e_shnum
)
6694 link_section
= section_headers
+ section
->sh_link
;
6695 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6697 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6702 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6704 string_sec
= section_headers
+ link_section
->sh_link
;
6706 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6707 string_sec
->sh_size
, _("version string table"));
6711 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6712 SECTION_NAME (section
), total
);
6714 printf (_(" Addr: "));
6715 printf_vma (section
->sh_addr
);
6716 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6717 (unsigned long) section
->sh_offset
, section
->sh_link
,
6718 SECTION_NAME (link_section
));
6720 off
= offset_from_vma (file
,
6721 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6722 total
* sizeof (short));
6723 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6724 _("version symbol data"));
6731 data
= cmalloc (total
, sizeof (short));
6733 for (cnt
= total
; cnt
--;)
6734 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6739 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6742 int check_def
, check_need
;
6745 printf (" %03x:", cnt
);
6747 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6748 switch (data
[cnt
+ j
])
6751 fputs (_(" 0 (*local*) "), stdout
);
6755 fputs (_(" 1 (*global*) "), stdout
);
6759 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6760 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6764 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6765 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6768 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6775 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6777 Elf_Internal_Verneed ivn
;
6778 unsigned long offset
;
6780 offset
= offset_from_vma
6781 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6782 sizeof (Elf_External_Verneed
));
6786 Elf_Internal_Vernaux ivna
;
6787 Elf_External_Verneed evn
;
6788 Elf_External_Vernaux evna
;
6789 unsigned long a_off
;
6791 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6794 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6795 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6797 a_off
= offset
+ ivn
.vn_aux
;
6801 get_data (&evna
, file
, a_off
, sizeof (evna
),
6802 1, _("version need aux (2)"));
6804 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6805 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6807 a_off
+= ivna
.vna_next
;
6809 while (ivna
.vna_other
!= data
[cnt
+ j
]
6810 && ivna
.vna_next
!= 0);
6812 if (ivna
.vna_other
== data
[cnt
+ j
])
6814 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6816 if (ivna
.vna_name
>= string_sec
->sh_size
)
6817 name
= _("*invalid*");
6819 name
= strtab
+ ivna
.vna_name
;
6820 nn
+= printf ("(%s%-*s",
6822 12 - (int) strlen (name
),
6828 offset
+= ivn
.vn_next
;
6830 while (ivn
.vn_next
);
6833 if (check_def
&& data
[cnt
+ j
] != 0x8001
6834 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6836 Elf_Internal_Verdef ivd
;
6837 Elf_External_Verdef evd
;
6838 unsigned long offset
;
6840 offset
= offset_from_vma
6841 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6846 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6849 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6850 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6852 offset
+= ivd
.vd_next
;
6854 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6855 && ivd
.vd_next
!= 0);
6857 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6859 Elf_External_Verdaux evda
;
6860 Elf_Internal_Verdaux ivda
;
6862 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6864 get_data (&evda
, file
,
6865 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6867 _("version def aux"));
6869 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6871 if (ivda
.vda_name
>= string_sec
->sh_size
)
6872 name
= _("*invalid*");
6874 name
= strtab
+ ivda
.vda_name
;
6875 nn
+= printf ("(%s%-*s",
6877 12 - (int) strlen (name
),
6883 printf ("%*c", 18 - nn
, ' ');
6901 printf (_("\nNo version information found in this file.\n"));
6907 get_symbol_binding (unsigned int binding
)
6909 static char buff
[32];
6913 case STB_LOCAL
: return "LOCAL";
6914 case STB_GLOBAL
: return "GLOBAL";
6915 case STB_WEAK
: return "WEAK";
6917 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6918 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6920 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6922 if (binding
== STB_GNU_UNIQUE
6923 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
6924 /* GNU/Linux is still using the default value 0. */
6925 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
6927 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6930 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6936 get_symbol_type (unsigned int type
)
6938 static char buff
[32];
6942 case STT_NOTYPE
: return "NOTYPE";
6943 case STT_OBJECT
: return "OBJECT";
6944 case STT_FUNC
: return "FUNC";
6945 case STT_SECTION
: return "SECTION";
6946 case STT_FILE
: return "FILE";
6947 case STT_COMMON
: return "COMMON";
6948 case STT_TLS
: return "TLS";
6949 case STT_RELC
: return "RELC";
6950 case STT_SRELC
: return "SRELC";
6952 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6954 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6955 return "THUMB_FUNC";
6957 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6960 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6961 return "PARISC_MILLI";
6963 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6965 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6967 if (elf_header
.e_machine
== EM_PARISC
)
6969 if (type
== STT_HP_OPAQUE
)
6971 if (type
== STT_HP_STUB
)
6975 if (type
== STT_GNU_IFUNC
6976 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
6977 /* GNU/Linux is still using the default value 0. */
6978 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
6981 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6984 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6990 get_symbol_visibility (unsigned int visibility
)
6994 case STV_DEFAULT
: return "DEFAULT";
6995 case STV_INTERNAL
: return "INTERNAL";
6996 case STV_HIDDEN
: return "HIDDEN";
6997 case STV_PROTECTED
: return "PROTECTED";
7003 get_mips_symbol_other (unsigned int other
)
7007 case STO_OPTIONAL
: return "OPTIONAL";
7008 case STO_MIPS16
: return "MIPS16";
7009 case STO_MIPS_PLT
: return "MIPS PLT";
7010 case STO_MIPS_PIC
: return "MIPS PIC";
7011 default: return NULL
;
7016 get_symbol_other (unsigned int other
)
7018 const char * result
= NULL
;
7019 static char buff
[32];
7024 switch (elf_header
.e_machine
)
7027 result
= get_mips_symbol_other (other
);
7035 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7040 get_symbol_index_type (unsigned int type
)
7042 static char buff
[32];
7046 case SHN_UNDEF
: return "UND";
7047 case SHN_ABS
: return "ABS";
7048 case SHN_COMMON
: return "COM";
7050 if (type
== SHN_IA_64_ANSI_COMMON
7051 && elf_header
.e_machine
== EM_IA_64
7052 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7054 else if ((elf_header
.e_machine
== EM_X86_64
7055 || elf_header
.e_machine
== EM_L1OM
)
7056 && type
== SHN_X86_64_LCOMMON
)
7058 else if (type
== SHN_MIPS_SCOMMON
7059 && elf_header
.e_machine
== EM_MIPS
)
7061 else if (type
== SHN_MIPS_SUNDEFINED
7062 && elf_header
.e_machine
== EM_MIPS
)
7064 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7065 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7066 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7067 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7068 else if (type
>= SHN_LORESERVE
)
7069 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7071 sprintf (buff
, "%3d", type
);
7079 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7081 unsigned char * e_data
;
7084 e_data
= cmalloc (number
, ent_size
);
7088 error (_("Out of memory\n"));
7092 if (fread (e_data
, ent_size
, number
, file
) != number
)
7094 error (_("Unable to read in dynamic data\n"));
7098 i_data
= cmalloc (number
, sizeof (*i_data
));
7102 error (_("Out of memory\n"));
7108 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7116 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7118 Elf_Internal_Sym
* psym
;
7121 psym
= dynamic_symbols
+ si
;
7123 n
= print_vma (si
, DEC_5
);
7125 fputs (" " + n
, stdout
);
7126 printf (" %3lu: ", hn
);
7127 print_vma (psym
->st_value
, LONG_HEX
);
7129 print_vma (psym
->st_size
, DEC_5
);
7131 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7132 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7133 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7134 /* Check to see if any other bits in the st_other field are set.
7135 Note - displaying this information disrupts the layout of the
7136 table being generated, but for the moment this case is very
7138 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7139 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7140 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7141 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7142 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7144 printf (" <corrupt: %14ld>", psym
->st_name
);
7148 /* Dump the symbol table. */
7150 process_symbol_table (FILE * file
)
7152 Elf_Internal_Shdr
* section
;
7153 bfd_vma nbuckets
= 0;
7154 bfd_vma nchains
= 0;
7155 bfd_vma
* buckets
= NULL
;
7156 bfd_vma
* chains
= NULL
;
7157 bfd_vma ngnubuckets
= 0;
7158 bfd_vma
* gnubuckets
= NULL
;
7159 bfd_vma
* gnuchains
= NULL
;
7160 bfd_vma gnusymidx
= 0;
7162 if (! do_syms
&& !do_histogram
)
7165 if (dynamic_info
[DT_HASH
]
7167 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7169 unsigned char nb
[8];
7170 unsigned char nc
[8];
7171 int hash_ent_size
= 4;
7173 if ((elf_header
.e_machine
== EM_ALPHA
7174 || elf_header
.e_machine
== EM_S390
7175 || elf_header
.e_machine
== EM_S390_OLD
)
7176 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7180 (archive_file_offset
7181 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7182 sizeof nb
+ sizeof nc
)),
7185 error (_("Unable to seek to start of dynamic information\n"));
7189 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7191 error (_("Failed to read in number of buckets\n"));
7195 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7197 error (_("Failed to read in number of chains\n"));
7201 nbuckets
= byte_get (nb
, hash_ent_size
);
7202 nchains
= byte_get (nc
, hash_ent_size
);
7204 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7205 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7208 if (buckets
== NULL
|| chains
== NULL
)
7210 if (do_using_dynamic
)
7221 if (dynamic_info_DT_GNU_HASH
7223 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7225 unsigned char nb
[16];
7226 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7227 bfd_vma buckets_vma
;
7230 (archive_file_offset
7231 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7235 error (_("Unable to seek to start of dynamic information\n"));
7239 if (fread (nb
, 16, 1, file
) != 1)
7241 error (_("Failed to read in number of buckets\n"));
7245 ngnubuckets
= byte_get (nb
, 4);
7246 gnusymidx
= byte_get (nb
+ 4, 4);
7247 bitmaskwords
= byte_get (nb
+ 8, 4);
7248 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7250 buckets_vma
+= bitmaskwords
* 4;
7252 buckets_vma
+= bitmaskwords
* 8;
7255 (archive_file_offset
7256 + offset_from_vma (file
, buckets_vma
, 4)),
7259 error (_("Unable to seek to start of dynamic information\n"));
7263 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7265 if (gnubuckets
== NULL
)
7268 for (i
= 0; i
< ngnubuckets
; i
++)
7269 if (gnubuckets
[i
] != 0)
7271 if (gnubuckets
[i
] < gnusymidx
)
7274 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7275 maxchain
= gnubuckets
[i
];
7278 if (maxchain
== 0xffffffff)
7281 maxchain
-= gnusymidx
;
7284 (archive_file_offset
7285 + offset_from_vma (file
, buckets_vma
7286 + 4 * (ngnubuckets
+ maxchain
), 4)),
7289 error (_("Unable to seek to start of dynamic information\n"));
7295 if (fread (nb
, 4, 1, file
) != 1)
7297 error (_("Failed to determine last chain length\n"));
7301 if (maxchain
+ 1 == 0)
7306 while ((byte_get (nb
, 4) & 1) == 0);
7309 (archive_file_offset
7310 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7313 error (_("Unable to seek to start of dynamic information\n"));
7317 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7320 if (gnuchains
== NULL
)
7325 if (do_using_dynamic
)
7330 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7333 && dynamic_strings
!= NULL
)
7337 if (dynamic_info
[DT_HASH
])
7341 printf (_("\nSymbol table for image:\n"));
7343 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7345 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7347 for (hn
= 0; hn
< nbuckets
; hn
++)
7352 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7353 print_dynamic_symbol (si
, hn
);
7357 if (dynamic_info_DT_GNU_HASH
)
7359 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7361 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7363 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7365 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7366 if (gnubuckets
[hn
] != 0)
7368 bfd_vma si
= gnubuckets
[hn
];
7369 bfd_vma off
= si
- gnusymidx
;
7373 print_dynamic_symbol (si
, hn
);
7376 while ((gnuchains
[off
++] & 1) == 0);
7380 else if (do_syms
&& !do_using_dynamic
)
7384 for (i
= 0, section
= section_headers
;
7385 i
< elf_header
.e_shnum
;
7389 char * strtab
= NULL
;
7390 unsigned long int strtab_size
= 0;
7391 Elf_Internal_Sym
* symtab
;
7392 Elf_Internal_Sym
* psym
;
7394 if ( section
->sh_type
!= SHT_SYMTAB
7395 && section
->sh_type
!= SHT_DYNSYM
)
7398 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7399 SECTION_NAME (section
),
7400 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7402 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7404 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7406 symtab
= GET_ELF_SYMBOLS (file
, section
);
7410 if (section
->sh_link
== elf_header
.e_shstrndx
)
7412 strtab
= string_table
;
7413 strtab_size
= string_table_length
;
7415 else if (section
->sh_link
< elf_header
.e_shnum
)
7417 Elf_Internal_Shdr
* string_sec
;
7419 string_sec
= section_headers
+ section
->sh_link
;
7421 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7422 1, string_sec
->sh_size
, _("string table"));
7423 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7426 for (si
= 0, psym
= symtab
;
7427 si
< section
->sh_size
/ section
->sh_entsize
;
7430 printf ("%6d: ", si
);
7431 print_vma (psym
->st_value
, LONG_HEX
);
7433 print_vma (psym
->st_size
, DEC_5
);
7434 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7435 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7436 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7437 /* Check to see if any other bits in the st_other field are set.
7438 Note - displaying this information disrupts the layout of the
7439 table being generated, but for the moment this case is very rare. */
7440 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7441 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7442 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7443 print_symbol (25, psym
->st_name
< strtab_size
7444 ? strtab
+ psym
->st_name
: "<corrupt>");
7446 if (section
->sh_type
== SHT_DYNSYM
&&
7447 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7449 unsigned char data
[2];
7450 unsigned short vers_data
;
7451 unsigned long offset
;
7455 offset
= offset_from_vma
7456 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7457 sizeof data
+ si
* sizeof (vers_data
));
7459 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7460 sizeof (data
), 1, _("version data"));
7462 vers_data
= byte_get (data
, 2);
7464 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7465 && section_headers
[psym
->st_shndx
].sh_type
7468 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7470 if ((vers_data
& 0x8000) || vers_data
> 1)
7472 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7473 && (is_nobits
|| ! check_def
))
7475 Elf_External_Verneed evn
;
7476 Elf_Internal_Verneed ivn
;
7477 Elf_Internal_Vernaux ivna
;
7479 /* We must test both. */
7480 offset
= offset_from_vma
7481 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7486 unsigned long vna_off
;
7488 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7491 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7492 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7494 vna_off
= offset
+ ivn
.vn_aux
;
7498 Elf_External_Vernaux evna
;
7500 get_data (&evna
, file
, vna_off
,
7502 _("version need aux (3)"));
7504 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7505 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7506 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7508 vna_off
+= ivna
.vna_next
;
7510 while (ivna
.vna_other
!= vers_data
7511 && ivna
.vna_next
!= 0);
7513 if (ivna
.vna_other
== vers_data
)
7516 offset
+= ivn
.vn_next
;
7518 while (ivn
.vn_next
!= 0);
7520 if (ivna
.vna_other
== vers_data
)
7523 ivna
.vna_name
< strtab_size
7524 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7528 else if (! is_nobits
)
7529 error (_("bad dynamic symbol\n"));
7536 if (vers_data
!= 0x8001
7537 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7539 Elf_Internal_Verdef ivd
;
7540 Elf_Internal_Verdaux ivda
;
7541 Elf_External_Verdaux evda
;
7542 unsigned long offset
;
7544 offset
= offset_from_vma
7546 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7547 sizeof (Elf_External_Verdef
));
7551 Elf_External_Verdef evd
;
7553 get_data (&evd
, file
, offset
, sizeof (evd
),
7554 1, _("version def"));
7556 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7557 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7558 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7560 offset
+= ivd
.vd_next
;
7562 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7563 && ivd
.vd_next
!= 0);
7565 offset
-= ivd
.vd_next
;
7566 offset
+= ivd
.vd_aux
;
7568 get_data (&evda
, file
, offset
, sizeof (evda
),
7569 1, _("version def aux"));
7571 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7573 if (psym
->st_name
!= ivda
.vda_name
)
7574 printf ((vers_data
& 0x8000)
7576 ivda
.vda_name
< strtab_size
7577 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7587 if (strtab
!= string_table
)
7593 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7595 if (do_histogram
&& buckets
!= NULL
)
7597 unsigned long * lengths
;
7598 unsigned long * counts
;
7601 unsigned long maxlength
= 0;
7602 unsigned long nzero_counts
= 0;
7603 unsigned long nsyms
= 0;
7605 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7606 (unsigned long) nbuckets
);
7607 printf (_(" Length Number %% of total Coverage\n"));
7609 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7610 if (lengths
== NULL
)
7612 error (_("Out of memory\n"));
7615 for (hn
= 0; hn
< nbuckets
; ++hn
)
7617 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7620 if (maxlength
< ++lengths
[hn
])
7625 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7628 error (_("Out of memory\n"));
7632 for (hn
= 0; hn
< nbuckets
; ++hn
)
7633 ++counts
[lengths
[hn
]];
7638 printf (" 0 %-10lu (%5.1f%%)\n",
7639 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7640 for (i
= 1; i
<= maxlength
; ++i
)
7642 nzero_counts
+= counts
[i
] * i
;
7643 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7644 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7645 (nzero_counts
* 100.0) / nsyms
);
7653 if (buckets
!= NULL
)
7659 if (do_histogram
&& gnubuckets
!= NULL
)
7661 unsigned long * lengths
;
7662 unsigned long * counts
;
7664 unsigned long maxlength
= 0;
7665 unsigned long nzero_counts
= 0;
7666 unsigned long nsyms
= 0;
7668 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7669 if (lengths
== NULL
)
7671 error (_("Out of memory\n"));
7675 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7676 (unsigned long) ngnubuckets
);
7677 printf (_(" Length Number %% of total Coverage\n"));
7679 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7680 if (gnubuckets
[hn
] != 0)
7682 bfd_vma off
, length
= 1;
7684 for (off
= gnubuckets
[hn
] - gnusymidx
;
7685 (gnuchains
[off
] & 1) == 0; ++off
)
7687 lengths
[hn
] = length
;
7688 if (length
> maxlength
)
7693 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7696 error (_("Out of memory\n"));
7700 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7701 ++counts
[lengths
[hn
]];
7703 if (ngnubuckets
> 0)
7706 printf (" 0 %-10lu (%5.1f%%)\n",
7707 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7708 for (j
= 1; j
<= maxlength
; ++j
)
7710 nzero_counts
+= counts
[j
] * j
;
7711 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7712 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7713 (nzero_counts
* 100.0) / nsyms
);
7727 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7731 if (dynamic_syminfo
== NULL
7733 /* No syminfo, this is ok. */
7736 /* There better should be a dynamic symbol section. */
7737 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7741 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7742 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7744 printf (_(" Num: Name BoundTo Flags\n"));
7745 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7747 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7749 printf ("%4d: ", i
);
7750 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7751 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7753 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7756 switch (dynamic_syminfo
[i
].si_boundto
)
7758 case SYMINFO_BT_SELF
:
7759 fputs ("SELF ", stdout
);
7761 case SYMINFO_BT_PARENT
:
7762 fputs ("PARENT ", stdout
);
7765 if (dynamic_syminfo
[i
].si_boundto
> 0
7766 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7767 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7769 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7773 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7777 if (flags
& SYMINFO_FLG_DIRECT
)
7779 if (flags
& SYMINFO_FLG_PASSTHRU
)
7780 printf (" PASSTHRU");
7781 if (flags
& SYMINFO_FLG_COPY
)
7783 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7784 printf (" LAZYLOAD");
7792 /* Check to see if the given reloc needs to be handled in a target specific
7793 manner. If so then process the reloc and return TRUE otherwise return
7797 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
7798 unsigned char * start
,
7799 Elf_Internal_Sym
* symtab
)
7801 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
7803 switch (elf_header
.e_machine
)
7806 case EM_CYGNUS_MN10300
:
7808 static Elf_Internal_Sym
* saved_sym
= NULL
;
7812 case 34: /* R_MN10300_ALIGN */
7814 case 33: /* R_MN10300_SYM_DIFF */
7815 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
7817 case 1: /* R_MN10300_32 */
7818 case 2: /* R_MN10300_16 */
7819 if (saved_sym
!= NULL
)
7823 value
= reloc
->r_addend
7824 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
7825 - saved_sym
->st_value
);
7827 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
7834 if (saved_sym
!= NULL
)
7835 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
7845 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7846 DWARF debug sections. This is a target specific test. Note - we do not
7847 go through the whole including-target-headers-multiple-times route, (as
7848 we have already done with <elf/h8.h>) because this would become very
7849 messy and even then this function would have to contain target specific
7850 information (the names of the relocs instead of their numeric values).
7851 FIXME: This is not the correct way to solve this problem. The proper way
7852 is to have target specific reloc sizing and typing functions created by
7853 the reloc-macros.h header, in the same way that it already creates the
7854 reloc naming functions. */
7857 is_32bit_abs_reloc (unsigned int reloc_type
)
7859 switch (elf_header
.e_machine
)
7863 return reloc_type
== 1; /* R_386_32. */
7865 return reloc_type
== 1; /* R_68K_32. */
7867 return reloc_type
== 1; /* R_860_32. */
7869 return reloc_type
== 1; /* XXX Is this right ? */
7871 return reloc_type
== 1; /* R_ARC_32. */
7873 return reloc_type
== 2; /* R_ARM_ABS32 */
7876 return reloc_type
== 1;
7878 return reloc_type
== 0x12; /* R_byte4_data. */
7880 return reloc_type
== 3; /* R_CRIS_32. */
7883 return reloc_type
== 3; /* R_CR16_NUM32. */
7885 return reloc_type
== 15; /* R_CRX_NUM32. */
7887 return reloc_type
== 1;
7888 case EM_CYGNUS_D10V
:
7890 return reloc_type
== 6; /* R_D10V_32. */
7891 case EM_CYGNUS_D30V
:
7893 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7895 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7896 case EM_CYGNUS_FR30
:
7898 return reloc_type
== 3; /* R_FR30_32. */
7902 return reloc_type
== 1; /* R_H8_DIR32. */
7904 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
7907 return reloc_type
== 2; /* R_IP2K_32. */
7909 return reloc_type
== 2; /* R_IQ2000_32. */
7910 case EM_LATTICEMICO32
:
7911 return reloc_type
== 3; /* R_LM32_32. */
7914 return reloc_type
== 3; /* R_M32C_32. */
7916 return reloc_type
== 34; /* R_M32R_32_RELA. */
7918 return reloc_type
== 1; /* R_MCORE_ADDR32. */
7920 return reloc_type
== 4; /* R_MEP_32. */
7922 return reloc_type
== 2; /* R_MIPS_32. */
7924 return reloc_type
== 4; /* R_MMIX_32. */
7925 case EM_CYGNUS_MN10200
:
7927 return reloc_type
== 1; /* R_MN10200_32. */
7928 case EM_CYGNUS_MN10300
:
7930 return reloc_type
== 1; /* R_MN10300_32. */
7933 return reloc_type
== 1; /* R_MSP43_32. */
7935 return reloc_type
== 2; /* R_MT_32. */
7936 case EM_ALTERA_NIOS2
:
7938 return reloc_type
== 1; /* R_NIOS_32. */
7941 return reloc_type
== 1; /* R_OR32_32. */
7943 return reloc_type
== 1; /* R_PARISC_DIR32. */
7946 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
7948 return reloc_type
== 1; /* R_PPC64_ADDR32. */
7950 return reloc_type
== 1; /* R_PPC_ADDR32. */
7952 return reloc_type
== 1; /* R_I370_ADDR31. */
7955 return reloc_type
== 4; /* R_S390_32. */
7957 return reloc_type
== 8; /* R_SCORE_ABS32. */
7959 return reloc_type
== 1; /* R_SH_DIR32. */
7960 case EM_SPARC32PLUS
:
7963 return reloc_type
== 3 /* R_SPARC_32. */
7964 || reloc_type
== 23; /* R_SPARC_UA32. */
7966 return reloc_type
== 6; /* R_SPU_ADDR32 */
7967 case EM_CYGNUS_V850
:
7969 return reloc_type
== 6; /* R_V850_ABS32. */
7971 return reloc_type
== 1; /* R_VAX_32. */
7974 return reloc_type
== 10; /* R_X86_64_32. */
7976 return reloc_type
== 1; /* R_XSTROMY16_32. */
7979 return reloc_type
== 1; /* R_XTENSA_32. */
7982 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
7983 elf_header
.e_machine
);
7988 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
7989 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
7992 is_32bit_pcrel_reloc (unsigned int reloc_type
)
7994 switch (elf_header
.e_machine
)
7998 return reloc_type
== 2; /* R_386_PC32. */
8000 return reloc_type
== 4; /* R_68K_PC32. */
8002 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8004 return reloc_type
== 3; /* R_ARM_REL32 */
8006 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8008 return reloc_type
== 26; /* R_PPC_REL32. */
8010 return reloc_type
== 26; /* R_PPC64_REL32. */
8013 return reloc_type
== 5; /* R_390_PC32. */
8015 return reloc_type
== 2; /* R_SH_REL32. */
8016 case EM_SPARC32PLUS
:
8019 return reloc_type
== 6; /* R_SPARC_DISP32. */
8021 return reloc_type
== 13; /* R_SPU_REL32. */
8024 return reloc_type
== 2; /* R_X86_64_PC32. */
8027 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8029 /* Do not abort or issue an error message here. Not all targets use
8030 pc-relative 32-bit relocs in their DWARF debug information and we
8031 have already tested for target coverage in is_32bit_abs_reloc. A
8032 more helpful warning message will be generated by apply_relocations
8033 anyway, so just return. */
8038 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8039 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8042 is_64bit_abs_reloc (unsigned int reloc_type
)
8044 switch (elf_header
.e_machine
)
8047 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8049 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8051 return reloc_type
== 80; /* R_PARISC_DIR64. */
8053 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8054 case EM_SPARC32PLUS
:
8057 return reloc_type
== 54; /* R_SPARC_UA64. */
8060 return reloc_type
== 1; /* R_X86_64_64. */
8063 return reloc_type
== 22; /* R_S390_64 */
8065 return reloc_type
== 18; /* R_MIPS_64 */
8071 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8072 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8075 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8077 switch (elf_header
.e_machine
)
8080 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8082 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8084 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8086 return reloc_type
== 44; /* R_PPC64_REL64 */
8087 case EM_SPARC32PLUS
:
8090 return reloc_type
== 46; /* R_SPARC_DISP64 */
8093 return reloc_type
== 24; /* R_X86_64_PC64 */
8096 return reloc_type
== 23; /* R_S390_PC64 */
8102 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8103 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8106 is_16bit_abs_reloc (unsigned int reloc_type
)
8108 switch (elf_header
.e_machine
)
8112 return reloc_type
== 4; /* R_AVR_16. */
8113 case EM_CYGNUS_D10V
:
8115 return reloc_type
== 3; /* R_D10V_16. */
8119 return reloc_type
== R_H8_DIR16
;
8122 return reloc_type
== 1; /* R_IP2K_16. */
8125 return reloc_type
== 1; /* R_M32C_16 */
8128 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8129 case EM_ALTERA_NIOS2
:
8131 return reloc_type
== 9; /* R_NIOS_16. */
8137 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8138 relocation entries (possibly formerly used for SHT_GROUP sections). */
8141 is_none_reloc (unsigned int reloc_type
)
8143 switch (elf_header
.e_machine
)
8145 case EM_68K
: /* R_68K_NONE. */
8146 case EM_386
: /* R_386_NONE. */
8147 case EM_SPARC32PLUS
:
8149 case EM_SPARC
: /* R_SPARC_NONE. */
8150 case EM_MIPS
: /* R_MIPS_NONE. */
8151 case EM_PARISC
: /* R_PARISC_NONE. */
8152 case EM_ALPHA
: /* R_ALPHA_NONE. */
8153 case EM_PPC
: /* R_PPC_NONE. */
8154 case EM_PPC64
: /* R_PPC64_NONE. */
8155 case EM_ARM
: /* R_ARM_NONE. */
8156 case EM_IA_64
: /* R_IA64_NONE. */
8157 case EM_SH
: /* R_SH_NONE. */
8159 case EM_S390
: /* R_390_NONE. */
8160 case EM_CRIS
: /* R_CRIS_NONE. */
8161 case EM_X86_64
: /* R_X86_64_NONE. */
8162 case EM_L1OM
: /* R_X86_64_NONE. */
8163 case EM_MN10300
: /* R_MN10300_NONE. */
8164 case EM_M32R
: /* R_M32R_NONE. */
8165 return reloc_type
== 0;
8170 /* Apply relocations to a section.
8171 Note: So far support has been added only for those relocations
8172 which can be found in debug sections.
8173 FIXME: Add support for more relocations ? */
8176 apply_relocations (void * file
,
8177 Elf_Internal_Shdr
* section
,
8178 unsigned char * start
)
8180 Elf_Internal_Shdr
* relsec
;
8181 unsigned char * end
= start
+ section
->sh_size
;
8183 if (elf_header
.e_type
!= ET_REL
)
8186 /* Find the reloc section associated with the section. */
8187 for (relsec
= section_headers
;
8188 relsec
< section_headers
+ elf_header
.e_shnum
;
8191 bfd_boolean is_rela
;
8192 unsigned long num_relocs
;
8193 Elf_Internal_Rela
* relocs
;
8194 Elf_Internal_Rela
* rp
;
8195 Elf_Internal_Shdr
* symsec
;
8196 Elf_Internal_Sym
* symtab
;
8197 Elf_Internal_Sym
* sym
;
8199 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8200 || relsec
->sh_info
>= elf_header
.e_shnum
8201 || section_headers
+ relsec
->sh_info
!= section
8202 || relsec
->sh_size
== 0
8203 || relsec
->sh_link
>= elf_header
.e_shnum
)
8206 is_rela
= relsec
->sh_type
== SHT_RELA
;
8210 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8211 & relocs
, & num_relocs
))
8216 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8217 & relocs
, & num_relocs
))
8221 /* SH uses RELA but uses in place value instead of the addend field. */
8222 if (elf_header
.e_machine
== EM_SH
)
8225 symsec
= section_headers
+ relsec
->sh_link
;
8226 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8228 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8231 unsigned int reloc_type
;
8232 unsigned int reloc_size
;
8233 unsigned char * loc
;
8235 reloc_type
= get_reloc_type (rp
->r_info
);
8237 if (target_specific_reloc_handling (rp
, start
, symtab
))
8239 else if (is_none_reloc (reloc_type
))
8241 else if (is_32bit_abs_reloc (reloc_type
)
8242 || is_32bit_pcrel_reloc (reloc_type
))
8244 else if (is_64bit_abs_reloc (reloc_type
)
8245 || is_64bit_pcrel_reloc (reloc_type
))
8247 else if (is_16bit_abs_reloc (reloc_type
))
8251 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8252 reloc_type
, SECTION_NAME (section
));
8256 loc
= start
+ rp
->r_offset
;
8257 if ((loc
+ reloc_size
) > end
)
8259 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8260 (unsigned long) rp
->r_offset
,
8261 SECTION_NAME (section
));
8265 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8267 /* If the reloc has a symbol associated with it,
8268 make sure that it is of an appropriate type.
8270 Relocations against symbols without type can happen.
8271 Gcc -feliminate-dwarf2-dups may generate symbols
8272 without type for debug info.
8274 Icc generates relocations against function symbols
8275 instead of local labels.
8277 Relocations against object symbols can happen, eg when
8278 referencing a global array. For an example of this see
8279 the _clz.o binary in libgcc.a. */
8281 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8283 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8284 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8285 (long int)(rp
- relocs
),
8286 SECTION_NAME (relsec
));
8290 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8292 if (is_32bit_pcrel_reloc (reloc_type
)
8293 || is_64bit_pcrel_reloc (reloc_type
))
8295 /* On HPPA, all pc-relative relocations are biased by 8. */
8296 if (elf_header
.e_machine
== EM_PARISC
)
8298 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8302 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8311 #ifdef SUPPORT_DISASSEMBLY
8313 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8315 printf (_("\nAssembly dump of section %s\n"),
8316 SECTION_NAME (section
));
8318 /* XXX -- to be done --- XXX */
8324 /* Reads in the contents of SECTION from FILE, returning a pointer
8325 to a malloc'ed buffer or NULL if something went wrong. */
8328 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8330 bfd_size_type num_bytes
;
8332 num_bytes
= section
->sh_size
;
8334 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8336 printf (_("\nSection '%s' has no data to dump.\n"),
8337 SECTION_NAME (section
));
8341 return get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8342 _("section contents"));
8347 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8349 Elf_Internal_Shdr
* relsec
;
8350 bfd_size_type num_bytes
;
8355 char * name
= SECTION_NAME (section
);
8356 bfd_boolean some_strings_shown
;
8358 start
= get_section_contents (section
, file
);
8362 printf (_("\nString dump of section '%s':\n"), name
);
8364 /* If the section being dumped has relocations against it the user might
8365 be expecting these relocations to have been applied. Check for this
8366 case and issue a warning message in order to avoid confusion.
8367 FIXME: Maybe we ought to have an option that dumps a section with
8369 for (relsec
= section_headers
;
8370 relsec
< section_headers
+ elf_header
.e_shnum
;
8373 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8374 || relsec
->sh_info
>= elf_header
.e_shnum
8375 || section_headers
+ relsec
->sh_info
!= section
8376 || relsec
->sh_size
== 0
8377 || relsec
->sh_link
>= elf_header
.e_shnum
)
8380 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8384 num_bytes
= section
->sh_size
;
8385 addr
= section
->sh_addr
;
8387 end
= start
+ num_bytes
;
8388 some_strings_shown
= FALSE
;
8392 while (!ISPRINT (* data
))
8399 printf (" [%6tx] %s\n", data
- start
, data
);
8401 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8403 data
+= strlen (data
);
8404 some_strings_shown
= TRUE
;
8408 if (! some_strings_shown
)
8409 printf (_(" No strings found in this section."));
8417 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8419 bfd_boolean relocate
)
8421 Elf_Internal_Shdr
* relsec
;
8422 bfd_size_type bytes
;
8424 unsigned char * data
;
8425 unsigned char * start
;
8427 start
= (unsigned char *) get_section_contents (section
, file
);
8431 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8435 apply_relocations (file
, section
, start
);
8439 /* If the section being dumped has relocations against it the user might
8440 be expecting these relocations to have been applied. Check for this
8441 case and issue a warning message in order to avoid confusion.
8442 FIXME: Maybe we ought to have an option that dumps a section with
8444 for (relsec
= section_headers
;
8445 relsec
< section_headers
+ elf_header
.e_shnum
;
8448 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8449 || relsec
->sh_info
>= elf_header
.e_shnum
8450 || section_headers
+ relsec
->sh_info
!= section
8451 || relsec
->sh_size
== 0
8452 || relsec
->sh_link
>= elf_header
.e_shnum
)
8455 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8460 addr
= section
->sh_addr
;
8461 bytes
= section
->sh_size
;
8470 lbytes
= (bytes
> 16 ? 16 : bytes
);
8472 printf (" 0x%8.8lx ", (unsigned long) addr
);
8474 for (j
= 0; j
< 16; j
++)
8477 printf ("%2.2x", data
[j
]);
8485 for (j
= 0; j
< lbytes
; j
++)
8488 if (k
>= ' ' && k
< 0x7f)
8506 /* Uncompresses a section that was compressed using zlib, in place.
8507 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8510 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8513 /* These are just to quiet gcc. */
8518 dwarf_size_type compressed_size
= *size
;
8519 unsigned char * compressed_buffer
= *buffer
;
8520 dwarf_size_type uncompressed_size
;
8521 unsigned char * uncompressed_buffer
;
8524 dwarf_size_type header_size
= 12;
8526 /* Read the zlib header. In this case, it should be "ZLIB" followed
8527 by the uncompressed section size, 8 bytes in big-endian order. */
8528 if (compressed_size
< header_size
8529 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8532 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8533 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8534 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8535 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8536 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8537 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8538 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8539 uncompressed_size
+= compressed_buffer
[11];
8541 /* It is possible the section consists of several compressed
8542 buffers concatenated together, so we uncompress in a loop. */
8546 strm
.avail_in
= compressed_size
- header_size
;
8547 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8548 strm
.avail_out
= uncompressed_size
;
8549 uncompressed_buffer
= xmalloc (uncompressed_size
);
8551 rc
= inflateInit (& strm
);
8552 while (strm
.avail_in
> 0)
8556 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8557 + (uncompressed_size
- strm
.avail_out
));
8558 rc
= inflate (&strm
, Z_FINISH
);
8559 if (rc
!= Z_STREAM_END
)
8561 rc
= inflateReset (& strm
);
8563 rc
= inflateEnd (& strm
);
8565 || strm
.avail_out
!= 0)
8568 free (compressed_buffer
);
8569 *buffer
= uncompressed_buffer
;
8570 *size
= uncompressed_size
;
8574 free (uncompressed_buffer
);
8576 #endif /* HAVE_ZLIB_H */
8580 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8581 Elf_Internal_Shdr
* sec
, void * file
)
8583 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8585 int section_is_compressed
;
8587 /* If it is already loaded, do nothing. */
8588 if (section
->start
!= NULL
)
8591 section_is_compressed
= section
->name
== section
->compressed_name
;
8593 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8594 section
->address
= sec
->sh_addr
;
8595 section
->size
= sec
->sh_size
;
8596 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8598 if (section
->start
== NULL
)
8601 if (section_is_compressed
)
8602 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8605 if (debug_displays
[debug
].relocate
)
8606 apply_relocations (file
, sec
, section
->start
);
8612 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8614 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8615 Elf_Internal_Shdr
* sec
;
8617 /* Locate the debug section. */
8618 sec
= find_section (section
->uncompressed_name
);
8620 section
->name
= section
->uncompressed_name
;
8623 sec
= find_section (section
->compressed_name
);
8625 section
->name
= section
->compressed_name
;
8630 return load_specific_debug_section (debug
, sec
, file
);
8634 free_debug_section (enum dwarf_section_display_enum debug
)
8636 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8638 if (section
->start
== NULL
)
8641 free ((char *) section
->start
);
8642 section
->start
= NULL
;
8643 section
->address
= 0;
8648 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8650 char * name
= SECTION_NAME (section
);
8651 bfd_size_type length
;
8653 enum dwarf_section_display_enum i
;
8655 length
= section
->sh_size
;
8658 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8661 if (section
->sh_type
== SHT_NOBITS
)
8663 /* There is no point in dumping the contents of a debugging section
8664 which has the NOBITS type - the bits in the file will be random.
8665 This can happen when a file containing a .eh_frame section is
8666 stripped with the --only-keep-debug command line option. */
8667 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8671 if (const_strneq (name
, ".gnu.linkonce.wi."))
8672 name
= ".debug_info";
8674 /* See if we know how to display the contents of this section. */
8675 for (i
= 0; i
< max
; i
++)
8676 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8677 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8679 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8680 int secondary
= (section
!= find_section (name
));
8683 free_debug_section (i
);
8685 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8686 sec
->name
= sec
->uncompressed_name
;
8688 sec
->name
= sec
->compressed_name
;
8689 if (load_specific_debug_section (i
, section
, file
))
8691 result
&= debug_displays
[i
].display (sec
, file
);
8693 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8694 free_debug_section (i
);
8702 printf (_("Unrecognized debug section: %s\n"), name
);
8709 /* Set DUMP_SECTS for all sections where dumps were requested
8710 based on section name. */
8713 initialise_dumps_byname (void)
8715 struct dump_list_entry
* cur
;
8717 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8722 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8723 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8725 request_dump_bynumber (i
, cur
->type
);
8730 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8736 process_section_contents (FILE * file
)
8738 Elf_Internal_Shdr
* section
;
8744 initialise_dumps_byname ();
8746 for (i
= 0, section
= section_headers
;
8747 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8750 #ifdef SUPPORT_DISASSEMBLY
8751 if (dump_sects
[i
] & DISASS_DUMP
)
8752 disassemble_section (section
, file
);
8754 if (dump_sects
[i
] & HEX_DUMP
)
8755 dump_section_as_bytes (section
, file
, FALSE
);
8757 if (dump_sects
[i
] & RELOC_DUMP
)
8758 dump_section_as_bytes (section
, file
, TRUE
);
8760 if (dump_sects
[i
] & STRING_DUMP
)
8761 dump_section_as_strings (section
, file
);
8763 if (dump_sects
[i
] & DEBUG_DUMP
)
8764 display_debug_section (section
, file
);
8767 /* Check to see if the user requested a
8768 dump of a section that does not exist. */
8769 while (i
++ < num_dump_sects
)
8771 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8775 process_mips_fpe_exception (int mask
)
8780 if (mask
& OEX_FPU_INEX
)
8781 fputs ("INEX", stdout
), first
= 0;
8782 if (mask
& OEX_FPU_UFLO
)
8783 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8784 if (mask
& OEX_FPU_OFLO
)
8785 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8786 if (mask
& OEX_FPU_DIV0
)
8787 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8788 if (mask
& OEX_FPU_INVAL
)
8789 printf ("%sINVAL", first
? "" : "|");
8792 fputs ("0", stdout
);
8795 /* ARM EABI attributes section. */
8800 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8802 const char ** table
;
8803 } arm_attr_public_tag
;
8805 static const char * arm_attr_tag_CPU_arch
[] =
8806 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8807 "v6K", "v7", "v6-M", "v6S-M"};
8808 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8809 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8810 {"No", "Thumb-1", "Thumb-2"};
8811 static const char * arm_attr_tag_VFP_arch
[] =
8812 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8813 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8814 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8815 static const char * arm_attr_tag_PCS_config
[] =
8816 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8817 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8818 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8819 {"V6", "SB", "TLS", "Unused"};
8820 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8821 {"Absolute", "PC-relative", "SB-relative", "None"};
8822 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8823 {"Absolute", "PC-relative", "None"};
8824 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8825 {"None", "direct", "GOT-indirect"};
8826 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8827 {"None", "??? 1", "2", "??? 3", "4"};
8828 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8829 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8830 {"Unused", "Needed", "Sign only"};
8831 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8832 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8833 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8834 {"Unused", "Finite", "RTABI", "IEEE 754"};
8835 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8836 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8837 {"No", "Yes, except leaf SP", "Yes"};
8838 static const char * arm_attr_tag_ABI_enum_size
[] =
8839 {"Unused", "small", "int", "forced to int"};
8840 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8841 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8842 static const char * arm_attr_tag_ABI_VFP_args
[] =
8843 {"AAPCS", "VFP registers", "custom"};
8844 static const char * arm_attr_tag_ABI_WMMX_args
[] =
8845 {"AAPCS", "WMMX registers", "custom"};
8846 static const char * arm_attr_tag_ABI_optimization_goals
[] =
8847 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8848 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8849 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
8850 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8851 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8852 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8853 static const char * arm_attr_tag_VFP_HP_extension
[] =
8854 {"Not Allowed", "Allowed"};
8855 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
8856 {"None", "IEEE 754", "Alternative Format"};
8857 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8858 static const char * arm_attr_tag_Virtualization_use
[] =
8859 {"Not Allowed", "Allowed"};
8860 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8862 #define LOOKUP(id, name) \
8863 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8864 static arm_attr_public_tag arm_attr_public_tags
[] =
8866 {4, "CPU_raw_name", 1, NULL
},
8867 {5, "CPU_name", 1, NULL
},
8868 LOOKUP(6, CPU_arch
),
8869 {7, "CPU_arch_profile", 0, NULL
},
8870 LOOKUP(8, ARM_ISA_use
),
8871 LOOKUP(9, THUMB_ISA_use
),
8872 LOOKUP(10, VFP_arch
),
8873 LOOKUP(11, WMMX_arch
),
8874 LOOKUP(12, Advanced_SIMD_arch
),
8875 LOOKUP(13, PCS_config
),
8876 LOOKUP(14, ABI_PCS_R9_use
),
8877 LOOKUP(15, ABI_PCS_RW_data
),
8878 LOOKUP(16, ABI_PCS_RO_data
),
8879 LOOKUP(17, ABI_PCS_GOT_use
),
8880 LOOKUP(18, ABI_PCS_wchar_t
),
8881 LOOKUP(19, ABI_FP_rounding
),
8882 LOOKUP(20, ABI_FP_denormal
),
8883 LOOKUP(21, ABI_FP_exceptions
),
8884 LOOKUP(22, ABI_FP_user_exceptions
),
8885 LOOKUP(23, ABI_FP_number_model
),
8886 LOOKUP(24, ABI_align8_needed
),
8887 LOOKUP(25, ABI_align8_preserved
),
8888 LOOKUP(26, ABI_enum_size
),
8889 LOOKUP(27, ABI_HardFP_use
),
8890 LOOKUP(28, ABI_VFP_args
),
8891 LOOKUP(29, ABI_WMMX_args
),
8892 LOOKUP(30, ABI_optimization_goals
),
8893 LOOKUP(31, ABI_FP_optimization_goals
),
8894 {32, "compatibility", 0, NULL
},
8895 LOOKUP(34, CPU_unaligned_access
),
8896 LOOKUP(36, VFP_HP_extension
),
8897 LOOKUP(38, ABI_FP_16bit_format
),
8898 {64, "nodefaults", 0, NULL
},
8899 {65, "also_compatible_with", 0, NULL
},
8900 LOOKUP(66, T2EE_use
),
8901 {67, "conformance", 1, NULL
},
8902 LOOKUP(68, Virtualization_use
),
8903 LOOKUP(70, MPextension_use
)
8907 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8911 read_uleb128 (unsigned char * p
, unsigned int * plen
)
8925 val
|= ((unsigned int)c
& 0x7f) << shift
;
8934 static unsigned char *
8935 display_arm_attribute (unsigned char * p
)
8940 arm_attr_public_tag
* attr
;
8944 tag
= read_uleb128 (p
, &len
);
8947 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
8949 if (arm_attr_public_tags
[i
].tag
== tag
)
8951 attr
= &arm_attr_public_tags
[i
];
8958 printf (" Tag_%s: ", attr
->name
);
8964 case 7: /* Tag_CPU_arch_profile. */
8965 val
= read_uleb128 (p
, &len
);
8969 case 0: printf ("None\n"); break;
8970 case 'A': printf ("Application\n"); break;
8971 case 'R': printf ("Realtime\n"); break;
8972 case 'M': printf ("Microcontroller\n"); break;
8973 default: printf ("??? (%d)\n", val
); break;
8977 case 32: /* Tag_compatibility. */
8978 val
= read_uleb128 (p
, &len
);
8980 printf ("flag = %d, vendor = %s\n", val
, p
);
8981 p
+= strlen ((char *) p
) + 1;
8984 case 64: /* Tag_nodefaults. */
8989 case 65: /* Tag_also_compatible_with. */
8990 val
= read_uleb128 (p
, &len
);
8992 if (val
== 6 /* Tag_CPU_arch. */)
8994 val
= read_uleb128 (p
, &len
);
8996 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
8997 printf ("??? (%d)\n", val
);
8999 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9003 while (*(p
++) != '\0' /* NUL terminator. */);
9017 assert (attr
->type
& 0x80);
9018 val
= read_uleb128 (p
, &len
);
9020 type
= attr
->type
& 0x7f;
9022 printf ("??? (%d)\n", val
);
9024 printf ("%s\n", attr
->table
[val
]);
9031 type
= 1; /* String. */
9033 type
= 2; /* uleb128. */
9034 printf (" Tag_unknown_%d: ", tag
);
9039 printf ("\"%s\"\n", p
);
9040 p
+= strlen ((char *) p
) + 1;
9044 val
= read_uleb128 (p
, &len
);
9046 printf ("%d (0x%x)\n", val
, val
);
9052 static unsigned char *
9053 display_gnu_attribute (unsigned char * p
,
9054 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9061 tag
= read_uleb128 (p
, &len
);
9064 /* Tag_compatibility is the only generic GNU attribute defined at
9068 val
= read_uleb128 (p
, &len
);
9070 printf ("flag = %d, vendor = %s\n", val
, p
);
9071 p
+= strlen ((char *) p
) + 1;
9075 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9076 return display_proc_gnu_attribute (p
, tag
);
9079 type
= 1; /* String. */
9081 type
= 2; /* uleb128. */
9082 printf (" Tag_unknown_%d: ", tag
);
9086 printf ("\"%s\"\n", p
);
9087 p
+= strlen ((char *) p
) + 1;
9091 val
= read_uleb128 (p
, &len
);
9093 printf ("%d (0x%x)\n", val
, val
);
9099 static unsigned char *
9100 display_power_gnu_attribute (unsigned char * p
, int tag
)
9106 if (tag
== Tag_GNU_Power_ABI_FP
)
9108 val
= read_uleb128 (p
, &len
);
9110 printf (" Tag_GNU_Power_ABI_FP: ");
9115 printf ("Hard or soft float\n");
9118 printf ("Hard float\n");
9121 printf ("Soft float\n");
9124 printf ("Single-precision hard float\n");
9127 printf ("??? (%d)\n", val
);
9133 if (tag
== Tag_GNU_Power_ABI_Vector
)
9135 val
= read_uleb128 (p
, &len
);
9137 printf (" Tag_GNU_Power_ABI_Vector: ");
9144 printf ("Generic\n");
9147 printf ("AltiVec\n");
9153 printf ("??? (%d)\n", val
);
9159 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9161 val
= read_uleb128 (p
, &len
);
9163 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9173 printf ("Memory\n");
9176 printf ("??? (%d)\n", val
);
9183 type
= 1; /* String. */
9185 type
= 2; /* uleb128. */
9186 printf (" Tag_unknown_%d: ", tag
);
9190 printf ("\"%s\"\n", p
);
9191 p
+= strlen ((char *) p
) + 1;
9195 val
= read_uleb128 (p
, &len
);
9197 printf ("%d (0x%x)\n", val
, val
);
9203 static unsigned char *
9204 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9210 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9212 val
= read_uleb128 (p
, &len
);
9214 printf (" Tag_GNU_MIPS_ABI_FP: ");
9219 printf ("Hard or soft float\n");
9222 printf ("Hard float (-mdouble-float)\n");
9225 printf ("Hard float (-msingle-float)\n");
9228 printf ("Soft float\n");
9231 printf ("64-bit float (-mips32r2 -mfp64)\n");
9234 printf ("??? (%d)\n", val
);
9241 type
= 1; /* String. */
9243 type
= 2; /* uleb128. */
9244 printf (" Tag_unknown_%d: ", tag
);
9248 printf ("\"%s\"\n", p
);
9249 p
+= strlen ((char *) p
) + 1;
9253 val
= read_uleb128 (p
, &len
);
9255 printf ("%d (0x%x)\n", val
, val
);
9262 process_attributes (FILE * file
,
9263 const char * public_name
,
9264 unsigned int proc_type
,
9265 unsigned char * (* display_pub_attribute
) (unsigned char *),
9266 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9268 Elf_Internal_Shdr
* sect
;
9269 unsigned char * contents
;
9271 unsigned char * end
;
9272 bfd_vma section_len
;
9276 /* Find the section header so that we get the size. */
9277 for (i
= 0, sect
= section_headers
;
9278 i
< elf_header
.e_shnum
;
9281 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9284 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9286 if (contents
== NULL
)
9292 len
= sect
->sh_size
- 1;
9298 bfd_boolean public_section
;
9299 bfd_boolean gnu_section
;
9301 section_len
= byte_get (p
, 4);
9304 if (section_len
> len
)
9306 printf (_("ERROR: Bad section length (%d > %d)\n"),
9307 (int) section_len
, (int) len
);
9312 printf ("Attribute Section: %s\n", p
);
9314 if (public_name
&& streq ((char *) p
, public_name
))
9315 public_section
= TRUE
;
9317 public_section
= FALSE
;
9319 if (streq ((char *) p
, "gnu"))
9322 gnu_section
= FALSE
;
9324 namelen
= strlen ((char *) p
) + 1;
9326 section_len
-= namelen
+ 4;
9328 while (section_len
> 0)
9334 size
= byte_get (p
, 4);
9335 if (size
> section_len
)
9337 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9338 (int) size
, (int) section_len
);
9342 section_len
-= size
;
9349 printf ("File Attributes\n");
9352 printf ("Section Attributes:");
9355 printf ("Symbol Attributes:");
9361 val
= read_uleb128 (p
, &i
);
9365 printf (" %d", val
);
9370 printf ("Unknown tag: %d\n", tag
);
9371 public_section
= FALSE
;
9378 p
= display_pub_attribute (p
);
9380 else if (gnu_section
)
9383 p
= display_gnu_attribute (p
,
9384 display_proc_gnu_attribute
);
9388 /* ??? Do something sensible, like dump hex. */
9389 printf (" Unknown section contexts\n");
9396 printf (_("Unknown format '%c'\n"), *p
);
9404 process_arm_specific (FILE * file
)
9406 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9407 display_arm_attribute
, NULL
);
9411 process_power_specific (FILE * file
)
9413 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9414 display_power_gnu_attribute
);
9417 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9418 Print the Address, Access and Initial fields of an entry at VMA ADDR
9419 and return the VMA of the next entry. */
9422 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9425 print_vma (addr
, LONG_HEX
);
9427 if (addr
< pltgot
+ 0xfff0)
9428 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9430 printf ("%10s", "");
9433 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9438 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9439 print_vma (entry
, LONG_HEX
);
9441 return addr
+ (is_32bit_elf
? 4 : 8);
9444 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9445 PLTGOT. Print the Address and Initial fields of an entry at VMA
9446 ADDR and return the VMA of the next entry. */
9449 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9452 print_vma (addr
, LONG_HEX
);
9455 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9460 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9461 print_vma (entry
, LONG_HEX
);
9463 return addr
+ (is_32bit_elf
? 4 : 8);
9467 process_mips_specific (FILE * file
)
9469 Elf_Internal_Dyn
* entry
;
9470 size_t liblist_offset
= 0;
9471 size_t liblistno
= 0;
9472 size_t conflictsno
= 0;
9473 size_t options_offset
= 0;
9474 size_t conflicts_offset
= 0;
9475 size_t pltrelsz
= 0;
9478 bfd_vma mips_pltgot
= 0;
9480 bfd_vma local_gotno
= 0;
9482 bfd_vma symtabno
= 0;
9484 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9485 display_mips_gnu_attribute
);
9487 /* We have a lot of special sections. Thanks SGI! */
9488 if (dynamic_section
== NULL
)
9489 /* No information available. */
9492 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9493 switch (entry
->d_tag
)
9495 case DT_MIPS_LIBLIST
:
9497 = offset_from_vma (file
, entry
->d_un
.d_val
,
9498 liblistno
* sizeof (Elf32_External_Lib
));
9500 case DT_MIPS_LIBLISTNO
:
9501 liblistno
= entry
->d_un
.d_val
;
9503 case DT_MIPS_OPTIONS
:
9504 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9506 case DT_MIPS_CONFLICT
:
9508 = offset_from_vma (file
, entry
->d_un
.d_val
,
9509 conflictsno
* sizeof (Elf32_External_Conflict
));
9511 case DT_MIPS_CONFLICTNO
:
9512 conflictsno
= entry
->d_un
.d_val
;
9515 pltgot
= entry
->d_un
.d_ptr
;
9517 case DT_MIPS_LOCAL_GOTNO
:
9518 local_gotno
= entry
->d_un
.d_val
;
9520 case DT_MIPS_GOTSYM
:
9521 gotsym
= entry
->d_un
.d_val
;
9523 case DT_MIPS_SYMTABNO
:
9524 symtabno
= entry
->d_un
.d_val
;
9526 case DT_MIPS_PLTGOT
:
9527 mips_pltgot
= entry
->d_un
.d_ptr
;
9530 pltrel
= entry
->d_un
.d_val
;
9533 pltrelsz
= entry
->d_un
.d_val
;
9536 jmprel
= entry
->d_un
.d_ptr
;
9542 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9544 Elf32_External_Lib
* elib
;
9547 elib
= get_data (NULL
, file
, liblist_offset
,
9548 liblistno
, sizeof (Elf32_External_Lib
),
9552 printf ("\nSection '.liblist' contains %lu entries:\n",
9553 (unsigned long) liblistno
);
9554 fputs (" Library Time Stamp Checksum Version Flags\n",
9557 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9564 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9565 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9566 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9567 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9568 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9570 tmp
= gmtime (&time
);
9571 snprintf (timebuf
, sizeof (timebuf
),
9572 "%04u-%02u-%02uT%02u:%02u:%02u",
9573 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9574 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9576 printf ("%3lu: ", (unsigned long) cnt
);
9577 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9578 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9580 printf ("<corrupt: %9ld>", liblist
.l_name
);
9581 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9584 if (liblist
.l_flags
== 0)
9595 { " EXACT_MATCH", LL_EXACT_MATCH
},
9596 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9597 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9598 { " EXPORTS", LL_EXPORTS
},
9599 { " DELAY_LOAD", LL_DELAY_LOAD
},
9600 { " DELTA", LL_DELTA
}
9602 int flags
= liblist
.l_flags
;
9605 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9606 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9608 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9609 flags
^= l_flags_vals
[fcnt
].bit
;
9612 printf (" %#x", (unsigned int) flags
);
9622 if (options_offset
!= 0)
9624 Elf_External_Options
* eopt
;
9625 Elf_Internal_Shdr
* sect
= section_headers
;
9626 Elf_Internal_Options
* iopt
;
9627 Elf_Internal_Options
* option
;
9631 /* Find the section header so that we get the size. */
9632 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9635 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9639 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9642 error (_("Out of memory\n"));
9649 while (offset
< sect
->sh_size
)
9651 Elf_External_Options
* eoption
;
9653 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9655 option
->kind
= BYTE_GET (eoption
->kind
);
9656 option
->size
= BYTE_GET (eoption
->size
);
9657 option
->section
= BYTE_GET (eoption
->section
);
9658 option
->info
= BYTE_GET (eoption
->info
);
9660 offset
+= option
->size
;
9666 printf (_("\nSection '%s' contains %d entries:\n"),
9667 SECTION_NAME (sect
), cnt
);
9675 switch (option
->kind
)
9678 /* This shouldn't happen. */
9679 printf (" NULL %d %lx", option
->section
, option
->info
);
9682 printf (" REGINFO ");
9683 if (elf_header
.e_machine
== EM_MIPS
)
9686 Elf32_External_RegInfo
* ereg
;
9687 Elf32_RegInfo reginfo
;
9689 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9690 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9691 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9692 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9693 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9694 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9695 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9697 printf ("GPR %08lx GP 0x%lx\n",
9699 (unsigned long) reginfo
.ri_gp_value
);
9700 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9701 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9702 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9707 Elf64_External_RegInfo
* ereg
;
9708 Elf64_Internal_RegInfo reginfo
;
9710 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9711 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9712 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9713 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9714 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9715 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9716 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9718 printf ("GPR %08lx GP 0x",
9719 reginfo
.ri_gprmask
);
9720 printf_vma (reginfo
.ri_gp_value
);
9723 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9724 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9725 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9729 case ODK_EXCEPTIONS
:
9730 fputs (" EXCEPTIONS fpe_min(", stdout
);
9731 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9732 fputs (") fpe_max(", stdout
);
9733 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9734 fputs (")", stdout
);
9736 if (option
->info
& OEX_PAGE0
)
9737 fputs (" PAGE0", stdout
);
9738 if (option
->info
& OEX_SMM
)
9739 fputs (" SMM", stdout
);
9740 if (option
->info
& OEX_FPDBUG
)
9741 fputs (" FPDBUG", stdout
);
9742 if (option
->info
& OEX_DISMISS
)
9743 fputs (" DISMISS", stdout
);
9746 fputs (" PAD ", stdout
);
9747 if (option
->info
& OPAD_PREFIX
)
9748 fputs (" PREFIX", stdout
);
9749 if (option
->info
& OPAD_POSTFIX
)
9750 fputs (" POSTFIX", stdout
);
9751 if (option
->info
& OPAD_SYMBOL
)
9752 fputs (" SYMBOL", stdout
);
9755 fputs (" HWPATCH ", stdout
);
9756 if (option
->info
& OHW_R4KEOP
)
9757 fputs (" R4KEOP", stdout
);
9758 if (option
->info
& OHW_R8KPFETCH
)
9759 fputs (" R8KPFETCH", stdout
);
9760 if (option
->info
& OHW_R5KEOP
)
9761 fputs (" R5KEOP", stdout
);
9762 if (option
->info
& OHW_R5KCVTL
)
9763 fputs (" R5KCVTL", stdout
);
9766 fputs (" FILL ", stdout
);
9767 /* XXX Print content of info word? */
9770 fputs (" TAGS ", stdout
);
9771 /* XXX Print content of info word? */
9774 fputs (" HWAND ", stdout
);
9775 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9776 fputs (" R4KEOP_CHECKED", stdout
);
9777 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9778 fputs (" R4KEOP_CLEAN", stdout
);
9781 fputs (" HWOR ", stdout
);
9782 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9783 fputs (" R4KEOP_CHECKED", stdout
);
9784 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9785 fputs (" R4KEOP_CLEAN", stdout
);
9788 printf (" GP_GROUP %#06lx self-contained %#06lx",
9789 option
->info
& OGP_GROUP
,
9790 (option
->info
& OGP_SELF
) >> 16);
9793 printf (" IDENT %#06lx self-contained %#06lx",
9794 option
->info
& OGP_GROUP
,
9795 (option
->info
& OGP_SELF
) >> 16);
9798 /* This shouldn't happen. */
9799 printf (" %3d ??? %d %lx",
9800 option
->kind
, option
->section
, option
->info
);
9804 len
= sizeof (* eopt
);
9805 while (len
< option
->size
)
9806 if (((char *) option
)[len
] >= ' '
9807 && ((char *) option
)[len
] < 0x7f)
9808 printf ("%c", ((char *) option
)[len
++]);
9810 printf ("\\%03o", ((char *) option
)[len
++]);
9812 fputs ("\n", stdout
);
9820 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9822 Elf32_Conflict
* iconf
;
9825 if (dynamic_symbols
== NULL
)
9827 error (_("conflict list found without a dynamic symbol table\n"));
9831 iconf
= cmalloc (conflictsno
, sizeof (* iconf
));
9834 error (_("Out of memory\n"));
9840 Elf32_External_Conflict
* econf32
;
9842 econf32
= get_data (NULL
, file
, conflicts_offset
,
9843 conflictsno
, sizeof (* econf32
), _("conflict"));
9847 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9848 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9854 Elf64_External_Conflict
* econf64
;
9856 econf64
= get_data (NULL
, file
, conflicts_offset
,
9857 conflictsno
, sizeof (* econf64
), _("conflict"));
9861 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9862 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9867 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9868 (unsigned long) conflictsno
);
9869 puts (_(" Num: Index Value Name"));
9871 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9873 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9875 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9876 print_vma (psym
->st_value
, FULL_HEX
);
9878 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9879 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9881 printf ("<corrupt: %14ld>", psym
->st_name
);
9888 if (pltgot
!= 0 && local_gotno
!= 0)
9890 bfd_vma entry
, local_end
, global_end
;
9892 unsigned char * data
;
9896 addr_size
= (is_32bit_elf
? 4 : 8);
9897 local_end
= pltgot
+ local_gotno
* addr_size
;
9898 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9900 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9901 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9902 printf (_("\nPrimary GOT:\n"));
9903 printf (_(" Canonical gp value: "));
9904 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9907 printf (_(" Reserved entries:\n"));
9908 printf (_(" %*s %10s %*s Purpose\n"),
9909 addr_size
* 2, "Address", "Access",
9910 addr_size
* 2, "Initial");
9911 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9912 printf (" Lazy resolver\n");
9914 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9915 >> (addr_size
* 8 - 1)) != 0)
9917 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9918 printf (" Module pointer (GNU extension)\n");
9922 if (entry
< local_end
)
9924 printf (_(" Local entries:\n"));
9925 printf (_(" %*s %10s %*s\n"),
9926 addr_size
* 2, "Address", "Access",
9927 addr_size
* 2, "Initial");
9928 while (entry
< local_end
)
9930 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9936 if (gotsym
< symtabno
)
9940 printf (_(" Global entries:\n"));
9941 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9942 addr_size
* 2, "Address", "Access",
9943 addr_size
* 2, "Initial",
9944 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9945 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9946 for (i
= gotsym
; i
< symtabno
; i
++)
9948 Elf_Internal_Sym
* psym
;
9950 psym
= dynamic_symbols
+ i
;
9951 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9953 print_vma (psym
->st_value
, LONG_HEX
);
9954 printf (" %-7s %3s ",
9955 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9956 get_symbol_index_type (psym
->st_shndx
));
9957 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9958 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9960 printf ("<corrupt: %14ld>", psym
->st_name
);
9970 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9973 size_t offset
, rel_offset
;
9974 unsigned long count
, i
;
9975 unsigned char * data
;
9976 int addr_size
, sym_width
;
9977 Elf_Internal_Rela
* rels
;
9979 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9980 if (pltrel
== DT_RELA
)
9982 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9987 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9991 entry
= mips_pltgot
;
9992 addr_size
= (is_32bit_elf
? 4 : 8);
9993 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9995 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9996 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9997 printf (_("\nPLT GOT:\n\n"));
9998 printf (_(" Reserved entries:\n"));
9999 printf (_(" %*s %*s Purpose\n"),
10000 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10001 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10002 printf (" PLT lazy resolver\n");
10003 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10004 printf (" Module pointer\n");
10007 printf (_(" Entries:\n"));
10008 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10009 addr_size
* 2, "Address",
10010 addr_size
* 2, "Initial",
10011 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10012 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10013 for (i
= 0; i
< count
; i
++)
10015 Elf_Internal_Sym
* psym
;
10017 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10018 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10020 print_vma (psym
->st_value
, LONG_HEX
);
10021 printf (" %-7s %3s ",
10022 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10023 get_symbol_index_type (psym
->st_shndx
));
10024 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10025 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10027 printf ("<corrupt: %14ld>", psym
->st_name
);
10041 process_gnu_liblist (FILE * file
)
10043 Elf_Internal_Shdr
* section
;
10044 Elf_Internal_Shdr
* string_sec
;
10045 Elf32_External_Lib
* elib
;
10047 size_t strtab_size
;
10054 for (i
= 0, section
= section_headers
;
10055 i
< elf_header
.e_shnum
;
10058 switch (section
->sh_type
)
10060 case SHT_GNU_LIBLIST
:
10061 if (section
->sh_link
>= elf_header
.e_shnum
)
10064 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10069 string_sec
= section_headers
+ section
->sh_link
;
10071 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10072 string_sec
->sh_size
, _("liblist string table"));
10073 strtab_size
= string_sec
->sh_size
;
10076 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10082 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10083 SECTION_NAME (section
),
10084 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10086 puts (" Library Time Stamp Checksum Version Flags");
10088 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10096 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10097 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10098 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10099 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10100 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10102 tmp
= gmtime (&time
);
10103 snprintf (timebuf
, sizeof (timebuf
),
10104 "%04u-%02u-%02uT%02u:%02u:%02u",
10105 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10106 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10108 printf ("%3lu: ", (unsigned long) cnt
);
10110 printf ("%-20s", liblist
.l_name
< strtab_size
10111 ? strtab
+ liblist
.l_name
: "<corrupt>");
10113 printf ("%-20.20s", liblist
.l_name
< strtab_size
10114 ? strtab
+ liblist
.l_name
: "<corrupt>");
10115 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10116 liblist
.l_version
, liblist
.l_flags
);
10126 static const char *
10127 get_note_type (unsigned e_type
)
10129 static char buff
[64];
10131 if (elf_header
.e_type
== ET_CORE
)
10135 return _("NT_AUXV (auxiliary vector)");
10137 return _("NT_PRSTATUS (prstatus structure)");
10139 return _("NT_FPREGSET (floating point registers)");
10141 return _("NT_PRPSINFO (prpsinfo structure)");
10142 case NT_TASKSTRUCT
:
10143 return _("NT_TASKSTRUCT (task structure)");
10145 return _("NT_PRXFPREG (user_xfpregs structure)");
10147 return _("NT_PPC_VMX (ppc Altivec registers)");
10149 return _("NT_PPC_VSX (ppc VSX registers)");
10151 return _("NT_PSTATUS (pstatus structure)");
10153 return _("NT_FPREGS (floating point registers)");
10155 return _("NT_PSINFO (psinfo structure)");
10157 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10159 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10160 case NT_WIN32PSTATUS
:
10161 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10169 return _("NT_VERSION (version)");
10171 return _("NT_ARCH (architecture)");
10176 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10180 static const char *
10181 get_gnu_elf_note_type (unsigned e_type
)
10183 static char buff
[64];
10187 case NT_GNU_ABI_TAG
:
10188 return _("NT_GNU_ABI_TAG (ABI version tag)");
10190 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10191 case NT_GNU_BUILD_ID
:
10192 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10193 case NT_GNU_GOLD_VERSION
:
10194 return _("NT_GNU_GOLD_VERSION (gold version)");
10199 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10203 static const char *
10204 get_netbsd_elfcore_note_type (unsigned e_type
)
10206 static char buff
[64];
10208 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10210 /* NetBSD core "procinfo" structure. */
10211 return _("NetBSD procinfo structure");
10214 /* As of Jan 2002 there are no other machine-independent notes
10215 defined for NetBSD core files. If the note type is less
10216 than the start of the machine-dependent note types, we don't
10219 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10221 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10225 switch (elf_header
.e_machine
)
10227 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10228 and PT_GETFPREGS == mach+2. */
10233 case EM_SPARC32PLUS
:
10237 case NT_NETBSDCORE_FIRSTMACH
+0:
10238 return _("PT_GETREGS (reg structure)");
10239 case NT_NETBSDCORE_FIRSTMACH
+2:
10240 return _("PT_GETFPREGS (fpreg structure)");
10246 /* On all other arch's, PT_GETREGS == mach+1 and
10247 PT_GETFPREGS == mach+3. */
10251 case NT_NETBSDCORE_FIRSTMACH
+1:
10252 return _("PT_GETREGS (reg structure)");
10253 case NT_NETBSDCORE_FIRSTMACH
+3:
10254 return _("PT_GETFPREGS (fpreg structure)");
10260 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10261 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10265 /* Note that by the ELF standard, the name field is already null byte
10266 terminated, and namesz includes the terminating null byte.
10267 I.E. the value of namesz for the name "FSF" is 4.
10269 If the value of namesz is zero, there is no name present. */
10271 process_note (Elf_Internal_Note
* pnote
)
10273 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10276 if (pnote
->namesz
== 0)
10277 /* If there is no note name, then use the default set of
10278 note type strings. */
10279 nt
= get_note_type (pnote
->type
);
10281 else if (const_strneq (pnote
->namedata
, "GNU"))
10282 /* GNU-specific object file notes. */
10283 nt
= get_gnu_elf_note_type (pnote
->type
);
10285 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10286 /* NetBSD-specific core file notes. */
10287 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10289 else if (strneq (pnote
->namedata
, "SPU/", 4))
10291 /* SPU-specific core file notes. */
10292 nt
= pnote
->namedata
+ 4;
10297 /* Don't recognize this note name; just use the default set of
10298 note type strings. */
10299 nt
= get_note_type (pnote
->type
);
10301 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10307 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10309 Elf_External_Note
* pnotes
;
10310 Elf_External_Note
* external
;
10316 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10322 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10323 (unsigned long) offset
, (unsigned long) length
);
10324 printf (_(" Owner\t\tData size\tDescription\n"));
10326 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10328 Elf_External_Note
* next
;
10329 Elf_Internal_Note inote
;
10330 char * temp
= NULL
;
10332 inote
.type
= BYTE_GET (external
->type
);
10333 inote
.namesz
= BYTE_GET (external
->namesz
);
10334 inote
.namedata
= external
->name
;
10335 inote
.descsz
= BYTE_GET (external
->descsz
);
10336 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10337 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10339 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10341 if (((char *) next
) > (((char *) pnotes
) + length
))
10343 warn (_("corrupt note found at offset %lx into core notes\n"),
10344 (unsigned long) ((char *) external
- (char *) pnotes
));
10345 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10346 inote
.type
, inote
.namesz
, inote
.descsz
);
10352 /* Verify that name is null terminated. It appears that at least
10353 one version of Linux (RedHat 6.0) generates corefiles that don't
10354 comply with the ELF spec by failing to include the null byte in
10356 if (inote
.namedata
[inote
.namesz
] != '\0')
10358 temp
= malloc (inote
.namesz
+ 1);
10362 error (_("Out of memory\n"));
10367 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10368 temp
[inote
.namesz
] = 0;
10370 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10371 inote
.namedata
= temp
;
10374 res
&= process_note (& inote
);
10389 process_corefile_note_segments (FILE * file
)
10391 Elf_Internal_Phdr
* segment
;
10395 if (! get_program_headers (file
))
10398 for (i
= 0, segment
= program_headers
;
10399 i
< elf_header
.e_phnum
;
10402 if (segment
->p_type
== PT_NOTE
)
10403 res
&= process_corefile_note_segment (file
,
10404 (bfd_vma
) segment
->p_offset
,
10405 (bfd_vma
) segment
->p_filesz
);
10412 process_note_sections (FILE * file
)
10414 Elf_Internal_Shdr
* section
;
10418 for (i
= 0, section
= section_headers
;
10419 i
< elf_header
.e_shnum
;
10421 if (section
->sh_type
== SHT_NOTE
)
10422 res
&= process_corefile_note_segment (file
,
10423 (bfd_vma
) section
->sh_offset
,
10424 (bfd_vma
) section
->sh_size
);
10430 process_notes (FILE * file
)
10432 /* If we have not been asked to display the notes then do nothing. */
10436 if (elf_header
.e_type
!= ET_CORE
)
10437 return process_note_sections (file
);
10439 /* No program headers means no NOTE segment. */
10440 if (elf_header
.e_phnum
> 0)
10441 return process_corefile_note_segments (file
);
10443 printf (_("No note segments present in the core file.\n"));
10448 process_arch_specific (FILE * file
)
10453 switch (elf_header
.e_machine
)
10456 return process_arm_specific (file
);
10458 case EM_MIPS_RS3_LE
:
10459 return process_mips_specific (file
);
10462 return process_power_specific (file
);
10471 get_file_header (FILE * file
)
10473 /* Read in the identity array. */
10474 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10477 /* Determine how to read the rest of the header. */
10478 switch (elf_header
.e_ident
[EI_DATA
])
10480 default: /* fall through */
10481 case ELFDATANONE
: /* fall through */
10483 byte_get
= byte_get_little_endian
;
10484 byte_put
= byte_put_little_endian
;
10487 byte_get
= byte_get_big_endian
;
10488 byte_put
= byte_put_big_endian
;
10492 /* For now we only support 32 bit and 64 bit ELF files. */
10493 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10495 /* Read in the rest of the header. */
10498 Elf32_External_Ehdr ehdr32
;
10500 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10503 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10504 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10505 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10506 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10507 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10508 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10509 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10510 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10511 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10512 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10513 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10514 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10515 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10519 Elf64_External_Ehdr ehdr64
;
10521 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10522 we will not be able to cope with the 64bit data found in
10523 64 ELF files. Detect this now and abort before we start
10524 overwriting things. */
10525 if (sizeof (bfd_vma
) < 8)
10527 error (_("This instance of readelf has been built without support for a\n\
10528 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10532 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10535 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10536 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10537 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10538 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10539 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10540 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10541 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10542 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10543 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10544 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10545 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10546 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10547 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10550 if (elf_header
.e_shoff
)
10552 /* There may be some extensions in the first section header. Don't
10553 bomb if we can't read it. */
10555 get_32bit_section_headers (file
, 1);
10557 get_64bit_section_headers (file
, 1);
10563 /* Process one ELF object file according to the command line options.
10564 This file may actually be stored in an archive. The file is
10565 positioned at the start of the ELF object. */
10568 process_object (char * file_name
, FILE * file
)
10572 if (! get_file_header (file
))
10574 error (_("%s: Failed to read file header\n"), file_name
);
10578 /* Initialise per file variables. */
10579 for (i
= ARRAY_SIZE (version_info
); i
--;)
10580 version_info
[i
] = 0;
10582 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10583 dynamic_info
[i
] = 0;
10585 /* Process the file. */
10587 printf (_("\nFile: %s\n"), file_name
);
10589 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10590 Note we do this even if cmdline_dump_sects is empty because we
10591 must make sure that the dump_sets array is zeroed out before each
10592 object file is processed. */
10593 if (num_dump_sects
> num_cmdline_dump_sects
)
10594 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10596 if (num_cmdline_dump_sects
> 0)
10598 if (num_dump_sects
== 0)
10599 /* A sneaky way of allocating the dump_sects array. */
10600 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10602 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10603 memcpy (dump_sects
, cmdline_dump_sects
,
10604 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10607 if (! process_file_header ())
10610 if (! process_section_headers (file
))
10612 /* Without loaded section headers we cannot process lots of
10614 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10616 if (! do_using_dynamic
)
10617 do_syms
= do_reloc
= 0;
10620 if (! process_section_groups (file
))
10622 /* Without loaded section groups we cannot process unwind. */
10626 if (process_program_headers (file
))
10627 process_dynamic_section (file
);
10629 process_relocs (file
);
10631 process_unwind (file
);
10633 process_symbol_table (file
);
10635 process_syminfo (file
);
10637 process_version_sections (file
);
10639 process_section_contents (file
);
10641 process_notes (file
);
10643 process_gnu_liblist (file
);
10645 process_arch_specific (file
);
10647 if (program_headers
)
10649 free (program_headers
);
10650 program_headers
= NULL
;
10653 if (section_headers
)
10655 free (section_headers
);
10656 section_headers
= NULL
;
10661 free (string_table
);
10662 string_table
= NULL
;
10663 string_table_length
= 0;
10666 if (dynamic_strings
)
10668 free (dynamic_strings
);
10669 dynamic_strings
= NULL
;
10670 dynamic_strings_length
= 0;
10673 if (dynamic_symbols
)
10675 free (dynamic_symbols
);
10676 dynamic_symbols
= NULL
;
10677 num_dynamic_syms
= 0;
10680 if (dynamic_syminfo
)
10682 free (dynamic_syminfo
);
10683 dynamic_syminfo
= NULL
;
10686 if (section_headers_groups
)
10688 free (section_headers_groups
);
10689 section_headers_groups
= NULL
;
10692 if (section_groups
)
10694 struct group_list
* g
;
10695 struct group_list
* next
;
10697 for (i
= 0; i
< group_count
; i
++)
10699 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10706 free (section_groups
);
10707 section_groups
= NULL
;
10710 free_debug_memory ();
10715 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10716 to the path name of the thin archive itself if necessary. Always returns
10717 a pointer to malloc'ed memory. */
10720 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10722 char * member_file_name
;
10723 const char * base_name
= lbasename (file_name
);
10725 /* This is a proxy entry for a thin archive member.
10726 If the extended name table contains an absolute path
10727 name, or if the archive is in the current directory,
10728 use the path name as given. Otherwise, we need to
10729 find the member relative to the directory where the
10730 archive is located. */
10731 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10733 member_file_name
= malloc (name_len
+ 1);
10734 if (member_file_name
== NULL
)
10736 error (_("Out of memory\n"));
10739 memcpy (member_file_name
, name
, name_len
);
10740 member_file_name
[name_len
] = '\0';
10744 /* Concatenate the path components of the archive file name
10745 to the relative path name from the extended name table. */
10746 size_t prefix_len
= base_name
- file_name
;
10747 member_file_name
= malloc (prefix_len
+ name_len
+ 1);
10748 if (member_file_name
== NULL
)
10750 error (_("Out of memory\n"));
10753 memcpy (member_file_name
, file_name
, prefix_len
);
10754 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10755 member_file_name
[prefix_len
+ name_len
] = '\0';
10757 return member_file_name
;
10760 /* Structure to hold information about an archive file. */
10762 struct archive_info
10764 char * file_name
; /* Archive file name. */
10765 FILE * file
; /* Open file descriptor. */
10766 unsigned long index_num
; /* Number of symbols in table. */
10767 unsigned long * index_array
; /* The array of member offsets. */
10768 char * sym_table
; /* The symbol table. */
10769 unsigned long sym_size
; /* Size of the symbol table. */
10770 char * longnames
; /* The long file names table. */
10771 unsigned long longnames_size
; /* Size of the long file names table. */
10772 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10773 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10774 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10775 struct ar_hdr arhdr
; /* Current archive header. */
10778 /* Read the symbol table and long-name table from an archive. */
10781 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10782 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10785 unsigned long size
;
10787 arch
->file_name
= strdup (file_name
);
10789 arch
->index_num
= 0;
10790 arch
->index_array
= NULL
;
10791 arch
->sym_table
= NULL
;
10792 arch
->sym_size
= 0;
10793 arch
->longnames
= NULL
;
10794 arch
->longnames_size
= 0;
10795 arch
->nested_member_origin
= 0;
10796 arch
->is_thin_archive
= is_thin_archive
;
10797 arch
->next_arhdr_offset
= SARMAG
;
10799 /* Read the first archive member header. */
10800 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10802 error (_("%s: failed to seek to first archive header\n"), file_name
);
10805 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10806 if (got
!= sizeof arch
->arhdr
)
10811 error (_("%s: failed to read archive header\n"), file_name
);
10815 /* See if this is the archive symbol table. */
10816 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10817 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10819 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10820 size
= size
+ (size
& 1);
10822 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10827 /* A buffer used to hold numbers read in from an archive index.
10828 These are always 4 bytes long and stored in big-endian format. */
10829 #define SIZEOF_AR_INDEX_NUMBERS 4
10830 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10831 unsigned char * index_buffer
;
10833 /* Check the size of the archive index. */
10834 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10836 error (_("%s: the archive index is empty\n"), file_name
);
10840 /* Read the numer of entries in the archive index. */
10841 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10842 if (got
!= sizeof (integer_buffer
))
10844 error (_("%s: failed to read archive index\n"), file_name
);
10847 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10848 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10850 /* Read in the archive index. */
10851 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10853 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10854 file_name
, arch
->index_num
);
10857 index_buffer
= malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10858 if (index_buffer
== NULL
)
10860 error (_("Out of memory whilst trying to read archive symbol index\n"));
10863 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
10864 if (got
!= arch
->index_num
)
10866 free (index_buffer
);
10867 error (_("%s: failed to read archive index\n"), file_name
);
10870 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10872 /* Convert the index numbers into the host's numeric format. */
10873 arch
->index_array
= malloc (arch
->index_num
* sizeof (* arch
->index_array
));
10874 if (arch
->index_array
== NULL
)
10876 free (index_buffer
);
10877 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10881 for (i
= 0; i
< arch
->index_num
; i
++)
10882 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10883 SIZEOF_AR_INDEX_NUMBERS
);
10884 free (index_buffer
);
10886 /* The remaining space in the header is taken up by the symbol table. */
10889 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10892 arch
->sym_table
= malloc (size
);
10893 arch
->sym_size
= size
;
10894 if (arch
->sym_table
== NULL
)
10896 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10899 got
= fread (arch
->sym_table
, 1, size
, file
);
10902 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10908 if (fseek (file
, size
, SEEK_CUR
) != 0)
10910 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10915 /* Read the next archive header. */
10916 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10917 if (got
!= sizeof arch
->arhdr
)
10921 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10925 else if (read_symbols
)
10926 printf (_("%s has no archive index\n"), file_name
);
10928 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
10930 /* This is the archive string table holding long member names. */
10931 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10932 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
10934 arch
->longnames
= malloc (arch
->longnames_size
);
10935 if (arch
->longnames
== NULL
)
10937 error (_("Out of memory reading long symbol names in archive\n"));
10941 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
10943 free (arch
->longnames
);
10944 arch
->longnames
= NULL
;
10945 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10949 if ((arch
->longnames_size
& 1) != 0)
10956 /* Release the memory used for the archive information. */
10959 release_archive (struct archive_info
* arch
)
10961 if (arch
->file_name
!= NULL
)
10962 free (arch
->file_name
);
10963 if (arch
->index_array
!= NULL
)
10964 free (arch
->index_array
);
10965 if (arch
->sym_table
!= NULL
)
10966 free (arch
->sym_table
);
10967 if (arch
->longnames
!= NULL
)
10968 free (arch
->longnames
);
10971 /* Open and setup a nested archive, if not already open. */
10974 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
10976 FILE * member_file
;
10978 /* Have we already setup this archive? */
10979 if (nested_arch
->file_name
!= NULL
10980 && streq (nested_arch
->file_name
, member_file_name
))
10983 /* Close previous file and discard cached information. */
10984 if (nested_arch
->file
!= NULL
)
10985 fclose (nested_arch
->file
);
10986 release_archive (nested_arch
);
10988 member_file
= fopen (member_file_name
, "rb");
10989 if (member_file
== NULL
)
10991 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
10995 get_archive_member_name_at (struct archive_info
* arch
,
10996 unsigned long offset
,
10997 struct archive_info
* nested_arch
);
10999 /* Get the name of an archive member from the current archive header.
11000 For simple names, this will modify the ar_name field of the current
11001 archive header. For long names, it will return a pointer to the
11002 longnames table. For nested archives, it will open the nested archive
11003 and get the name recursively. NESTED_ARCH is a single-entry cache so
11004 we don't keep rereading the same information from a nested archive. */
11007 get_archive_member_name (struct archive_info
* arch
,
11008 struct archive_info
* nested_arch
)
11010 unsigned long j
, k
;
11012 if (arch
->arhdr
.ar_name
[0] == '/')
11014 /* We have a long name. */
11016 char * member_file_name
;
11017 char * member_name
;
11019 arch
->nested_member_origin
= 0;
11020 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11021 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11022 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11024 while ((j
< arch
->longnames_size
)
11025 && (arch
->longnames
[j
] != '\n')
11026 && (arch
->longnames
[j
] != '\0'))
11028 if (arch
->longnames
[j
-1] == '/')
11030 arch
->longnames
[j
] = '\0';
11032 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11033 return arch
->longnames
+ k
;
11035 /* This is a proxy for a member of a nested archive.
11036 Find the name of the member in that archive. */
11037 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11038 if (member_file_name
!= NULL
11039 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11040 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11042 free (member_file_name
);
11043 return member_name
;
11045 free (member_file_name
);
11047 /* Last resort: just return the name of the nested archive. */
11048 return arch
->longnames
+ k
;
11051 /* We have a normal (short) name. */
11053 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11055 arch
->arhdr
.ar_name
[j
] = '\0';
11056 return arch
->arhdr
.ar_name
;
11059 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11062 get_archive_member_name_at (struct archive_info
* arch
,
11063 unsigned long offset
,
11064 struct archive_info
* nested_arch
)
11068 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11070 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11073 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11074 if (got
!= sizeof arch
->arhdr
)
11076 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11079 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11081 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11085 return get_archive_member_name (arch
, nested_arch
);
11088 /* Construct a string showing the name of the archive member, qualified
11089 with the name of the containing archive file. For thin archives, we
11090 use square brackets to denote the indirection. For nested archives,
11091 we show the qualified name of the external member inside the square
11092 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11095 make_qualified_name (struct archive_info
* arch
,
11096 struct archive_info
* nested_arch
,
11097 char * member_name
)
11102 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11103 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11104 len
+= strlen (nested_arch
->file_name
) + 2;
11106 name
= malloc (len
);
11109 error (_("Out of memory\n"));
11113 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11114 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11115 else if (arch
->is_thin_archive
)
11116 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11118 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11123 /* Process an ELF archive.
11124 On entry the file is positioned just after the ARMAG string. */
11127 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11129 struct archive_info arch
;
11130 struct archive_info nested_arch
;
11132 size_t file_name_size
;
11137 /* The ARCH structure is used to hold information about this archive. */
11138 arch
.file_name
= NULL
;
11140 arch
.index_array
= NULL
;
11141 arch
.sym_table
= NULL
;
11142 arch
.longnames
= NULL
;
11144 /* The NESTED_ARCH structure is used as a single-item cache of information
11145 about a nested archive (when members of a thin archive reside within
11146 another regular archive file). */
11147 nested_arch
.file_name
= NULL
;
11148 nested_arch
.file
= NULL
;
11149 nested_arch
.index_array
= NULL
;
11150 nested_arch
.sym_table
= NULL
;
11151 nested_arch
.longnames
= NULL
;
11153 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11159 if (do_archive_index
)
11161 if (arch
.sym_table
== NULL
)
11162 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11166 unsigned long current_pos
;
11168 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11169 file_name
, arch
.index_num
, arch
.sym_size
);
11170 current_pos
= ftell (file
);
11172 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11174 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11176 char * member_name
;
11178 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11180 if (member_name
!= NULL
)
11182 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11184 if (qualified_name
!= NULL
)
11186 printf (_("Binary %s contains:\n"), qualified_name
);
11187 free (qualified_name
);
11192 if (l
>= arch
.sym_size
)
11194 error (_("%s: end of the symbol table reached before the end of the index\n"),
11198 printf ("\t%s\n", arch
.sym_table
+ l
);
11199 l
+= strlen (arch
.sym_table
+ l
) + 1;
11204 if (l
< arch
.sym_size
)
11205 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11208 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11210 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11216 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11217 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11218 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11219 && !do_section_groups
)
11221 ret
= 0; /* Archive index only. */
11226 file_name_size
= strlen (file_name
);
11233 char * qualified_name
;
11235 /* Read the next archive header. */
11236 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11238 error (_("%s: failed to seek to next archive header\n"), file_name
);
11241 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11242 if (got
!= sizeof arch
.arhdr
)
11246 error (_("%s: failed to read archive header\n"), file_name
);
11250 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11252 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11257 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11259 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11260 if (archive_file_size
& 01)
11261 ++archive_file_size
;
11263 name
= get_archive_member_name (&arch
, &nested_arch
);
11266 error (_("%s: bad archive file name\n"), file_name
);
11270 namelen
= strlen (name
);
11272 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11273 if (qualified_name
== NULL
)
11275 error (_("%s: bad archive file name\n"), file_name
);
11280 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11282 /* This is a proxy for an external member of a thin archive. */
11283 FILE * member_file
;
11284 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11285 if (member_file_name
== NULL
)
11291 member_file
= fopen (member_file_name
, "rb");
11292 if (member_file
== NULL
)
11294 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11295 free (member_file_name
);
11300 archive_file_offset
= arch
.nested_member_origin
;
11302 ret
|= process_object (qualified_name
, member_file
);
11304 fclose (member_file
);
11305 free (member_file_name
);
11307 else if (is_thin_archive
)
11309 /* This is a proxy for a member of a nested archive. */
11310 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11312 /* The nested archive file will have been opened and setup by
11313 get_archive_member_name. */
11314 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11316 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11321 ret
|= process_object (qualified_name
, nested_arch
.file
);
11325 archive_file_offset
= arch
.next_arhdr_offset
;
11326 arch
.next_arhdr_offset
+= archive_file_size
;
11328 ret
|= process_object (qualified_name
, file
);
11331 free (qualified_name
);
11335 if (nested_arch
.file
!= NULL
)
11336 fclose (nested_arch
.file
);
11337 release_archive (&nested_arch
);
11338 release_archive (&arch
);
11344 process_file (char * file_name
)
11347 struct stat statbuf
;
11348 char armag
[SARMAG
];
11351 if (stat (file_name
, &statbuf
) < 0)
11353 if (errno
== ENOENT
)
11354 error (_("'%s': No such file\n"), file_name
);
11356 error (_("Could not locate '%s'. System error message: %s\n"),
11357 file_name
, strerror (errno
));
11361 if (! S_ISREG (statbuf
.st_mode
))
11363 error (_("'%s' is not an ordinary file\n"), file_name
);
11367 file
= fopen (file_name
, "rb");
11370 error (_("Input file '%s' is not readable.\n"), file_name
);
11374 if (fread (armag
, SARMAG
, 1, file
) != 1)
11376 error (_("%s: Failed to read file's magic number\n"), file_name
);
11381 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11382 ret
= process_archive (file_name
, file
, FALSE
);
11383 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11384 ret
= process_archive (file_name
, file
, TRUE
);
11387 if (do_archive_index
)
11388 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11392 archive_file_size
= archive_file_offset
= 0;
11393 ret
= process_object (file_name
, file
);
11401 #ifdef SUPPORT_DISASSEMBLY
11402 /* Needed by the i386 disassembler. For extra credit, someone could
11403 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11407 print_address (unsigned int addr
, FILE * outfile
)
11409 fprintf (outfile
,"0x%8.8x", addr
);
11412 /* Needed by the i386 disassembler. */
11414 db_task_printsym (unsigned int addr
)
11416 print_address (addr
, stderr
);
11421 main (int argc
, char ** argv
)
11425 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11426 setlocale (LC_MESSAGES
, "");
11428 #if defined (HAVE_SETLOCALE)
11429 setlocale (LC_CTYPE
, "");
11431 bindtextdomain (PACKAGE
, LOCALEDIR
);
11432 textdomain (PACKAGE
);
11434 expandargv (&argc
, &argv
);
11436 parse_args (argc
, argv
);
11438 if (num_dump_sects
> 0)
11440 /* Make a copy of the dump_sects array. */
11441 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
11442 if (cmdline_dump_sects
== NULL
)
11443 error (_("Out of memory allocating dump request table.\n"));
11446 memcpy (cmdline_dump_sects
, dump_sects
,
11447 num_dump_sects
* sizeof (* dump_sects
));
11448 num_cmdline_dump_sects
= num_dump_sects
;
11452 if (optind
< (argc
- 1))
11456 while (optind
< argc
)
11457 err
|= process_file (argv
[optind
++]);
11459 if (dump_sects
!= NULL
)
11461 if (cmdline_dump_sects
!= NULL
)
11462 free (cmdline_dump_sects
);