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/mips.h"
123 #include "elf/mmix.h"
124 #include "elf/mn10200.h"
125 #include "elf/mn10300.h"
127 #include "elf/msp430.h"
128 #include "elf/or32.h"
131 #include "elf/ppc64.h"
132 #include "elf/s390.h"
133 #include "elf/score.h"
135 #include "elf/sparc.h"
137 #include "elf/v850.h"
139 #include "elf/x86-64.h"
140 #include "elf/xstormy16.h"
141 #include "elf/xtensa.h"
146 #include "libiberty.h"
147 #include "safe-ctype.h"
148 #include "filenames.h"
150 char * program_name
= "readelf";
152 static long archive_file_offset
;
153 static unsigned long archive_file_size
;
154 static unsigned long dynamic_addr
;
155 static bfd_size_type dynamic_size
;
156 static unsigned int dynamic_nent
;
157 static char * dynamic_strings
;
158 static unsigned long dynamic_strings_length
;
159 static char * string_table
;
160 static unsigned long string_table_length
;
161 static unsigned long num_dynamic_syms
;
162 static Elf_Internal_Sym
* dynamic_symbols
;
163 static Elf_Internal_Syminfo
* dynamic_syminfo
;
164 static unsigned long dynamic_syminfo_offset
;
165 static unsigned int dynamic_syminfo_nent
;
166 static char program_interpreter
[PATH_MAX
];
167 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
168 static bfd_vma dynamic_info_DT_GNU_HASH
;
169 static bfd_vma version_info
[16];
170 static Elf_Internal_Ehdr elf_header
;
171 static Elf_Internal_Shdr
* section_headers
;
172 static Elf_Internal_Phdr
* program_headers
;
173 static Elf_Internal_Dyn
* dynamic_section
;
174 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
175 static int show_name
;
176 static int do_dynamic
;
179 static int do_sections
;
180 static int do_section_groups
;
181 static int do_section_details
;
182 static int do_segments
;
183 static int do_unwind
;
184 static int do_using_dynamic
;
185 static int do_header
;
187 static int do_version
;
188 static int do_histogram
;
189 static int do_debugging
;
192 static int do_archive_index
;
193 static int is_32bit_elf
;
197 struct group_list
* next
;
198 unsigned int section_index
;
203 struct group_list
* root
;
204 unsigned int group_index
;
207 static size_t group_count
;
208 static struct group
* section_groups
;
209 static struct group
** section_headers_groups
;
212 /* Flag bits indicating particular types of dump. */
213 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
214 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
215 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
216 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
217 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
219 typedef unsigned char dump_type
;
221 /* A linked list of the section names for which dumps were requested. */
222 struct dump_list_entry
226 struct dump_list_entry
* next
;
228 static struct dump_list_entry
* dump_sects_byname
;
230 /* A dynamic array of flags indicating for which sections a dump
231 has been requested via command line switches. */
232 static dump_type
* cmdline_dump_sects
= NULL
;
233 static unsigned int num_cmdline_dump_sects
= 0;
235 /* A dynamic array of flags indicating for which sections a dump of
236 some kind has been requested. It is reset on a per-object file
237 basis and then initialised from the cmdline_dump_sects array,
238 the results of interpreting the -w switch, and the
239 dump_sects_byname list. */
240 static dump_type
* dump_sects
= NULL
;
241 static unsigned int num_dump_sects
= 0;
244 /* How to print a vma value. */
245 typedef enum print_mode
257 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
261 #define SECTION_NAME(X) \
262 ((X) == NULL ? "<none>" \
263 : string_table == NULL ? "<no-name>" \
264 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
265 : string_table + (X)->sh_name))
267 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
269 #define BYTE_GET(field) byte_get (field, sizeof (field))
271 #define GET_ELF_SYMBOLS(file, section) \
272 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
273 : get_64bit_elf_symbols (file, section))
275 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
276 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
277 already been called and verified that the string exists. */
278 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
280 /* This is just a bit of syntatic sugar. */
281 #define streq(a,b) (strcmp ((a), (b)) == 0)
282 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
283 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
286 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
291 if (size
== 0 || nmemb
== 0)
294 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
296 error (_("Unable to seek to 0x%lx for %s\n"),
297 (unsigned long) archive_file_offset
+ offset
, reason
);
304 /* Check for overflow. */
305 if (nmemb
< (~(size_t) 0 - 1) / size
)
306 /* + 1 so that we can '\0' terminate invalid string table sections. */
307 mvar
= malloc (size
* nmemb
+ 1);
311 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
312 (unsigned long)(size
* nmemb
), reason
);
316 ((char *) mvar
)[size
* nmemb
] = '\0';
319 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
321 error (_("Unable to read in 0x%lx bytes of %s\n"),
322 (unsigned long)(size
* nmemb
), reason
);
332 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
337 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
338 field
[6] = ((value
>> 24) >> 24) & 0xff;
339 field
[5] = ((value
>> 24) >> 16) & 0xff;
340 field
[4] = ((value
>> 24) >> 8) & 0xff;
343 field
[3] = (value
>> 24) & 0xff;
344 field
[2] = (value
>> 16) & 0xff;
347 field
[1] = (value
>> 8) & 0xff;
350 field
[0] = value
& 0xff;
354 error (_("Unhandled data length: %d\n"), size
);
359 /* Print a VMA value. */
362 print_vma (bfd_vma vma
, print_mode mode
)
375 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
382 return printf ("%5" BFD_VMA_FMT
"d", vma
);
390 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
393 return printf ("%" BFD_VMA_FMT
"d", vma
);
396 return printf ("%" BFD_VMA_FMT
"u", vma
);
401 /* Display a symbol on stdout. Handles the display of non-printing characters.
403 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
404 truncating as necessary. If WIDTH is negative then format the string to be
405 exactly - WIDTH characters, truncating or padding as necessary.
407 Returns the number of emitted characters. */
410 print_symbol (int width
, const char * symbol
)
413 bfd_boolean extra_padding
= FALSE
;
414 unsigned int num_printed
= 0;
418 /* Set the width to a very large value. This simplifies the code below. */
423 /* Keep the width positive. This also helps. */
425 extra_padding
= TRUE
;
434 /* Look for non-printing symbols inside the symbol's name.
435 This test is triggered in particular by the names generated
436 by the assembler for local labels. */
437 while (ISPRINT (* c
))
447 printf ("%.*s", len
, symbol
);
453 if (* c
== 0 || width
== 0)
456 /* Now display the non-printing character, if
457 there is room left in which to dipslay it. */
463 printf ("^%c", *c
+ 0x40);
473 printf ("<0x%.2x>", *c
);
482 if (extra_padding
&& width
> 0)
484 /* Fill in the remaining spaces. */
485 printf ("%-*s", width
, " ");
493 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
498 field
[7] = value
& 0xff;
499 field
[6] = (value
>> 8) & 0xff;
500 field
[5] = (value
>> 16) & 0xff;
501 field
[4] = (value
>> 24) & 0xff;
506 field
[3] = value
& 0xff;
507 field
[2] = (value
>> 8) & 0xff;
511 field
[1] = value
& 0xff;
515 field
[0] = value
& 0xff;
519 error (_("Unhandled data length: %d\n"), size
);
524 /* Return a pointer to section NAME, or NULL if no such section exists. */
526 static Elf_Internal_Shdr
*
527 find_section (const char * name
)
531 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
532 if (streq (SECTION_NAME (section_headers
+ i
), name
))
533 return section_headers
+ i
;
538 /* Guess the relocation size commonly used by the specific machines. */
541 guess_is_rela (unsigned int e_machine
)
545 /* Targets that use REL relocations. */
561 /* Targets that use RELA relocations. */
565 case EM_ALTERA_NIOS2
:
585 case EM_LATTICEMICO32
:
593 case EM_CYGNUS_MN10200
:
595 case EM_CYGNUS_MN10300
:
636 warn (_("Don't know about relocations on this machine architecture\n"));
642 slurp_rela_relocs (FILE * file
,
643 unsigned long rel_offset
,
644 unsigned long rel_size
,
645 Elf_Internal_Rela
** relasp
,
646 unsigned long * nrelasp
)
648 Elf_Internal_Rela
* relas
;
649 unsigned long nrelas
;
654 Elf32_External_Rela
* erelas
;
656 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
660 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
662 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
667 error (_("out of memory parsing relocs\n"));
671 for (i
= 0; i
< nrelas
; i
++)
673 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
674 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
675 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
682 Elf64_External_Rela
* erelas
;
684 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
688 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
690 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
695 error (_("out of memory parsing relocs\n"));
699 for (i
= 0; i
< nrelas
; i
++)
701 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
702 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
703 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
705 /* The #ifdef BFD64 below is to prevent a compile time
706 warning. We know that if we do not have a 64 bit data
707 type that we will never execute this code anyway. */
709 if (elf_header
.e_machine
== EM_MIPS
710 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
712 /* In little-endian objects, r_info isn't really a
713 64-bit little-endian value: it has a 32-bit
714 little-endian symbol index followed by four
715 individual byte fields. Reorder INFO
717 bfd_vma info
= relas
[i
].r_info
;
718 info
= (((info
& 0xffffffff) << 32)
719 | ((info
>> 56) & 0xff)
720 | ((info
>> 40) & 0xff00)
721 | ((info
>> 24) & 0xff0000)
722 | ((info
>> 8) & 0xff000000));
723 relas
[i
].r_info
= info
;
736 slurp_rel_relocs (FILE * file
,
737 unsigned long rel_offset
,
738 unsigned long rel_size
,
739 Elf_Internal_Rela
** relsp
,
740 unsigned long * nrelsp
)
742 Elf_Internal_Rela
* rels
;
748 Elf32_External_Rel
* erels
;
750 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
754 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
756 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
761 error (_("out of memory parsing relocs\n"));
765 for (i
= 0; i
< nrels
; i
++)
767 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
768 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
769 rels
[i
].r_addend
= 0;
776 Elf64_External_Rel
* erels
;
778 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
782 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
784 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
789 error (_("out of memory parsing relocs\n"));
793 for (i
= 0; i
< nrels
; i
++)
795 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
796 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
797 rels
[i
].r_addend
= 0;
799 /* The #ifdef BFD64 below is to prevent a compile time
800 warning. We know that if we do not have a 64 bit data
801 type that we will never execute this code anyway. */
803 if (elf_header
.e_machine
== EM_MIPS
804 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
806 /* In little-endian objects, r_info isn't really a
807 64-bit little-endian value: it has a 32-bit
808 little-endian symbol index followed by four
809 individual byte fields. Reorder INFO
811 bfd_vma info
= rels
[i
].r_info
;
812 info
= (((info
& 0xffffffff) << 32)
813 | ((info
>> 56) & 0xff)
814 | ((info
>> 40) & 0xff00)
815 | ((info
>> 24) & 0xff0000)
816 | ((info
>> 8) & 0xff000000));
817 rels
[i
].r_info
= info
;
829 /* Returns the reloc type extracted from the reloc info field. */
832 get_reloc_type (bfd_vma reloc_info
)
835 return ELF32_R_TYPE (reloc_info
);
837 switch (elf_header
.e_machine
)
840 /* Note: We assume that reloc_info has already been adjusted for us. */
841 return ELF64_MIPS_R_TYPE (reloc_info
);
844 return ELF64_R_TYPE_ID (reloc_info
);
847 return ELF64_R_TYPE (reloc_info
);
851 /* Return the symbol index extracted from the reloc info field. */
854 get_reloc_symindex (bfd_vma reloc_info
)
856 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
859 /* Display the contents of the relocation data found at the specified
863 dump_relocations (FILE * file
,
864 unsigned long rel_offset
,
865 unsigned long rel_size
,
866 Elf_Internal_Sym
* symtab
,
869 unsigned long strtablen
,
873 Elf_Internal_Rela
* rels
;
875 if (is_rela
== UNKNOWN
)
876 is_rela
= guess_is_rela (elf_header
.e_machine
);
880 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
885 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
894 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
896 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
901 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
903 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
911 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
913 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
918 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
920 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
924 for (i
= 0; i
< rel_size
; i
++)
929 bfd_vma symtab_index
;
932 offset
= rels
[i
].r_offset
;
933 info
= rels
[i
].r_info
;
935 type
= get_reloc_type (info
);
936 symtab_index
= get_reloc_symindex (info
);
940 printf ("%8.8lx %8.8lx ",
941 (unsigned long) offset
& 0xffffffff,
942 (unsigned long) info
& 0xffffffff);
946 #if BFD_HOST_64BIT_LONG
948 ? "%16.16lx %16.16lx "
949 : "%12.12lx %12.12lx ",
951 #elif BFD_HOST_64BIT_LONG_LONG
954 ? "%16.16llx %16.16llx "
955 : "%12.12llx %12.12llx ",
959 ? "%16.16I64x %16.16I64x "
960 : "%12.12I64x %12.12I64x ",
965 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
966 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
967 _bfd_int64_high (offset
),
968 _bfd_int64_low (offset
),
969 _bfd_int64_high (info
),
970 _bfd_int64_low (info
));
974 switch (elf_header
.e_machine
)
982 rtype
= elf_m32r_reloc_type (type
);
987 rtype
= elf_i386_reloc_type (type
);
992 rtype
= elf_m68hc11_reloc_type (type
);
996 rtype
= elf_m68k_reloc_type (type
);
1000 rtype
= elf_i960_reloc_type (type
);
1005 rtype
= elf_avr_reloc_type (type
);
1008 case EM_OLD_SPARCV9
:
1009 case EM_SPARC32PLUS
:
1012 rtype
= elf_sparc_reloc_type (type
);
1016 rtype
= elf_spu_reloc_type (type
);
1020 case EM_CYGNUS_V850
:
1021 rtype
= v850_reloc_type (type
);
1025 case EM_CYGNUS_D10V
:
1026 rtype
= elf_d10v_reloc_type (type
);
1030 case EM_CYGNUS_D30V
:
1031 rtype
= elf_d30v_reloc_type (type
);
1035 rtype
= elf_dlx_reloc_type (type
);
1039 rtype
= elf_sh_reloc_type (type
);
1043 case EM_CYGNUS_MN10300
:
1044 rtype
= elf_mn10300_reloc_type (type
);
1048 case EM_CYGNUS_MN10200
:
1049 rtype
= elf_mn10200_reloc_type (type
);
1053 case EM_CYGNUS_FR30
:
1054 rtype
= elf_fr30_reloc_type (type
);
1058 rtype
= elf_frv_reloc_type (type
);
1062 rtype
= elf_mcore_reloc_type (type
);
1066 rtype
= elf_mmix_reloc_type (type
);
1071 rtype
= elf_msp430_reloc_type (type
);
1075 rtype
= elf_ppc_reloc_type (type
);
1079 rtype
= elf_ppc64_reloc_type (type
);
1083 case EM_MIPS_RS3_LE
:
1084 rtype
= elf_mips_reloc_type (type
);
1088 rtype
= elf_alpha_reloc_type (type
);
1092 rtype
= elf_arm_reloc_type (type
);
1096 rtype
= elf_arc_reloc_type (type
);
1100 rtype
= elf_hppa_reloc_type (type
);
1106 rtype
= elf_h8_reloc_type (type
);
1111 rtype
= elf_or32_reloc_type (type
);
1116 rtype
= elf_pj_reloc_type (type
);
1119 rtype
= elf_ia64_reloc_type (type
);
1123 rtype
= elf_cris_reloc_type (type
);
1127 rtype
= elf_i860_reloc_type (type
);
1131 rtype
= elf_x86_64_reloc_type (type
);
1135 rtype
= i370_reloc_type (type
);
1140 rtype
= elf_s390_reloc_type (type
);
1144 rtype
= elf_score_reloc_type (type
);
1148 rtype
= elf_xstormy16_reloc_type (type
);
1152 rtype
= elf_crx_reloc_type (type
);
1156 rtype
= elf_vax_reloc_type (type
);
1161 rtype
= elf_ip2k_reloc_type (type
);
1165 rtype
= elf_iq2000_reloc_type (type
);
1170 rtype
= elf_xtensa_reloc_type (type
);
1173 case EM_LATTICEMICO32
:
1174 rtype
= elf_lm32_reloc_type (type
);
1179 rtype
= elf_m32c_reloc_type (type
);
1183 rtype
= elf_mt_reloc_type (type
);
1187 rtype
= elf_bfin_reloc_type (type
);
1191 rtype
= elf_mep_reloc_type (type
);
1196 rtype
= elf_cr16_reloc_type (type
);
1201 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1203 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1205 if (elf_header
.e_machine
== EM_ALPHA
1207 && streq (rtype
, "R_ALPHA_LITUSE")
1210 switch (rels
[i
].r_addend
)
1212 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1213 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1214 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1215 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1216 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1217 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1218 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1219 default: rtype
= NULL
;
1222 printf (" (%s)", rtype
);
1226 printf (_("<unknown addend: %lx>"),
1227 (unsigned long) rels
[i
].r_addend
);
1230 else if (symtab_index
)
1232 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1233 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1236 Elf_Internal_Sym
* psym
;
1238 psym
= symtab
+ symtab_index
;
1242 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1246 unsigned int width
= is_32bit_elf
? 8 : 14;
1248 /* Relocations against GNU_IFUNC symbols do not use the value
1249 of the symbol as the address to relocate against. Instead
1250 they invoke the function named by the symbol and use its
1251 result as the address for relocation.
1253 To indicate this to the user, do not display the value of
1254 the symbol in the "Symbols's Value" field. Instead show
1255 its name followed by () as a hint that the symbol is
1259 || psym
->st_name
== 0
1260 || psym
->st_name
>= strtablen
)
1263 name
= strtab
+ psym
->st_name
;
1265 len
= print_symbol (width
, name
);
1266 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1270 print_vma (psym
->st_value
, LONG_HEX
);
1272 printf (is_32bit_elf
? " " : " ");
1275 if (psym
->st_name
== 0)
1277 const char * sec_name
= "<null>";
1280 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1282 if (psym
->st_shndx
< elf_header
.e_shnum
)
1284 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1285 else if (psym
->st_shndx
== SHN_ABS
)
1287 else if (psym
->st_shndx
== SHN_COMMON
)
1288 sec_name
= "COMMON";
1289 else if (elf_header
.e_machine
== EM_MIPS
1290 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1291 sec_name
= "SCOMMON";
1292 else if (elf_header
.e_machine
== EM_MIPS
1293 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1294 sec_name
= "SUNDEF";
1295 else if (elf_header
.e_machine
== EM_X86_64
1296 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1297 sec_name
= "LARGE_COMMON";
1298 else if (elf_header
.e_machine
== EM_IA_64
1299 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1300 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1301 sec_name
= "ANSI_COM";
1302 else if (elf_header
.e_machine
== EM_IA_64
1303 && (elf_header
.e_ident
[EI_OSABI
]
1304 == ELFOSABI_OPENVMS
)
1305 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1306 sec_name
= "VMS_SYMVEC";
1309 sprintf (name_buf
, "<section 0x%x>",
1310 (unsigned int) psym
->st_shndx
);
1311 sec_name
= name_buf
;
1314 print_symbol (22, sec_name
);
1316 else if (strtab
== NULL
)
1317 printf (_("<string table index: %3ld>"), psym
->st_name
);
1318 else if (psym
->st_name
>= strtablen
)
1319 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1321 print_symbol (22, strtab
+ psym
->st_name
);
1325 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1328 printf (" - %lx", - offset
);
1330 printf (" + %lx", offset
);
1336 printf ("%*c", is_32bit_elf
?
1337 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1338 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1341 if (elf_header
.e_machine
== EM_SPARCV9
1343 && streq (rtype
, "R_SPARC_OLO10"))
1344 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1349 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1351 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1352 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1353 const char * rtype2
= elf_mips_reloc_type (type2
);
1354 const char * rtype3
= elf_mips_reloc_type (type3
);
1356 printf (" Type2: ");
1359 printf (_("unrecognized: %-7lx"),
1360 (unsigned long) type2
& 0xffffffff);
1362 printf ("%-17.17s", rtype2
);
1364 printf ("\n Type3: ");
1367 printf (_("unrecognized: %-7lx"),
1368 (unsigned long) type3
& 0xffffffff);
1370 printf ("%-17.17s", rtype3
);
1381 get_mips_dynamic_type (unsigned long type
)
1385 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1386 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1387 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1388 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1389 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1390 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1391 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1392 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1393 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1394 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1395 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1396 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1397 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1398 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1399 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1400 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1401 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1402 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1403 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1404 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1405 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1406 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1407 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1408 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1409 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1410 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1411 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1412 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1413 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1414 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1415 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1416 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1417 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1418 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1419 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1420 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1421 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1422 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1423 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1424 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1425 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1426 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1427 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1428 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1429 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1436 get_sparc64_dynamic_type (unsigned long type
)
1440 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1447 get_ppc_dynamic_type (unsigned long type
)
1451 case DT_PPC_GOT
: return "PPC_GOT";
1458 get_ppc64_dynamic_type (unsigned long type
)
1462 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1463 case DT_PPC64_OPD
: return "PPC64_OPD";
1464 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1471 get_parisc_dynamic_type (unsigned long type
)
1475 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1476 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1477 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1478 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1479 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1480 case DT_HP_PREINIT
: return "HP_PREINIT";
1481 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1482 case DT_HP_NEEDED
: return "HP_NEEDED";
1483 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1484 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1485 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1486 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1487 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1488 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1489 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1490 case DT_HP_FILTERED
: return "HP_FILTERED";
1491 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1492 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1493 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1494 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1495 case DT_PLT
: return "PLT";
1496 case DT_PLT_SIZE
: return "PLT_SIZE";
1497 case DT_DLT
: return "DLT";
1498 case DT_DLT_SIZE
: return "DLT_SIZE";
1505 get_ia64_dynamic_type (unsigned long type
)
1509 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1510 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1511 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1512 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1513 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1514 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1515 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1516 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1517 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1518 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1519 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1520 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1521 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1522 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1523 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1524 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1525 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1526 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1527 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1528 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1529 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1530 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1531 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1532 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1533 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1534 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1535 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1536 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1537 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1538 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1539 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1546 get_alpha_dynamic_type (unsigned long type
)
1550 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1557 get_score_dynamic_type (unsigned long type
)
1561 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1562 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1563 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1564 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1565 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1566 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1574 get_dynamic_type (unsigned long type
)
1576 static char buff
[64];
1580 case DT_NULL
: return "NULL";
1581 case DT_NEEDED
: return "NEEDED";
1582 case DT_PLTRELSZ
: return "PLTRELSZ";
1583 case DT_PLTGOT
: return "PLTGOT";
1584 case DT_HASH
: return "HASH";
1585 case DT_STRTAB
: return "STRTAB";
1586 case DT_SYMTAB
: return "SYMTAB";
1587 case DT_RELA
: return "RELA";
1588 case DT_RELASZ
: return "RELASZ";
1589 case DT_RELAENT
: return "RELAENT";
1590 case DT_STRSZ
: return "STRSZ";
1591 case DT_SYMENT
: return "SYMENT";
1592 case DT_INIT
: return "INIT";
1593 case DT_FINI
: return "FINI";
1594 case DT_SONAME
: return "SONAME";
1595 case DT_RPATH
: return "RPATH";
1596 case DT_SYMBOLIC
: return "SYMBOLIC";
1597 case DT_REL
: return "REL";
1598 case DT_RELSZ
: return "RELSZ";
1599 case DT_RELENT
: return "RELENT";
1600 case DT_PLTREL
: return "PLTREL";
1601 case DT_DEBUG
: return "DEBUG";
1602 case DT_TEXTREL
: return "TEXTREL";
1603 case DT_JMPREL
: return "JMPREL";
1604 case DT_BIND_NOW
: return "BIND_NOW";
1605 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1606 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1607 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1608 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1609 case DT_RUNPATH
: return "RUNPATH";
1610 case DT_FLAGS
: return "FLAGS";
1612 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1613 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1615 case DT_CHECKSUM
: return "CHECKSUM";
1616 case DT_PLTPADSZ
: return "PLTPADSZ";
1617 case DT_MOVEENT
: return "MOVEENT";
1618 case DT_MOVESZ
: return "MOVESZ";
1619 case DT_FEATURE
: return "FEATURE";
1620 case DT_POSFLAG_1
: return "POSFLAG_1";
1621 case DT_SYMINSZ
: return "SYMINSZ";
1622 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1624 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1625 case DT_CONFIG
: return "CONFIG";
1626 case DT_DEPAUDIT
: return "DEPAUDIT";
1627 case DT_AUDIT
: return "AUDIT";
1628 case DT_PLTPAD
: return "PLTPAD";
1629 case DT_MOVETAB
: return "MOVETAB";
1630 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1632 case DT_VERSYM
: return "VERSYM";
1634 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1635 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1636 case DT_RELACOUNT
: return "RELACOUNT";
1637 case DT_RELCOUNT
: return "RELCOUNT";
1638 case DT_FLAGS_1
: return "FLAGS_1";
1639 case DT_VERDEF
: return "VERDEF";
1640 case DT_VERDEFNUM
: return "VERDEFNUM";
1641 case DT_VERNEED
: return "VERNEED";
1642 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1644 case DT_AUXILIARY
: return "AUXILIARY";
1645 case DT_USED
: return "USED";
1646 case DT_FILTER
: return "FILTER";
1648 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1649 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1650 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1651 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1652 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1653 case DT_GNU_HASH
: return "GNU_HASH";
1656 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1658 const char * result
;
1660 switch (elf_header
.e_machine
)
1663 case EM_MIPS_RS3_LE
:
1664 result
= get_mips_dynamic_type (type
);
1667 result
= get_sparc64_dynamic_type (type
);
1670 result
= get_ppc_dynamic_type (type
);
1673 result
= get_ppc64_dynamic_type (type
);
1676 result
= get_ia64_dynamic_type (type
);
1679 result
= get_alpha_dynamic_type (type
);
1682 result
= get_score_dynamic_type (type
);
1692 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1694 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1695 || (elf_header
.e_machine
== EM_PARISC
1696 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1698 const char * result
;
1700 switch (elf_header
.e_machine
)
1703 result
= get_parisc_dynamic_type (type
);
1706 result
= get_ia64_dynamic_type (type
);
1716 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1720 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1727 get_file_type (unsigned e_type
)
1729 static char buff
[32];
1733 case ET_NONE
: return _("NONE (None)");
1734 case ET_REL
: return _("REL (Relocatable file)");
1735 case ET_EXEC
: return _("EXEC (Executable file)");
1736 case ET_DYN
: return _("DYN (Shared object file)");
1737 case ET_CORE
: return _("CORE (Core file)");
1740 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1741 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1742 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1743 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1745 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1751 get_machine_name (unsigned e_machine
)
1753 static char buff
[64]; /* XXX */
1757 case EM_NONE
: return _("None");
1758 case EM_M32
: return "WE32100";
1759 case EM_SPARC
: return "Sparc";
1760 case EM_SPU
: return "SPU";
1761 case EM_386
: return "Intel 80386";
1762 case EM_68K
: return "MC68000";
1763 case EM_88K
: return "MC88000";
1764 case EM_486
: return "Intel 80486";
1765 case EM_860
: return "Intel 80860";
1766 case EM_MIPS
: return "MIPS R3000";
1767 case EM_S370
: return "IBM System/370";
1768 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1769 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1770 case EM_PARISC
: return "HPPA";
1771 case EM_PPC_OLD
: return "Power PC (old)";
1772 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1773 case EM_960
: return "Intel 90860";
1774 case EM_PPC
: return "PowerPC";
1775 case EM_PPC64
: return "PowerPC64";
1776 case EM_V800
: return "NEC V800";
1777 case EM_FR20
: return "Fujitsu FR20";
1778 case EM_RH32
: return "TRW RH32";
1779 case EM_MCORE
: return "MCORE";
1780 case EM_ARM
: return "ARM";
1781 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1782 case EM_SH
: return "Renesas / SuperH SH";
1783 case EM_SPARCV9
: return "Sparc v9";
1784 case EM_TRICORE
: return "Siemens Tricore";
1785 case EM_ARC
: return "ARC";
1786 case EM_H8_300
: return "Renesas H8/300";
1787 case EM_H8_300H
: return "Renesas H8/300H";
1788 case EM_H8S
: return "Renesas H8S";
1789 case EM_H8_500
: return "Renesas H8/500";
1790 case EM_IA_64
: return "Intel IA-64";
1791 case EM_MIPS_X
: return "Stanford MIPS-X";
1792 case EM_COLDFIRE
: return "Motorola Coldfire";
1793 case EM_68HC12
: return "Motorola M68HC12";
1794 case EM_ALPHA
: return "Alpha";
1795 case EM_CYGNUS_D10V
:
1796 case EM_D10V
: return "d10v";
1797 case EM_CYGNUS_D30V
:
1798 case EM_D30V
: return "d30v";
1799 case EM_CYGNUS_M32R
:
1800 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1801 case EM_CYGNUS_V850
:
1802 case EM_V850
: return "NEC v850";
1803 case EM_CYGNUS_MN10300
:
1804 case EM_MN10300
: return "mn10300";
1805 case EM_CYGNUS_MN10200
:
1806 case EM_MN10200
: return "mn10200";
1807 case EM_CYGNUS_FR30
:
1808 case EM_FR30
: return "Fujitsu FR30";
1809 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1811 case EM_PJ
: return "picoJava";
1812 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1813 case EM_PCP
: return "Siemens PCP";
1814 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1815 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1816 case EM_STARCORE
: return "Motorola Star*Core processor";
1817 case EM_ME16
: return "Toyota ME16 processor";
1818 case EM_ST100
: return "STMicroelectronics ST100 processor";
1819 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1820 case EM_FX66
: return "Siemens FX66 microcontroller";
1821 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1822 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1823 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1824 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1825 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1826 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1827 case EM_SVX
: return "Silicon Graphics SVx";
1828 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1829 case EM_VAX
: return "Digital VAX";
1831 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1832 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1833 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1834 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1835 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1836 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1837 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1838 case EM_PRISM
: return "Vitesse Prism";
1839 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1841 case EM_S390
: return "IBM S/390";
1842 case EM_SCORE
: return "SUNPLUS S+Core";
1843 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1845 case EM_OR32
: return "OpenRISC";
1846 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1847 case EM_DLX
: return "OpenDLX";
1849 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1850 case EM_IQ2000
: return "Vitesse IQ2000";
1852 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1853 case EM_LATTICEMICO32
: return "Lattice Mico32";
1855 case EM_M32C
: return "Renesas M32c";
1856 case EM_MT
: return "Morpho Techologies MT processor";
1857 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1858 case EM_NIOS32
: return "Altera Nios";
1859 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1860 case EM_XC16X
: return "Infineon Technologies xc16x";
1861 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1863 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1865 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1871 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1876 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1877 e_flags
&= ~ EF_ARM_EABIMASK
;
1879 /* Handle "generic" ARM flags. */
1880 if (e_flags
& EF_ARM_RELEXEC
)
1882 strcat (buf
, ", relocatable executable");
1883 e_flags
&= ~ EF_ARM_RELEXEC
;
1886 if (e_flags
& EF_ARM_HASENTRY
)
1888 strcat (buf
, ", has entry point");
1889 e_flags
&= ~ EF_ARM_HASENTRY
;
1892 /* Now handle EABI specific flags. */
1896 strcat (buf
, ", <unrecognized EABI>");
1901 case EF_ARM_EABI_VER1
:
1902 strcat (buf
, ", Version1 EABI");
1907 /* Process flags one bit at a time. */
1908 flag
= e_flags
& - e_flags
;
1913 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1914 strcat (buf
, ", sorted symbol tables");
1924 case EF_ARM_EABI_VER2
:
1925 strcat (buf
, ", Version2 EABI");
1930 /* Process flags one bit at a time. */
1931 flag
= e_flags
& - e_flags
;
1936 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1937 strcat (buf
, ", sorted symbol tables");
1940 case EF_ARM_DYNSYMSUSESEGIDX
:
1941 strcat (buf
, ", dynamic symbols use segment index");
1944 case EF_ARM_MAPSYMSFIRST
:
1945 strcat (buf
, ", mapping symbols precede others");
1955 case EF_ARM_EABI_VER3
:
1956 strcat (buf
, ", Version3 EABI");
1959 case EF_ARM_EABI_VER4
:
1960 strcat (buf
, ", Version4 EABI");
1963 case EF_ARM_EABI_VER5
:
1964 strcat (buf
, ", Version5 EABI");
1970 /* Process flags one bit at a time. */
1971 flag
= e_flags
& - e_flags
;
1977 strcat (buf
, ", BE8");
1981 strcat (buf
, ", LE8");
1991 case EF_ARM_EABI_UNKNOWN
:
1992 strcat (buf
, ", GNU EABI");
1997 /* Process flags one bit at a time. */
1998 flag
= e_flags
& - e_flags
;
2003 case EF_ARM_INTERWORK
:
2004 strcat (buf
, ", interworking enabled");
2007 case EF_ARM_APCS_26
:
2008 strcat (buf
, ", uses APCS/26");
2011 case EF_ARM_APCS_FLOAT
:
2012 strcat (buf
, ", uses APCS/float");
2016 strcat (buf
, ", position independent");
2020 strcat (buf
, ", 8 bit structure alignment");
2023 case EF_ARM_NEW_ABI
:
2024 strcat (buf
, ", uses new ABI");
2027 case EF_ARM_OLD_ABI
:
2028 strcat (buf
, ", uses old ABI");
2031 case EF_ARM_SOFT_FLOAT
:
2032 strcat (buf
, ", software FP");
2035 case EF_ARM_VFP_FLOAT
:
2036 strcat (buf
, ", VFP");
2039 case EF_ARM_MAVERICK_FLOAT
:
2040 strcat (buf
, ", Maverick FP");
2051 strcat (buf
,", <unknown>");
2055 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2057 static char buf
[1024];
2069 decode_ARM_machine_flags (e_flags
, buf
);
2073 switch (e_flags
& EF_FRV_CPU_MASK
)
2075 case EF_FRV_CPU_GENERIC
:
2079 strcat (buf
, ", fr???");
2082 case EF_FRV_CPU_FR300
:
2083 strcat (buf
, ", fr300");
2086 case EF_FRV_CPU_FR400
:
2087 strcat (buf
, ", fr400");
2089 case EF_FRV_CPU_FR405
:
2090 strcat (buf
, ", fr405");
2093 case EF_FRV_CPU_FR450
:
2094 strcat (buf
, ", fr450");
2097 case EF_FRV_CPU_FR500
:
2098 strcat (buf
, ", fr500");
2100 case EF_FRV_CPU_FR550
:
2101 strcat (buf
, ", fr550");
2104 case EF_FRV_CPU_SIMPLE
:
2105 strcat (buf
, ", simple");
2107 case EF_FRV_CPU_TOMCAT
:
2108 strcat (buf
, ", tomcat");
2114 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2115 strcat (buf
, ", m68000");
2116 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2117 strcat (buf
, ", cpu32");
2118 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2119 strcat (buf
, ", fido_a");
2122 char const * isa
= _("unknown");
2123 char const * mac
= _("unknown mac");
2124 char const * additional
= NULL
;
2126 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2128 case EF_M68K_CF_ISA_A_NODIV
:
2130 additional
= ", nodiv";
2132 case EF_M68K_CF_ISA_A
:
2135 case EF_M68K_CF_ISA_A_PLUS
:
2138 case EF_M68K_CF_ISA_B_NOUSP
:
2140 additional
= ", nousp";
2142 case EF_M68K_CF_ISA_B
:
2146 strcat (buf
, ", cf, isa ");
2149 strcat (buf
, additional
);
2150 if (e_flags
& EF_M68K_CF_FLOAT
)
2151 strcat (buf
, ", float");
2152 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2157 case EF_M68K_CF_MAC
:
2160 case EF_M68K_CF_EMAC
:
2173 if (e_flags
& EF_PPC_EMB
)
2174 strcat (buf
, ", emb");
2176 if (e_flags
& EF_PPC_RELOCATABLE
)
2177 strcat (buf
, ", relocatable");
2179 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2180 strcat (buf
, ", relocatable-lib");
2184 case EM_CYGNUS_V850
:
2185 switch (e_flags
& EF_V850_ARCH
)
2188 strcat (buf
, ", v850e1");
2191 strcat (buf
, ", v850e");
2194 strcat (buf
, ", v850");
2197 strcat (buf
, ", unknown v850 architecture variant");
2203 case EM_CYGNUS_M32R
:
2204 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2205 strcat (buf
, ", m32r");
2209 case EM_MIPS_RS3_LE
:
2210 if (e_flags
& EF_MIPS_NOREORDER
)
2211 strcat (buf
, ", noreorder");
2213 if (e_flags
& EF_MIPS_PIC
)
2214 strcat (buf
, ", pic");
2216 if (e_flags
& EF_MIPS_CPIC
)
2217 strcat (buf
, ", cpic");
2219 if (e_flags
& EF_MIPS_UCODE
)
2220 strcat (buf
, ", ugen_reserved");
2222 if (e_flags
& EF_MIPS_ABI2
)
2223 strcat (buf
, ", abi2");
2225 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2226 strcat (buf
, ", odk first");
2228 if (e_flags
& EF_MIPS_32BITMODE
)
2229 strcat (buf
, ", 32bitmode");
2231 switch ((e_flags
& EF_MIPS_MACH
))
2233 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2234 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2235 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2236 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2237 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2238 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2239 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2240 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2241 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2242 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2243 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2244 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2245 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2246 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2248 /* We simply ignore the field in this case to avoid confusion:
2249 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2252 default: strcat (buf
, ", unknown CPU"); break;
2255 switch ((e_flags
& EF_MIPS_ABI
))
2257 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2258 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2259 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2260 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2262 /* We simply ignore the field in this case to avoid confusion:
2263 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2264 This means it is likely to be an o32 file, but not for
2267 default: strcat (buf
, ", unknown ABI"); break;
2270 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2271 strcat (buf
, ", mdmx");
2273 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2274 strcat (buf
, ", mips16");
2276 switch ((e_flags
& EF_MIPS_ARCH
))
2278 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2279 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2280 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2281 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2282 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2283 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2284 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2285 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2286 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2287 default: strcat (buf
, ", unknown ISA"); break;
2293 switch ((e_flags
& EF_SH_MACH_MASK
))
2295 case EF_SH1
: strcat (buf
, ", sh1"); break;
2296 case EF_SH2
: strcat (buf
, ", sh2"); break;
2297 case EF_SH3
: strcat (buf
, ", sh3"); break;
2298 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2299 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2300 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2301 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2302 case EF_SH4
: strcat (buf
, ", sh4"); break;
2303 case EF_SH5
: strcat (buf
, ", sh5"); break;
2304 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2305 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2306 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2307 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2308 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2309 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2310 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2311 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2312 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2313 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2314 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2315 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2316 default: strcat (buf
, ", unknown ISA"); break;
2322 if (e_flags
& EF_SPARC_32PLUS
)
2323 strcat (buf
, ", v8+");
2325 if (e_flags
& EF_SPARC_SUN_US1
)
2326 strcat (buf
, ", ultrasparcI");
2328 if (e_flags
& EF_SPARC_SUN_US3
)
2329 strcat (buf
, ", ultrasparcIII");
2331 if (e_flags
& EF_SPARC_HAL_R1
)
2332 strcat (buf
, ", halr1");
2334 if (e_flags
& EF_SPARC_LEDATA
)
2335 strcat (buf
, ", ledata");
2337 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2338 strcat (buf
, ", tso");
2340 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2341 strcat (buf
, ", pso");
2343 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2344 strcat (buf
, ", rmo");
2348 switch (e_flags
& EF_PARISC_ARCH
)
2350 case EFA_PARISC_1_0
:
2351 strcpy (buf
, ", PA-RISC 1.0");
2353 case EFA_PARISC_1_1
:
2354 strcpy (buf
, ", PA-RISC 1.1");
2356 case EFA_PARISC_2_0
:
2357 strcpy (buf
, ", PA-RISC 2.0");
2362 if (e_flags
& EF_PARISC_TRAPNIL
)
2363 strcat (buf
, ", trapnil");
2364 if (e_flags
& EF_PARISC_EXT
)
2365 strcat (buf
, ", ext");
2366 if (e_flags
& EF_PARISC_LSB
)
2367 strcat (buf
, ", lsb");
2368 if (e_flags
& EF_PARISC_WIDE
)
2369 strcat (buf
, ", wide");
2370 if (e_flags
& EF_PARISC_NO_KABP
)
2371 strcat (buf
, ", no kabp");
2372 if (e_flags
& EF_PARISC_LAZYSWAP
)
2373 strcat (buf
, ", lazyswap");
2378 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2379 strcat (buf
, ", new calling convention");
2381 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2382 strcat (buf
, ", gnu calling convention");
2386 if ((e_flags
& EF_IA_64_ABI64
))
2387 strcat (buf
, ", 64-bit");
2389 strcat (buf
, ", 32-bit");
2390 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2391 strcat (buf
, ", reduced fp model");
2392 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2393 strcat (buf
, ", no function descriptors, constant gp");
2394 else if ((e_flags
& EF_IA_64_CONS_GP
))
2395 strcat (buf
, ", constant gp");
2396 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2397 strcat (buf
, ", absolute");
2401 if ((e_flags
& EF_VAX_NONPIC
))
2402 strcat (buf
, ", non-PIC");
2403 if ((e_flags
& EF_VAX_DFLOAT
))
2404 strcat (buf
, ", D-Float");
2405 if ((e_flags
& EF_VAX_GFLOAT
))
2406 strcat (buf
, ", G-Float");
2415 get_osabi_name (unsigned int osabi
)
2417 static char buff
[32];
2421 case ELFOSABI_NONE
: return "UNIX - System V";
2422 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2423 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2424 case ELFOSABI_LINUX
: return "UNIX - Linux";
2425 case ELFOSABI_HURD
: return "GNU/Hurd";
2426 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2427 case ELFOSABI_AIX
: return "UNIX - AIX";
2428 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2429 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2430 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2431 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2432 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2433 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2434 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2435 case ELFOSABI_AROS
: return "AROS";
2436 case ELFOSABI_STANDALONE
: return _("Standalone App");
2437 case ELFOSABI_ARM
: return "ARM";
2439 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2445 get_arm_segment_type (unsigned long type
)
2459 get_mips_segment_type (unsigned long type
)
2463 case PT_MIPS_REGINFO
:
2465 case PT_MIPS_RTPROC
:
2467 case PT_MIPS_OPTIONS
:
2477 get_parisc_segment_type (unsigned long type
)
2481 case PT_HP_TLS
: return "HP_TLS";
2482 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2483 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2484 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2485 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2486 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2487 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2488 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2489 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2490 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2491 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2492 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2493 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2494 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2495 case PT_HP_STACK
: return "HP_STACK";
2496 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2497 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2498 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2499 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2508 get_ia64_segment_type (unsigned long type
)
2512 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2513 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2514 case PT_HP_TLS
: return "HP_TLS";
2515 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2516 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2517 case PT_IA_64_HP_STACK
: return "HP_STACK";
2526 get_segment_type (unsigned long p_type
)
2528 static char buff
[32];
2532 case PT_NULL
: return "NULL";
2533 case PT_LOAD
: return "LOAD";
2534 case PT_DYNAMIC
: return "DYNAMIC";
2535 case PT_INTERP
: return "INTERP";
2536 case PT_NOTE
: return "NOTE";
2537 case PT_SHLIB
: return "SHLIB";
2538 case PT_PHDR
: return "PHDR";
2539 case PT_TLS
: return "TLS";
2541 case PT_GNU_EH_FRAME
:
2542 return "GNU_EH_FRAME";
2543 case PT_GNU_STACK
: return "GNU_STACK";
2544 case PT_GNU_RELRO
: return "GNU_RELRO";
2547 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2549 const char * result
;
2551 switch (elf_header
.e_machine
)
2554 result
= get_arm_segment_type (p_type
);
2557 case EM_MIPS_RS3_LE
:
2558 result
= get_mips_segment_type (p_type
);
2561 result
= get_parisc_segment_type (p_type
);
2564 result
= get_ia64_segment_type (p_type
);
2574 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2576 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2578 const char * result
;
2580 switch (elf_header
.e_machine
)
2583 result
= get_parisc_segment_type (p_type
);
2586 result
= get_ia64_segment_type (p_type
);
2596 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2599 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2606 get_mips_section_type_name (unsigned int sh_type
)
2610 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2611 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2612 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2613 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2614 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2615 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2616 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2617 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2618 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2619 case SHT_MIPS_RELD
: return "MIPS_RELD";
2620 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2621 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2622 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2623 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2624 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2625 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2626 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2627 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2628 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2629 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2630 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2631 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2632 case SHT_MIPS_LINE
: return "MIPS_LINE";
2633 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2634 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2635 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2636 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2637 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2638 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2639 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2640 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2641 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2642 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2643 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2644 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2645 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2646 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2647 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2648 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2656 get_parisc_section_type_name (unsigned int sh_type
)
2660 case SHT_PARISC_EXT
: return "PARISC_EXT";
2661 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2662 case SHT_PARISC_DOC
: return "PARISC_DOC";
2663 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2664 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2665 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2666 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2674 get_ia64_section_type_name (unsigned int sh_type
)
2676 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2677 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2678 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2682 case SHT_IA_64_EXT
: return "IA_64_EXT";
2683 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2684 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2685 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2686 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2687 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2688 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2689 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2690 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2691 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2699 get_x86_64_section_type_name (unsigned int sh_type
)
2703 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2711 get_arm_section_type_name (unsigned int sh_type
)
2717 case SHT_ARM_PREEMPTMAP
:
2718 return "ARM_PREEMPTMAP";
2719 case SHT_ARM_ATTRIBUTES
:
2720 return "ARM_ATTRIBUTES";
2728 get_section_type_name (unsigned int sh_type
)
2730 static char buff
[32];
2734 case SHT_NULL
: return "NULL";
2735 case SHT_PROGBITS
: return "PROGBITS";
2736 case SHT_SYMTAB
: return "SYMTAB";
2737 case SHT_STRTAB
: return "STRTAB";
2738 case SHT_RELA
: return "RELA";
2739 case SHT_HASH
: return "HASH";
2740 case SHT_DYNAMIC
: return "DYNAMIC";
2741 case SHT_NOTE
: return "NOTE";
2742 case SHT_NOBITS
: return "NOBITS";
2743 case SHT_REL
: return "REL";
2744 case SHT_SHLIB
: return "SHLIB";
2745 case SHT_DYNSYM
: return "DYNSYM";
2746 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2747 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2748 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2749 case SHT_GNU_HASH
: return "GNU_HASH";
2750 case SHT_GROUP
: return "GROUP";
2751 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2752 case SHT_GNU_verdef
: return "VERDEF";
2753 case SHT_GNU_verneed
: return "VERNEED";
2754 case SHT_GNU_versym
: return "VERSYM";
2755 case 0x6ffffff0: return "VERSYM";
2756 case 0x6ffffffc: return "VERDEF";
2757 case 0x7ffffffd: return "AUXILIARY";
2758 case 0x7fffffff: return "FILTER";
2759 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2762 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2764 const char * result
;
2766 switch (elf_header
.e_machine
)
2769 case EM_MIPS_RS3_LE
:
2770 result
= get_mips_section_type_name (sh_type
);
2773 result
= get_parisc_section_type_name (sh_type
);
2776 result
= get_ia64_section_type_name (sh_type
);
2779 result
= get_x86_64_section_type_name (sh_type
);
2782 result
= get_arm_section_type_name (sh_type
);
2792 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2794 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2796 const char * result
;
2798 switch (elf_header
.e_machine
)
2801 result
= get_ia64_section_type_name (sh_type
);
2811 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2813 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2814 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2816 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2822 #define OPTION_DEBUG_DUMP 512
2824 static struct option options
[] =
2826 {"all", no_argument
, 0, 'a'},
2827 {"file-header", no_argument
, 0, 'h'},
2828 {"program-headers", no_argument
, 0, 'l'},
2829 {"headers", no_argument
, 0, 'e'},
2830 {"histogram", no_argument
, 0, 'I'},
2831 {"segments", no_argument
, 0, 'l'},
2832 {"sections", no_argument
, 0, 'S'},
2833 {"section-headers", no_argument
, 0, 'S'},
2834 {"section-groups", no_argument
, 0, 'g'},
2835 {"section-details", no_argument
, 0, 't'},
2836 {"full-section-name",no_argument
, 0, 'N'},
2837 {"symbols", no_argument
, 0, 's'},
2838 {"syms", no_argument
, 0, 's'},
2839 {"relocs", no_argument
, 0, 'r'},
2840 {"notes", no_argument
, 0, 'n'},
2841 {"dynamic", no_argument
, 0, 'd'},
2842 {"arch-specific", no_argument
, 0, 'A'},
2843 {"version-info", no_argument
, 0, 'V'},
2844 {"use-dynamic", no_argument
, 0, 'D'},
2845 {"unwind", no_argument
, 0, 'u'},
2846 {"archive-index", no_argument
, 0, 'c'},
2847 {"hex-dump", required_argument
, 0, 'x'},
2848 {"relocated-dump", required_argument
, 0, 'R'},
2849 {"string-dump", required_argument
, 0, 'p'},
2850 #ifdef SUPPORT_DISASSEMBLY
2851 {"instruction-dump", required_argument
, 0, 'i'},
2853 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2855 {"version", no_argument
, 0, 'v'},
2856 {"wide", no_argument
, 0, 'W'},
2857 {"help", no_argument
, 0, 'H'},
2858 {0, no_argument
, 0, 0}
2862 usage (FILE * stream
)
2864 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2865 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2866 fprintf (stream
, _(" Options are:\n\
2867 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2868 -h --file-header Display the ELF file header\n\
2869 -l --program-headers Display the program headers\n\
2870 --segments An alias for --program-headers\n\
2871 -S --section-headers Display the sections' header\n\
2872 --sections An alias for --section-headers\n\
2873 -g --section-groups Display the section groups\n\
2874 -t --section-details Display the section details\n\
2875 -e --headers Equivalent to: -h -l -S\n\
2876 -s --syms Display the symbol table\n\
2877 --symbols An alias for --syms\n\
2878 -n --notes Display the core notes (if present)\n\
2879 -r --relocs Display the relocations (if present)\n\
2880 -u --unwind Display the unwind info (if present)\n\
2881 -d --dynamic Display the dynamic section (if present)\n\
2882 -V --version-info Display the version sections (if present)\n\
2883 -A --arch-specific Display architecture specific information (if any).\n\
2884 -c --archive-index Display the symbol/file index in an archive\n\
2885 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2886 -x --hex-dump=<number|name>\n\
2887 Dump the contents of section <number|name> as bytes\n\
2888 -p --string-dump=<number|name>\n\
2889 Dump the contents of section <number|name> as strings\n\
2890 -R --relocated-dump=<number|name>\n\
2891 Dump the contents of section <number|name> as relocated bytes\n\
2892 -w[lLiaprmfFsoR] or\n\
2893 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2894 Display the contents of DWARF2 debug sections\n"));
2895 #ifdef SUPPORT_DISASSEMBLY
2896 fprintf (stream
, _("\
2897 -i --instruction-dump=<number|name>\n\
2898 Disassemble the contents of section <number|name>\n"));
2900 fprintf (stream
, _("\
2901 -I --histogram Display histogram of bucket list lengths\n\
2902 -W --wide Allow output width to exceed 80 characters\n\
2903 @<file> Read options from <file>\n\
2904 -H --help Display this information\n\
2905 -v --version Display the version number of readelf\n"));
2907 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2908 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2910 exit (stream
== stdout
? 0 : 1);
2913 /* Record the fact that the user wants the contents of section number
2914 SECTION to be displayed using the method(s) encoded as flags bits
2915 in TYPE. Note, TYPE can be zero if we are creating the array for
2919 request_dump_bynumber (unsigned int section
, dump_type type
)
2921 if (section
>= num_dump_sects
)
2923 dump_type
* new_dump_sects
;
2925 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2927 if (new_dump_sects
== NULL
)
2928 error (_("Out of memory allocating dump request table.\n"));
2931 /* Copy current flag settings. */
2932 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2936 dump_sects
= new_dump_sects
;
2937 num_dump_sects
= section
+ 1;
2942 dump_sects
[section
] |= type
;
2947 /* Request a dump by section name. */
2950 request_dump_byname (const char * section
, dump_type type
)
2952 struct dump_list_entry
* new_request
;
2954 new_request
= malloc (sizeof (struct dump_list_entry
));
2956 error (_("Out of memory allocating dump request table.\n"));
2958 new_request
->name
= strdup (section
);
2959 if (!new_request
->name
)
2960 error (_("Out of memory allocating dump request table.\n"));
2962 new_request
->type
= type
;
2964 new_request
->next
= dump_sects_byname
;
2965 dump_sects_byname
= new_request
;
2969 request_dump (dump_type type
)
2975 section
= strtoul (optarg
, & cp
, 0);
2977 if (! *cp
&& section
>= 0)
2978 request_dump_bynumber (section
, type
);
2980 request_dump_byname (optarg
, type
);
2985 parse_args (int argc
, char ** argv
)
2992 while ((c
= getopt_long
2993 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3011 do_section_groups
++;
3019 do_section_groups
++;
3024 do_section_details
++;
3068 request_dump (HEX_DUMP
);
3071 request_dump (STRING_DUMP
);
3074 request_dump (RELOC_DUMP
);
3081 dwarf_select_sections_all ();
3086 dwarf_select_sections_by_letters (optarg
);
3089 case OPTION_DEBUG_DUMP
:
3096 dwarf_select_sections_by_names (optarg
);
3099 #ifdef SUPPORT_DISASSEMBLY
3101 request_dump (DISASS_DUMP
);
3105 print_version (program_name
);
3114 /* xgettext:c-format */
3115 error (_("Invalid option '-%c'\n"), c
);
3122 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3123 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3124 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3125 && !do_section_groups
&& !do_archive_index
)
3129 warn (_("Nothing to do.\n"));
3135 get_elf_class (unsigned int elf_class
)
3137 static char buff
[32];
3141 case ELFCLASSNONE
: return _("none");
3142 case ELFCLASS32
: return "ELF32";
3143 case ELFCLASS64
: return "ELF64";
3145 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3151 get_data_encoding (unsigned int encoding
)
3153 static char buff
[32];
3157 case ELFDATANONE
: return _("none");
3158 case ELFDATA2LSB
: return _("2's complement, little endian");
3159 case ELFDATA2MSB
: return _("2's complement, big endian");
3161 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3166 /* Decode the data held in 'elf_header'. */
3169 process_file_header (void)
3171 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3172 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3173 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3174 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3177 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3181 init_dwarf_regnames (elf_header
.e_machine
);
3187 printf (_("ELF Header:\n"));
3188 printf (_(" Magic: "));
3189 for (i
= 0; i
< EI_NIDENT
; i
++)
3190 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3192 printf (_(" Class: %s\n"),
3193 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3194 printf (_(" Data: %s\n"),
3195 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3196 printf (_(" Version: %d %s\n"),
3197 elf_header
.e_ident
[EI_VERSION
],
3198 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3200 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3203 printf (_(" OS/ABI: %s\n"),
3204 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3205 printf (_(" ABI Version: %d\n"),
3206 elf_header
.e_ident
[EI_ABIVERSION
]);
3207 printf (_(" Type: %s\n"),
3208 get_file_type (elf_header
.e_type
));
3209 printf (_(" Machine: %s\n"),
3210 get_machine_name (elf_header
.e_machine
));
3211 printf (_(" Version: 0x%lx\n"),
3212 (unsigned long) elf_header
.e_version
);
3214 printf (_(" Entry point address: "));
3215 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3216 printf (_("\n Start of program headers: "));
3217 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3218 printf (_(" (bytes into file)\n Start of section headers: "));
3219 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3220 printf (_(" (bytes into file)\n"));
3222 printf (_(" Flags: 0x%lx%s\n"),
3223 (unsigned long) elf_header
.e_flags
,
3224 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3225 printf (_(" Size of this header: %ld (bytes)\n"),
3226 (long) elf_header
.e_ehsize
);
3227 printf (_(" Size of program headers: %ld (bytes)\n"),
3228 (long) elf_header
.e_phentsize
);
3229 printf (_(" Number of program headers: %ld\n"),
3230 (long) elf_header
.e_phnum
);
3231 printf (_(" Size of section headers: %ld (bytes)\n"),
3232 (long) elf_header
.e_shentsize
);
3233 printf (_(" Number of section headers: %ld"),
3234 (long) elf_header
.e_shnum
);
3235 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3236 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3237 putc ('\n', stdout
);
3238 printf (_(" Section header string table index: %ld"),
3239 (long) elf_header
.e_shstrndx
);
3240 if (section_headers
!= NULL
3241 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3242 printf (" (%u)", section_headers
[0].sh_link
);
3243 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3244 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3245 printf (" <corrupt: out of range>");
3246 putc ('\n', stdout
);
3249 if (section_headers
!= NULL
)
3251 if (elf_header
.e_shnum
== SHN_UNDEF
)
3252 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3253 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3254 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3255 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3256 elf_header
.e_shstrndx
= SHN_UNDEF
;
3257 free (section_headers
);
3258 section_headers
= NULL
;
3266 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3268 Elf32_External_Phdr
* phdrs
;
3269 Elf32_External_Phdr
* external
;
3270 Elf_Internal_Phdr
* internal
;
3273 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3274 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3275 _("program headers"));
3279 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3280 i
< elf_header
.e_phnum
;
3281 i
++, internal
++, external
++)
3283 internal
->p_type
= BYTE_GET (external
->p_type
);
3284 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3285 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3286 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3287 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3288 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3289 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3290 internal
->p_align
= BYTE_GET (external
->p_align
);
3299 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3301 Elf64_External_Phdr
* phdrs
;
3302 Elf64_External_Phdr
* external
;
3303 Elf_Internal_Phdr
* internal
;
3306 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3307 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3308 _("program headers"));
3312 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3313 i
< elf_header
.e_phnum
;
3314 i
++, internal
++, external
++)
3316 internal
->p_type
= BYTE_GET (external
->p_type
);
3317 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3318 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3319 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3320 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3321 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3322 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3323 internal
->p_align
= BYTE_GET (external
->p_align
);
3331 /* Returns 1 if the program headers were read into `program_headers'. */
3334 get_program_headers (FILE * file
)
3336 Elf_Internal_Phdr
* phdrs
;
3338 /* Check cache of prior read. */
3339 if (program_headers
!= NULL
)
3342 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3346 error (_("Out of memory\n"));
3351 ? get_32bit_program_headers (file
, phdrs
)
3352 : get_64bit_program_headers (file
, phdrs
))
3354 program_headers
= phdrs
;
3362 /* Returns 1 if the program headers were loaded. */
3365 process_program_headers (FILE * file
)
3367 Elf_Internal_Phdr
* segment
;
3370 if (elf_header
.e_phnum
== 0)
3373 printf (_("\nThere are no program headers in this file.\n"));
3377 if (do_segments
&& !do_header
)
3379 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3380 printf (_("Entry point "));
3381 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3382 printf (_("\nThere are %d program headers, starting at offset "),
3383 elf_header
.e_phnum
);
3384 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3388 if (! get_program_headers (file
))
3393 if (elf_header
.e_phnum
> 1)
3394 printf (_("\nProgram Headers:\n"));
3396 printf (_("\nProgram Headers:\n"));
3400 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3403 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3407 (_(" Type Offset VirtAddr PhysAddr\n"));
3409 (_(" FileSiz MemSiz Flags Align\n"));
3416 for (i
= 0, segment
= program_headers
;
3417 i
< elf_header
.e_phnum
;
3422 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3426 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3427 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3428 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3429 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3430 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3432 (segment
->p_flags
& PF_R
? 'R' : ' '),
3433 (segment
->p_flags
& PF_W
? 'W' : ' '),
3434 (segment
->p_flags
& PF_X
? 'E' : ' '));
3435 printf ("%#lx", (unsigned long) segment
->p_align
);
3439 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3440 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3443 print_vma (segment
->p_offset
, FULL_HEX
);
3447 print_vma (segment
->p_vaddr
, FULL_HEX
);
3449 print_vma (segment
->p_paddr
, FULL_HEX
);
3452 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3453 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3456 print_vma (segment
->p_filesz
, FULL_HEX
);
3460 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3461 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3464 print_vma (segment
->p_offset
, FULL_HEX
);
3468 (segment
->p_flags
& PF_R
? 'R' : ' '),
3469 (segment
->p_flags
& PF_W
? 'W' : ' '),
3470 (segment
->p_flags
& PF_X
? 'E' : ' '));
3472 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3473 printf ("%#lx", (unsigned long) segment
->p_align
);
3476 print_vma (segment
->p_align
, PREFIX_HEX
);
3481 print_vma (segment
->p_offset
, FULL_HEX
);
3483 print_vma (segment
->p_vaddr
, FULL_HEX
);
3485 print_vma (segment
->p_paddr
, FULL_HEX
);
3487 print_vma (segment
->p_filesz
, FULL_HEX
);
3489 print_vma (segment
->p_memsz
, FULL_HEX
);
3491 (segment
->p_flags
& PF_R
? 'R' : ' '),
3492 (segment
->p_flags
& PF_W
? 'W' : ' '),
3493 (segment
->p_flags
& PF_X
? 'E' : ' '));
3494 print_vma (segment
->p_align
, HEX
);
3498 switch (segment
->p_type
)
3502 error (_("more than one dynamic segment\n"));
3504 /* By default, assume that the .dynamic section is the first
3505 section in the DYNAMIC segment. */
3506 dynamic_addr
= segment
->p_offset
;
3507 dynamic_size
= segment
->p_filesz
;
3509 /* Try to locate the .dynamic section. If there is
3510 a section header table, we can easily locate it. */
3511 if (section_headers
!= NULL
)
3513 Elf_Internal_Shdr
* sec
;
3515 sec
= find_section (".dynamic");
3516 if (sec
== NULL
|| sec
->sh_size
== 0)
3518 error (_("no .dynamic section in the dynamic segment\n"));
3522 if (sec
->sh_type
== SHT_NOBITS
)
3528 dynamic_addr
= sec
->sh_offset
;
3529 dynamic_size
= sec
->sh_size
;
3531 if (dynamic_addr
< segment
->p_offset
3532 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3533 warn (_("the .dynamic section is not contained"
3534 " within the dynamic segment\n"));
3535 else if (dynamic_addr
> segment
->p_offset
)
3536 warn (_("the .dynamic section is not the first section"
3537 " in the dynamic segment.\n"));
3542 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3544 error (_("Unable to find program interpreter name\n"));
3548 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3550 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3551 error (_("Internal error: failed to create format string to display program interpreter\n"));
3553 program_interpreter
[0] = 0;
3554 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3555 error (_("Unable to read program interpreter name\n"));
3558 printf (_("\n [Requesting program interpreter: %s]"),
3559 program_interpreter
);
3565 putc ('\n', stdout
);
3568 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3570 printf (_("\n Section to Segment mapping:\n"));
3571 printf (_(" Segment Sections...\n"));
3573 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3576 Elf_Internal_Shdr
* section
;
3578 segment
= program_headers
+ i
;
3579 section
= section_headers
+ 1;
3581 printf (" %2.2d ", i
);
3583 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3585 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3586 printf ("%s ", SECTION_NAME (section
));
3597 /* Find the file offset corresponding to VMA by using the program headers. */
3600 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3602 Elf_Internal_Phdr
* seg
;
3604 if (! get_program_headers (file
))
3606 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3610 for (seg
= program_headers
;
3611 seg
< program_headers
+ elf_header
.e_phnum
;
3614 if (seg
->p_type
!= PT_LOAD
)
3617 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3618 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3619 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3622 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3623 (unsigned long) vma
);
3629 get_32bit_section_headers (FILE * file
, unsigned int num
)
3631 Elf32_External_Shdr
* shdrs
;
3632 Elf_Internal_Shdr
* internal
;
3635 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3636 elf_header
.e_shentsize
, num
, _("section headers"));
3640 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3642 if (section_headers
== NULL
)
3644 error (_("Out of memory\n"));
3648 for (i
= 0, internal
= section_headers
;
3652 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3653 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3654 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3655 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3656 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3657 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3658 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3659 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3660 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3661 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3670 get_64bit_section_headers (FILE * file
, unsigned int num
)
3672 Elf64_External_Shdr
* shdrs
;
3673 Elf_Internal_Shdr
* internal
;
3676 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3677 elf_header
.e_shentsize
, num
, _("section headers"));
3681 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3683 if (section_headers
== NULL
)
3685 error (_("Out of memory\n"));
3689 for (i
= 0, internal
= section_headers
;
3693 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3694 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3695 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3696 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3697 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3698 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3699 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3700 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3701 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3702 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3710 static Elf_Internal_Sym
*
3711 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3713 unsigned long number
;
3714 Elf32_External_Sym
* esyms
;
3715 Elf_External_Sym_Shndx
* shndx
;
3716 Elf_Internal_Sym
* isyms
;
3717 Elf_Internal_Sym
* psym
;
3720 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3726 if (symtab_shndx_hdr
!= NULL
3727 && (symtab_shndx_hdr
->sh_link
3728 == (unsigned long) (section
- section_headers
)))
3730 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3731 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3739 number
= section
->sh_size
/ section
->sh_entsize
;
3740 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3744 error (_("Out of memory\n"));
3751 for (j
= 0, psym
= isyms
;
3755 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3756 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3757 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3758 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3759 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3761 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3762 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3763 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3764 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3765 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3775 static Elf_Internal_Sym
*
3776 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3778 unsigned long number
;
3779 Elf64_External_Sym
* esyms
;
3780 Elf_External_Sym_Shndx
* shndx
;
3781 Elf_Internal_Sym
* isyms
;
3782 Elf_Internal_Sym
* psym
;
3785 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3791 if (symtab_shndx_hdr
!= NULL
3792 && (symtab_shndx_hdr
->sh_link
3793 == (unsigned long) (section
- section_headers
)))
3795 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3796 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3804 number
= section
->sh_size
/ section
->sh_entsize
;
3805 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3809 error (_("Out of memory\n"));
3816 for (j
= 0, psym
= isyms
;
3820 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3821 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3822 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3823 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3824 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3826 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3827 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3828 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3829 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3830 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3841 get_elf_section_flags (bfd_vma sh_flags
)
3843 static char buff
[1024];
3845 int field_size
= is_32bit_elf
? 8 : 16;
3846 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3847 bfd_vma os_flags
= 0;
3848 bfd_vma proc_flags
= 0;
3849 bfd_vma unknown_flags
= 0;
3863 { "LINK ORDER", 10 },
3864 { "OS NONCONF", 10 },
3867 /* IA-64 specific. */
3870 /* IA-64 OpenVMS specific. */
3871 { "VMS_GLOBAL", 10 },
3872 { "VMS_OVERLAID", 12 },
3873 { "VMS_SHARED", 10 },
3874 { "VMS_VECTOR", 10 },
3875 { "VMS_ALLOC_64BIT", 15 },
3876 { "VMS_PROTECTED", 13}
3879 if (do_section_details
)
3881 sprintf (buff
, "[%*.*lx]: ",
3882 field_size
, field_size
, (unsigned long) sh_flags
);
3883 p
+= field_size
+ 4;
3890 flag
= sh_flags
& - sh_flags
;
3893 if (do_section_details
)
3897 case SHF_WRITE
: index
= 0; break;
3898 case SHF_ALLOC
: index
= 1; break;
3899 case SHF_EXECINSTR
: index
= 2; break;
3900 case SHF_MERGE
: index
= 3; break;
3901 case SHF_STRINGS
: index
= 4; break;
3902 case SHF_INFO_LINK
: index
= 5; break;
3903 case SHF_LINK_ORDER
: index
= 6; break;
3904 case SHF_OS_NONCONFORMING
: index
= 7; break;
3905 case SHF_GROUP
: index
= 8; break;
3906 case SHF_TLS
: index
= 9; break;
3910 if (elf_header
.e_machine
== EM_IA_64
)
3912 if (flag
== SHF_IA_64_SHORT
)
3914 else if (flag
== SHF_IA_64_NORECOV
)
3917 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3920 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3921 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3922 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3923 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3924 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3925 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3935 if (p
!= buff
+ field_size
+ 4)
3937 if (size
< (10 + 2))
3944 size
-= flags
[index
].len
;
3945 p
= stpcpy (p
, flags
[index
].str
);
3947 else if (flag
& SHF_MASKOS
)
3949 else if (flag
& SHF_MASKPROC
)
3952 unknown_flags
|= flag
;
3958 case SHF_WRITE
: *p
= 'W'; break;
3959 case SHF_ALLOC
: *p
= 'A'; break;
3960 case SHF_EXECINSTR
: *p
= 'X'; break;
3961 case SHF_MERGE
: *p
= 'M'; break;
3962 case SHF_STRINGS
: *p
= 'S'; break;
3963 case SHF_INFO_LINK
: *p
= 'I'; break;
3964 case SHF_LINK_ORDER
: *p
= 'L'; break;
3965 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3966 case SHF_GROUP
: *p
= 'G'; break;
3967 case SHF_TLS
: *p
= 'T'; break;
3970 if (elf_header
.e_machine
== EM_X86_64
3971 && flag
== SHF_X86_64_LARGE
)
3973 else if (flag
& SHF_MASKOS
)
3976 sh_flags
&= ~ SHF_MASKOS
;
3978 else if (flag
& SHF_MASKPROC
)
3981 sh_flags
&= ~ SHF_MASKPROC
;
3991 if (do_section_details
)
3995 size
-= 5 + field_size
;
3996 if (p
!= buff
+ field_size
+ 4)
4004 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4005 (unsigned long) os_flags
);
4006 p
+= 5 + field_size
;
4010 size
-= 7 + field_size
;
4011 if (p
!= buff
+ field_size
+ 4)
4019 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4020 (unsigned long) proc_flags
);
4021 p
+= 7 + field_size
;
4025 size
-= 10 + field_size
;
4026 if (p
!= buff
+ field_size
+ 4)
4034 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4035 (unsigned long) unknown_flags
);
4036 p
+= 10 + field_size
;
4045 process_section_headers (FILE * file
)
4047 Elf_Internal_Shdr
* section
;
4050 section_headers
= NULL
;
4052 if (elf_header
.e_shnum
== 0)
4055 printf (_("\nThere are no sections in this file.\n"));
4060 if (do_sections
&& !do_header
)
4061 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4062 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4066 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4069 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4072 /* Read in the string table, so that we have names to display. */
4073 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4074 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4076 section
= section_headers
+ elf_header
.e_shstrndx
;
4078 if (section
->sh_size
!= 0)
4080 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4081 1, section
->sh_size
, _("string table"));
4083 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4087 /* Scan the sections for the dynamic symbol table
4088 and dynamic string table and debug sections. */
4089 dynamic_symbols
= NULL
;
4090 dynamic_strings
= NULL
;
4091 dynamic_syminfo
= NULL
;
4092 symtab_shndx_hdr
= NULL
;
4094 eh_addr_size
= is_32bit_elf
? 4 : 8;
4095 switch (elf_header
.e_machine
)
4098 case EM_MIPS_RS3_LE
:
4099 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4100 FDE addresses. However, the ABI also has a semi-official ILP32
4101 variant for which the normal FDE address size rules apply.
4103 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4104 section, where XX is the size of longs in bits. Unfortunately,
4105 earlier compilers provided no way of distinguishing ILP32 objects
4106 from LP64 objects, so if there's any doubt, we should assume that
4107 the official LP64 form is being used. */
4108 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4109 && find_section (".gcc_compiled_long32") == NULL
)
4115 switch (elf_header
.e_flags
& EF_H8_MACH
)
4117 case E_H8_MACH_H8300
:
4118 case E_H8_MACH_H8300HN
:
4119 case E_H8_MACH_H8300SN
:
4120 case E_H8_MACH_H8300SXN
:
4123 case E_H8_MACH_H8300H
:
4124 case E_H8_MACH_H8300S
:
4125 case E_H8_MACH_H8300SX
:
4133 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4135 case EF_M32C_CPU_M16C
:
4142 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4145 size_t expected_entsize \
4146 = is_32bit_elf ? size32 : size64; \
4147 if (section->sh_entsize != expected_entsize) \
4148 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4149 i, (unsigned long int) section->sh_entsize, \
4150 (unsigned long int) expected_entsize); \
4151 section->sh_entsize = expected_entsize; \
4154 #define CHECK_ENTSIZE(section, i, type) \
4155 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4156 sizeof (Elf64_External_##type))
4158 for (i
= 0, section
= section_headers
;
4159 i
< elf_header
.e_shnum
;
4162 char * name
= SECTION_NAME (section
);
4164 if (section
->sh_type
== SHT_DYNSYM
)
4166 if (dynamic_symbols
!= NULL
)
4168 error (_("File contains multiple dynamic symbol tables\n"));
4172 CHECK_ENTSIZE (section
, i
, Sym
);
4173 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4174 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4176 else if (section
->sh_type
== SHT_STRTAB
4177 && streq (name
, ".dynstr"))
4179 if (dynamic_strings
!= NULL
)
4181 error (_("File contains multiple dynamic string tables\n"));
4185 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4186 1, section
->sh_size
, _("dynamic strings"));
4187 dynamic_strings_length
= section
->sh_size
;
4189 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4191 if (symtab_shndx_hdr
!= NULL
)
4193 error (_("File contains multiple symtab shndx tables\n"));
4196 symtab_shndx_hdr
= section
;
4198 else if (section
->sh_type
== SHT_SYMTAB
)
4199 CHECK_ENTSIZE (section
, i
, Sym
);
4200 else if (section
->sh_type
== SHT_GROUP
)
4201 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4202 else if (section
->sh_type
== SHT_REL
)
4203 CHECK_ENTSIZE (section
, i
, Rel
);
4204 else if (section
->sh_type
== SHT_RELA
)
4205 CHECK_ENTSIZE (section
, i
, Rela
);
4206 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4207 || do_debug_lines
|| do_debug_pubnames
4208 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4209 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4210 && (const_strneq (name
, ".debug_")
4211 || const_strneq (name
, ".zdebug_")))
4214 name
+= sizeof (".zdebug_") - 1;
4216 name
+= sizeof (".debug_") - 1;
4219 || (do_debug_info
&& streq (name
, "info"))
4220 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4221 || (do_debug_lines
&& streq (name
, "line"))
4222 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4223 || (do_debug_aranges
&& streq (name
, "aranges"))
4224 || (do_debug_ranges
&& streq (name
, "ranges"))
4225 || (do_debug_frames
&& streq (name
, "frame"))
4226 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4227 || (do_debug_str
&& streq (name
, "str"))
4228 || (do_debug_loc
&& streq (name
, "loc"))
4230 request_dump_bynumber (i
, DEBUG_DUMP
);
4232 /* Linkonce section to be combined with .debug_info at link time. */
4233 else if ((do_debugging
|| do_debug_info
)
4234 && const_strneq (name
, ".gnu.linkonce.wi."))
4235 request_dump_bynumber (i
, DEBUG_DUMP
);
4236 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4237 request_dump_bynumber (i
, DEBUG_DUMP
);
4243 if (elf_header
.e_shnum
> 1)
4244 printf (_("\nSection Headers:\n"));
4246 printf (_("\nSection Header:\n"));
4250 if (do_section_details
)
4252 printf (_(" [Nr] Name\n"));
4253 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4257 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4261 if (do_section_details
)
4263 printf (_(" [Nr] Name\n"));
4264 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4268 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4272 if (do_section_details
)
4274 printf (_(" [Nr] Name\n"));
4275 printf (_(" Type Address Offset Link\n"));
4276 printf (_(" Size EntSize Info Align\n"));
4280 printf (_(" [Nr] Name Type Address Offset\n"));
4281 printf (_(" Size EntSize Flags Link Info Align\n"));
4285 if (do_section_details
)
4286 printf (_(" Flags\n"));
4288 for (i
= 0, section
= section_headers
;
4289 i
< elf_header
.e_shnum
;
4292 if (do_section_details
)
4294 printf (" [%2u] %s\n",
4296 SECTION_NAME (section
));
4297 if (is_32bit_elf
|| do_wide
)
4298 printf (" %-15.15s ",
4299 get_section_type_name (section
->sh_type
));
4302 printf ((do_wide
? " [%2u] %-17s %-15s "
4303 : " [%2u] %-17.17s %-15.15s "),
4305 SECTION_NAME (section
),
4306 get_section_type_name (section
->sh_type
));
4310 print_vma (section
->sh_addr
, LONG_HEX
);
4312 printf ( " %6.6lx %6.6lx %2.2lx",
4313 (unsigned long) section
->sh_offset
,
4314 (unsigned long) section
->sh_size
,
4315 (unsigned long) section
->sh_entsize
);
4317 if (do_section_details
)
4318 fputs (" ", stdout
);
4320 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4322 printf ("%2u %3u %2lu\n",
4325 (unsigned long) section
->sh_addralign
);
4329 print_vma (section
->sh_addr
, LONG_HEX
);
4331 if ((long) section
->sh_offset
== section
->sh_offset
)
4332 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4336 print_vma (section
->sh_offset
, LONG_HEX
);
4339 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4340 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4344 print_vma (section
->sh_size
, LONG_HEX
);
4347 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4348 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4352 print_vma (section
->sh_entsize
, LONG_HEX
);
4355 if (do_section_details
)
4356 fputs (" ", stdout
);
4358 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4360 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4362 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4363 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4366 print_vma (section
->sh_addralign
, DEC
);
4370 else if (do_section_details
)
4372 printf (" %-15.15s ",
4373 get_section_type_name (section
->sh_type
));
4374 print_vma (section
->sh_addr
, LONG_HEX
);
4375 if ((long) section
->sh_offset
== section
->sh_offset
)
4376 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4380 print_vma (section
->sh_offset
, LONG_HEX
);
4382 printf (" %u\n ", section
->sh_link
);
4383 print_vma (section
->sh_size
, LONG_HEX
);
4385 print_vma (section
->sh_entsize
, LONG_HEX
);
4387 printf (" %-16u %lu\n",
4389 (unsigned long) section
->sh_addralign
);
4394 print_vma (section
->sh_addr
, LONG_HEX
);
4395 if ((long) section
->sh_offset
== section
->sh_offset
)
4396 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4400 print_vma (section
->sh_offset
, LONG_HEX
);
4403 print_vma (section
->sh_size
, LONG_HEX
);
4405 print_vma (section
->sh_entsize
, LONG_HEX
);
4407 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4409 printf (" %2u %3u %lu\n",
4412 (unsigned long) section
->sh_addralign
);
4415 if (do_section_details
)
4416 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4419 if (!do_section_details
)
4420 printf (_("Key to Flags:\n\
4421 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4422 I (info), L (link order), G (group), x (unknown)\n\
4423 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4429 get_group_flags (unsigned int flags
)
4431 static char buff
[32];
4438 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4445 process_section_groups (FILE * file
)
4447 Elf_Internal_Shdr
* section
;
4449 struct group
* group
;
4450 Elf_Internal_Shdr
* symtab_sec
;
4451 Elf_Internal_Shdr
* strtab_sec
;
4452 Elf_Internal_Sym
* symtab
;
4456 /* Don't process section groups unless needed. */
4457 if (!do_unwind
&& !do_section_groups
)
4460 if (elf_header
.e_shnum
== 0)
4462 if (do_section_groups
)
4463 printf (_("\nThere are no sections in this file.\n"));
4468 if (section_headers
== NULL
)
4470 error (_("Section headers are not available!\n"));
4474 section_headers_groups
= calloc (elf_header
.e_shnum
,
4475 sizeof (struct group
*));
4477 if (section_headers_groups
== NULL
)
4479 error (_("Out of memory\n"));
4483 /* Scan the sections for the group section. */
4485 for (i
= 0, section
= section_headers
;
4486 i
< elf_header
.e_shnum
;
4488 if (section
->sh_type
== SHT_GROUP
)
4491 if (group_count
== 0)
4493 if (do_section_groups
)
4494 printf (_("\nThere are no section groups in this file.\n"));
4499 section_groups
= calloc (group_count
, sizeof (struct group
));
4501 if (section_groups
== NULL
)
4503 error (_("Out of memory\n"));
4512 for (i
= 0, section
= section_headers
, group
= section_groups
;
4513 i
< elf_header
.e_shnum
;
4516 if (section
->sh_type
== SHT_GROUP
)
4518 char * name
= SECTION_NAME (section
);
4520 unsigned char * start
;
4521 unsigned char * indices
;
4522 unsigned int entry
, j
, size
;
4523 Elf_Internal_Shdr
* sec
;
4524 Elf_Internal_Sym
* sym
;
4526 /* Get the symbol table. */
4527 if (section
->sh_link
>= elf_header
.e_shnum
4528 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4531 error (_("Bad sh_link in group section `%s'\n"), name
);
4535 if (symtab_sec
!= sec
)
4540 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4543 sym
= symtab
+ section
->sh_info
;
4545 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4547 if (sym
->st_shndx
== 0
4548 || sym
->st_shndx
>= elf_header
.e_shnum
)
4550 error (_("Bad sh_info in group section `%s'\n"), name
);
4554 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4563 /* Get the string table. */
4564 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4573 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4578 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4579 1, strtab_sec
->sh_size
,
4581 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4583 group_name
= sym
->st_name
< strtab_size
4584 ? strtab
+ sym
->st_name
: "<corrupt>";
4587 start
= get_data (NULL
, file
, section
->sh_offset
,
4588 1, section
->sh_size
, _("section data"));
4591 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4592 entry
= byte_get (indices
, 4);
4595 if (do_section_groups
)
4597 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4598 get_group_flags (entry
), i
, name
, group_name
, size
);
4600 printf (_(" [Index] Name\n"));
4603 group
->group_index
= i
;
4605 for (j
= 0; j
< size
; j
++)
4607 struct group_list
* g
;
4609 entry
= byte_get (indices
, 4);
4612 if (entry
>= elf_header
.e_shnum
)
4614 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4615 entry
, i
, elf_header
.e_shnum
- 1);
4619 if (section_headers_groups
[entry
] != NULL
)
4623 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4625 section_headers_groups
[entry
]->group_index
);
4630 /* Intel C/C++ compiler may put section 0 in a
4631 section group. We just warn it the first time
4632 and ignore it afterwards. */
4633 static int warned
= 0;
4636 error (_("section 0 in group section [%5u]\n"),
4637 section_headers_groups
[entry
]->group_index
);
4643 section_headers_groups
[entry
] = group
;
4645 if (do_section_groups
)
4647 sec
= section_headers
+ entry
;
4648 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4651 g
= xmalloc (sizeof (struct group_list
));
4652 g
->section_index
= entry
;
4653 g
->next
= group
->root
;
4677 } dynamic_relocations
[] =
4679 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4680 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4681 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4684 /* Process the reloc section. */
4687 process_relocs (FILE * file
)
4689 unsigned long rel_size
;
4690 unsigned long rel_offset
;
4696 if (do_using_dynamic
)
4700 int has_dynamic_reloc
;
4703 has_dynamic_reloc
= 0;
4705 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4707 is_rela
= dynamic_relocations
[i
].rela
;
4708 name
= dynamic_relocations
[i
].name
;
4709 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4710 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4712 has_dynamic_reloc
|= rel_size
;
4714 if (is_rela
== UNKNOWN
)
4716 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4717 switch (dynamic_info
[DT_PLTREL
])
4731 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4732 name
, rel_offset
, rel_size
);
4734 dump_relocations (file
,
4735 offset_from_vma (file
, rel_offset
, rel_size
),
4737 dynamic_symbols
, num_dynamic_syms
,
4738 dynamic_strings
, dynamic_strings_length
, is_rela
);
4742 if (! has_dynamic_reloc
)
4743 printf (_("\nThere are no dynamic relocations in this file.\n"));
4747 Elf_Internal_Shdr
* section
;
4751 for (i
= 0, section
= section_headers
;
4752 i
< elf_header
.e_shnum
;
4755 if ( section
->sh_type
!= SHT_RELA
4756 && section
->sh_type
!= SHT_REL
)
4759 rel_offset
= section
->sh_offset
;
4760 rel_size
= section
->sh_size
;
4764 Elf_Internal_Shdr
* strsec
;
4767 printf (_("\nRelocation section "));
4769 if (string_table
== NULL
)
4770 printf ("%d", section
->sh_name
);
4772 printf (_("'%s'"), SECTION_NAME (section
));
4774 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4775 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4777 is_rela
= section
->sh_type
== SHT_RELA
;
4779 if (section
->sh_link
!= 0
4780 && section
->sh_link
< elf_header
.e_shnum
)
4782 Elf_Internal_Shdr
* symsec
;
4783 Elf_Internal_Sym
* symtab
;
4784 unsigned long nsyms
;
4785 unsigned long strtablen
= 0;
4786 char * strtab
= NULL
;
4788 symsec
= section_headers
+ section
->sh_link
;
4789 if (symsec
->sh_type
!= SHT_SYMTAB
4790 && symsec
->sh_type
!= SHT_DYNSYM
)
4793 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4794 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4799 if (symsec
->sh_link
!= 0
4800 && symsec
->sh_link
< elf_header
.e_shnum
)
4802 strsec
= section_headers
+ symsec
->sh_link
;
4804 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4807 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4810 dump_relocations (file
, rel_offset
, rel_size
,
4811 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4817 dump_relocations (file
, rel_offset
, rel_size
,
4818 NULL
, 0, NULL
, 0, is_rela
);
4825 printf (_("\nThere are no relocations in this file.\n"));
4831 /* Process the unwind section. */
4833 #include "unwind-ia64.h"
4835 /* An absolute address consists of a section and an offset. If the
4836 section is NULL, the offset itself is the address, otherwise, the
4837 address equals to LOAD_ADDRESS(section) + offset. */
4841 unsigned short section
;
4845 #define ABSADDR(a) \
4847 ? section_headers [(a).section].sh_addr + (a).offset \
4850 struct ia64_unw_aux_info
4852 struct ia64_unw_table_entry
4854 struct absaddr start
;
4856 struct absaddr info
;
4858 *table
; /* Unwind table. */
4859 unsigned long table_len
; /* Length of unwind table. */
4860 unsigned char * info
; /* Unwind info. */
4861 unsigned long info_size
; /* Size of unwind info. */
4862 bfd_vma info_addr
; /* starting address of unwind info. */
4863 bfd_vma seg_base
; /* Starting address of segment. */
4864 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4865 unsigned long nsyms
; /* Number of symbols. */
4866 char * strtab
; /* The string table. */
4867 unsigned long strtab_size
; /* Size of string table. */
4871 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4872 unsigned long nsyms
,
4873 const char * strtab
,
4874 unsigned long strtab_size
,
4875 struct absaddr addr
,
4876 const char ** symname
,
4879 bfd_vma dist
= 0x100000;
4880 Elf_Internal_Sym
* sym
;
4881 Elf_Internal_Sym
* best
= NULL
;
4884 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4886 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4887 && sym
->st_name
!= 0
4888 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4889 && addr
.offset
>= sym
->st_value
4890 && addr
.offset
- sym
->st_value
< dist
)
4893 dist
= addr
.offset
- sym
->st_value
;
4900 *symname
= (best
->st_name
>= strtab_size
4901 ? "<corrupt>" : strtab
+ best
->st_name
);
4906 *offset
= addr
.offset
;
4910 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
4912 struct ia64_unw_table_entry
* tp
;
4915 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4919 const unsigned char * dp
;
4920 const unsigned char * head
;
4921 const char * procname
;
4923 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4924 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4926 fputs ("\n<", stdout
);
4930 fputs (procname
, stdout
);
4933 printf ("+%lx", (unsigned long) offset
);
4936 fputs (">: [", stdout
);
4937 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4938 fputc ('-', stdout
);
4939 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4940 printf ("], info at +0x%lx\n",
4941 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4943 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4944 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4946 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4947 (unsigned) UNW_VER (stamp
),
4948 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4949 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4950 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4951 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4953 if (UNW_VER (stamp
) != 1)
4955 printf ("\tUnknown version.\n");
4960 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4961 dp
= unw_decode (dp
, in_body
, & in_body
);
4966 slurp_ia64_unwind_table (FILE * file
,
4967 struct ia64_unw_aux_info
* aux
,
4968 Elf_Internal_Shdr
* sec
)
4970 unsigned long size
, nrelas
, i
;
4971 Elf_Internal_Phdr
* seg
;
4972 struct ia64_unw_table_entry
* tep
;
4973 Elf_Internal_Shdr
* relsec
;
4974 Elf_Internal_Rela
* rela
;
4975 Elf_Internal_Rela
* rp
;
4976 unsigned char * table
;
4978 Elf_Internal_Sym
* sym
;
4979 const char * relname
;
4981 /* First, find the starting address of the segment that includes
4984 if (elf_header
.e_phnum
)
4986 if (! get_program_headers (file
))
4989 for (seg
= program_headers
;
4990 seg
< program_headers
+ elf_header
.e_phnum
;
4993 if (seg
->p_type
!= PT_LOAD
)
4996 if (sec
->sh_addr
>= seg
->p_vaddr
4997 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4999 aux
->seg_base
= seg
->p_vaddr
;
5005 /* Second, build the unwind table from the contents of the unwind section: */
5006 size
= sec
->sh_size
;
5007 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5011 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5013 for (tp
= table
; tp
< table
+ size
; ++tep
)
5015 tep
->start
.section
= SHN_UNDEF
;
5016 tep
->end
.section
= SHN_UNDEF
;
5017 tep
->info
.section
= SHN_UNDEF
;
5018 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5019 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5020 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5021 tep
->start
.offset
+= aux
->seg_base
;
5022 tep
->end
.offset
+= aux
->seg_base
;
5023 tep
->info
.offset
+= aux
->seg_base
;
5027 /* Third, apply any relocations to the unwind table: */
5028 for (relsec
= section_headers
;
5029 relsec
< section_headers
+ elf_header
.e_shnum
;
5032 if (relsec
->sh_type
!= SHT_RELA
5033 || relsec
->sh_info
>= elf_header
.e_shnum
5034 || section_headers
+ relsec
->sh_info
!= sec
)
5037 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5041 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5043 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5044 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5046 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5048 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5052 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5054 switch (rp
->r_offset
/eh_addr_size
% 3)
5057 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5058 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5061 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5062 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5065 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5066 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5076 aux
->table_len
= size
/ (3 * eh_addr_size
);
5081 ia64_process_unwind (FILE * file
)
5083 Elf_Internal_Shdr
* sec
;
5084 Elf_Internal_Shdr
* unwsec
= NULL
;
5085 Elf_Internal_Shdr
* strsec
;
5086 unsigned long i
, unwcount
= 0, unwstart
= 0;
5087 struct ia64_unw_aux_info aux
;
5089 memset (& aux
, 0, sizeof (aux
));
5091 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5093 if (sec
->sh_type
== SHT_SYMTAB
5094 && sec
->sh_link
< elf_header
.e_shnum
)
5096 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5097 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5099 strsec
= section_headers
+ sec
->sh_link
;
5100 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5101 1, strsec
->sh_size
, _("string table"));
5102 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5104 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5109 printf (_("\nThere are no unwind sections in this file.\n"));
5111 while (unwcount
-- > 0)
5116 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5117 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5118 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5125 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5127 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5129 /* We need to find which section group it is in. */
5130 struct group_list
* g
= section_headers_groups
[i
]->root
;
5132 for (; g
!= NULL
; g
= g
->next
)
5134 sec
= section_headers
+ g
->section_index
;
5136 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5141 i
= elf_header
.e_shnum
;
5143 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5145 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5146 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5147 suffix
= SECTION_NAME (unwsec
) + len
;
5148 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5150 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5151 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5156 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5157 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5158 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5159 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5161 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5162 suffix
= SECTION_NAME (unwsec
) + len
;
5163 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5165 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5166 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5170 if (i
== elf_header
.e_shnum
)
5172 printf (_("\nCould not find unwind info section for "));
5174 if (string_table
== NULL
)
5175 printf ("%d", unwsec
->sh_name
);
5177 printf (_("'%s'"), SECTION_NAME (unwsec
));
5181 aux
.info_size
= sec
->sh_size
;
5182 aux
.info_addr
= sec
->sh_addr
;
5183 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5186 printf (_("\nUnwind section "));
5188 if (string_table
== NULL
)
5189 printf ("%d", unwsec
->sh_name
);
5191 printf (_("'%s'"), SECTION_NAME (unwsec
));
5193 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5194 (unsigned long) unwsec
->sh_offset
,
5195 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5197 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5199 if (aux
.table_len
> 0)
5200 dump_ia64_unwind (& aux
);
5203 free ((char *) aux
.table
);
5205 free ((char *) aux
.info
);
5214 free ((char *) aux
.strtab
);
5219 struct hppa_unw_aux_info
5221 struct hppa_unw_table_entry
5223 struct absaddr start
;
5225 unsigned int Cannot_unwind
:1; /* 0 */
5226 unsigned int Millicode
:1; /* 1 */
5227 unsigned int Millicode_save_sr0
:1; /* 2 */
5228 unsigned int Region_description
:2; /* 3..4 */
5229 unsigned int reserved1
:1; /* 5 */
5230 unsigned int Entry_SR
:1; /* 6 */
5231 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5232 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5233 unsigned int Args_stored
:1; /* 16 */
5234 unsigned int Variable_Frame
:1; /* 17 */
5235 unsigned int Separate_Package_Body
:1; /* 18 */
5236 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5237 unsigned int Stack_Overflow_Check
:1; /* 20 */
5238 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5239 unsigned int Ada_Region
:1; /* 22 */
5240 unsigned int cxx_info
:1; /* 23 */
5241 unsigned int cxx_try_catch
:1; /* 24 */
5242 unsigned int sched_entry_seq
:1; /* 25 */
5243 unsigned int reserved2
:1; /* 26 */
5244 unsigned int Save_SP
:1; /* 27 */
5245 unsigned int Save_RP
:1; /* 28 */
5246 unsigned int Save_MRP_in_frame
:1; /* 29 */
5247 unsigned int extn_ptr_defined
:1; /* 30 */
5248 unsigned int Cleanup_defined
:1; /* 31 */
5250 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5251 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5252 unsigned int Large_frame
:1; /* 2 */
5253 unsigned int Pseudo_SP_Set
:1; /* 3 */
5254 unsigned int reserved4
:1; /* 4 */
5255 unsigned int Total_frame_size
:27; /* 5..31 */
5257 *table
; /* Unwind table. */
5258 unsigned long table_len
; /* Length of unwind table. */
5259 bfd_vma seg_base
; /* Starting address of segment. */
5260 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5261 unsigned long nsyms
; /* Number of symbols. */
5262 char * strtab
; /* The string table. */
5263 unsigned long strtab_size
; /* Size of string table. */
5267 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5269 struct hppa_unw_table_entry
* tp
;
5271 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5274 const char * procname
;
5276 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5277 aux
->strtab_size
, tp
->start
, &procname
,
5280 fputs ("\n<", stdout
);
5284 fputs (procname
, stdout
);
5287 printf ("+%lx", (unsigned long) offset
);
5290 fputs (">: [", stdout
);
5291 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5292 fputc ('-', stdout
);
5293 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5296 #define PF(_m) if (tp->_m) printf (#_m " ");
5297 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5300 PF(Millicode_save_sr0
);
5301 /* PV(Region_description); */
5307 PF(Separate_Package_Body
);
5308 PF(Frame_Extension_Millicode
);
5309 PF(Stack_Overflow_Check
);
5310 PF(Two_Instruction_SP_Increment
);
5314 PF(sched_entry_seq
);
5317 PF(Save_MRP_in_frame
);
5318 PF(extn_ptr_defined
);
5319 PF(Cleanup_defined
);
5320 PF(MPE_XL_interrupt_marker
);
5321 PF(HP_UX_interrupt_marker
);
5324 PV(Total_frame_size
);
5333 slurp_hppa_unwind_table (FILE * file
,
5334 struct hppa_unw_aux_info
* aux
,
5335 Elf_Internal_Shdr
* sec
)
5337 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5338 Elf_Internal_Phdr
* seg
;
5339 struct hppa_unw_table_entry
* tep
;
5340 Elf_Internal_Shdr
* relsec
;
5341 Elf_Internal_Rela
* rela
;
5342 Elf_Internal_Rela
* rp
;
5343 unsigned char * table
;
5345 Elf_Internal_Sym
* sym
;
5346 const char * relname
;
5348 /* First, find the starting address of the segment that includes
5351 if (elf_header
.e_phnum
)
5353 if (! get_program_headers (file
))
5356 for (seg
= program_headers
;
5357 seg
< program_headers
+ elf_header
.e_phnum
;
5360 if (seg
->p_type
!= PT_LOAD
)
5363 if (sec
->sh_addr
>= seg
->p_vaddr
5364 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5366 aux
->seg_base
= seg
->p_vaddr
;
5372 /* Second, build the unwind table from the contents of the unwind
5374 size
= sec
->sh_size
;
5375 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5380 nentries
= size
/ unw_ent_size
;
5381 size
= unw_ent_size
* nentries
;
5383 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5385 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5387 unsigned int tmp1
, tmp2
;
5389 tep
->start
.section
= SHN_UNDEF
;
5390 tep
->end
.section
= SHN_UNDEF
;
5392 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5393 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5394 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5395 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5397 tep
->start
.offset
+= aux
->seg_base
;
5398 tep
->end
.offset
+= aux
->seg_base
;
5400 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5401 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5402 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5403 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5404 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5405 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5406 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5407 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5408 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5409 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5410 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5411 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5412 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5413 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5414 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5415 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5416 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5417 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5418 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5419 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5420 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5421 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5422 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5423 tep
->Cleanup_defined
= tmp1
& 0x1;
5425 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5426 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5427 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5428 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5429 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5430 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5434 /* Third, apply any relocations to the unwind table. */
5435 for (relsec
= section_headers
;
5436 relsec
< section_headers
+ elf_header
.e_shnum
;
5439 if (relsec
->sh_type
!= SHT_RELA
5440 || relsec
->sh_info
>= elf_header
.e_shnum
5441 || section_headers
+ relsec
->sh_info
!= sec
)
5444 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5448 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5450 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5451 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5453 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5454 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5456 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5460 i
= rp
->r_offset
/ unw_ent_size
;
5462 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5465 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5466 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5469 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5470 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5480 aux
->table_len
= nentries
;
5486 hppa_process_unwind (FILE * file
)
5488 struct hppa_unw_aux_info aux
;
5489 Elf_Internal_Shdr
* unwsec
= NULL
;
5490 Elf_Internal_Shdr
* strsec
;
5491 Elf_Internal_Shdr
* sec
;
5494 memset (& aux
, 0, sizeof (aux
));
5496 if (string_table
== NULL
)
5499 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5501 if (sec
->sh_type
== SHT_SYMTAB
5502 && sec
->sh_link
< elf_header
.e_shnum
)
5504 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5505 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5507 strsec
= section_headers
+ sec
->sh_link
;
5508 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5509 1, strsec
->sh_size
, _("string table"));
5510 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5512 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5517 printf (_("\nThere are no unwind sections in this file.\n"));
5519 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5521 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5523 printf (_("\nUnwind section "));
5524 printf (_("'%s'"), SECTION_NAME (sec
));
5526 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5527 (unsigned long) sec
->sh_offset
,
5528 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5530 slurp_hppa_unwind_table (file
, &aux
, sec
);
5531 if (aux
.table_len
> 0)
5532 dump_hppa_unwind (&aux
);
5535 free ((char *) aux
.table
);
5543 free ((char *) aux
.strtab
);
5549 process_unwind (FILE * file
)
5551 struct unwind_handler
5554 int (* handler
)(FILE *);
5557 { EM_IA_64
, ia64_process_unwind
},
5558 { EM_PARISC
, hppa_process_unwind
},
5566 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5567 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5568 return handlers
[i
].handler (file
);
5570 printf (_("\nThere are no unwind sections in this file.\n"));
5575 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5577 switch (entry
->d_tag
)
5580 if (entry
->d_un
.d_val
== 0)
5584 static const char * opts
[] =
5586 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5587 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5588 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5589 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5594 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5595 if (entry
->d_un
.d_val
& (1 << cnt
))
5597 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5604 case DT_MIPS_IVERSION
:
5605 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5606 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5608 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5611 case DT_MIPS_TIME_STAMP
:
5616 time_t time
= entry
->d_un
.d_val
;
5617 tmp
= gmtime (&time
);
5618 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5619 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5620 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5621 printf ("Time Stamp: %s\n", timebuf
);
5625 case DT_MIPS_RLD_VERSION
:
5626 case DT_MIPS_LOCAL_GOTNO
:
5627 case DT_MIPS_CONFLICTNO
:
5628 case DT_MIPS_LIBLISTNO
:
5629 case DT_MIPS_SYMTABNO
:
5630 case DT_MIPS_UNREFEXTNO
:
5631 case DT_MIPS_HIPAGENO
:
5632 case DT_MIPS_DELTA_CLASS_NO
:
5633 case DT_MIPS_DELTA_INSTANCE_NO
:
5634 case DT_MIPS_DELTA_RELOC_NO
:
5635 case DT_MIPS_DELTA_SYM_NO
:
5636 case DT_MIPS_DELTA_CLASSSYM_NO
:
5637 case DT_MIPS_COMPACT_SIZE
:
5638 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5642 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5648 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5650 switch (entry
->d_tag
)
5652 case DT_HP_DLD_FLAGS
:
5661 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5662 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5663 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5664 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5665 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5666 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5667 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5668 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5669 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5670 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5671 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5672 { DT_HP_GST
, "HP_GST" },
5673 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5674 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5675 { DT_HP_NODELETE
, "HP_NODELETE" },
5676 { DT_HP_GROUP
, "HP_GROUP" },
5677 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5681 bfd_vma val
= entry
->d_un
.d_val
;
5683 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5684 if (val
& flags
[cnt
].bit
)
5688 fputs (flags
[cnt
].str
, stdout
);
5690 val
^= flags
[cnt
].bit
;
5693 if (val
!= 0 || first
)
5697 print_vma (val
, HEX
);
5703 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5710 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5712 switch (entry
->d_tag
)
5714 case DT_IA_64_PLT_RESERVE
:
5715 /* First 3 slots reserved. */
5716 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5718 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5722 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5729 get_32bit_dynamic_section (FILE * file
)
5731 Elf32_External_Dyn
* edyn
;
5732 Elf32_External_Dyn
* ext
;
5733 Elf_Internal_Dyn
* entry
;
5735 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5736 _("dynamic section"));
5740 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5741 might not have the luxury of section headers. Look for the DT_NULL
5742 terminator to determine the number of entries. */
5743 for (ext
= edyn
, dynamic_nent
= 0;
5744 (char *) ext
< (char *) edyn
+ dynamic_size
;
5748 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5752 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5753 if (dynamic_section
== NULL
)
5755 error (_("Out of memory\n"));
5760 for (ext
= edyn
, entry
= dynamic_section
;
5761 entry
< dynamic_section
+ dynamic_nent
;
5764 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5765 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5774 get_64bit_dynamic_section (FILE * file
)
5776 Elf64_External_Dyn
* edyn
;
5777 Elf64_External_Dyn
* ext
;
5778 Elf_Internal_Dyn
* entry
;
5780 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5781 _("dynamic section"));
5785 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5786 might not have the luxury of section headers. Look for the DT_NULL
5787 terminator to determine the number of entries. */
5788 for (ext
= edyn
, dynamic_nent
= 0;
5789 (char *) ext
< (char *) edyn
+ dynamic_size
;
5793 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5797 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5798 if (dynamic_section
== NULL
)
5800 error (_("Out of memory\n"));
5805 for (ext
= edyn
, entry
= dynamic_section
;
5806 entry
< dynamic_section
+ dynamic_nent
;
5809 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5810 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5819 print_dynamic_flags (bfd_vma flags
)
5827 flag
= flags
& - flags
;
5837 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5838 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5839 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5840 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5841 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5842 default: fputs ("unknown", stdout
); break;
5848 /* Parse and display the contents of the dynamic section. */
5851 process_dynamic_section (FILE * file
)
5853 Elf_Internal_Dyn
* entry
;
5855 if (dynamic_size
== 0)
5858 printf (_("\nThere is no dynamic section in this file.\n"));
5865 if (! get_32bit_dynamic_section (file
))
5868 else if (! get_64bit_dynamic_section (file
))
5871 /* Find the appropriate symbol table. */
5872 if (dynamic_symbols
== NULL
)
5874 for (entry
= dynamic_section
;
5875 entry
< dynamic_section
+ dynamic_nent
;
5878 Elf_Internal_Shdr section
;
5880 if (entry
->d_tag
!= DT_SYMTAB
)
5883 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5885 /* Since we do not know how big the symbol table is,
5886 we default to reading in the entire file (!) and
5887 processing that. This is overkill, I know, but it
5889 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5891 if (archive_file_offset
!= 0)
5892 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5895 if (fseek (file
, 0, SEEK_END
))
5896 error (_("Unable to seek to end of file!\n"));
5898 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5902 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5904 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5906 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5907 if (num_dynamic_syms
< 1)
5909 error (_("Unable to determine the number of symbols to load\n"));
5913 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5917 /* Similarly find a string table. */
5918 if (dynamic_strings
== NULL
)
5920 for (entry
= dynamic_section
;
5921 entry
< dynamic_section
+ dynamic_nent
;
5924 unsigned long offset
;
5927 if (entry
->d_tag
!= DT_STRTAB
)
5930 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5932 /* Since we do not know how big the string table is,
5933 we default to reading in the entire file (!) and
5934 processing that. This is overkill, I know, but it
5937 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5939 if (archive_file_offset
!= 0)
5940 str_tab_len
= archive_file_size
- offset
;
5943 if (fseek (file
, 0, SEEK_END
))
5944 error (_("Unable to seek to end of file\n"));
5945 str_tab_len
= ftell (file
) - offset
;
5948 if (str_tab_len
< 1)
5951 (_("Unable to determine the length of the dynamic string table\n"));
5955 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5956 _("dynamic string table"));
5957 dynamic_strings_length
= str_tab_len
;
5962 /* And find the syminfo section if available. */
5963 if (dynamic_syminfo
== NULL
)
5965 unsigned long syminsz
= 0;
5967 for (entry
= dynamic_section
;
5968 entry
< dynamic_section
+ dynamic_nent
;
5971 if (entry
->d_tag
== DT_SYMINENT
)
5973 /* Note: these braces are necessary to avoid a syntax
5974 error from the SunOS4 C compiler. */
5975 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5977 else if (entry
->d_tag
== DT_SYMINSZ
)
5978 syminsz
= entry
->d_un
.d_val
;
5979 else if (entry
->d_tag
== DT_SYMINFO
)
5980 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5984 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5986 Elf_External_Syminfo
* extsyminfo
;
5987 Elf_External_Syminfo
* extsym
;
5988 Elf_Internal_Syminfo
* syminfo
;
5990 /* There is a syminfo section. Read the data. */
5991 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5992 syminsz
, _("symbol information"));
5996 dynamic_syminfo
= malloc (syminsz
);
5997 if (dynamic_syminfo
== NULL
)
5999 error (_("Out of memory\n"));
6003 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6004 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6005 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6006 ++syminfo
, ++extsym
)
6008 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6009 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6016 if (do_dynamic
&& dynamic_addr
)
6017 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6018 dynamic_addr
, dynamic_nent
);
6020 printf (_(" Tag Type Name/Value\n"));
6022 for (entry
= dynamic_section
;
6023 entry
< dynamic_section
+ dynamic_nent
;
6031 print_vma (entry
->d_tag
, FULL_HEX
);
6032 dtype
= get_dynamic_type (entry
->d_tag
);
6033 printf (" (%s)%*s", dtype
,
6034 ((is_32bit_elf
? 27 : 19)
6035 - (int) strlen (dtype
)),
6039 switch (entry
->d_tag
)
6043 print_dynamic_flags (entry
->d_un
.d_val
);
6053 switch (entry
->d_tag
)
6056 printf (_("Auxiliary library"));
6060 printf (_("Filter library"));
6064 printf (_("Configuration file"));
6068 printf (_("Dependency audit library"));
6072 printf (_("Audit library"));
6076 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6077 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6081 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6090 printf (_("Flags:"));
6092 if (entry
->d_un
.d_val
== 0)
6093 printf (_(" None\n"));
6096 unsigned long int val
= entry
->d_un
.d_val
;
6098 if (val
& DTF_1_PARINIT
)
6100 printf (" PARINIT");
6101 val
^= DTF_1_PARINIT
;
6103 if (val
& DTF_1_CONFEXP
)
6105 printf (" CONFEXP");
6106 val
^= DTF_1_CONFEXP
;
6109 printf (" %lx", val
);
6118 printf (_("Flags:"));
6120 if (entry
->d_un
.d_val
== 0)
6121 printf (_(" None\n"));
6124 unsigned long int val
= entry
->d_un
.d_val
;
6126 if (val
& DF_P1_LAZYLOAD
)
6128 printf (" LAZYLOAD");
6129 val
^= DF_P1_LAZYLOAD
;
6131 if (val
& DF_P1_GROUPPERM
)
6133 printf (" GROUPPERM");
6134 val
^= DF_P1_GROUPPERM
;
6137 printf (" %lx", val
);
6146 printf (_("Flags:"));
6147 if (entry
->d_un
.d_val
== 0)
6148 printf (_(" None\n"));
6151 unsigned long int val
= entry
->d_un
.d_val
;
6158 if (val
& DF_1_GLOBAL
)
6163 if (val
& DF_1_GROUP
)
6168 if (val
& DF_1_NODELETE
)
6170 printf (" NODELETE");
6171 val
^= DF_1_NODELETE
;
6173 if (val
& DF_1_LOADFLTR
)
6175 printf (" LOADFLTR");
6176 val
^= DF_1_LOADFLTR
;
6178 if (val
& DF_1_INITFIRST
)
6180 printf (" INITFIRST");
6181 val
^= DF_1_INITFIRST
;
6183 if (val
& DF_1_NOOPEN
)
6188 if (val
& DF_1_ORIGIN
)
6193 if (val
& DF_1_DIRECT
)
6198 if (val
& DF_1_TRANS
)
6203 if (val
& DF_1_INTERPOSE
)
6205 printf (" INTERPOSE");
6206 val
^= DF_1_INTERPOSE
;
6208 if (val
& DF_1_NODEFLIB
)
6210 printf (" NODEFLIB");
6211 val
^= DF_1_NODEFLIB
;
6213 if (val
& DF_1_NODUMP
)
6218 if (val
& DF_1_CONLFAT
)
6220 printf (" CONLFAT");
6221 val
^= DF_1_CONLFAT
;
6224 printf (" %lx", val
);
6231 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6233 puts (get_dynamic_type (entry
->d_un
.d_val
));
6253 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6259 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6260 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6266 switch (entry
->d_tag
)
6269 printf (_("Shared library: [%s]"), name
);
6271 if (streq (name
, program_interpreter
))
6272 printf (_(" program interpreter"));
6276 printf (_("Library soname: [%s]"), name
);
6280 printf (_("Library rpath: [%s]"), name
);
6284 printf (_("Library runpath: [%s]"), name
);
6288 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6293 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6306 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6310 case DT_INIT_ARRAYSZ
:
6311 case DT_FINI_ARRAYSZ
:
6312 case DT_GNU_CONFLICTSZ
:
6313 case DT_GNU_LIBLISTSZ
:
6316 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6317 printf (" (bytes)\n");
6327 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6340 if (entry
->d_tag
== DT_USED
6341 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6343 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6347 printf (_("Not needed object: [%s]\n"), name
);
6352 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6358 /* The value of this entry is ignored. */
6363 case DT_GNU_PRELINKED
:
6367 time_t time
= entry
->d_un
.d_val
;
6369 tmp
= gmtime (&time
);
6370 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6371 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6372 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6378 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6381 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6387 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6388 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6393 switch (elf_header
.e_machine
)
6396 case EM_MIPS_RS3_LE
:
6397 dynamic_section_mips_val (entry
);
6400 dynamic_section_parisc_val (entry
);
6403 dynamic_section_ia64_val (entry
);
6406 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6418 get_ver_flags (unsigned int flags
)
6420 static char buff
[32];
6427 if (flags
& VER_FLG_BASE
)
6428 strcat (buff
, "BASE ");
6430 if (flags
& VER_FLG_WEAK
)
6432 if (flags
& VER_FLG_BASE
)
6433 strcat (buff
, "| ");
6435 strcat (buff
, "WEAK ");
6438 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6439 strcat (buff
, "| <unknown>");
6444 /* Display the contents of the version sections. */
6447 process_version_sections (FILE * file
)
6449 Elf_Internal_Shdr
* section
;
6456 for (i
= 0, section
= section_headers
;
6457 i
< elf_header
.e_shnum
;
6460 switch (section
->sh_type
)
6462 case SHT_GNU_verdef
:
6464 Elf_External_Verdef
* edefs
;
6472 (_("\nVersion definition section '%s' contains %u entries:\n"),
6473 SECTION_NAME (section
), section
->sh_info
);
6475 printf (_(" Addr: 0x"));
6476 printf_vma (section
->sh_addr
);
6477 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6478 (unsigned long) section
->sh_offset
, section
->sh_link
,
6479 section
->sh_link
< elf_header
.e_shnum
6480 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6483 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6485 _("version definition section"));
6486 endbuf
= (char *) edefs
+ section
->sh_size
;
6490 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6493 Elf_External_Verdef
* edef
;
6494 Elf_Internal_Verdef ent
;
6495 Elf_External_Verdaux
* eaux
;
6496 Elf_Internal_Verdaux aux
;
6500 vstart
= ((char *) edefs
) + idx
;
6501 if (vstart
+ sizeof (*edef
) > endbuf
)
6504 edef
= (Elf_External_Verdef
*) vstart
;
6506 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6507 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6508 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6509 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6510 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6511 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6512 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6514 printf (_(" %#06x: Rev: %d Flags: %s"),
6515 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6517 printf (_(" Index: %d Cnt: %d "),
6518 ent
.vd_ndx
, ent
.vd_cnt
);
6520 vstart
+= ent
.vd_aux
;
6522 eaux
= (Elf_External_Verdaux
*) vstart
;
6524 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6525 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6527 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6528 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6530 printf (_("Name index: %ld\n"), aux
.vda_name
);
6532 isum
= idx
+ ent
.vd_aux
;
6534 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6536 isum
+= aux
.vda_next
;
6537 vstart
+= aux
.vda_next
;
6539 eaux
= (Elf_External_Verdaux
*) vstart
;
6540 if (vstart
+ sizeof (*eaux
) > endbuf
)
6543 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6544 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6546 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6547 printf (_(" %#06x: Parent %d: %s\n"),
6548 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6550 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6551 isum
, j
, aux
.vda_name
);
6554 printf (_(" Version def aux past end of section\n"));
6558 if (cnt
< section
->sh_info
)
6559 printf (_(" Version definition past end of section\n"));
6565 case SHT_GNU_verneed
:
6567 Elf_External_Verneed
* eneed
;
6574 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6575 SECTION_NAME (section
), section
->sh_info
);
6577 printf (_(" Addr: 0x"));
6578 printf_vma (section
->sh_addr
);
6579 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6580 (unsigned long) section
->sh_offset
, section
->sh_link
,
6581 section
->sh_link
< elf_header
.e_shnum
6582 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6585 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6587 _("version need section"));
6588 endbuf
= (char *) eneed
+ section
->sh_size
;
6592 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6594 Elf_External_Verneed
* entry
;
6595 Elf_Internal_Verneed ent
;
6600 vstart
= ((char *) eneed
) + idx
;
6601 if (vstart
+ sizeof (*entry
) > endbuf
)
6604 entry
= (Elf_External_Verneed
*) vstart
;
6606 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6607 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6608 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6609 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6610 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6612 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6614 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6615 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6617 printf (_(" File: %lx"), ent
.vn_file
);
6619 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6621 vstart
+= ent
.vn_aux
;
6623 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6625 Elf_External_Vernaux
* eaux
;
6626 Elf_Internal_Vernaux aux
;
6628 if (vstart
+ sizeof (*eaux
) > endbuf
)
6630 eaux
= (Elf_External_Vernaux
*) vstart
;
6632 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6633 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6634 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6635 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6636 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6638 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6639 printf (_(" %#06x: Name: %s"),
6640 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6642 printf (_(" %#06x: Name index: %lx"),
6643 isum
, aux
.vna_name
);
6645 printf (_(" Flags: %s Version: %d\n"),
6646 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6648 isum
+= aux
.vna_next
;
6649 vstart
+= aux
.vna_next
;
6652 printf (_(" Version need aux past end of section\n"));
6656 if (cnt
< section
->sh_info
)
6657 printf (_(" Version need past end of section\n"));
6663 case SHT_GNU_versym
:
6665 Elf_Internal_Shdr
* link_section
;
6668 unsigned char * edata
;
6669 unsigned short * data
;
6671 Elf_Internal_Sym
* symbols
;
6672 Elf_Internal_Shdr
* string_sec
;
6675 if (section
->sh_link
>= elf_header
.e_shnum
)
6678 link_section
= section_headers
+ section
->sh_link
;
6679 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6681 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6686 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6688 string_sec
= section_headers
+ link_section
->sh_link
;
6690 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6691 string_sec
->sh_size
, _("version string table"));
6695 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6696 SECTION_NAME (section
), total
);
6698 printf (_(" Addr: "));
6699 printf_vma (section
->sh_addr
);
6700 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6701 (unsigned long) section
->sh_offset
, section
->sh_link
,
6702 SECTION_NAME (link_section
));
6704 off
= offset_from_vma (file
,
6705 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6706 total
* sizeof (short));
6707 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6708 _("version symbol data"));
6715 data
= cmalloc (total
, sizeof (short));
6717 for (cnt
= total
; cnt
--;)
6718 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6723 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6726 int check_def
, check_need
;
6729 printf (" %03x:", cnt
);
6731 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6732 switch (data
[cnt
+ j
])
6735 fputs (_(" 0 (*local*) "), stdout
);
6739 fputs (_(" 1 (*global*) "), stdout
);
6743 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6744 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6748 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6749 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6752 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6759 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6761 Elf_Internal_Verneed ivn
;
6762 unsigned long offset
;
6764 offset
= offset_from_vma
6765 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6766 sizeof (Elf_External_Verneed
));
6770 Elf_Internal_Vernaux ivna
;
6771 Elf_External_Verneed evn
;
6772 Elf_External_Vernaux evna
;
6773 unsigned long a_off
;
6775 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6778 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6779 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6781 a_off
= offset
+ ivn
.vn_aux
;
6785 get_data (&evna
, file
, a_off
, sizeof (evna
),
6786 1, _("version need aux (2)"));
6788 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6789 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6791 a_off
+= ivna
.vna_next
;
6793 while (ivna
.vna_other
!= data
[cnt
+ j
]
6794 && ivna
.vna_next
!= 0);
6796 if (ivna
.vna_other
== data
[cnt
+ j
])
6798 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6800 if (ivna
.vna_name
>= string_sec
->sh_size
)
6801 name
= _("*invalid*");
6803 name
= strtab
+ ivna
.vna_name
;
6804 nn
+= printf ("(%s%-*s",
6806 12 - (int) strlen (name
),
6812 offset
+= ivn
.vn_next
;
6814 while (ivn
.vn_next
);
6817 if (check_def
&& data
[cnt
+ j
] != 0x8001
6818 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6820 Elf_Internal_Verdef ivd
;
6821 Elf_External_Verdef evd
;
6822 unsigned long offset
;
6824 offset
= offset_from_vma
6825 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6830 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6833 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6834 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6836 offset
+= ivd
.vd_next
;
6838 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6839 && ivd
.vd_next
!= 0);
6841 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6843 Elf_External_Verdaux evda
;
6844 Elf_Internal_Verdaux ivda
;
6846 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6848 get_data (&evda
, file
,
6849 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6851 _("version def aux"));
6853 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6855 if (ivda
.vda_name
>= string_sec
->sh_size
)
6856 name
= _("*invalid*");
6858 name
= strtab
+ ivda
.vda_name
;
6859 nn
+= printf ("(%s%-*s",
6861 12 - (int) strlen (name
),
6867 printf ("%*c", 18 - nn
, ' ');
6885 printf (_("\nNo version information found in this file.\n"));
6891 get_symbol_binding (unsigned int binding
)
6893 static char buff
[32];
6897 case STB_LOCAL
: return "LOCAL";
6898 case STB_GLOBAL
: return "GLOBAL";
6899 case STB_WEAK
: return "WEAK";
6901 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6902 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6904 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6906 if (binding
== STB_GNU_UNIQUE
6907 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
6908 /* GNU/Linux is still using the default value 0. */
6909 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
6911 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6914 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6920 get_symbol_type (unsigned int type
)
6922 static char buff
[32];
6926 case STT_NOTYPE
: return "NOTYPE";
6927 case STT_OBJECT
: return "OBJECT";
6928 case STT_FUNC
: return "FUNC";
6929 case STT_SECTION
: return "SECTION";
6930 case STT_FILE
: return "FILE";
6931 case STT_COMMON
: return "COMMON";
6932 case STT_TLS
: return "TLS";
6933 case STT_RELC
: return "RELC";
6934 case STT_SRELC
: return "SRELC";
6936 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6938 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6939 return "THUMB_FUNC";
6941 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6944 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6945 return "PARISC_MILLI";
6947 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6949 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6951 if (elf_header
.e_machine
== EM_PARISC
)
6953 if (type
== STT_HP_OPAQUE
)
6955 if (type
== STT_HP_STUB
)
6959 if (type
== STT_GNU_IFUNC
6960 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
6961 /* GNU/Linux is still using the default value 0. */
6962 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
6965 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6968 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6974 get_symbol_visibility (unsigned int visibility
)
6978 case STV_DEFAULT
: return "DEFAULT";
6979 case STV_INTERNAL
: return "INTERNAL";
6980 case STV_HIDDEN
: return "HIDDEN";
6981 case STV_PROTECTED
: return "PROTECTED";
6987 get_mips_symbol_other (unsigned int other
)
6991 case STO_OPTIONAL
: return "OPTIONAL";
6992 case STO_MIPS16
: return "MIPS16";
6993 case STO_MIPS_PLT
: return "MIPS PLT";
6994 case STO_MIPS_PIC
: return "MIPS PIC";
6995 default: return NULL
;
7000 get_symbol_other (unsigned int other
)
7002 const char * result
= NULL
;
7003 static char buff
[32];
7008 switch (elf_header
.e_machine
)
7011 result
= get_mips_symbol_other (other
);
7019 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7024 get_symbol_index_type (unsigned int type
)
7026 static char buff
[32];
7030 case SHN_UNDEF
: return "UND";
7031 case SHN_ABS
: return "ABS";
7032 case SHN_COMMON
: return "COM";
7034 if (type
== SHN_IA_64_ANSI_COMMON
7035 && elf_header
.e_machine
== EM_IA_64
7036 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7038 else if (elf_header
.e_machine
== EM_X86_64
7039 && type
== SHN_X86_64_LCOMMON
)
7041 else if (type
== SHN_MIPS_SCOMMON
7042 && elf_header
.e_machine
== EM_MIPS
)
7044 else if (type
== SHN_MIPS_SUNDEFINED
7045 && elf_header
.e_machine
== EM_MIPS
)
7047 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7048 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7049 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7050 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7051 else if (type
>= SHN_LORESERVE
)
7052 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7054 sprintf (buff
, "%3d", type
);
7062 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7064 unsigned char * e_data
;
7067 e_data
= cmalloc (number
, ent_size
);
7071 error (_("Out of memory\n"));
7075 if (fread (e_data
, ent_size
, number
, file
) != number
)
7077 error (_("Unable to read in dynamic data\n"));
7081 i_data
= cmalloc (number
, sizeof (*i_data
));
7085 error (_("Out of memory\n"));
7091 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7099 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7101 Elf_Internal_Sym
* psym
;
7104 psym
= dynamic_symbols
+ si
;
7106 n
= print_vma (si
, DEC_5
);
7108 fputs (" " + n
, stdout
);
7109 printf (" %3lu: ", hn
);
7110 print_vma (psym
->st_value
, LONG_HEX
);
7112 print_vma (psym
->st_size
, DEC_5
);
7114 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7115 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7116 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7117 /* Check to see if any other bits in the st_other field are set.
7118 Note - displaying this information disrupts the layout of the
7119 table being generated, but for the moment this case is very
7121 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7122 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7123 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7124 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7125 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7127 printf (" <corrupt: %14ld>", psym
->st_name
);
7131 /* Dump the symbol table. */
7133 process_symbol_table (FILE * file
)
7135 Elf_Internal_Shdr
* section
;
7136 bfd_vma nbuckets
= 0;
7137 bfd_vma nchains
= 0;
7138 bfd_vma
* buckets
= NULL
;
7139 bfd_vma
* chains
= NULL
;
7140 bfd_vma ngnubuckets
= 0;
7141 bfd_vma
* gnubuckets
= NULL
;
7142 bfd_vma
* gnuchains
= NULL
;
7143 bfd_vma gnusymidx
= 0;
7145 if (! do_syms
&& !do_histogram
)
7148 if (dynamic_info
[DT_HASH
]
7150 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7152 unsigned char nb
[8];
7153 unsigned char nc
[8];
7154 int hash_ent_size
= 4;
7156 if ((elf_header
.e_machine
== EM_ALPHA
7157 || elf_header
.e_machine
== EM_S390
7158 || elf_header
.e_machine
== EM_S390_OLD
)
7159 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7163 (archive_file_offset
7164 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7165 sizeof nb
+ sizeof nc
)),
7168 error (_("Unable to seek to start of dynamic information\n"));
7172 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7174 error (_("Failed to read in number of buckets\n"));
7178 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7180 error (_("Failed to read in number of chains\n"));
7184 nbuckets
= byte_get (nb
, hash_ent_size
);
7185 nchains
= byte_get (nc
, hash_ent_size
);
7187 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7188 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7191 if (buckets
== NULL
|| chains
== NULL
)
7193 if (do_using_dynamic
)
7204 if (dynamic_info_DT_GNU_HASH
7206 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7208 unsigned char nb
[16];
7209 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7210 bfd_vma buckets_vma
;
7213 (archive_file_offset
7214 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7218 error (_("Unable to seek to start of dynamic information\n"));
7222 if (fread (nb
, 16, 1, file
) != 1)
7224 error (_("Failed to read in number of buckets\n"));
7228 ngnubuckets
= byte_get (nb
, 4);
7229 gnusymidx
= byte_get (nb
+ 4, 4);
7230 bitmaskwords
= byte_get (nb
+ 8, 4);
7231 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7233 buckets_vma
+= bitmaskwords
* 4;
7235 buckets_vma
+= bitmaskwords
* 8;
7238 (archive_file_offset
7239 + offset_from_vma (file
, buckets_vma
, 4)),
7242 error (_("Unable to seek to start of dynamic information\n"));
7246 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7248 if (gnubuckets
== NULL
)
7251 for (i
= 0; i
< ngnubuckets
; i
++)
7252 if (gnubuckets
[i
] != 0)
7254 if (gnubuckets
[i
] < gnusymidx
)
7257 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7258 maxchain
= gnubuckets
[i
];
7261 if (maxchain
== 0xffffffff)
7264 maxchain
-= gnusymidx
;
7267 (archive_file_offset
7268 + offset_from_vma (file
, buckets_vma
7269 + 4 * (ngnubuckets
+ maxchain
), 4)),
7272 error (_("Unable to seek to start of dynamic information\n"));
7278 if (fread (nb
, 4, 1, file
) != 1)
7280 error (_("Failed to determine last chain length\n"));
7284 if (maxchain
+ 1 == 0)
7289 while ((byte_get (nb
, 4) & 1) == 0);
7292 (archive_file_offset
7293 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7296 error (_("Unable to seek to start of dynamic information\n"));
7300 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7303 if (gnuchains
== NULL
)
7308 if (do_using_dynamic
)
7313 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7316 && dynamic_strings
!= NULL
)
7320 if (dynamic_info
[DT_HASH
])
7324 printf (_("\nSymbol table for image:\n"));
7326 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7328 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7330 for (hn
= 0; hn
< nbuckets
; hn
++)
7335 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7336 print_dynamic_symbol (si
, hn
);
7340 if (dynamic_info_DT_GNU_HASH
)
7342 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7344 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7346 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7348 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7349 if (gnubuckets
[hn
] != 0)
7351 bfd_vma si
= gnubuckets
[hn
];
7352 bfd_vma off
= si
- gnusymidx
;
7356 print_dynamic_symbol (si
, hn
);
7359 while ((gnuchains
[off
++] & 1) == 0);
7363 else if (do_syms
&& !do_using_dynamic
)
7367 for (i
= 0, section
= section_headers
;
7368 i
< elf_header
.e_shnum
;
7372 char * strtab
= NULL
;
7373 unsigned long int strtab_size
= 0;
7374 Elf_Internal_Sym
* symtab
;
7375 Elf_Internal_Sym
* psym
;
7377 if ( section
->sh_type
!= SHT_SYMTAB
7378 && section
->sh_type
!= SHT_DYNSYM
)
7381 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7382 SECTION_NAME (section
),
7383 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7385 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7387 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7389 symtab
= GET_ELF_SYMBOLS (file
, section
);
7393 if (section
->sh_link
== elf_header
.e_shstrndx
)
7395 strtab
= string_table
;
7396 strtab_size
= string_table_length
;
7398 else if (section
->sh_link
< elf_header
.e_shnum
)
7400 Elf_Internal_Shdr
* string_sec
;
7402 string_sec
= section_headers
+ section
->sh_link
;
7404 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7405 1, string_sec
->sh_size
, _("string table"));
7406 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7409 for (si
= 0, psym
= symtab
;
7410 si
< section
->sh_size
/ section
->sh_entsize
;
7413 printf ("%6d: ", si
);
7414 print_vma (psym
->st_value
, LONG_HEX
);
7416 print_vma (psym
->st_size
, DEC_5
);
7417 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7418 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7419 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7420 /* Check to see if any other bits in the st_other field are set.
7421 Note - displaying this information disrupts the layout of the
7422 table being generated, but for the moment this case is very rare. */
7423 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7424 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7425 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7426 print_symbol (25, psym
->st_name
< strtab_size
7427 ? strtab
+ psym
->st_name
: "<corrupt>");
7429 if (section
->sh_type
== SHT_DYNSYM
&&
7430 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7432 unsigned char data
[2];
7433 unsigned short vers_data
;
7434 unsigned long offset
;
7438 offset
= offset_from_vma
7439 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7440 sizeof data
+ si
* sizeof (vers_data
));
7442 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7443 sizeof (data
), 1, _("version data"));
7445 vers_data
= byte_get (data
, 2);
7447 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7448 && section_headers
[psym
->st_shndx
].sh_type
7451 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7453 if ((vers_data
& 0x8000) || vers_data
> 1)
7455 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7456 && (is_nobits
|| ! check_def
))
7458 Elf_External_Verneed evn
;
7459 Elf_Internal_Verneed ivn
;
7460 Elf_Internal_Vernaux ivna
;
7462 /* We must test both. */
7463 offset
= offset_from_vma
7464 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7469 unsigned long vna_off
;
7471 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7474 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7475 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7477 vna_off
= offset
+ ivn
.vn_aux
;
7481 Elf_External_Vernaux evna
;
7483 get_data (&evna
, file
, vna_off
,
7485 _("version need aux (3)"));
7487 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7488 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7489 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7491 vna_off
+= ivna
.vna_next
;
7493 while (ivna
.vna_other
!= vers_data
7494 && ivna
.vna_next
!= 0);
7496 if (ivna
.vna_other
== vers_data
)
7499 offset
+= ivn
.vn_next
;
7501 while (ivn
.vn_next
!= 0);
7503 if (ivna
.vna_other
== vers_data
)
7506 ivna
.vna_name
< strtab_size
7507 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7511 else if (! is_nobits
)
7512 error (_("bad dynamic symbol\n"));
7519 if (vers_data
!= 0x8001
7520 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7522 Elf_Internal_Verdef ivd
;
7523 Elf_Internal_Verdaux ivda
;
7524 Elf_External_Verdaux evda
;
7525 unsigned long offset
;
7527 offset
= offset_from_vma
7529 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7530 sizeof (Elf_External_Verdef
));
7534 Elf_External_Verdef evd
;
7536 get_data (&evd
, file
, offset
, sizeof (evd
),
7537 1, _("version def"));
7539 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7540 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7541 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7543 offset
+= ivd
.vd_next
;
7545 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7546 && ivd
.vd_next
!= 0);
7548 offset
-= ivd
.vd_next
;
7549 offset
+= ivd
.vd_aux
;
7551 get_data (&evda
, file
, offset
, sizeof (evda
),
7552 1, _("version def aux"));
7554 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7556 if (psym
->st_name
!= ivda
.vda_name
)
7557 printf ((vers_data
& 0x8000)
7559 ivda
.vda_name
< strtab_size
7560 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7570 if (strtab
!= string_table
)
7576 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7578 if (do_histogram
&& buckets
!= NULL
)
7580 unsigned long * lengths
;
7581 unsigned long * counts
;
7584 unsigned long maxlength
= 0;
7585 unsigned long nzero_counts
= 0;
7586 unsigned long nsyms
= 0;
7588 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7589 (unsigned long) nbuckets
);
7590 printf (_(" Length Number %% of total Coverage\n"));
7592 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7593 if (lengths
== NULL
)
7595 error (_("Out of memory\n"));
7598 for (hn
= 0; hn
< nbuckets
; ++hn
)
7600 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7603 if (maxlength
< ++lengths
[hn
])
7608 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7611 error (_("Out of memory\n"));
7615 for (hn
= 0; hn
< nbuckets
; ++hn
)
7616 ++counts
[lengths
[hn
]];
7621 printf (" 0 %-10lu (%5.1f%%)\n",
7622 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7623 for (i
= 1; i
<= maxlength
; ++i
)
7625 nzero_counts
+= counts
[i
] * i
;
7626 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7627 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7628 (nzero_counts
* 100.0) / nsyms
);
7636 if (buckets
!= NULL
)
7642 if (do_histogram
&& gnubuckets
!= NULL
)
7644 unsigned long * lengths
;
7645 unsigned long * counts
;
7647 unsigned long maxlength
= 0;
7648 unsigned long nzero_counts
= 0;
7649 unsigned long nsyms
= 0;
7651 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7652 if (lengths
== NULL
)
7654 error (_("Out of memory\n"));
7658 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7659 (unsigned long) ngnubuckets
);
7660 printf (_(" Length Number %% of total Coverage\n"));
7662 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7663 if (gnubuckets
[hn
] != 0)
7665 bfd_vma off
, length
= 1;
7667 for (off
= gnubuckets
[hn
] - gnusymidx
;
7668 (gnuchains
[off
] & 1) == 0; ++off
)
7670 lengths
[hn
] = length
;
7671 if (length
> maxlength
)
7676 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7679 error (_("Out of memory\n"));
7683 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7684 ++counts
[lengths
[hn
]];
7686 if (ngnubuckets
> 0)
7689 printf (" 0 %-10lu (%5.1f%%)\n",
7690 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7691 for (j
= 1; j
<= maxlength
; ++j
)
7693 nzero_counts
+= counts
[j
] * j
;
7694 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7695 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7696 (nzero_counts
* 100.0) / nsyms
);
7710 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7714 if (dynamic_syminfo
== NULL
7716 /* No syminfo, this is ok. */
7719 /* There better should be a dynamic symbol section. */
7720 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7724 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7725 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7727 printf (_(" Num: Name BoundTo Flags\n"));
7728 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7730 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7732 printf ("%4d: ", i
);
7733 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7734 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7736 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7739 switch (dynamic_syminfo
[i
].si_boundto
)
7741 case SYMINFO_BT_SELF
:
7742 fputs ("SELF ", stdout
);
7744 case SYMINFO_BT_PARENT
:
7745 fputs ("PARENT ", stdout
);
7748 if (dynamic_syminfo
[i
].si_boundto
> 0
7749 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7750 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7752 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7756 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7760 if (flags
& SYMINFO_FLG_DIRECT
)
7762 if (flags
& SYMINFO_FLG_PASSTHRU
)
7763 printf (" PASSTHRU");
7764 if (flags
& SYMINFO_FLG_COPY
)
7766 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7767 printf (" LAZYLOAD");
7775 /* Check to see if the given reloc needs to be handled in a target specific
7776 manner. If so then process the reloc and return TRUE otherwise return
7780 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
7781 unsigned char * start
,
7782 Elf_Internal_Sym
* symtab
)
7784 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
7786 switch (elf_header
.e_machine
)
7789 case EM_CYGNUS_MN10300
:
7791 static Elf_Internal_Sym
* saved_sym
= NULL
;
7795 case 34: /* R_MN10300_ALIGN */
7797 case 33: /* R_MN10300_SYM_DIFF */
7798 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
7800 case 1: /* R_MN10300_32 */
7801 case 2: /* R_MN10300_16 */
7802 if (saved_sym
!= NULL
)
7806 value
= reloc
->r_addend
7807 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
7808 - saved_sym
->st_value
);
7810 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
7817 if (saved_sym
!= NULL
)
7818 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
7828 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7829 DWARF debug sections. This is a target specific test. Note - we do not
7830 go through the whole including-target-headers-multiple-times route, (as
7831 we have already done with <elf/h8.h>) because this would become very
7832 messy and even then this function would have to contain target specific
7833 information (the names of the relocs instead of their numeric values).
7834 FIXME: This is not the correct way to solve this problem. The proper way
7835 is to have target specific reloc sizing and typing functions created by
7836 the reloc-macros.h header, in the same way that it already creates the
7837 reloc naming functions. */
7840 is_32bit_abs_reloc (unsigned int reloc_type
)
7842 switch (elf_header
.e_machine
)
7846 return reloc_type
== 1; /* R_386_32. */
7848 return reloc_type
== 1; /* R_68K_32. */
7850 return reloc_type
== 1; /* R_860_32. */
7852 return reloc_type
== 1; /* XXX Is this right ? */
7854 return reloc_type
== 1; /* R_ARC_32. */
7856 return reloc_type
== 2; /* R_ARM_ABS32 */
7859 return reloc_type
== 1;
7861 return reloc_type
== 0x12; /* R_byte4_data. */
7863 return reloc_type
== 3; /* R_CRIS_32. */
7866 return reloc_type
== 3; /* R_CR16_NUM32. */
7868 return reloc_type
== 15; /* R_CRX_NUM32. */
7870 return reloc_type
== 1;
7871 case EM_CYGNUS_D10V
:
7873 return reloc_type
== 6; /* R_D10V_32. */
7874 case EM_CYGNUS_D30V
:
7876 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7878 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7879 case EM_CYGNUS_FR30
:
7881 return reloc_type
== 3; /* R_FR30_32. */
7885 return reloc_type
== 1; /* R_H8_DIR32. */
7887 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
7890 return reloc_type
== 2; /* R_IP2K_32. */
7892 return reloc_type
== 2; /* R_IQ2000_32. */
7893 case EM_LATTICEMICO32
:
7894 return reloc_type
== 3; /* R_LM32_32. */
7897 return reloc_type
== 3; /* R_M32C_32. */
7899 return reloc_type
== 34; /* R_M32R_32_RELA. */
7901 return reloc_type
== 1; /* R_MCORE_ADDR32. */
7903 return reloc_type
== 4; /* R_MEP_32. */
7905 return reloc_type
== 2; /* R_MIPS_32. */
7907 return reloc_type
== 4; /* R_MMIX_32. */
7908 case EM_CYGNUS_MN10200
:
7910 return reloc_type
== 1; /* R_MN10200_32. */
7911 case EM_CYGNUS_MN10300
:
7913 return reloc_type
== 1; /* R_MN10300_32. */
7916 return reloc_type
== 1; /* R_MSP43_32. */
7918 return reloc_type
== 2; /* R_MT_32. */
7919 case EM_ALTERA_NIOS2
:
7921 return reloc_type
== 1; /* R_NIOS_32. */
7924 return reloc_type
== 1; /* R_OR32_32. */
7926 return reloc_type
== 1; /* R_PARISC_DIR32. */
7929 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
7931 return reloc_type
== 1; /* R_PPC64_ADDR32. */
7933 return reloc_type
== 1; /* R_PPC_ADDR32. */
7935 return reloc_type
== 1; /* R_I370_ADDR31. */
7938 return reloc_type
== 4; /* R_S390_32. */
7940 return reloc_type
== 8; /* R_SCORE_ABS32. */
7942 return reloc_type
== 1; /* R_SH_DIR32. */
7943 case EM_SPARC32PLUS
:
7946 return reloc_type
== 3 /* R_SPARC_32. */
7947 || reloc_type
== 23; /* R_SPARC_UA32. */
7949 return reloc_type
== 6; /* R_SPU_ADDR32 */
7950 case EM_CYGNUS_V850
:
7952 return reloc_type
== 6; /* R_V850_ABS32. */
7954 return reloc_type
== 1; /* R_VAX_32. */
7956 return reloc_type
== 10; /* R_X86_64_32. */
7958 return reloc_type
== 1; /* R_XSTROMY16_32. */
7961 return reloc_type
== 1; /* R_XTENSA_32. */
7964 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
7965 elf_header
.e_machine
);
7970 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
7971 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
7974 is_32bit_pcrel_reloc (unsigned int reloc_type
)
7976 switch (elf_header
.e_machine
)
7980 return reloc_type
== 2; /* R_386_PC32. */
7982 return reloc_type
== 4; /* R_68K_PC32. */
7984 return reloc_type
== 10; /* R_ALPHA_SREL32. */
7986 return reloc_type
== 3; /* R_ARM_REL32 */
7988 return reloc_type
== 9; /* R_PARISC_PCREL32. */
7990 return reloc_type
== 26; /* R_PPC_REL32. */
7992 return reloc_type
== 26; /* R_PPC64_REL32. */
7995 return reloc_type
== 5; /* R_390_PC32. */
7997 return reloc_type
== 2; /* R_SH_REL32. */
7998 case EM_SPARC32PLUS
:
8001 return reloc_type
== 6; /* R_SPARC_DISP32. */
8003 return reloc_type
== 13; /* R_SPU_REL32. */
8005 return reloc_type
== 2; /* R_X86_64_PC32. */
8008 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8010 /* Do not abort or issue an error message here. Not all targets use
8011 pc-relative 32-bit relocs in their DWARF debug information and we
8012 have already tested for target coverage in is_32bit_abs_reloc. A
8013 more helpful warning message will be generated by apply_relocations
8014 anyway, so just return. */
8019 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8020 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8023 is_64bit_abs_reloc (unsigned int reloc_type
)
8025 switch (elf_header
.e_machine
)
8028 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8030 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8032 return reloc_type
== 80; /* R_PARISC_DIR64. */
8034 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8035 case EM_SPARC32PLUS
:
8038 return reloc_type
== 54; /* R_SPARC_UA64. */
8040 return reloc_type
== 1; /* R_X86_64_64. */
8043 return reloc_type
== 22; /* R_S390_64 */
8045 return reloc_type
== 18; /* R_MIPS_64 */
8051 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8052 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8055 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8057 switch (elf_header
.e_machine
)
8060 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8062 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8064 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8066 return reloc_type
== 44; /* R_PPC64_REL64 */
8067 case EM_SPARC32PLUS
:
8070 return reloc_type
== 46; /* R_SPARC_DISP64 */
8072 return reloc_type
== 24; /* R_X86_64_PC64 */
8075 return reloc_type
== 23; /* R_S390_PC64 */
8081 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8082 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8085 is_16bit_abs_reloc (unsigned int reloc_type
)
8087 switch (elf_header
.e_machine
)
8091 return reloc_type
== 4; /* R_AVR_16. */
8092 case EM_CYGNUS_D10V
:
8094 return reloc_type
== 3; /* R_D10V_16. */
8098 return reloc_type
== R_H8_DIR16
;
8101 return reloc_type
== 1; /* R_IP2K_16. */
8104 return reloc_type
== 1; /* R_M32C_16 */
8107 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8108 case EM_ALTERA_NIOS2
:
8110 return reloc_type
== 9; /* R_NIOS_16. */
8116 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8117 relocation entries (possibly formerly used for SHT_GROUP sections). */
8120 is_none_reloc (unsigned int reloc_type
)
8122 switch (elf_header
.e_machine
)
8124 case EM_68K
: /* R_68K_NONE. */
8125 case EM_386
: /* R_386_NONE. */
8126 case EM_SPARC32PLUS
:
8128 case EM_SPARC
: /* R_SPARC_NONE. */
8129 case EM_MIPS
: /* R_MIPS_NONE. */
8130 case EM_PARISC
: /* R_PARISC_NONE. */
8131 case EM_ALPHA
: /* R_ALPHA_NONE. */
8132 case EM_PPC
: /* R_PPC_NONE. */
8133 case EM_PPC64
: /* R_PPC64_NONE. */
8134 case EM_ARM
: /* R_ARM_NONE. */
8135 case EM_IA_64
: /* R_IA64_NONE. */
8136 case EM_SH
: /* R_SH_NONE. */
8138 case EM_S390
: /* R_390_NONE. */
8139 case EM_CRIS
: /* R_CRIS_NONE. */
8140 case EM_X86_64
: /* R_X86_64_NONE. */
8141 case EM_MN10300
: /* R_MN10300_NONE. */
8142 case EM_M32R
: /* R_M32R_NONE. */
8143 return reloc_type
== 0;
8148 /* Apply relocations to a section.
8149 Note: So far support has been added only for those relocations
8150 which can be found in debug sections.
8151 FIXME: Add support for more relocations ? */
8154 apply_relocations (void * file
,
8155 Elf_Internal_Shdr
* section
,
8156 unsigned char * start
)
8158 Elf_Internal_Shdr
* relsec
;
8159 unsigned char * end
= start
+ section
->sh_size
;
8161 if (elf_header
.e_type
!= ET_REL
)
8164 /* Find the reloc section associated with the section. */
8165 for (relsec
= section_headers
;
8166 relsec
< section_headers
+ elf_header
.e_shnum
;
8169 bfd_boolean is_rela
;
8170 unsigned long num_relocs
;
8171 Elf_Internal_Rela
* relocs
;
8172 Elf_Internal_Rela
* rp
;
8173 Elf_Internal_Shdr
* symsec
;
8174 Elf_Internal_Sym
* symtab
;
8175 Elf_Internal_Sym
* sym
;
8177 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8178 || relsec
->sh_info
>= elf_header
.e_shnum
8179 || section_headers
+ relsec
->sh_info
!= section
8180 || relsec
->sh_size
== 0
8181 || relsec
->sh_link
>= elf_header
.e_shnum
)
8184 is_rela
= relsec
->sh_type
== SHT_RELA
;
8188 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8189 & relocs
, & num_relocs
))
8194 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8195 & relocs
, & num_relocs
))
8199 /* SH uses RELA but uses in place value instead of the addend field. */
8200 if (elf_header
.e_machine
== EM_SH
)
8203 symsec
= section_headers
+ relsec
->sh_link
;
8204 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8206 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8209 unsigned int reloc_type
;
8210 unsigned int reloc_size
;
8211 unsigned char * loc
;
8213 reloc_type
= get_reloc_type (rp
->r_info
);
8215 if (target_specific_reloc_handling (rp
, start
, symtab
))
8217 else if (is_none_reloc (reloc_type
))
8219 else if (is_32bit_abs_reloc (reloc_type
)
8220 || is_32bit_pcrel_reloc (reloc_type
))
8222 else if (is_64bit_abs_reloc (reloc_type
)
8223 || is_64bit_pcrel_reloc (reloc_type
))
8225 else if (is_16bit_abs_reloc (reloc_type
))
8229 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8230 reloc_type
, SECTION_NAME (section
));
8234 loc
= start
+ rp
->r_offset
;
8235 if ((loc
+ reloc_size
) > end
)
8237 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8238 (unsigned long) rp
->r_offset
,
8239 SECTION_NAME (section
));
8243 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8245 /* If the reloc has a symbol associated with it,
8246 make sure that it is of an appropriate type.
8248 Relocations against symbols without type can happen.
8249 Gcc -feliminate-dwarf2-dups may generate symbols
8250 without type for debug info.
8252 Icc generates relocations against function symbols
8253 instead of local labels.
8255 Relocations against object symbols can happen, eg when
8256 referencing a global array. For an example of this see
8257 the _clz.o binary in libgcc.a. */
8259 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8261 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8262 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8263 (long int)(rp
- relocs
),
8264 SECTION_NAME (relsec
));
8268 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8270 if (is_32bit_pcrel_reloc (reloc_type
)
8271 || is_64bit_pcrel_reloc (reloc_type
))
8273 /* On HPPA, all pc-relative relocations are biased by 8. */
8274 if (elf_header
.e_machine
== EM_PARISC
)
8276 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8280 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8289 #ifdef SUPPORT_DISASSEMBLY
8291 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8293 printf (_("\nAssembly dump of section %s\n"),
8294 SECTION_NAME (section
));
8296 /* XXX -- to be done --- XXX */
8302 /* Reads in the contents of SECTION from FILE, returning a pointer
8303 to a malloc'ed buffer or NULL if something went wrong. */
8306 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8308 bfd_size_type num_bytes
;
8310 num_bytes
= section
->sh_size
;
8312 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8314 printf (_("\nSection '%s' has no data to dump.\n"),
8315 SECTION_NAME (section
));
8319 return get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8320 _("section contents"));
8325 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8327 Elf_Internal_Shdr
* relsec
;
8328 bfd_size_type num_bytes
;
8333 char * name
= SECTION_NAME (section
);
8334 bfd_boolean some_strings_shown
;
8336 start
= get_section_contents (section
, file
);
8340 printf (_("\nString dump of section '%s':\n"), name
);
8342 /* If the section being dumped has relocations against it the user might
8343 be expecting these relocations to have been applied. Check for this
8344 case and issue a warning message in order to avoid confusion.
8345 FIXME: Maybe we ought to have an option that dumps a section with
8347 for (relsec
= section_headers
;
8348 relsec
< section_headers
+ elf_header
.e_shnum
;
8351 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8352 || relsec
->sh_info
>= elf_header
.e_shnum
8353 || section_headers
+ relsec
->sh_info
!= section
8354 || relsec
->sh_size
== 0
8355 || relsec
->sh_link
>= elf_header
.e_shnum
)
8358 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8362 num_bytes
= section
->sh_size
;
8363 addr
= section
->sh_addr
;
8365 end
= start
+ num_bytes
;
8366 some_strings_shown
= FALSE
;
8370 while (!ISPRINT (* data
))
8377 printf (" [%6tx] %s\n", data
- start
, data
);
8379 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8381 data
+= strlen (data
);
8382 some_strings_shown
= TRUE
;
8386 if (! some_strings_shown
)
8387 printf (_(" No strings found in this section."));
8395 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8397 bfd_boolean relocate
)
8399 Elf_Internal_Shdr
* relsec
;
8400 bfd_size_type bytes
;
8402 unsigned char * data
;
8403 unsigned char * start
;
8405 start
= (unsigned char *) get_section_contents (section
, file
);
8409 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8413 apply_relocations (file
, section
, start
);
8417 /* If the section being dumped has relocations against it the user might
8418 be expecting these relocations to have been applied. Check for this
8419 case and issue a warning message in order to avoid confusion.
8420 FIXME: Maybe we ought to have an option that dumps a section with
8422 for (relsec
= section_headers
;
8423 relsec
< section_headers
+ elf_header
.e_shnum
;
8426 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8427 || relsec
->sh_info
>= elf_header
.e_shnum
8428 || section_headers
+ relsec
->sh_info
!= section
8429 || relsec
->sh_size
== 0
8430 || relsec
->sh_link
>= elf_header
.e_shnum
)
8433 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8438 addr
= section
->sh_addr
;
8439 bytes
= section
->sh_size
;
8448 lbytes
= (bytes
> 16 ? 16 : bytes
);
8450 printf (" 0x%8.8lx ", (unsigned long) addr
);
8452 for (j
= 0; j
< 16; j
++)
8455 printf ("%2.2x", data
[j
]);
8463 for (j
= 0; j
< lbytes
; j
++)
8466 if (k
>= ' ' && k
< 0x7f)
8484 /* Uncompresses a section that was compressed using zlib, in place.
8485 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8488 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8491 /* These are just to quiet gcc. */
8496 dwarf_size_type compressed_size
= *size
;
8497 unsigned char * compressed_buffer
= *buffer
;
8498 dwarf_size_type uncompressed_size
;
8499 unsigned char * uncompressed_buffer
;
8502 dwarf_size_type header_size
= 12;
8504 /* Read the zlib header. In this case, it should be "ZLIB" followed
8505 by the uncompressed section size, 8 bytes in big-endian order. */
8506 if (compressed_size
< header_size
8507 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8510 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8511 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8512 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8513 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8514 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8515 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8516 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8517 uncompressed_size
+= compressed_buffer
[11];
8519 /* It is possible the section consists of several compressed
8520 buffers concatenated together, so we uncompress in a loop. */
8524 strm
.avail_in
= compressed_size
- header_size
;
8525 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8526 strm
.avail_out
= uncompressed_size
;
8527 uncompressed_buffer
= xmalloc (uncompressed_size
);
8529 rc
= inflateInit (& strm
);
8530 while (strm
.avail_in
> 0)
8534 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8535 + (uncompressed_size
- strm
.avail_out
));
8536 rc
= inflate (&strm
, Z_FINISH
);
8537 if (rc
!= Z_STREAM_END
)
8539 rc
= inflateReset (& strm
);
8541 rc
= inflateEnd (& strm
);
8543 || strm
.avail_out
!= 0)
8546 free (compressed_buffer
);
8547 *buffer
= uncompressed_buffer
;
8548 *size
= uncompressed_size
;
8552 free (uncompressed_buffer
);
8554 #endif /* HAVE_ZLIB_H */
8558 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8559 Elf_Internal_Shdr
* sec
, void * file
)
8561 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8563 int section_is_compressed
;
8565 /* If it is already loaded, do nothing. */
8566 if (section
->start
!= NULL
)
8569 section_is_compressed
= section
->name
== section
->compressed_name
;
8571 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8572 section
->address
= sec
->sh_addr
;
8573 section
->size
= sec
->sh_size
;
8574 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8576 if (section
->start
== NULL
)
8579 if (section_is_compressed
)
8580 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8583 if (debug_displays
[debug
].relocate
)
8584 apply_relocations (file
, sec
, section
->start
);
8590 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8592 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8593 Elf_Internal_Shdr
* sec
;
8595 /* Locate the debug section. */
8596 sec
= find_section (section
->uncompressed_name
);
8598 section
->name
= section
->uncompressed_name
;
8601 sec
= find_section (section
->compressed_name
);
8603 section
->name
= section
->compressed_name
;
8608 return load_specific_debug_section (debug
, sec
, file
);
8612 free_debug_section (enum dwarf_section_display_enum debug
)
8614 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8616 if (section
->start
== NULL
)
8619 free ((char *) section
->start
);
8620 section
->start
= NULL
;
8621 section
->address
= 0;
8626 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8628 char * name
= SECTION_NAME (section
);
8629 bfd_size_type length
;
8631 enum dwarf_section_display_enum i
;
8633 length
= section
->sh_size
;
8636 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8639 if (section
->sh_type
== SHT_NOBITS
)
8641 /* There is no point in dumping the contents of a debugging section
8642 which has the NOBITS type - the bits in the file will be random.
8643 This can happen when a file containing a .eh_frame section is
8644 stripped with the --only-keep-debug command line option. */
8645 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8649 if (const_strneq (name
, ".gnu.linkonce.wi."))
8650 name
= ".debug_info";
8652 /* See if we know how to display the contents of this section. */
8653 for (i
= 0; i
< max
; i
++)
8654 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8655 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8657 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8658 int secondary
= (section
!= find_section (name
));
8661 free_debug_section (i
);
8663 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8664 sec
->name
= sec
->uncompressed_name
;
8666 sec
->name
= sec
->compressed_name
;
8667 if (load_specific_debug_section (i
, section
, file
))
8669 result
&= debug_displays
[i
].display (sec
, file
);
8671 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8672 free_debug_section (i
);
8680 printf (_("Unrecognized debug section: %s\n"), name
);
8687 /* Set DUMP_SECTS for all sections where dumps were requested
8688 based on section name. */
8691 initialise_dumps_byname (void)
8693 struct dump_list_entry
* cur
;
8695 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8700 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8701 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8703 request_dump_bynumber (i
, cur
->type
);
8708 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8714 process_section_contents (FILE * file
)
8716 Elf_Internal_Shdr
* section
;
8722 initialise_dumps_byname ();
8724 for (i
= 0, section
= section_headers
;
8725 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8728 #ifdef SUPPORT_DISASSEMBLY
8729 if (dump_sects
[i
] & DISASS_DUMP
)
8730 disassemble_section (section
, file
);
8732 if (dump_sects
[i
] & HEX_DUMP
)
8733 dump_section_as_bytes (section
, file
, FALSE
);
8735 if (dump_sects
[i
] & RELOC_DUMP
)
8736 dump_section_as_bytes (section
, file
, TRUE
);
8738 if (dump_sects
[i
] & STRING_DUMP
)
8739 dump_section_as_strings (section
, file
);
8741 if (dump_sects
[i
] & DEBUG_DUMP
)
8742 display_debug_section (section
, file
);
8745 /* Check to see if the user requested a
8746 dump of a section that does not exist. */
8747 while (i
++ < num_dump_sects
)
8749 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8753 process_mips_fpe_exception (int mask
)
8758 if (mask
& OEX_FPU_INEX
)
8759 fputs ("INEX", stdout
), first
= 0;
8760 if (mask
& OEX_FPU_UFLO
)
8761 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8762 if (mask
& OEX_FPU_OFLO
)
8763 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8764 if (mask
& OEX_FPU_DIV0
)
8765 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8766 if (mask
& OEX_FPU_INVAL
)
8767 printf ("%sINVAL", first
? "" : "|");
8770 fputs ("0", stdout
);
8773 /* ARM EABI attributes section. */
8778 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8780 const char ** table
;
8781 } arm_attr_public_tag
;
8783 static const char * arm_attr_tag_CPU_arch
[] =
8784 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8785 "v6K", "v7", "v6-M", "v6S-M"};
8786 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8787 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8788 {"No", "Thumb-1", "Thumb-2"};
8789 static const char * arm_attr_tag_VFP_arch
[] =
8790 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8791 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8792 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8793 static const char * arm_attr_tag_PCS_config
[] =
8794 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8795 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8796 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8797 {"V6", "SB", "TLS", "Unused"};
8798 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8799 {"Absolute", "PC-relative", "SB-relative", "None"};
8800 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8801 {"Absolute", "PC-relative", "None"};
8802 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8803 {"None", "direct", "GOT-indirect"};
8804 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8805 {"None", "??? 1", "2", "??? 3", "4"};
8806 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8807 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8808 {"Unused", "Needed", "Sign only"};
8809 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8810 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8811 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8812 {"Unused", "Finite", "RTABI", "IEEE 754"};
8813 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8814 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8815 {"No", "Yes, except leaf SP", "Yes"};
8816 static const char * arm_attr_tag_ABI_enum_size
[] =
8817 {"Unused", "small", "int", "forced to int"};
8818 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8819 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8820 static const char * arm_attr_tag_ABI_VFP_args
[] =
8821 {"AAPCS", "VFP registers", "custom"};
8822 static const char * arm_attr_tag_ABI_WMMX_args
[] =
8823 {"AAPCS", "WMMX registers", "custom"};
8824 static const char * arm_attr_tag_ABI_optimization_goals
[] =
8825 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8826 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8827 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
8828 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8829 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8830 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8831 static const char * arm_attr_tag_VFP_HP_extension
[] =
8832 {"Not Allowed", "Allowed"};
8833 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
8834 {"None", "IEEE 754", "Alternative Format"};
8835 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8836 static const char * arm_attr_tag_Virtualization_use
[] =
8837 {"Not Allowed", "Allowed"};
8838 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8840 #define LOOKUP(id, name) \
8841 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8842 static arm_attr_public_tag arm_attr_public_tags
[] =
8844 {4, "CPU_raw_name", 1, NULL
},
8845 {5, "CPU_name", 1, NULL
},
8846 LOOKUP(6, CPU_arch
),
8847 {7, "CPU_arch_profile", 0, NULL
},
8848 LOOKUP(8, ARM_ISA_use
),
8849 LOOKUP(9, THUMB_ISA_use
),
8850 LOOKUP(10, VFP_arch
),
8851 LOOKUP(11, WMMX_arch
),
8852 LOOKUP(12, Advanced_SIMD_arch
),
8853 LOOKUP(13, PCS_config
),
8854 LOOKUP(14, ABI_PCS_R9_use
),
8855 LOOKUP(15, ABI_PCS_RW_data
),
8856 LOOKUP(16, ABI_PCS_RO_data
),
8857 LOOKUP(17, ABI_PCS_GOT_use
),
8858 LOOKUP(18, ABI_PCS_wchar_t
),
8859 LOOKUP(19, ABI_FP_rounding
),
8860 LOOKUP(20, ABI_FP_denormal
),
8861 LOOKUP(21, ABI_FP_exceptions
),
8862 LOOKUP(22, ABI_FP_user_exceptions
),
8863 LOOKUP(23, ABI_FP_number_model
),
8864 LOOKUP(24, ABI_align8_needed
),
8865 LOOKUP(25, ABI_align8_preserved
),
8866 LOOKUP(26, ABI_enum_size
),
8867 LOOKUP(27, ABI_HardFP_use
),
8868 LOOKUP(28, ABI_VFP_args
),
8869 LOOKUP(29, ABI_WMMX_args
),
8870 LOOKUP(30, ABI_optimization_goals
),
8871 LOOKUP(31, ABI_FP_optimization_goals
),
8872 {32, "compatibility", 0, NULL
},
8873 LOOKUP(34, CPU_unaligned_access
),
8874 LOOKUP(36, VFP_HP_extension
),
8875 LOOKUP(38, ABI_FP_16bit_format
),
8876 {64, "nodefaults", 0, NULL
},
8877 {65, "also_compatible_with", 0, NULL
},
8878 LOOKUP(66, T2EE_use
),
8879 {67, "conformance", 1, NULL
},
8880 LOOKUP(68, Virtualization_use
),
8881 LOOKUP(70, MPextension_use
)
8885 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8889 read_uleb128 (unsigned char * p
, unsigned int * plen
)
8903 val
|= ((unsigned int)c
& 0x7f) << shift
;
8912 static unsigned char *
8913 display_arm_attribute (unsigned char * p
)
8918 arm_attr_public_tag
* attr
;
8922 tag
= read_uleb128 (p
, &len
);
8925 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
8927 if (arm_attr_public_tags
[i
].tag
== tag
)
8929 attr
= &arm_attr_public_tags
[i
];
8936 printf (" Tag_%s: ", attr
->name
);
8942 case 7: /* Tag_CPU_arch_profile. */
8943 val
= read_uleb128 (p
, &len
);
8947 case 0: printf ("None\n"); break;
8948 case 'A': printf ("Application\n"); break;
8949 case 'R': printf ("Realtime\n"); break;
8950 case 'M': printf ("Microcontroller\n"); break;
8951 default: printf ("??? (%d)\n", val
); break;
8955 case 32: /* Tag_compatibility. */
8956 val
= read_uleb128 (p
, &len
);
8958 printf ("flag = %d, vendor = %s\n", val
, p
);
8959 p
+= strlen ((char *) p
) + 1;
8962 case 64: /* Tag_nodefaults. */
8967 case 65: /* Tag_also_compatible_with. */
8968 val
= read_uleb128 (p
, &len
);
8970 if (val
== 6 /* Tag_CPU_arch. */)
8972 val
= read_uleb128 (p
, &len
);
8974 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
8975 printf ("??? (%d)\n", val
);
8977 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
8981 while (*(p
++) != '\0' /* NUL terminator. */);
8995 assert (attr
->type
& 0x80);
8996 val
= read_uleb128 (p
, &len
);
8998 type
= attr
->type
& 0x7f;
9000 printf ("??? (%d)\n", val
);
9002 printf ("%s\n", attr
->table
[val
]);
9009 type
= 1; /* String. */
9011 type
= 2; /* uleb128. */
9012 printf (" Tag_unknown_%d: ", tag
);
9017 printf ("\"%s\"\n", p
);
9018 p
+= strlen ((char *) p
) + 1;
9022 val
= read_uleb128 (p
, &len
);
9024 printf ("%d (0x%x)\n", val
, val
);
9030 static unsigned char *
9031 display_gnu_attribute (unsigned char * p
,
9032 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9039 tag
= read_uleb128 (p
, &len
);
9042 /* Tag_compatibility is the only generic GNU attribute defined at
9046 val
= read_uleb128 (p
, &len
);
9048 printf ("flag = %d, vendor = %s\n", val
, p
);
9049 p
+= strlen ((char *) p
) + 1;
9053 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9054 return display_proc_gnu_attribute (p
, tag
);
9057 type
= 1; /* String. */
9059 type
= 2; /* uleb128. */
9060 printf (" Tag_unknown_%d: ", tag
);
9064 printf ("\"%s\"\n", p
);
9065 p
+= strlen ((char *) p
) + 1;
9069 val
= read_uleb128 (p
, &len
);
9071 printf ("%d (0x%x)\n", val
, val
);
9077 static unsigned char *
9078 display_power_gnu_attribute (unsigned char * p
, int tag
)
9084 if (tag
== Tag_GNU_Power_ABI_FP
)
9086 val
= read_uleb128 (p
, &len
);
9088 printf (" Tag_GNU_Power_ABI_FP: ");
9093 printf ("Hard or soft float\n");
9096 printf ("Hard float\n");
9099 printf ("Soft float\n");
9102 printf ("Single-precision hard float\n");
9105 printf ("??? (%d)\n", val
);
9111 if (tag
== Tag_GNU_Power_ABI_Vector
)
9113 val
= read_uleb128 (p
, &len
);
9115 printf (" Tag_GNU_Power_ABI_Vector: ");
9122 printf ("Generic\n");
9125 printf ("AltiVec\n");
9131 printf ("??? (%d)\n", val
);
9137 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9139 val
= read_uleb128 (p
, &len
);
9141 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9151 printf ("Memory\n");
9154 printf ("??? (%d)\n", val
);
9161 type
= 1; /* String. */
9163 type
= 2; /* uleb128. */
9164 printf (" Tag_unknown_%d: ", tag
);
9168 printf ("\"%s\"\n", p
);
9169 p
+= strlen ((char *) p
) + 1;
9173 val
= read_uleb128 (p
, &len
);
9175 printf ("%d (0x%x)\n", val
, val
);
9181 static unsigned char *
9182 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9188 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9190 val
= read_uleb128 (p
, &len
);
9192 printf (" Tag_GNU_MIPS_ABI_FP: ");
9197 printf ("Hard or soft float\n");
9200 printf ("Hard float (-mdouble-float)\n");
9203 printf ("Hard float (-msingle-float)\n");
9206 printf ("Soft float\n");
9209 printf ("64-bit float (-mips32r2 -mfp64)\n");
9212 printf ("??? (%d)\n", val
);
9219 type
= 1; /* String. */
9221 type
= 2; /* uleb128. */
9222 printf (" Tag_unknown_%d: ", tag
);
9226 printf ("\"%s\"\n", p
);
9227 p
+= strlen ((char *) p
) + 1;
9231 val
= read_uleb128 (p
, &len
);
9233 printf ("%d (0x%x)\n", val
, val
);
9240 process_attributes (FILE * file
,
9241 const char * public_name
,
9242 unsigned int proc_type
,
9243 unsigned char * (* display_pub_attribute
) (unsigned char *),
9244 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9246 Elf_Internal_Shdr
* sect
;
9247 unsigned char * contents
;
9249 unsigned char * end
;
9250 bfd_vma section_len
;
9254 /* Find the section header so that we get the size. */
9255 for (i
= 0, sect
= section_headers
;
9256 i
< elf_header
.e_shnum
;
9259 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9262 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9264 if (contents
== NULL
)
9270 len
= sect
->sh_size
- 1;
9276 bfd_boolean public_section
;
9277 bfd_boolean gnu_section
;
9279 section_len
= byte_get (p
, 4);
9282 if (section_len
> len
)
9284 printf (_("ERROR: Bad section length (%d > %d)\n"),
9285 (int) section_len
, (int) len
);
9290 printf ("Attribute Section: %s\n", p
);
9292 if (public_name
&& streq ((char *) p
, public_name
))
9293 public_section
= TRUE
;
9295 public_section
= FALSE
;
9297 if (streq ((char *) p
, "gnu"))
9300 gnu_section
= FALSE
;
9302 namelen
= strlen ((char *) p
) + 1;
9304 section_len
-= namelen
+ 4;
9306 while (section_len
> 0)
9312 size
= byte_get (p
, 4);
9313 if (size
> section_len
)
9315 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9316 (int) size
, (int) section_len
);
9320 section_len
-= size
;
9327 printf ("File Attributes\n");
9330 printf ("Section Attributes:");
9333 printf ("Symbol Attributes:");
9339 val
= read_uleb128 (p
, &i
);
9343 printf (" %d", val
);
9348 printf ("Unknown tag: %d\n", tag
);
9349 public_section
= FALSE
;
9356 p
= display_pub_attribute (p
);
9358 else if (gnu_section
)
9361 p
= display_gnu_attribute (p
,
9362 display_proc_gnu_attribute
);
9366 /* ??? Do something sensible, like dump hex. */
9367 printf (" Unknown section contexts\n");
9374 printf (_("Unknown format '%c'\n"), *p
);
9382 process_arm_specific (FILE * file
)
9384 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9385 display_arm_attribute
, NULL
);
9389 process_power_specific (FILE * file
)
9391 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9392 display_power_gnu_attribute
);
9395 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9396 Print the Address, Access and Initial fields of an entry at VMA ADDR
9397 and return the VMA of the next entry. */
9400 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9403 print_vma (addr
, LONG_HEX
);
9405 if (addr
< pltgot
+ 0xfff0)
9406 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9408 printf ("%10s", "");
9411 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9416 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9417 print_vma (entry
, LONG_HEX
);
9419 return addr
+ (is_32bit_elf
? 4 : 8);
9422 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9423 PLTGOT. Print the Address and Initial fields of an entry at VMA
9424 ADDR and return the VMA of the next entry. */
9427 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9430 print_vma (addr
, LONG_HEX
);
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);
9445 process_mips_specific (FILE * file
)
9447 Elf_Internal_Dyn
* entry
;
9448 size_t liblist_offset
= 0;
9449 size_t liblistno
= 0;
9450 size_t conflictsno
= 0;
9451 size_t options_offset
= 0;
9452 size_t conflicts_offset
= 0;
9453 size_t pltrelsz
= 0;
9456 bfd_vma mips_pltgot
= 0;
9458 bfd_vma local_gotno
= 0;
9460 bfd_vma symtabno
= 0;
9462 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9463 display_mips_gnu_attribute
);
9465 /* We have a lot of special sections. Thanks SGI! */
9466 if (dynamic_section
== NULL
)
9467 /* No information available. */
9470 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9471 switch (entry
->d_tag
)
9473 case DT_MIPS_LIBLIST
:
9475 = offset_from_vma (file
, entry
->d_un
.d_val
,
9476 liblistno
* sizeof (Elf32_External_Lib
));
9478 case DT_MIPS_LIBLISTNO
:
9479 liblistno
= entry
->d_un
.d_val
;
9481 case DT_MIPS_OPTIONS
:
9482 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9484 case DT_MIPS_CONFLICT
:
9486 = offset_from_vma (file
, entry
->d_un
.d_val
,
9487 conflictsno
* sizeof (Elf32_External_Conflict
));
9489 case DT_MIPS_CONFLICTNO
:
9490 conflictsno
= entry
->d_un
.d_val
;
9493 pltgot
= entry
->d_un
.d_ptr
;
9495 case DT_MIPS_LOCAL_GOTNO
:
9496 local_gotno
= entry
->d_un
.d_val
;
9498 case DT_MIPS_GOTSYM
:
9499 gotsym
= entry
->d_un
.d_val
;
9501 case DT_MIPS_SYMTABNO
:
9502 symtabno
= entry
->d_un
.d_val
;
9504 case DT_MIPS_PLTGOT
:
9505 mips_pltgot
= entry
->d_un
.d_ptr
;
9508 pltrel
= entry
->d_un
.d_val
;
9511 pltrelsz
= entry
->d_un
.d_val
;
9514 jmprel
= entry
->d_un
.d_ptr
;
9520 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9522 Elf32_External_Lib
* elib
;
9525 elib
= get_data (NULL
, file
, liblist_offset
,
9526 liblistno
, sizeof (Elf32_External_Lib
),
9530 printf ("\nSection '.liblist' contains %lu entries:\n",
9531 (unsigned long) liblistno
);
9532 fputs (" Library Time Stamp Checksum Version Flags\n",
9535 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9542 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9543 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9544 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9545 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9546 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9548 tmp
= gmtime (&time
);
9549 snprintf (timebuf
, sizeof (timebuf
),
9550 "%04u-%02u-%02uT%02u:%02u:%02u",
9551 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9552 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9554 printf ("%3lu: ", (unsigned long) cnt
);
9555 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9556 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9558 printf ("<corrupt: %9ld>", liblist
.l_name
);
9559 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9562 if (liblist
.l_flags
== 0)
9573 { " EXACT_MATCH", LL_EXACT_MATCH
},
9574 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9575 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9576 { " EXPORTS", LL_EXPORTS
},
9577 { " DELAY_LOAD", LL_DELAY_LOAD
},
9578 { " DELTA", LL_DELTA
}
9580 int flags
= liblist
.l_flags
;
9583 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9584 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9586 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9587 flags
^= l_flags_vals
[fcnt
].bit
;
9590 printf (" %#x", (unsigned int) flags
);
9600 if (options_offset
!= 0)
9602 Elf_External_Options
* eopt
;
9603 Elf_Internal_Shdr
* sect
= section_headers
;
9604 Elf_Internal_Options
* iopt
;
9605 Elf_Internal_Options
* option
;
9609 /* Find the section header so that we get the size. */
9610 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9613 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9617 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9620 error (_("Out of memory\n"));
9627 while (offset
< sect
->sh_size
)
9629 Elf_External_Options
* eoption
;
9631 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9633 option
->kind
= BYTE_GET (eoption
->kind
);
9634 option
->size
= BYTE_GET (eoption
->size
);
9635 option
->section
= BYTE_GET (eoption
->section
);
9636 option
->info
= BYTE_GET (eoption
->info
);
9638 offset
+= option
->size
;
9644 printf (_("\nSection '%s' contains %d entries:\n"),
9645 SECTION_NAME (sect
), cnt
);
9653 switch (option
->kind
)
9656 /* This shouldn't happen. */
9657 printf (" NULL %d %lx", option
->section
, option
->info
);
9660 printf (" REGINFO ");
9661 if (elf_header
.e_machine
== EM_MIPS
)
9664 Elf32_External_RegInfo
* ereg
;
9665 Elf32_RegInfo reginfo
;
9667 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9668 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9669 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9670 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9671 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9672 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9673 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9675 printf ("GPR %08lx GP 0x%lx\n",
9677 (unsigned long) reginfo
.ri_gp_value
);
9678 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9679 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9680 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9685 Elf64_External_RegInfo
* ereg
;
9686 Elf64_Internal_RegInfo reginfo
;
9688 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9689 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9690 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9691 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9692 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9693 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9694 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9696 printf ("GPR %08lx GP 0x",
9697 reginfo
.ri_gprmask
);
9698 printf_vma (reginfo
.ri_gp_value
);
9701 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9702 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9703 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9707 case ODK_EXCEPTIONS
:
9708 fputs (" EXCEPTIONS fpe_min(", stdout
);
9709 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9710 fputs (") fpe_max(", stdout
);
9711 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9712 fputs (")", stdout
);
9714 if (option
->info
& OEX_PAGE0
)
9715 fputs (" PAGE0", stdout
);
9716 if (option
->info
& OEX_SMM
)
9717 fputs (" SMM", stdout
);
9718 if (option
->info
& OEX_FPDBUG
)
9719 fputs (" FPDBUG", stdout
);
9720 if (option
->info
& OEX_DISMISS
)
9721 fputs (" DISMISS", stdout
);
9724 fputs (" PAD ", stdout
);
9725 if (option
->info
& OPAD_PREFIX
)
9726 fputs (" PREFIX", stdout
);
9727 if (option
->info
& OPAD_POSTFIX
)
9728 fputs (" POSTFIX", stdout
);
9729 if (option
->info
& OPAD_SYMBOL
)
9730 fputs (" SYMBOL", stdout
);
9733 fputs (" HWPATCH ", stdout
);
9734 if (option
->info
& OHW_R4KEOP
)
9735 fputs (" R4KEOP", stdout
);
9736 if (option
->info
& OHW_R8KPFETCH
)
9737 fputs (" R8KPFETCH", stdout
);
9738 if (option
->info
& OHW_R5KEOP
)
9739 fputs (" R5KEOP", stdout
);
9740 if (option
->info
& OHW_R5KCVTL
)
9741 fputs (" R5KCVTL", stdout
);
9744 fputs (" FILL ", stdout
);
9745 /* XXX Print content of info word? */
9748 fputs (" TAGS ", stdout
);
9749 /* XXX Print content of info word? */
9752 fputs (" HWAND ", stdout
);
9753 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9754 fputs (" R4KEOP_CHECKED", stdout
);
9755 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9756 fputs (" R4KEOP_CLEAN", stdout
);
9759 fputs (" HWOR ", stdout
);
9760 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9761 fputs (" R4KEOP_CHECKED", stdout
);
9762 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9763 fputs (" R4KEOP_CLEAN", stdout
);
9766 printf (" GP_GROUP %#06lx self-contained %#06lx",
9767 option
->info
& OGP_GROUP
,
9768 (option
->info
& OGP_SELF
) >> 16);
9771 printf (" IDENT %#06lx self-contained %#06lx",
9772 option
->info
& OGP_GROUP
,
9773 (option
->info
& OGP_SELF
) >> 16);
9776 /* This shouldn't happen. */
9777 printf (" %3d ??? %d %lx",
9778 option
->kind
, option
->section
, option
->info
);
9782 len
= sizeof (* eopt
);
9783 while (len
< option
->size
)
9784 if (((char *) option
)[len
] >= ' '
9785 && ((char *) option
)[len
] < 0x7f)
9786 printf ("%c", ((char *) option
)[len
++]);
9788 printf ("\\%03o", ((char *) option
)[len
++]);
9790 fputs ("\n", stdout
);
9798 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9800 Elf32_Conflict
* iconf
;
9803 if (dynamic_symbols
== NULL
)
9805 error (_("conflict list found without a dynamic symbol table\n"));
9809 iconf
= cmalloc (conflictsno
, sizeof (* iconf
));
9812 error (_("Out of memory\n"));
9818 Elf32_External_Conflict
* econf32
;
9820 econf32
= get_data (NULL
, file
, conflicts_offset
,
9821 conflictsno
, sizeof (* econf32
), _("conflict"));
9825 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9826 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9832 Elf64_External_Conflict
* econf64
;
9834 econf64
= get_data (NULL
, file
, conflicts_offset
,
9835 conflictsno
, sizeof (* econf64
), _("conflict"));
9839 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9840 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9845 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9846 (unsigned long) conflictsno
);
9847 puts (_(" Num: Index Value Name"));
9849 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9851 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9853 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9854 print_vma (psym
->st_value
, FULL_HEX
);
9856 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9857 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9859 printf ("<corrupt: %14ld>", psym
->st_name
);
9866 if (pltgot
!= 0 && local_gotno
!= 0)
9868 bfd_vma entry
, local_end
, global_end
;
9870 unsigned char * data
;
9874 addr_size
= (is_32bit_elf
? 4 : 8);
9875 local_end
= pltgot
+ local_gotno
* addr_size
;
9876 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9878 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9879 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9880 printf (_("\nPrimary GOT:\n"));
9881 printf (_(" Canonical gp value: "));
9882 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9885 printf (_(" Reserved entries:\n"));
9886 printf (_(" %*s %10s %*s Purpose\n"),
9887 addr_size
* 2, "Address", "Access",
9888 addr_size
* 2, "Initial");
9889 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9890 printf (" Lazy resolver\n");
9892 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9893 >> (addr_size
* 8 - 1)) != 0)
9895 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9896 printf (" Module pointer (GNU extension)\n");
9900 if (entry
< local_end
)
9902 printf (_(" Local entries:\n"));
9903 printf (_(" %*s %10s %*s\n"),
9904 addr_size
* 2, "Address", "Access",
9905 addr_size
* 2, "Initial");
9906 while (entry
< local_end
)
9908 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9914 if (gotsym
< symtabno
)
9918 printf (_(" Global entries:\n"));
9919 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9920 addr_size
* 2, "Address", "Access",
9921 addr_size
* 2, "Initial",
9922 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9923 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9924 for (i
= gotsym
; i
< symtabno
; i
++)
9926 Elf_Internal_Sym
* psym
;
9928 psym
= dynamic_symbols
+ i
;
9929 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9931 print_vma (psym
->st_value
, LONG_HEX
);
9932 printf (" %-7s %3s ",
9933 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9934 get_symbol_index_type (psym
->st_shndx
));
9935 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9936 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9938 printf ("<corrupt: %14ld>", psym
->st_name
);
9948 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9951 size_t offset
, rel_offset
;
9952 unsigned long count
, i
;
9953 unsigned char * data
;
9954 int addr_size
, sym_width
;
9955 Elf_Internal_Rela
* rels
;
9957 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9958 if (pltrel
== DT_RELA
)
9960 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9965 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9969 entry
= mips_pltgot
;
9970 addr_size
= (is_32bit_elf
? 4 : 8);
9971 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9973 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9974 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9975 printf (_("\nPLT GOT:\n\n"));
9976 printf (_(" Reserved entries:\n"));
9977 printf (_(" %*s %*s Purpose\n"),
9978 addr_size
* 2, "Address", addr_size
* 2, "Initial");
9979 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9980 printf (" PLT lazy resolver\n");
9981 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9982 printf (" Module pointer\n");
9985 printf (_(" Entries:\n"));
9986 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9987 addr_size
* 2, "Address",
9988 addr_size
* 2, "Initial",
9989 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9990 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
9991 for (i
= 0; i
< count
; i
++)
9993 Elf_Internal_Sym
* psym
;
9995 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
9996 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9998 print_vma (psym
->st_value
, LONG_HEX
);
9999 printf (" %-7s %3s ",
10000 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10001 get_symbol_index_type (psym
->st_shndx
));
10002 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10003 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10005 printf ("<corrupt: %14ld>", psym
->st_name
);
10019 process_gnu_liblist (FILE * file
)
10021 Elf_Internal_Shdr
* section
;
10022 Elf_Internal_Shdr
* string_sec
;
10023 Elf32_External_Lib
* elib
;
10025 size_t strtab_size
;
10032 for (i
= 0, section
= section_headers
;
10033 i
< elf_header
.e_shnum
;
10036 switch (section
->sh_type
)
10038 case SHT_GNU_LIBLIST
:
10039 if (section
->sh_link
>= elf_header
.e_shnum
)
10042 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10047 string_sec
= section_headers
+ section
->sh_link
;
10049 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10050 string_sec
->sh_size
, _("liblist string table"));
10051 strtab_size
= string_sec
->sh_size
;
10054 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10060 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10061 SECTION_NAME (section
),
10062 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10064 puts (" Library Time Stamp Checksum Version Flags");
10066 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10074 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10075 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10076 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10077 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10078 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10080 tmp
= gmtime (&time
);
10081 snprintf (timebuf
, sizeof (timebuf
),
10082 "%04u-%02u-%02uT%02u:%02u:%02u",
10083 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10084 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10086 printf ("%3lu: ", (unsigned long) cnt
);
10088 printf ("%-20s", liblist
.l_name
< strtab_size
10089 ? strtab
+ liblist
.l_name
: "<corrupt>");
10091 printf ("%-20.20s", liblist
.l_name
< strtab_size
10092 ? strtab
+ liblist
.l_name
: "<corrupt>");
10093 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10094 liblist
.l_version
, liblist
.l_flags
);
10104 static const char *
10105 get_note_type (unsigned e_type
)
10107 static char buff
[64];
10109 if (elf_header
.e_type
== ET_CORE
)
10113 return _("NT_AUXV (auxiliary vector)");
10115 return _("NT_PRSTATUS (prstatus structure)");
10117 return _("NT_FPREGSET (floating point registers)");
10119 return _("NT_PRPSINFO (prpsinfo structure)");
10120 case NT_TASKSTRUCT
:
10121 return _("NT_TASKSTRUCT (task structure)");
10123 return _("NT_PRXFPREG (user_xfpregs structure)");
10125 return _("NT_PPC_VMX (ppc Altivec registers)");
10127 return _("NT_PPC_VSX (ppc VSX registers)");
10129 return _("NT_PSTATUS (pstatus structure)");
10131 return _("NT_FPREGS (floating point registers)");
10133 return _("NT_PSINFO (psinfo structure)");
10135 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10137 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10138 case NT_WIN32PSTATUS
:
10139 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10147 return _("NT_VERSION (version)");
10149 return _("NT_ARCH (architecture)");
10154 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10158 static const char *
10159 get_gnu_elf_note_type (unsigned e_type
)
10161 static char buff
[64];
10165 case NT_GNU_ABI_TAG
:
10166 return _("NT_GNU_ABI_TAG (ABI version tag)");
10168 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10169 case NT_GNU_BUILD_ID
:
10170 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10171 case NT_GNU_GOLD_VERSION
:
10172 return _("NT_GNU_GOLD_VERSION (gold version)");
10177 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10181 static const char *
10182 get_netbsd_elfcore_note_type (unsigned e_type
)
10184 static char buff
[64];
10186 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10188 /* NetBSD core "procinfo" structure. */
10189 return _("NetBSD procinfo structure");
10192 /* As of Jan 2002 there are no other machine-independent notes
10193 defined for NetBSD core files. If the note type is less
10194 than the start of the machine-dependent note types, we don't
10197 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10199 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10203 switch (elf_header
.e_machine
)
10205 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10206 and PT_GETFPREGS == mach+2. */
10211 case EM_SPARC32PLUS
:
10215 case NT_NETBSDCORE_FIRSTMACH
+0:
10216 return _("PT_GETREGS (reg structure)");
10217 case NT_NETBSDCORE_FIRSTMACH
+2:
10218 return _("PT_GETFPREGS (fpreg structure)");
10224 /* On all other arch's, PT_GETREGS == mach+1 and
10225 PT_GETFPREGS == mach+3. */
10229 case NT_NETBSDCORE_FIRSTMACH
+1:
10230 return _("PT_GETREGS (reg structure)");
10231 case NT_NETBSDCORE_FIRSTMACH
+3:
10232 return _("PT_GETFPREGS (fpreg structure)");
10238 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10239 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10243 /* Note that by the ELF standard, the name field is already null byte
10244 terminated, and namesz includes the terminating null byte.
10245 I.E. the value of namesz for the name "FSF" is 4.
10247 If the value of namesz is zero, there is no name present. */
10249 process_note (Elf_Internal_Note
* pnote
)
10251 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10254 if (pnote
->namesz
== 0)
10255 /* If there is no note name, then use the default set of
10256 note type strings. */
10257 nt
= get_note_type (pnote
->type
);
10259 else if (const_strneq (pnote
->namedata
, "GNU"))
10260 /* GNU-specific object file notes. */
10261 nt
= get_gnu_elf_note_type (pnote
->type
);
10263 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10264 /* NetBSD-specific core file notes. */
10265 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10267 else if (strneq (pnote
->namedata
, "SPU/", 4))
10269 /* SPU-specific core file notes. */
10270 nt
= pnote
->namedata
+ 4;
10275 /* Don't recognize this note name; just use the default set of
10276 note type strings. */
10277 nt
= get_note_type (pnote
->type
);
10279 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10285 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10287 Elf_External_Note
* pnotes
;
10288 Elf_External_Note
* external
;
10294 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10300 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10301 (unsigned long) offset
, (unsigned long) length
);
10302 printf (_(" Owner\t\tData size\tDescription\n"));
10304 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10306 Elf_External_Note
* next
;
10307 Elf_Internal_Note inote
;
10308 char * temp
= NULL
;
10310 inote
.type
= BYTE_GET (external
->type
);
10311 inote
.namesz
= BYTE_GET (external
->namesz
);
10312 inote
.namedata
= external
->name
;
10313 inote
.descsz
= BYTE_GET (external
->descsz
);
10314 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10315 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10317 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10319 if (((char *) next
) > (((char *) pnotes
) + length
))
10321 warn (_("corrupt note found at offset %lx into core notes\n"),
10322 (unsigned long) ((char *) external
- (char *) pnotes
));
10323 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10324 inote
.type
, inote
.namesz
, inote
.descsz
);
10330 /* Verify that name is null terminated. It appears that at least
10331 one version of Linux (RedHat 6.0) generates corefiles that don't
10332 comply with the ELF spec by failing to include the null byte in
10334 if (inote
.namedata
[inote
.namesz
] != '\0')
10336 temp
= malloc (inote
.namesz
+ 1);
10340 error (_("Out of memory\n"));
10345 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10346 temp
[inote
.namesz
] = 0;
10348 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10349 inote
.namedata
= temp
;
10352 res
&= process_note (& inote
);
10367 process_corefile_note_segments (FILE * file
)
10369 Elf_Internal_Phdr
* segment
;
10373 if (! get_program_headers (file
))
10376 for (i
= 0, segment
= program_headers
;
10377 i
< elf_header
.e_phnum
;
10380 if (segment
->p_type
== PT_NOTE
)
10381 res
&= process_corefile_note_segment (file
,
10382 (bfd_vma
) segment
->p_offset
,
10383 (bfd_vma
) segment
->p_filesz
);
10390 process_note_sections (FILE * file
)
10392 Elf_Internal_Shdr
* section
;
10396 for (i
= 0, section
= section_headers
;
10397 i
< elf_header
.e_shnum
;
10399 if (section
->sh_type
== SHT_NOTE
)
10400 res
&= process_corefile_note_segment (file
,
10401 (bfd_vma
) section
->sh_offset
,
10402 (bfd_vma
) section
->sh_size
);
10408 process_notes (FILE * file
)
10410 /* If we have not been asked to display the notes then do nothing. */
10414 if (elf_header
.e_type
!= ET_CORE
)
10415 return process_note_sections (file
);
10417 /* No program headers means no NOTE segment. */
10418 if (elf_header
.e_phnum
> 0)
10419 return process_corefile_note_segments (file
);
10421 printf (_("No note segments present in the core file.\n"));
10426 process_arch_specific (FILE * file
)
10431 switch (elf_header
.e_machine
)
10434 return process_arm_specific (file
);
10436 case EM_MIPS_RS3_LE
:
10437 return process_mips_specific (file
);
10440 return process_power_specific (file
);
10449 get_file_header (FILE * file
)
10451 /* Read in the identity array. */
10452 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10455 /* Determine how to read the rest of the header. */
10456 switch (elf_header
.e_ident
[EI_DATA
])
10458 default: /* fall through */
10459 case ELFDATANONE
: /* fall through */
10461 byte_get
= byte_get_little_endian
;
10462 byte_put
= byte_put_little_endian
;
10465 byte_get
= byte_get_big_endian
;
10466 byte_put
= byte_put_big_endian
;
10470 /* For now we only support 32 bit and 64 bit ELF files. */
10471 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10473 /* Read in the rest of the header. */
10476 Elf32_External_Ehdr ehdr32
;
10478 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10481 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10482 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10483 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10484 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10485 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10486 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10487 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10488 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10489 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10490 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10491 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10492 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10493 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10497 Elf64_External_Ehdr ehdr64
;
10499 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10500 we will not be able to cope with the 64bit data found in
10501 64 ELF files. Detect this now and abort before we start
10502 overwriting things. */
10503 if (sizeof (bfd_vma
) < 8)
10505 error (_("This instance of readelf has been built without support for a\n\
10506 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10510 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10513 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10514 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10515 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10516 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10517 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10518 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10519 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10520 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10521 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10522 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10523 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10524 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10525 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10528 if (elf_header
.e_shoff
)
10530 /* There may be some extensions in the first section header. Don't
10531 bomb if we can't read it. */
10533 get_32bit_section_headers (file
, 1);
10535 get_64bit_section_headers (file
, 1);
10541 /* Process one ELF object file according to the command line options.
10542 This file may actually be stored in an archive. The file is
10543 positioned at the start of the ELF object. */
10546 process_object (char * file_name
, FILE * file
)
10550 if (! get_file_header (file
))
10552 error (_("%s: Failed to read file header\n"), file_name
);
10556 /* Initialise per file variables. */
10557 for (i
= ARRAY_SIZE (version_info
); i
--;)
10558 version_info
[i
] = 0;
10560 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10561 dynamic_info
[i
] = 0;
10563 /* Process the file. */
10565 printf (_("\nFile: %s\n"), file_name
);
10567 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10568 Note we do this even if cmdline_dump_sects is empty because we
10569 must make sure that the dump_sets array is zeroed out before each
10570 object file is processed. */
10571 if (num_dump_sects
> num_cmdline_dump_sects
)
10572 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10574 if (num_cmdline_dump_sects
> 0)
10576 if (num_dump_sects
== 0)
10577 /* A sneaky way of allocating the dump_sects array. */
10578 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10580 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10581 memcpy (dump_sects
, cmdline_dump_sects
,
10582 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10585 if (! process_file_header ())
10588 if (! process_section_headers (file
))
10590 /* Without loaded section headers we cannot process lots of
10592 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10594 if (! do_using_dynamic
)
10595 do_syms
= do_reloc
= 0;
10598 if (! process_section_groups (file
))
10600 /* Without loaded section groups we cannot process unwind. */
10604 if (process_program_headers (file
))
10605 process_dynamic_section (file
);
10607 process_relocs (file
);
10609 process_unwind (file
);
10611 process_symbol_table (file
);
10613 process_syminfo (file
);
10615 process_version_sections (file
);
10617 process_section_contents (file
);
10619 process_notes (file
);
10621 process_gnu_liblist (file
);
10623 process_arch_specific (file
);
10625 if (program_headers
)
10627 free (program_headers
);
10628 program_headers
= NULL
;
10631 if (section_headers
)
10633 free (section_headers
);
10634 section_headers
= NULL
;
10639 free (string_table
);
10640 string_table
= NULL
;
10641 string_table_length
= 0;
10644 if (dynamic_strings
)
10646 free (dynamic_strings
);
10647 dynamic_strings
= NULL
;
10648 dynamic_strings_length
= 0;
10651 if (dynamic_symbols
)
10653 free (dynamic_symbols
);
10654 dynamic_symbols
= NULL
;
10655 num_dynamic_syms
= 0;
10658 if (dynamic_syminfo
)
10660 free (dynamic_syminfo
);
10661 dynamic_syminfo
= NULL
;
10664 if (section_headers_groups
)
10666 free (section_headers_groups
);
10667 section_headers_groups
= NULL
;
10670 if (section_groups
)
10672 struct group_list
* g
;
10673 struct group_list
* next
;
10675 for (i
= 0; i
< group_count
; i
++)
10677 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10684 free (section_groups
);
10685 section_groups
= NULL
;
10688 free_debug_memory ();
10693 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10694 to the path name of the thin archive itself if necessary. Always returns
10695 a pointer to malloc'ed memory. */
10698 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10700 char * member_file_name
;
10701 const char * base_name
= lbasename (file_name
);
10703 /* This is a proxy entry for a thin archive member.
10704 If the extended name table contains an absolute path
10705 name, or if the archive is in the current directory,
10706 use the path name as given. Otherwise, we need to
10707 find the member relative to the directory where the
10708 archive is located. */
10709 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10711 member_file_name
= malloc (name_len
+ 1);
10712 if (member_file_name
== NULL
)
10714 error (_("Out of memory\n"));
10717 memcpy (member_file_name
, name
, name_len
);
10718 member_file_name
[name_len
] = '\0';
10722 /* Concatenate the path components of the archive file name
10723 to the relative path name from the extended name table. */
10724 size_t prefix_len
= base_name
- file_name
;
10725 member_file_name
= malloc (prefix_len
+ name_len
+ 1);
10726 if (member_file_name
== NULL
)
10728 error (_("Out of memory\n"));
10731 memcpy (member_file_name
, file_name
, prefix_len
);
10732 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10733 member_file_name
[prefix_len
+ name_len
] = '\0';
10735 return member_file_name
;
10738 /* Structure to hold information about an archive file. */
10740 struct archive_info
10742 char * file_name
; /* Archive file name. */
10743 FILE * file
; /* Open file descriptor. */
10744 unsigned long index_num
; /* Number of symbols in table. */
10745 unsigned long * index_array
; /* The array of member offsets. */
10746 char * sym_table
; /* The symbol table. */
10747 unsigned long sym_size
; /* Size of the symbol table. */
10748 char * longnames
; /* The long file names table. */
10749 unsigned long longnames_size
; /* Size of the long file names table. */
10750 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10751 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10752 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10753 struct ar_hdr arhdr
; /* Current archive header. */
10756 /* Read the symbol table and long-name table from an archive. */
10759 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10760 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10763 unsigned long size
;
10765 arch
->file_name
= strdup (file_name
);
10767 arch
->index_num
= 0;
10768 arch
->index_array
= NULL
;
10769 arch
->sym_table
= NULL
;
10770 arch
->sym_size
= 0;
10771 arch
->longnames
= NULL
;
10772 arch
->longnames_size
= 0;
10773 arch
->nested_member_origin
= 0;
10774 arch
->is_thin_archive
= is_thin_archive
;
10775 arch
->next_arhdr_offset
= SARMAG
;
10777 /* Read the first archive member header. */
10778 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10780 error (_("%s: failed to seek to first archive header\n"), file_name
);
10783 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10784 if (got
!= sizeof arch
->arhdr
)
10789 error (_("%s: failed to read archive header\n"), file_name
);
10793 /* See if this is the archive symbol table. */
10794 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10795 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10797 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10798 size
= size
+ (size
& 1);
10800 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10805 /* A buffer used to hold numbers read in from an archive index.
10806 These are always 4 bytes long and stored in big-endian format. */
10807 #define SIZEOF_AR_INDEX_NUMBERS 4
10808 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10809 unsigned char * index_buffer
;
10811 /* Check the size of the archive index. */
10812 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10814 error (_("%s: the archive index is empty\n"), file_name
);
10818 /* Read the numer of entries in the archive index. */
10819 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10820 if (got
!= sizeof (integer_buffer
))
10822 error (_("%s: failed to read archive index\n"), file_name
);
10825 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10826 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10828 /* Read in the archive index. */
10829 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10831 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10832 file_name
, arch
->index_num
);
10835 index_buffer
= malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10836 if (index_buffer
== NULL
)
10838 error (_("Out of memory whilst trying to read archive symbol index\n"));
10841 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
10842 if (got
!= arch
->index_num
)
10844 free (index_buffer
);
10845 error (_("%s: failed to read archive index\n"), file_name
);
10848 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10850 /* Convert the index numbers into the host's numeric format. */
10851 arch
->index_array
= malloc (arch
->index_num
* sizeof (* arch
->index_array
));
10852 if (arch
->index_array
== NULL
)
10854 free (index_buffer
);
10855 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10859 for (i
= 0; i
< arch
->index_num
; i
++)
10860 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10861 SIZEOF_AR_INDEX_NUMBERS
);
10862 free (index_buffer
);
10864 /* The remaining space in the header is taken up by the symbol table. */
10867 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10870 arch
->sym_table
= malloc (size
);
10871 arch
->sym_size
= size
;
10872 if (arch
->sym_table
== NULL
)
10874 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10877 got
= fread (arch
->sym_table
, 1, size
, file
);
10880 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10886 if (fseek (file
, size
, SEEK_CUR
) != 0)
10888 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10893 /* Read the next archive header. */
10894 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10895 if (got
!= sizeof arch
->arhdr
)
10899 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10903 else if (read_symbols
)
10904 printf (_("%s has no archive index\n"), file_name
);
10906 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
10908 /* This is the archive string table holding long member names. */
10909 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10910 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
10912 arch
->longnames
= malloc (arch
->longnames_size
);
10913 if (arch
->longnames
== NULL
)
10915 error (_("Out of memory reading long symbol names in archive\n"));
10919 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
10921 free (arch
->longnames
);
10922 arch
->longnames
= NULL
;
10923 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10927 if ((arch
->longnames_size
& 1) != 0)
10934 /* Release the memory used for the archive information. */
10937 release_archive (struct archive_info
* arch
)
10939 if (arch
->file_name
!= NULL
)
10940 free (arch
->file_name
);
10941 if (arch
->index_array
!= NULL
)
10942 free (arch
->index_array
);
10943 if (arch
->sym_table
!= NULL
)
10944 free (arch
->sym_table
);
10945 if (arch
->longnames
!= NULL
)
10946 free (arch
->longnames
);
10949 /* Open and setup a nested archive, if not already open. */
10952 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
10954 FILE * member_file
;
10956 /* Have we already setup this archive? */
10957 if (nested_arch
->file_name
!= NULL
10958 && streq (nested_arch
->file_name
, member_file_name
))
10961 /* Close previous file and discard cached information. */
10962 if (nested_arch
->file
!= NULL
)
10963 fclose (nested_arch
->file
);
10964 release_archive (nested_arch
);
10966 member_file
= fopen (member_file_name
, "rb");
10967 if (member_file
== NULL
)
10969 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
10973 get_archive_member_name_at (struct archive_info
* arch
,
10974 unsigned long offset
,
10975 struct archive_info
* nested_arch
);
10977 /* Get the name of an archive member from the current archive header.
10978 For simple names, this will modify the ar_name field of the current
10979 archive header. For long names, it will return a pointer to the
10980 longnames table. For nested archives, it will open the nested archive
10981 and get the name recursively. NESTED_ARCH is a single-entry cache so
10982 we don't keep rereading the same information from a nested archive. */
10985 get_archive_member_name (struct archive_info
* arch
,
10986 struct archive_info
* nested_arch
)
10988 unsigned long j
, k
;
10990 if (arch
->arhdr
.ar_name
[0] == '/')
10992 /* We have a long name. */
10994 char * member_file_name
;
10995 char * member_name
;
10997 arch
->nested_member_origin
= 0;
10998 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
10999 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11000 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11002 while ((j
< arch
->longnames_size
)
11003 && (arch
->longnames
[j
] != '\n')
11004 && (arch
->longnames
[j
] != '\0'))
11006 if (arch
->longnames
[j
-1] == '/')
11008 arch
->longnames
[j
] = '\0';
11010 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11011 return arch
->longnames
+ k
;
11013 /* This is a proxy for a member of a nested archive.
11014 Find the name of the member in that archive. */
11015 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11016 if (member_file_name
!= NULL
11017 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11018 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11020 free (member_file_name
);
11021 return member_name
;
11023 free (member_file_name
);
11025 /* Last resort: just return the name of the nested archive. */
11026 return arch
->longnames
+ k
;
11029 /* We have a normal (short) name. */
11031 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11033 arch
->arhdr
.ar_name
[j
] = '\0';
11034 return arch
->arhdr
.ar_name
;
11037 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11040 get_archive_member_name_at (struct archive_info
* arch
,
11041 unsigned long offset
,
11042 struct archive_info
* nested_arch
)
11046 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11048 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11051 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11052 if (got
!= sizeof arch
->arhdr
)
11054 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11057 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11059 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11063 return get_archive_member_name (arch
, nested_arch
);
11066 /* Construct a string showing the name of the archive member, qualified
11067 with the name of the containing archive file. For thin archives, we
11068 use square brackets to denote the indirection. For nested archives,
11069 we show the qualified name of the external member inside the square
11070 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11073 make_qualified_name (struct archive_info
* arch
,
11074 struct archive_info
* nested_arch
,
11075 char * member_name
)
11080 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11081 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11082 len
+= strlen (nested_arch
->file_name
) + 2;
11084 name
= malloc (len
);
11087 error (_("Out of memory\n"));
11091 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11092 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11093 else if (arch
->is_thin_archive
)
11094 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11096 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11101 /* Process an ELF archive.
11102 On entry the file is positioned just after the ARMAG string. */
11105 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11107 struct archive_info arch
;
11108 struct archive_info nested_arch
;
11110 size_t file_name_size
;
11115 /* The ARCH structure is used to hold information about this archive. */
11116 arch
.file_name
= NULL
;
11118 arch
.index_array
= NULL
;
11119 arch
.sym_table
= NULL
;
11120 arch
.longnames
= NULL
;
11122 /* The NESTED_ARCH structure is used as a single-item cache of information
11123 about a nested archive (when members of a thin archive reside within
11124 another regular archive file). */
11125 nested_arch
.file_name
= NULL
;
11126 nested_arch
.file
= NULL
;
11127 nested_arch
.index_array
= NULL
;
11128 nested_arch
.sym_table
= NULL
;
11129 nested_arch
.longnames
= NULL
;
11131 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11137 if (do_archive_index
)
11139 if (arch
.sym_table
== NULL
)
11140 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11144 unsigned long current_pos
;
11146 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11147 file_name
, arch
.index_num
, arch
.sym_size
);
11148 current_pos
= ftell (file
);
11150 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11152 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11154 char * member_name
;
11156 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11158 if (member_name
!= NULL
)
11160 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11162 if (qualified_name
!= NULL
)
11164 printf (_("Binary %s contains:\n"), qualified_name
);
11165 free (qualified_name
);
11170 if (l
>= arch
.sym_size
)
11172 error (_("%s: end of the symbol table reached before the end of the index\n"),
11176 printf ("\t%s\n", arch
.sym_table
+ l
);
11177 l
+= strlen (arch
.sym_table
+ l
) + 1;
11182 if (l
< arch
.sym_size
)
11183 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11186 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11188 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11194 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11195 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11196 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11197 && !do_section_groups
)
11199 ret
= 0; /* Archive index only. */
11204 file_name_size
= strlen (file_name
);
11211 char * qualified_name
;
11213 /* Read the next archive header. */
11214 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11216 error (_("%s: failed to seek to next archive header\n"), file_name
);
11219 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11220 if (got
!= sizeof arch
.arhdr
)
11224 error (_("%s: failed to read archive header\n"), file_name
);
11228 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11230 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11235 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11237 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11238 if (archive_file_size
& 01)
11239 ++archive_file_size
;
11241 name
= get_archive_member_name (&arch
, &nested_arch
);
11244 error (_("%s: bad archive file name\n"), file_name
);
11248 namelen
= strlen (name
);
11250 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11251 if (qualified_name
== NULL
)
11253 error (_("%s: bad archive file name\n"), file_name
);
11258 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11260 /* This is a proxy for an external member of a thin archive. */
11261 FILE * member_file
;
11262 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11263 if (member_file_name
== NULL
)
11269 member_file
= fopen (member_file_name
, "rb");
11270 if (member_file
== NULL
)
11272 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11273 free (member_file_name
);
11278 archive_file_offset
= arch
.nested_member_origin
;
11280 ret
|= process_object (qualified_name
, member_file
);
11282 fclose (member_file
);
11283 free (member_file_name
);
11285 else if (is_thin_archive
)
11287 /* This is a proxy for a member of a nested archive. */
11288 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11290 /* The nested archive file will have been opened and setup by
11291 get_archive_member_name. */
11292 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11294 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11299 ret
|= process_object (qualified_name
, nested_arch
.file
);
11303 archive_file_offset
= arch
.next_arhdr_offset
;
11304 arch
.next_arhdr_offset
+= archive_file_size
;
11306 ret
|= process_object (qualified_name
, file
);
11309 free (qualified_name
);
11313 if (nested_arch
.file
!= NULL
)
11314 fclose (nested_arch
.file
);
11315 release_archive (&nested_arch
);
11316 release_archive (&arch
);
11322 process_file (char * file_name
)
11325 struct stat statbuf
;
11326 char armag
[SARMAG
];
11329 if (stat (file_name
, &statbuf
) < 0)
11331 if (errno
== ENOENT
)
11332 error (_("'%s': No such file\n"), file_name
);
11334 error (_("Could not locate '%s'. System error message: %s\n"),
11335 file_name
, strerror (errno
));
11339 if (! S_ISREG (statbuf
.st_mode
))
11341 error (_("'%s' is not an ordinary file\n"), file_name
);
11345 file
= fopen (file_name
, "rb");
11348 error (_("Input file '%s' is not readable.\n"), file_name
);
11352 if (fread (armag
, SARMAG
, 1, file
) != 1)
11354 error (_("%s: Failed to read file's magic number\n"), file_name
);
11359 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11360 ret
= process_archive (file_name
, file
, FALSE
);
11361 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11362 ret
= process_archive (file_name
, file
, TRUE
);
11365 if (do_archive_index
)
11366 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11370 archive_file_size
= archive_file_offset
= 0;
11371 ret
= process_object (file_name
, file
);
11379 #ifdef SUPPORT_DISASSEMBLY
11380 /* Needed by the i386 disassembler. For extra credit, someone could
11381 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11385 print_address (unsigned int addr
, FILE * outfile
)
11387 fprintf (outfile
,"0x%8.8x", addr
);
11390 /* Needed by the i386 disassembler. */
11392 db_task_printsym (unsigned int addr
)
11394 print_address (addr
, stderr
);
11399 main (int argc
, char ** argv
)
11403 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11404 setlocale (LC_MESSAGES
, "");
11406 #if defined (HAVE_SETLOCALE)
11407 setlocale (LC_CTYPE
, "");
11409 bindtextdomain (PACKAGE
, LOCALEDIR
);
11410 textdomain (PACKAGE
);
11412 expandargv (&argc
, &argv
);
11414 parse_args (argc
, argv
);
11416 if (num_dump_sects
> 0)
11418 /* Make a copy of the dump_sects array. */
11419 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
11420 if (cmdline_dump_sects
== NULL
)
11421 error (_("Out of memory allocating dump request table.\n"));
11424 memcpy (cmdline_dump_sects
, dump_sects
,
11425 num_dump_sects
* sizeof (* dump_sects
));
11426 num_cmdline_dump_sects
= num_dump_sects
;
11430 if (optind
< (argc
- 1))
11434 while (optind
< argc
)
11435 err
|= process_file (argv
[optind
++]);
11437 if (dump_sects
!= NULL
)
11439 if (cmdline_dump_sects
!= NULL
)
11440 free (cmdline_dump_sects
);