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. */
218 typedef unsigned char dump_type
;
220 /* A linked list of the section names for which dumps were requested. */
221 struct dump_list_entry
225 struct dump_list_entry
* next
;
227 static struct dump_list_entry
* dump_sects_byname
;
229 /* A dynamic array of flags indicating for which sections a dump
230 has been requested via command line switches. */
231 static dump_type
* cmdline_dump_sects
= NULL
;
232 static unsigned int num_cmdline_dump_sects
= 0;
234 /* A dynamic array of flags indicating for which sections a dump of
235 some kind has been requested. It is reset on a per-object file
236 basis and then initialised from the cmdline_dump_sects array,
237 the results of interpreting the -w switch, and the
238 dump_sects_byname list. */
239 static dump_type
* dump_sects
= NULL
;
240 static unsigned int num_dump_sects
= 0;
243 /* How to print a vma value. */
244 typedef enum print_mode
256 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
260 #define SECTION_NAME(X) \
261 ((X) == NULL ? "<none>" \
262 : string_table == NULL ? "<no-name>" \
263 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
264 : string_table + (X)->sh_name))
266 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
268 #define BYTE_GET(field) byte_get (field, sizeof (field))
270 #define GET_ELF_SYMBOLS(file, section) \
271 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
272 : get_64bit_elf_symbols (file, section))
274 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
275 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
276 already been called and verified that the string exists. */
277 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
279 /* This is just a bit of syntatic sugar. */
280 #define streq(a,b) (strcmp ((a), (b)) == 0)
281 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
282 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
285 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
290 if (size
== 0 || nmemb
== 0)
293 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
295 error (_("Unable to seek to 0x%lx for %s\n"),
296 (unsigned long) archive_file_offset
+ offset
, reason
);
303 /* Check for overflow. */
304 if (nmemb
< (~(size_t) 0 - 1) / size
)
305 /* + 1 so that we can '\0' terminate invalid string table sections. */
306 mvar
= malloc (size
* nmemb
+ 1);
310 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
311 (unsigned long)(size
* nmemb
), reason
);
315 ((char *) mvar
)[size
* nmemb
] = '\0';
318 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
320 error (_("Unable to read in 0x%lx bytes of %s\n"),
321 (unsigned long)(size
* nmemb
), reason
);
331 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
336 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
337 field
[6] = ((value
>> 24) >> 24) & 0xff;
338 field
[5] = ((value
>> 24) >> 16) & 0xff;
339 field
[4] = ((value
>> 24) >> 8) & 0xff;
342 field
[3] = (value
>> 24) & 0xff;
343 field
[2] = (value
>> 16) & 0xff;
346 field
[1] = (value
>> 8) & 0xff;
349 field
[0] = value
& 0xff;
353 error (_("Unhandled data length: %d\n"), size
);
358 /* Print a VMA value. */
361 print_vma (bfd_vma vma
, print_mode mode
)
374 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
381 return printf ("%5" BFD_VMA_FMT
"d", vma
);
389 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
392 return printf ("%" BFD_VMA_FMT
"d", vma
);
395 return printf ("%" BFD_VMA_FMT
"u", vma
);
400 /* Display a symbol on stdout. Handles the display of non-printing characters.
402 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
403 truncating as necessary. If WIDTH is negative then format the string to be
404 exactly - WIDTH characters, truncating or padding as necessary.
406 Returns the number of emitted characters. */
409 print_symbol (int width
, const char * symbol
)
412 bfd_boolean extra_padding
= FALSE
;
413 unsigned int num_printed
= 0;
417 /* Set the width to a very large value. This simplifies the code below. */
422 /* Keep the width positive. This also helps. */
424 extra_padding
= TRUE
;
433 /* Look for non-printing symbols inside the symbol's name.
434 This test is triggered in particular by the names generated
435 by the assembler for local labels. */
436 while (ISPRINT (* c
))
446 printf ("%.*s", len
, symbol
);
452 if (* c
== 0 || width
== 0)
455 /* Now display the non-printing character, if
456 there is room left in which to dipslay it. */
462 printf ("^%c", *c
+ 0x40);
472 printf ("<0x%.2x>", *c
);
481 if (extra_padding
&& width
> 0)
483 /* Fill in the remaining spaces. */
484 printf ("%-*s", width
, " ");
492 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
497 field
[7] = value
& 0xff;
498 field
[6] = (value
>> 8) & 0xff;
499 field
[5] = (value
>> 16) & 0xff;
500 field
[4] = (value
>> 24) & 0xff;
505 field
[3] = value
& 0xff;
506 field
[2] = (value
>> 8) & 0xff;
510 field
[1] = value
& 0xff;
514 field
[0] = value
& 0xff;
518 error (_("Unhandled data length: %d\n"), size
);
523 /* Return a pointer to section NAME, or NULL if no such section exists. */
525 static Elf_Internal_Shdr
*
526 find_section (const char * name
)
530 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
531 if (streq (SECTION_NAME (section_headers
+ i
), name
))
532 return section_headers
+ i
;
537 /* Guess the relocation size commonly used by the specific machines. */
540 guess_is_rela (unsigned int e_machine
)
544 /* Targets that use REL relocations. */
560 /* Targets that use RELA relocations. */
564 case EM_ALTERA_NIOS2
:
584 case EM_LATTICEMICO32
:
592 case EM_CYGNUS_MN10200
:
594 case EM_CYGNUS_MN10300
:
635 warn (_("Don't know about relocations on this machine architecture\n"));
641 slurp_rela_relocs (FILE * file
,
642 unsigned long rel_offset
,
643 unsigned long rel_size
,
644 Elf_Internal_Rela
** relasp
,
645 unsigned long * nrelasp
)
647 Elf_Internal_Rela
* relas
;
648 unsigned long nrelas
;
653 Elf32_External_Rela
* erelas
;
655 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
659 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
661 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
666 error (_("out of memory parsing relocs\n"));
670 for (i
= 0; i
< nrelas
; i
++)
672 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
673 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
674 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
681 Elf64_External_Rela
* erelas
;
683 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
687 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
689 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
694 error (_("out of memory parsing relocs\n"));
698 for (i
= 0; i
< nrelas
; i
++)
700 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
701 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
702 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
704 /* The #ifdef BFD64 below is to prevent a compile time
705 warning. We know that if we do not have a 64 bit data
706 type that we will never execute this code anyway. */
708 if (elf_header
.e_machine
== EM_MIPS
709 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
711 /* In little-endian objects, r_info isn't really a
712 64-bit little-endian value: it has a 32-bit
713 little-endian symbol index followed by four
714 individual byte fields. Reorder INFO
716 bfd_vma info
= relas
[i
].r_info
;
717 info
= (((info
& 0xffffffff) << 32)
718 | ((info
>> 56) & 0xff)
719 | ((info
>> 40) & 0xff00)
720 | ((info
>> 24) & 0xff0000)
721 | ((info
>> 8) & 0xff000000));
722 relas
[i
].r_info
= info
;
735 slurp_rel_relocs (FILE * file
,
736 unsigned long rel_offset
,
737 unsigned long rel_size
,
738 Elf_Internal_Rela
** relsp
,
739 unsigned long * nrelsp
)
741 Elf_Internal_Rela
* rels
;
747 Elf32_External_Rel
* erels
;
749 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
753 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
755 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
760 error (_("out of memory parsing relocs\n"));
764 for (i
= 0; i
< nrels
; i
++)
766 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
767 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
768 rels
[i
].r_addend
= 0;
775 Elf64_External_Rel
* erels
;
777 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
781 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
783 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
788 error (_("out of memory parsing relocs\n"));
792 for (i
= 0; i
< nrels
; i
++)
794 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
795 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
796 rels
[i
].r_addend
= 0;
798 /* The #ifdef BFD64 below is to prevent a compile time
799 warning. We know that if we do not have a 64 bit data
800 type that we will never execute this code anyway. */
802 if (elf_header
.e_machine
== EM_MIPS
803 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
805 /* In little-endian objects, r_info isn't really a
806 64-bit little-endian value: it has a 32-bit
807 little-endian symbol index followed by four
808 individual byte fields. Reorder INFO
810 bfd_vma info
= rels
[i
].r_info
;
811 info
= (((info
& 0xffffffff) << 32)
812 | ((info
>> 56) & 0xff)
813 | ((info
>> 40) & 0xff00)
814 | ((info
>> 24) & 0xff0000)
815 | ((info
>> 8) & 0xff000000));
816 rels
[i
].r_info
= info
;
828 /* Returns the reloc type extracted from the reloc info field. */
831 get_reloc_type (bfd_vma reloc_info
)
834 return ELF32_R_TYPE (reloc_info
);
836 switch (elf_header
.e_machine
)
839 /* Note: We assume that reloc_info has already been adjusted for us. */
840 return ELF64_MIPS_R_TYPE (reloc_info
);
843 return ELF64_R_TYPE_ID (reloc_info
);
846 return ELF64_R_TYPE (reloc_info
);
850 /* Return the symbol index extracted from the reloc info field. */
853 get_reloc_symindex (bfd_vma reloc_info
)
855 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
858 /* Display the contents of the relocation data found at the specified
862 dump_relocations (FILE * file
,
863 unsigned long rel_offset
,
864 unsigned long rel_size
,
865 Elf_Internal_Sym
* symtab
,
868 unsigned long strtablen
,
872 Elf_Internal_Rela
* rels
;
874 if (is_rela
== UNKNOWN
)
875 is_rela
= guess_is_rela (elf_header
.e_machine
);
879 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
884 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
893 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
895 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
900 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
902 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
910 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
912 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
917 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
919 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
923 for (i
= 0; i
< rel_size
; i
++)
928 bfd_vma symtab_index
;
931 offset
= rels
[i
].r_offset
;
932 info
= rels
[i
].r_info
;
934 type
= get_reloc_type (info
);
935 symtab_index
= get_reloc_symindex (info
);
939 printf ("%8.8lx %8.8lx ",
940 (unsigned long) offset
& 0xffffffff,
941 (unsigned long) info
& 0xffffffff);
945 #if BFD_HOST_64BIT_LONG
947 ? "%16.16lx %16.16lx "
948 : "%12.12lx %12.12lx ",
950 #elif BFD_HOST_64BIT_LONG_LONG
953 ? "%16.16llx %16.16llx "
954 : "%12.12llx %12.12llx ",
958 ? "%16.16I64x %16.16I64x "
959 : "%12.12I64x %12.12I64x ",
964 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
965 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
966 _bfd_int64_high (offset
),
967 _bfd_int64_low (offset
),
968 _bfd_int64_high (info
),
969 _bfd_int64_low (info
));
973 switch (elf_header
.e_machine
)
981 rtype
= elf_m32r_reloc_type (type
);
986 rtype
= elf_i386_reloc_type (type
);
991 rtype
= elf_m68hc11_reloc_type (type
);
995 rtype
= elf_m68k_reloc_type (type
);
999 rtype
= elf_i960_reloc_type (type
);
1004 rtype
= elf_avr_reloc_type (type
);
1007 case EM_OLD_SPARCV9
:
1008 case EM_SPARC32PLUS
:
1011 rtype
= elf_sparc_reloc_type (type
);
1015 rtype
= elf_spu_reloc_type (type
);
1019 case EM_CYGNUS_V850
:
1020 rtype
= v850_reloc_type (type
);
1024 case EM_CYGNUS_D10V
:
1025 rtype
= elf_d10v_reloc_type (type
);
1029 case EM_CYGNUS_D30V
:
1030 rtype
= elf_d30v_reloc_type (type
);
1034 rtype
= elf_dlx_reloc_type (type
);
1038 rtype
= elf_sh_reloc_type (type
);
1042 case EM_CYGNUS_MN10300
:
1043 rtype
= elf_mn10300_reloc_type (type
);
1047 case EM_CYGNUS_MN10200
:
1048 rtype
= elf_mn10200_reloc_type (type
);
1052 case EM_CYGNUS_FR30
:
1053 rtype
= elf_fr30_reloc_type (type
);
1057 rtype
= elf_frv_reloc_type (type
);
1061 rtype
= elf_mcore_reloc_type (type
);
1065 rtype
= elf_mmix_reloc_type (type
);
1070 rtype
= elf_msp430_reloc_type (type
);
1074 rtype
= elf_ppc_reloc_type (type
);
1078 rtype
= elf_ppc64_reloc_type (type
);
1082 case EM_MIPS_RS3_LE
:
1083 rtype
= elf_mips_reloc_type (type
);
1087 rtype
= elf_alpha_reloc_type (type
);
1091 rtype
= elf_arm_reloc_type (type
);
1095 rtype
= elf_arc_reloc_type (type
);
1099 rtype
= elf_hppa_reloc_type (type
);
1105 rtype
= elf_h8_reloc_type (type
);
1110 rtype
= elf_or32_reloc_type (type
);
1115 rtype
= elf_pj_reloc_type (type
);
1118 rtype
= elf_ia64_reloc_type (type
);
1122 rtype
= elf_cris_reloc_type (type
);
1126 rtype
= elf_i860_reloc_type (type
);
1130 rtype
= elf_x86_64_reloc_type (type
);
1134 rtype
= i370_reloc_type (type
);
1139 rtype
= elf_s390_reloc_type (type
);
1143 rtype
= elf_score_reloc_type (type
);
1147 rtype
= elf_xstormy16_reloc_type (type
);
1151 rtype
= elf_crx_reloc_type (type
);
1155 rtype
= elf_vax_reloc_type (type
);
1160 rtype
= elf_ip2k_reloc_type (type
);
1164 rtype
= elf_iq2000_reloc_type (type
);
1169 rtype
= elf_xtensa_reloc_type (type
);
1172 case EM_LATTICEMICO32
:
1173 rtype
= elf_lm32_reloc_type (type
);
1178 rtype
= elf_m32c_reloc_type (type
);
1182 rtype
= elf_mt_reloc_type (type
);
1186 rtype
= elf_bfin_reloc_type (type
);
1190 rtype
= elf_mep_reloc_type (type
);
1195 rtype
= elf_cr16_reloc_type (type
);
1200 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1202 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1204 if (elf_header
.e_machine
== EM_ALPHA
1206 && streq (rtype
, "R_ALPHA_LITUSE")
1209 switch (rels
[i
].r_addend
)
1211 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1212 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1213 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1214 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1215 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1216 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1217 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1218 default: rtype
= NULL
;
1221 printf (" (%s)", rtype
);
1225 printf (_("<unknown addend: %lx>"),
1226 (unsigned long) rels
[i
].r_addend
);
1229 else if (symtab_index
)
1231 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1232 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1235 Elf_Internal_Sym
* psym
;
1237 psym
= symtab
+ symtab_index
;
1241 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1245 unsigned int width
= is_32bit_elf
? 8 : 14;
1247 /* Relocations against GNU_IFUNC symbols do not use the value
1248 of the symbol as the address to relocate against. Instead
1249 they invoke the function named by the symbol and use its
1250 result as the address for relocation.
1252 To indicate this to the user, do not display the value of
1253 the symbol in the "Symbols's Value" field. Instead show
1254 its name followed by () as a hint that the symbol is
1258 || psym
->st_name
== 0
1259 || psym
->st_name
>= strtablen
)
1262 name
= strtab
+ psym
->st_name
;
1264 len
= print_symbol (width
, name
);
1265 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1269 print_vma (psym
->st_value
, LONG_HEX
);
1271 printf (is_32bit_elf
? " " : " ");
1274 if (psym
->st_name
== 0)
1276 const char * sec_name
= "<null>";
1279 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1281 if (psym
->st_shndx
< elf_header
.e_shnum
)
1283 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1284 else if (psym
->st_shndx
== SHN_ABS
)
1286 else if (psym
->st_shndx
== SHN_COMMON
)
1287 sec_name
= "COMMON";
1288 else if (elf_header
.e_machine
== EM_MIPS
1289 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1290 sec_name
= "SCOMMON";
1291 else if (elf_header
.e_machine
== EM_MIPS
1292 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1293 sec_name
= "SUNDEF";
1294 else if (elf_header
.e_machine
== EM_X86_64
1295 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1296 sec_name
= "LARGE_COMMON";
1297 else if (elf_header
.e_machine
== EM_IA_64
1298 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1299 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1300 sec_name
= "ANSI_COM";
1301 else if (elf_header
.e_machine
== EM_IA_64
1302 && (elf_header
.e_ident
[EI_OSABI
]
1303 == ELFOSABI_OPENVMS
)
1304 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1305 sec_name
= "VMS_SYMVEC";
1308 sprintf (name_buf
, "<section 0x%x>",
1309 (unsigned int) psym
->st_shndx
);
1310 sec_name
= name_buf
;
1313 print_symbol (22, sec_name
);
1315 else if (strtab
== NULL
)
1316 printf (_("<string table index: %3ld>"), psym
->st_name
);
1317 else if (psym
->st_name
>= strtablen
)
1318 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1320 print_symbol (22, strtab
+ psym
->st_name
);
1324 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1327 printf (" - %lx", - offset
);
1329 printf (" + %lx", offset
);
1335 printf ("%*c", is_32bit_elf
?
1336 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1337 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1340 if (elf_header
.e_machine
== EM_SPARCV9
1342 && streq (rtype
, "R_SPARC_OLO10"))
1343 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1348 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1350 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1351 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1352 const char * rtype2
= elf_mips_reloc_type (type2
);
1353 const char * rtype3
= elf_mips_reloc_type (type3
);
1355 printf (" Type2: ");
1358 printf (_("unrecognized: %-7lx"),
1359 (unsigned long) type2
& 0xffffffff);
1361 printf ("%-17.17s", rtype2
);
1363 printf ("\n Type3: ");
1366 printf (_("unrecognized: %-7lx"),
1367 (unsigned long) type3
& 0xffffffff);
1369 printf ("%-17.17s", rtype3
);
1380 get_mips_dynamic_type (unsigned long type
)
1384 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1385 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1386 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1387 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1388 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1389 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1390 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1391 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1392 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1393 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1394 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1395 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1396 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1397 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1398 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1399 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1400 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1401 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1402 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1403 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1404 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1405 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1406 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1407 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1408 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1409 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1410 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1411 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1412 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1413 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1414 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1415 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1416 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1417 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1418 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1419 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1420 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1421 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1422 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1423 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1424 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1425 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1426 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1427 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1428 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1435 get_sparc64_dynamic_type (unsigned long type
)
1439 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1446 get_ppc_dynamic_type (unsigned long type
)
1450 case DT_PPC_GOT
: return "PPC_GOT";
1457 get_ppc64_dynamic_type (unsigned long type
)
1461 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1462 case DT_PPC64_OPD
: return "PPC64_OPD";
1463 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1470 get_parisc_dynamic_type (unsigned long type
)
1474 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1475 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1476 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1477 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1478 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1479 case DT_HP_PREINIT
: return "HP_PREINIT";
1480 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1481 case DT_HP_NEEDED
: return "HP_NEEDED";
1482 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1483 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1484 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1485 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1486 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1487 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1488 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1489 case DT_HP_FILTERED
: return "HP_FILTERED";
1490 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1491 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1492 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1493 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1494 case DT_PLT
: return "PLT";
1495 case DT_PLT_SIZE
: return "PLT_SIZE";
1496 case DT_DLT
: return "DLT";
1497 case DT_DLT_SIZE
: return "DLT_SIZE";
1504 get_ia64_dynamic_type (unsigned long type
)
1508 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1509 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1510 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1511 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1512 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1513 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1514 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1515 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1516 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1517 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1518 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1519 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1520 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1521 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1522 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1523 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1524 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1525 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1526 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1527 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1528 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1529 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1530 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1531 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1532 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1533 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1534 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1535 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1536 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1537 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1538 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1545 get_alpha_dynamic_type (unsigned long type
)
1549 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1556 get_score_dynamic_type (unsigned long type
)
1560 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1561 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1562 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1563 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1564 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1565 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1573 get_dynamic_type (unsigned long type
)
1575 static char buff
[64];
1579 case DT_NULL
: return "NULL";
1580 case DT_NEEDED
: return "NEEDED";
1581 case DT_PLTRELSZ
: return "PLTRELSZ";
1582 case DT_PLTGOT
: return "PLTGOT";
1583 case DT_HASH
: return "HASH";
1584 case DT_STRTAB
: return "STRTAB";
1585 case DT_SYMTAB
: return "SYMTAB";
1586 case DT_RELA
: return "RELA";
1587 case DT_RELASZ
: return "RELASZ";
1588 case DT_RELAENT
: return "RELAENT";
1589 case DT_STRSZ
: return "STRSZ";
1590 case DT_SYMENT
: return "SYMENT";
1591 case DT_INIT
: return "INIT";
1592 case DT_FINI
: return "FINI";
1593 case DT_SONAME
: return "SONAME";
1594 case DT_RPATH
: return "RPATH";
1595 case DT_SYMBOLIC
: return "SYMBOLIC";
1596 case DT_REL
: return "REL";
1597 case DT_RELSZ
: return "RELSZ";
1598 case DT_RELENT
: return "RELENT";
1599 case DT_PLTREL
: return "PLTREL";
1600 case DT_DEBUG
: return "DEBUG";
1601 case DT_TEXTREL
: return "TEXTREL";
1602 case DT_JMPREL
: return "JMPREL";
1603 case DT_BIND_NOW
: return "BIND_NOW";
1604 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1605 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1606 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1607 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1608 case DT_RUNPATH
: return "RUNPATH";
1609 case DT_FLAGS
: return "FLAGS";
1611 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1612 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1614 case DT_CHECKSUM
: return "CHECKSUM";
1615 case DT_PLTPADSZ
: return "PLTPADSZ";
1616 case DT_MOVEENT
: return "MOVEENT";
1617 case DT_MOVESZ
: return "MOVESZ";
1618 case DT_FEATURE
: return "FEATURE";
1619 case DT_POSFLAG_1
: return "POSFLAG_1";
1620 case DT_SYMINSZ
: return "SYMINSZ";
1621 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1623 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1624 case DT_CONFIG
: return "CONFIG";
1625 case DT_DEPAUDIT
: return "DEPAUDIT";
1626 case DT_AUDIT
: return "AUDIT";
1627 case DT_PLTPAD
: return "PLTPAD";
1628 case DT_MOVETAB
: return "MOVETAB";
1629 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1631 case DT_VERSYM
: return "VERSYM";
1633 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1634 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1635 case DT_RELACOUNT
: return "RELACOUNT";
1636 case DT_RELCOUNT
: return "RELCOUNT";
1637 case DT_FLAGS_1
: return "FLAGS_1";
1638 case DT_VERDEF
: return "VERDEF";
1639 case DT_VERDEFNUM
: return "VERDEFNUM";
1640 case DT_VERNEED
: return "VERNEED";
1641 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1643 case DT_AUXILIARY
: return "AUXILIARY";
1644 case DT_USED
: return "USED";
1645 case DT_FILTER
: return "FILTER";
1647 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1648 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1649 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1650 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1651 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1652 case DT_GNU_HASH
: return "GNU_HASH";
1655 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1657 const char * result
;
1659 switch (elf_header
.e_machine
)
1662 case EM_MIPS_RS3_LE
:
1663 result
= get_mips_dynamic_type (type
);
1666 result
= get_sparc64_dynamic_type (type
);
1669 result
= get_ppc_dynamic_type (type
);
1672 result
= get_ppc64_dynamic_type (type
);
1675 result
= get_ia64_dynamic_type (type
);
1678 result
= get_alpha_dynamic_type (type
);
1681 result
= get_score_dynamic_type (type
);
1691 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1693 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1694 || (elf_header
.e_machine
== EM_PARISC
1695 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1697 const char * result
;
1699 switch (elf_header
.e_machine
)
1702 result
= get_parisc_dynamic_type (type
);
1705 result
= get_ia64_dynamic_type (type
);
1715 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1719 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1726 get_file_type (unsigned e_type
)
1728 static char buff
[32];
1732 case ET_NONE
: return _("NONE (None)");
1733 case ET_REL
: return _("REL (Relocatable file)");
1734 case ET_EXEC
: return _("EXEC (Executable file)");
1735 case ET_DYN
: return _("DYN (Shared object file)");
1736 case ET_CORE
: return _("CORE (Core file)");
1739 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1740 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1741 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1742 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1744 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1750 get_machine_name (unsigned e_machine
)
1752 static char buff
[64]; /* XXX */
1756 case EM_NONE
: return _("None");
1757 case EM_M32
: return "WE32100";
1758 case EM_SPARC
: return "Sparc";
1759 case EM_SPU
: return "SPU";
1760 case EM_386
: return "Intel 80386";
1761 case EM_68K
: return "MC68000";
1762 case EM_88K
: return "MC88000";
1763 case EM_486
: return "Intel 80486";
1764 case EM_860
: return "Intel 80860";
1765 case EM_MIPS
: return "MIPS R3000";
1766 case EM_S370
: return "IBM System/370";
1767 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1768 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1769 case EM_PARISC
: return "HPPA";
1770 case EM_PPC_OLD
: return "Power PC (old)";
1771 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1772 case EM_960
: return "Intel 90860";
1773 case EM_PPC
: return "PowerPC";
1774 case EM_PPC64
: return "PowerPC64";
1775 case EM_V800
: return "NEC V800";
1776 case EM_FR20
: return "Fujitsu FR20";
1777 case EM_RH32
: return "TRW RH32";
1778 case EM_MCORE
: return "MCORE";
1779 case EM_ARM
: return "ARM";
1780 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1781 case EM_SH
: return "Renesas / SuperH SH";
1782 case EM_SPARCV9
: return "Sparc v9";
1783 case EM_TRICORE
: return "Siemens Tricore";
1784 case EM_ARC
: return "ARC";
1785 case EM_H8_300
: return "Renesas H8/300";
1786 case EM_H8_300H
: return "Renesas H8/300H";
1787 case EM_H8S
: return "Renesas H8S";
1788 case EM_H8_500
: return "Renesas H8/500";
1789 case EM_IA_64
: return "Intel IA-64";
1790 case EM_MIPS_X
: return "Stanford MIPS-X";
1791 case EM_COLDFIRE
: return "Motorola Coldfire";
1792 case EM_68HC12
: return "Motorola M68HC12";
1793 case EM_ALPHA
: return "Alpha";
1794 case EM_CYGNUS_D10V
:
1795 case EM_D10V
: return "d10v";
1796 case EM_CYGNUS_D30V
:
1797 case EM_D30V
: return "d30v";
1798 case EM_CYGNUS_M32R
:
1799 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1800 case EM_CYGNUS_V850
:
1801 case EM_V850
: return "NEC v850";
1802 case EM_CYGNUS_MN10300
:
1803 case EM_MN10300
: return "mn10300";
1804 case EM_CYGNUS_MN10200
:
1805 case EM_MN10200
: return "mn10200";
1806 case EM_CYGNUS_FR30
:
1807 case EM_FR30
: return "Fujitsu FR30";
1808 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1810 case EM_PJ
: return "picoJava";
1811 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1812 case EM_PCP
: return "Siemens PCP";
1813 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1814 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1815 case EM_STARCORE
: return "Motorola Star*Core processor";
1816 case EM_ME16
: return "Toyota ME16 processor";
1817 case EM_ST100
: return "STMicroelectronics ST100 processor";
1818 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1819 case EM_FX66
: return "Siemens FX66 microcontroller";
1820 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1821 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1822 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1823 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1824 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1825 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1826 case EM_SVX
: return "Silicon Graphics SVx";
1827 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1828 case EM_VAX
: return "Digital VAX";
1830 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1831 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1832 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1833 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1834 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1835 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1836 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1837 case EM_PRISM
: return "Vitesse Prism";
1838 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1840 case EM_S390
: return "IBM S/390";
1841 case EM_SCORE
: return "SUNPLUS S+Core";
1842 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1844 case EM_OR32
: return "OpenRISC";
1845 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1846 case EM_DLX
: return "OpenDLX";
1848 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1849 case EM_IQ2000
: return "Vitesse IQ2000";
1851 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1852 case EM_LATTICEMICO32
: return "Lattice Mico32";
1854 case EM_M32C
: return "Renesas M32c";
1855 case EM_MT
: return "Morpho Techologies MT processor";
1856 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1857 case EM_NIOS32
: return "Altera Nios";
1858 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1859 case EM_XC16X
: return "Infineon Technologies xc16x";
1860 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1862 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1864 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1870 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1875 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1876 e_flags
&= ~ EF_ARM_EABIMASK
;
1878 /* Handle "generic" ARM flags. */
1879 if (e_flags
& EF_ARM_RELEXEC
)
1881 strcat (buf
, ", relocatable executable");
1882 e_flags
&= ~ EF_ARM_RELEXEC
;
1885 if (e_flags
& EF_ARM_HASENTRY
)
1887 strcat (buf
, ", has entry point");
1888 e_flags
&= ~ EF_ARM_HASENTRY
;
1891 /* Now handle EABI specific flags. */
1895 strcat (buf
, ", <unrecognized EABI>");
1900 case EF_ARM_EABI_VER1
:
1901 strcat (buf
, ", Version1 EABI");
1906 /* Process flags one bit at a time. */
1907 flag
= e_flags
& - e_flags
;
1912 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1913 strcat (buf
, ", sorted symbol tables");
1923 case EF_ARM_EABI_VER2
:
1924 strcat (buf
, ", Version2 EABI");
1929 /* Process flags one bit at a time. */
1930 flag
= e_flags
& - e_flags
;
1935 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1936 strcat (buf
, ", sorted symbol tables");
1939 case EF_ARM_DYNSYMSUSESEGIDX
:
1940 strcat (buf
, ", dynamic symbols use segment index");
1943 case EF_ARM_MAPSYMSFIRST
:
1944 strcat (buf
, ", mapping symbols precede others");
1954 case EF_ARM_EABI_VER3
:
1955 strcat (buf
, ", Version3 EABI");
1958 case EF_ARM_EABI_VER4
:
1959 strcat (buf
, ", Version4 EABI");
1962 case EF_ARM_EABI_VER5
:
1963 strcat (buf
, ", Version5 EABI");
1969 /* Process flags one bit at a time. */
1970 flag
= e_flags
& - e_flags
;
1976 strcat (buf
, ", BE8");
1980 strcat (buf
, ", LE8");
1990 case EF_ARM_EABI_UNKNOWN
:
1991 strcat (buf
, ", GNU EABI");
1996 /* Process flags one bit at a time. */
1997 flag
= e_flags
& - e_flags
;
2002 case EF_ARM_INTERWORK
:
2003 strcat (buf
, ", interworking enabled");
2006 case EF_ARM_APCS_26
:
2007 strcat (buf
, ", uses APCS/26");
2010 case EF_ARM_APCS_FLOAT
:
2011 strcat (buf
, ", uses APCS/float");
2015 strcat (buf
, ", position independent");
2019 strcat (buf
, ", 8 bit structure alignment");
2022 case EF_ARM_NEW_ABI
:
2023 strcat (buf
, ", uses new ABI");
2026 case EF_ARM_OLD_ABI
:
2027 strcat (buf
, ", uses old ABI");
2030 case EF_ARM_SOFT_FLOAT
:
2031 strcat (buf
, ", software FP");
2034 case EF_ARM_VFP_FLOAT
:
2035 strcat (buf
, ", VFP");
2038 case EF_ARM_MAVERICK_FLOAT
:
2039 strcat (buf
, ", Maverick FP");
2050 strcat (buf
,", <unknown>");
2054 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2056 static char buf
[1024];
2068 decode_ARM_machine_flags (e_flags
, buf
);
2072 switch (e_flags
& EF_FRV_CPU_MASK
)
2074 case EF_FRV_CPU_GENERIC
:
2078 strcat (buf
, ", fr???");
2081 case EF_FRV_CPU_FR300
:
2082 strcat (buf
, ", fr300");
2085 case EF_FRV_CPU_FR400
:
2086 strcat (buf
, ", fr400");
2088 case EF_FRV_CPU_FR405
:
2089 strcat (buf
, ", fr405");
2092 case EF_FRV_CPU_FR450
:
2093 strcat (buf
, ", fr450");
2096 case EF_FRV_CPU_FR500
:
2097 strcat (buf
, ", fr500");
2099 case EF_FRV_CPU_FR550
:
2100 strcat (buf
, ", fr550");
2103 case EF_FRV_CPU_SIMPLE
:
2104 strcat (buf
, ", simple");
2106 case EF_FRV_CPU_TOMCAT
:
2107 strcat (buf
, ", tomcat");
2113 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2114 strcat (buf
, ", m68000");
2115 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2116 strcat (buf
, ", cpu32");
2117 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2118 strcat (buf
, ", fido_a");
2121 char const * isa
= _("unknown");
2122 char const * mac
= _("unknown mac");
2123 char const * additional
= NULL
;
2125 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2127 case EF_M68K_CF_ISA_A_NODIV
:
2129 additional
= ", nodiv";
2131 case EF_M68K_CF_ISA_A
:
2134 case EF_M68K_CF_ISA_A_PLUS
:
2137 case EF_M68K_CF_ISA_B_NOUSP
:
2139 additional
= ", nousp";
2141 case EF_M68K_CF_ISA_B
:
2145 strcat (buf
, ", cf, isa ");
2148 strcat (buf
, additional
);
2149 if (e_flags
& EF_M68K_CF_FLOAT
)
2150 strcat (buf
, ", float");
2151 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2156 case EF_M68K_CF_MAC
:
2159 case EF_M68K_CF_EMAC
:
2172 if (e_flags
& EF_PPC_EMB
)
2173 strcat (buf
, ", emb");
2175 if (e_flags
& EF_PPC_RELOCATABLE
)
2176 strcat (buf
, ", relocatable");
2178 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2179 strcat (buf
, ", relocatable-lib");
2183 case EM_CYGNUS_V850
:
2184 switch (e_flags
& EF_V850_ARCH
)
2187 strcat (buf
, ", v850e1");
2190 strcat (buf
, ", v850e");
2193 strcat (buf
, ", v850");
2196 strcat (buf
, ", unknown v850 architecture variant");
2202 case EM_CYGNUS_M32R
:
2203 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2204 strcat (buf
, ", m32r");
2208 case EM_MIPS_RS3_LE
:
2209 if (e_flags
& EF_MIPS_NOREORDER
)
2210 strcat (buf
, ", noreorder");
2212 if (e_flags
& EF_MIPS_PIC
)
2213 strcat (buf
, ", pic");
2215 if (e_flags
& EF_MIPS_CPIC
)
2216 strcat (buf
, ", cpic");
2218 if (e_flags
& EF_MIPS_UCODE
)
2219 strcat (buf
, ", ugen_reserved");
2221 if (e_flags
& EF_MIPS_ABI2
)
2222 strcat (buf
, ", abi2");
2224 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2225 strcat (buf
, ", odk first");
2227 if (e_flags
& EF_MIPS_32BITMODE
)
2228 strcat (buf
, ", 32bitmode");
2230 switch ((e_flags
& EF_MIPS_MACH
))
2232 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2233 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2234 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2235 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2236 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2237 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2238 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2239 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2240 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2241 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2242 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2243 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2244 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2245 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2247 /* We simply ignore the field in this case to avoid confusion:
2248 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2251 default: strcat (buf
, ", unknown CPU"); break;
2254 switch ((e_flags
& EF_MIPS_ABI
))
2256 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2257 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2258 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2259 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2261 /* We simply ignore the field in this case to avoid confusion:
2262 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2263 This means it is likely to be an o32 file, but not for
2266 default: strcat (buf
, ", unknown ABI"); break;
2269 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2270 strcat (buf
, ", mdmx");
2272 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2273 strcat (buf
, ", mips16");
2275 switch ((e_flags
& EF_MIPS_ARCH
))
2277 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2278 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2279 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2280 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2281 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2282 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2283 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2284 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2285 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2286 default: strcat (buf
, ", unknown ISA"); break;
2292 switch ((e_flags
& EF_SH_MACH_MASK
))
2294 case EF_SH1
: strcat (buf
, ", sh1"); break;
2295 case EF_SH2
: strcat (buf
, ", sh2"); break;
2296 case EF_SH3
: strcat (buf
, ", sh3"); break;
2297 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2298 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2299 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2300 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2301 case EF_SH4
: strcat (buf
, ", sh4"); break;
2302 case EF_SH5
: strcat (buf
, ", sh5"); break;
2303 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2304 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2305 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2306 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2307 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2308 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2309 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2310 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2311 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2312 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2313 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2314 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2315 default: strcat (buf
, ", unknown ISA"); break;
2321 if (e_flags
& EF_SPARC_32PLUS
)
2322 strcat (buf
, ", v8+");
2324 if (e_flags
& EF_SPARC_SUN_US1
)
2325 strcat (buf
, ", ultrasparcI");
2327 if (e_flags
& EF_SPARC_SUN_US3
)
2328 strcat (buf
, ", ultrasparcIII");
2330 if (e_flags
& EF_SPARC_HAL_R1
)
2331 strcat (buf
, ", halr1");
2333 if (e_flags
& EF_SPARC_LEDATA
)
2334 strcat (buf
, ", ledata");
2336 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2337 strcat (buf
, ", tso");
2339 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2340 strcat (buf
, ", pso");
2342 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2343 strcat (buf
, ", rmo");
2347 switch (e_flags
& EF_PARISC_ARCH
)
2349 case EFA_PARISC_1_0
:
2350 strcpy (buf
, ", PA-RISC 1.0");
2352 case EFA_PARISC_1_1
:
2353 strcpy (buf
, ", PA-RISC 1.1");
2355 case EFA_PARISC_2_0
:
2356 strcpy (buf
, ", PA-RISC 2.0");
2361 if (e_flags
& EF_PARISC_TRAPNIL
)
2362 strcat (buf
, ", trapnil");
2363 if (e_flags
& EF_PARISC_EXT
)
2364 strcat (buf
, ", ext");
2365 if (e_flags
& EF_PARISC_LSB
)
2366 strcat (buf
, ", lsb");
2367 if (e_flags
& EF_PARISC_WIDE
)
2368 strcat (buf
, ", wide");
2369 if (e_flags
& EF_PARISC_NO_KABP
)
2370 strcat (buf
, ", no kabp");
2371 if (e_flags
& EF_PARISC_LAZYSWAP
)
2372 strcat (buf
, ", lazyswap");
2377 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2378 strcat (buf
, ", new calling convention");
2380 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2381 strcat (buf
, ", gnu calling convention");
2385 if ((e_flags
& EF_IA_64_ABI64
))
2386 strcat (buf
, ", 64-bit");
2388 strcat (buf
, ", 32-bit");
2389 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2390 strcat (buf
, ", reduced fp model");
2391 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2392 strcat (buf
, ", no function descriptors, constant gp");
2393 else if ((e_flags
& EF_IA_64_CONS_GP
))
2394 strcat (buf
, ", constant gp");
2395 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2396 strcat (buf
, ", absolute");
2400 if ((e_flags
& EF_VAX_NONPIC
))
2401 strcat (buf
, ", non-PIC");
2402 if ((e_flags
& EF_VAX_DFLOAT
))
2403 strcat (buf
, ", D-Float");
2404 if ((e_flags
& EF_VAX_GFLOAT
))
2405 strcat (buf
, ", G-Float");
2414 get_osabi_name (unsigned int osabi
)
2416 static char buff
[32];
2420 case ELFOSABI_NONE
: return "UNIX - System V";
2421 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2422 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2423 case ELFOSABI_LINUX
: return "UNIX - Linux";
2424 case ELFOSABI_HURD
: return "GNU/Hurd";
2425 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2426 case ELFOSABI_AIX
: return "UNIX - AIX";
2427 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2428 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2429 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2430 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2431 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2432 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2433 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2434 case ELFOSABI_AROS
: return "AROS";
2435 case ELFOSABI_STANDALONE
: return _("Standalone App");
2436 case ELFOSABI_ARM
: return "ARM";
2438 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2444 get_arm_segment_type (unsigned long type
)
2458 get_mips_segment_type (unsigned long type
)
2462 case PT_MIPS_REGINFO
:
2464 case PT_MIPS_RTPROC
:
2466 case PT_MIPS_OPTIONS
:
2476 get_parisc_segment_type (unsigned long type
)
2480 case PT_HP_TLS
: return "HP_TLS";
2481 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2482 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2483 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2484 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2485 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2486 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2487 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2488 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2489 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2490 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2491 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2492 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2493 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2494 case PT_HP_STACK
: return "HP_STACK";
2495 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2496 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2497 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2498 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2507 get_ia64_segment_type (unsigned long type
)
2511 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2512 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2513 case PT_HP_TLS
: return "HP_TLS";
2514 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2515 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2516 case PT_IA_64_HP_STACK
: return "HP_STACK";
2525 get_segment_type (unsigned long p_type
)
2527 static char buff
[32];
2531 case PT_NULL
: return "NULL";
2532 case PT_LOAD
: return "LOAD";
2533 case PT_DYNAMIC
: return "DYNAMIC";
2534 case PT_INTERP
: return "INTERP";
2535 case PT_NOTE
: return "NOTE";
2536 case PT_SHLIB
: return "SHLIB";
2537 case PT_PHDR
: return "PHDR";
2538 case PT_TLS
: return "TLS";
2540 case PT_GNU_EH_FRAME
:
2541 return "GNU_EH_FRAME";
2542 case PT_GNU_STACK
: return "GNU_STACK";
2543 case PT_GNU_RELRO
: return "GNU_RELRO";
2546 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2548 const char * result
;
2550 switch (elf_header
.e_machine
)
2553 result
= get_arm_segment_type (p_type
);
2556 case EM_MIPS_RS3_LE
:
2557 result
= get_mips_segment_type (p_type
);
2560 result
= get_parisc_segment_type (p_type
);
2563 result
= get_ia64_segment_type (p_type
);
2573 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2575 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2577 const char * result
;
2579 switch (elf_header
.e_machine
)
2582 result
= get_parisc_segment_type (p_type
);
2585 result
= get_ia64_segment_type (p_type
);
2595 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2598 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2605 get_mips_section_type_name (unsigned int sh_type
)
2609 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2610 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2611 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2612 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2613 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2614 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2615 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2616 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2617 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2618 case SHT_MIPS_RELD
: return "MIPS_RELD";
2619 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2620 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2621 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2622 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2623 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2624 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2625 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2626 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2627 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2628 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2629 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2630 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2631 case SHT_MIPS_LINE
: return "MIPS_LINE";
2632 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2633 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2634 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2635 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2636 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2637 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2638 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2639 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2640 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2641 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2642 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2643 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2644 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2645 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2646 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2647 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2655 get_parisc_section_type_name (unsigned int sh_type
)
2659 case SHT_PARISC_EXT
: return "PARISC_EXT";
2660 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2661 case SHT_PARISC_DOC
: return "PARISC_DOC";
2662 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2663 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2664 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2665 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2673 get_ia64_section_type_name (unsigned int sh_type
)
2675 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2676 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2677 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2681 case SHT_IA_64_EXT
: return "IA_64_EXT";
2682 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2683 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2684 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2685 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2686 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2687 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2688 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2689 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2690 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2698 get_x86_64_section_type_name (unsigned int sh_type
)
2702 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2710 get_arm_section_type_name (unsigned int sh_type
)
2716 case SHT_ARM_PREEMPTMAP
:
2717 return "ARM_PREEMPTMAP";
2718 case SHT_ARM_ATTRIBUTES
:
2719 return "ARM_ATTRIBUTES";
2727 get_section_type_name (unsigned int sh_type
)
2729 static char buff
[32];
2733 case SHT_NULL
: return "NULL";
2734 case SHT_PROGBITS
: return "PROGBITS";
2735 case SHT_SYMTAB
: return "SYMTAB";
2736 case SHT_STRTAB
: return "STRTAB";
2737 case SHT_RELA
: return "RELA";
2738 case SHT_HASH
: return "HASH";
2739 case SHT_DYNAMIC
: return "DYNAMIC";
2740 case SHT_NOTE
: return "NOTE";
2741 case SHT_NOBITS
: return "NOBITS";
2742 case SHT_REL
: return "REL";
2743 case SHT_SHLIB
: return "SHLIB";
2744 case SHT_DYNSYM
: return "DYNSYM";
2745 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2746 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2747 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2748 case SHT_GNU_HASH
: return "GNU_HASH";
2749 case SHT_GROUP
: return "GROUP";
2750 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2751 case SHT_GNU_verdef
: return "VERDEF";
2752 case SHT_GNU_verneed
: return "VERNEED";
2753 case SHT_GNU_versym
: return "VERSYM";
2754 case 0x6ffffff0: return "VERSYM";
2755 case 0x6ffffffc: return "VERDEF";
2756 case 0x7ffffffd: return "AUXILIARY";
2757 case 0x7fffffff: return "FILTER";
2758 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2761 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2763 const char * result
;
2765 switch (elf_header
.e_machine
)
2768 case EM_MIPS_RS3_LE
:
2769 result
= get_mips_section_type_name (sh_type
);
2772 result
= get_parisc_section_type_name (sh_type
);
2775 result
= get_ia64_section_type_name (sh_type
);
2778 result
= get_x86_64_section_type_name (sh_type
);
2781 result
= get_arm_section_type_name (sh_type
);
2791 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2793 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2795 const char * result
;
2797 switch (elf_header
.e_machine
)
2800 result
= get_ia64_section_type_name (sh_type
);
2810 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2812 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2813 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2815 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2821 #define OPTION_DEBUG_DUMP 512
2823 static struct option options
[] =
2825 {"all", no_argument
, 0, 'a'},
2826 {"file-header", no_argument
, 0, 'h'},
2827 {"program-headers", no_argument
, 0, 'l'},
2828 {"headers", no_argument
, 0, 'e'},
2829 {"histogram", no_argument
, 0, 'I'},
2830 {"segments", no_argument
, 0, 'l'},
2831 {"sections", no_argument
, 0, 'S'},
2832 {"section-headers", no_argument
, 0, 'S'},
2833 {"section-groups", no_argument
, 0, 'g'},
2834 {"section-details", no_argument
, 0, 't'},
2835 {"full-section-name",no_argument
, 0, 'N'},
2836 {"symbols", no_argument
, 0, 's'},
2837 {"syms", no_argument
, 0, 's'},
2838 {"relocs", no_argument
, 0, 'r'},
2839 {"notes", no_argument
, 0, 'n'},
2840 {"dynamic", no_argument
, 0, 'd'},
2841 {"arch-specific", no_argument
, 0, 'A'},
2842 {"version-info", no_argument
, 0, 'V'},
2843 {"use-dynamic", no_argument
, 0, 'D'},
2844 {"unwind", no_argument
, 0, 'u'},
2845 {"archive-index", no_argument
, 0, 'c'},
2846 {"hex-dump", required_argument
, 0, 'x'},
2847 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2848 {"string-dump", required_argument
, 0, 'p'},
2849 #ifdef SUPPORT_DISASSEMBLY
2850 {"instruction-dump", required_argument
, 0, 'i'},
2853 {"version", no_argument
, 0, 'v'},
2854 {"wide", no_argument
, 0, 'W'},
2855 {"help", no_argument
, 0, 'H'},
2856 {0, no_argument
, 0, 0}
2860 usage (FILE * stream
)
2862 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2863 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2864 fprintf (stream
, _(" Options are:\n\
2865 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2866 -h --file-header Display the ELF file header\n\
2867 -l --program-headers Display the program headers\n\
2868 --segments An alias for --program-headers\n\
2869 -S --section-headers Display the sections' header\n\
2870 --sections An alias for --section-headers\n\
2871 -g --section-groups Display the section groups\n\
2872 -t --section-details Display the section details\n\
2873 -e --headers Equivalent to: -h -l -S\n\
2874 -s --syms Display the symbol table\n\
2875 --symbols An alias for --syms\n\
2876 -n --notes Display the core notes (if present)\n\
2877 -r --relocs Display the relocations (if present)\n\
2878 -u --unwind Display the unwind info (if present)\n\
2879 -d --dynamic Display the dynamic section (if present)\n\
2880 -V --version-info Display the version sections (if present)\n\
2881 -A --arch-specific Display architecture specific information (if any).\n\
2882 -c --archive-index Display the symbol/file index in an archive\n\
2883 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2884 -x --hex-dump=<number|name>\n\
2885 Dump the contents of section <number|name> as bytes\n\
2886 -p --string-dump=<number|name>\n\
2887 Dump the contents of section <number|name> as strings\n\
2888 -w[lLiaprmfFsoR] or\n\
2889 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2890 Display the contents of DWARF2 debug sections\n"));
2891 #ifdef SUPPORT_DISASSEMBLY
2892 fprintf (stream
, _("\
2893 -i --instruction-dump=<number|name>\n\
2894 Disassemble the contents of section <number|name>\n"));
2896 fprintf (stream
, _("\
2897 -I --histogram Display histogram of bucket list lengths\n\
2898 -W --wide Allow output width to exceed 80 characters\n\
2899 @<file> Read options from <file>\n\
2900 -H --help Display this information\n\
2901 -v --version Display the version number of readelf\n"));
2903 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2904 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2906 exit (stream
== stdout
? 0 : 1);
2909 /* Record the fact that the user wants the contents of section number
2910 SECTION to be displayed using the method(s) encoded as flags bits
2911 in TYPE. Note, TYPE can be zero if we are creating the array for
2915 request_dump_bynumber (unsigned int section
, dump_type type
)
2917 if (section
>= num_dump_sects
)
2919 dump_type
* new_dump_sects
;
2921 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2923 if (new_dump_sects
== NULL
)
2924 error (_("Out of memory allocating dump request table.\n"));
2927 /* Copy current flag settings. */
2928 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2932 dump_sects
= new_dump_sects
;
2933 num_dump_sects
= section
+ 1;
2938 dump_sects
[section
] |= type
;
2943 /* Request a dump by section name. */
2946 request_dump_byname (const char * section
, dump_type type
)
2948 struct dump_list_entry
* new_request
;
2950 new_request
= malloc (sizeof (struct dump_list_entry
));
2952 error (_("Out of memory allocating dump request table.\n"));
2954 new_request
->name
= strdup (section
);
2955 if (!new_request
->name
)
2956 error (_("Out of memory allocating dump request table.\n"));
2958 new_request
->type
= type
;
2960 new_request
->next
= dump_sects_byname
;
2961 dump_sects_byname
= new_request
;
2965 parse_args (int argc
, char ** argv
)
2972 while ((c
= getopt_long
2973 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
2994 do_section_groups
++;
3002 do_section_groups
++;
3007 do_section_details
++;
3052 section
= strtoul (optarg
, & cp
, 0);
3053 if (! *cp
&& section
>= 0)
3054 request_dump_bynumber (section
, HEX_DUMP
);
3056 request_dump_byname (optarg
, HEX_DUMP
);
3060 section
= strtoul (optarg
, & cp
, 0);
3061 if (! *cp
&& section
>= 0)
3062 request_dump_bynumber (section
, STRING_DUMP
);
3064 request_dump_byname (optarg
, STRING_DUMP
);
3071 dwarf_select_sections_all ();
3076 dwarf_select_sections_by_letters (optarg
);
3079 case OPTION_DEBUG_DUMP
:
3086 dwarf_select_sections_by_names (optarg
);
3089 #ifdef SUPPORT_DISASSEMBLY
3092 section
= strtoul (optarg
, & cp
, 0);
3093 if (! *cp
&& section
>= 0)
3094 request_dump_bynumber (section
, DISASS_DUMP
);
3096 request_dump_byname (optarg
, DISASS_DUMP
);
3099 print_version (program_name
);
3108 /* xgettext:c-format */
3109 error (_("Invalid option '-%c'\n"), c
);
3116 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3117 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3118 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3119 && !do_section_groups
&& !do_archive_index
)
3123 warn (_("Nothing to do.\n"));
3129 get_elf_class (unsigned int elf_class
)
3131 static char buff
[32];
3135 case ELFCLASSNONE
: return _("none");
3136 case ELFCLASS32
: return "ELF32";
3137 case ELFCLASS64
: return "ELF64";
3139 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3145 get_data_encoding (unsigned int encoding
)
3147 static char buff
[32];
3151 case ELFDATANONE
: return _("none");
3152 case ELFDATA2LSB
: return _("2's complement, little endian");
3153 case ELFDATA2MSB
: return _("2's complement, big endian");
3155 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3160 /* Decode the data held in 'elf_header'. */
3163 process_file_header (void)
3165 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3166 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3167 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3168 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3171 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3175 init_dwarf_regnames (elf_header
.e_machine
);
3181 printf (_("ELF Header:\n"));
3182 printf (_(" Magic: "));
3183 for (i
= 0; i
< EI_NIDENT
; i
++)
3184 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3186 printf (_(" Class: %s\n"),
3187 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3188 printf (_(" Data: %s\n"),
3189 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3190 printf (_(" Version: %d %s\n"),
3191 elf_header
.e_ident
[EI_VERSION
],
3192 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3194 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3197 printf (_(" OS/ABI: %s\n"),
3198 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3199 printf (_(" ABI Version: %d\n"),
3200 elf_header
.e_ident
[EI_ABIVERSION
]);
3201 printf (_(" Type: %s\n"),
3202 get_file_type (elf_header
.e_type
));
3203 printf (_(" Machine: %s\n"),
3204 get_machine_name (elf_header
.e_machine
));
3205 printf (_(" Version: 0x%lx\n"),
3206 (unsigned long) elf_header
.e_version
);
3208 printf (_(" Entry point address: "));
3209 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3210 printf (_("\n Start of program headers: "));
3211 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3212 printf (_(" (bytes into file)\n Start of section headers: "));
3213 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3214 printf (_(" (bytes into file)\n"));
3216 printf (_(" Flags: 0x%lx%s\n"),
3217 (unsigned long) elf_header
.e_flags
,
3218 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3219 printf (_(" Size of this header: %ld (bytes)\n"),
3220 (long) elf_header
.e_ehsize
);
3221 printf (_(" Size of program headers: %ld (bytes)\n"),
3222 (long) elf_header
.e_phentsize
);
3223 printf (_(" Number of program headers: %ld\n"),
3224 (long) elf_header
.e_phnum
);
3225 printf (_(" Size of section headers: %ld (bytes)\n"),
3226 (long) elf_header
.e_shentsize
);
3227 printf (_(" Number of section headers: %ld"),
3228 (long) elf_header
.e_shnum
);
3229 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3230 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3231 putc ('\n', stdout
);
3232 printf (_(" Section header string table index: %ld"),
3233 (long) elf_header
.e_shstrndx
);
3234 if (section_headers
!= NULL
3235 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3236 printf (" (%u)", section_headers
[0].sh_link
);
3237 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3238 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3239 printf (" <corrupt: out of range>");
3240 putc ('\n', stdout
);
3243 if (section_headers
!= NULL
)
3245 if (elf_header
.e_shnum
== SHN_UNDEF
)
3246 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3247 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3248 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3249 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3250 elf_header
.e_shstrndx
= SHN_UNDEF
;
3251 free (section_headers
);
3252 section_headers
= NULL
;
3260 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3262 Elf32_External_Phdr
* phdrs
;
3263 Elf32_External_Phdr
* external
;
3264 Elf_Internal_Phdr
* internal
;
3267 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3268 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3269 _("program headers"));
3273 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3274 i
< elf_header
.e_phnum
;
3275 i
++, internal
++, external
++)
3277 internal
->p_type
= BYTE_GET (external
->p_type
);
3278 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3279 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3280 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3281 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3282 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3283 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3284 internal
->p_align
= BYTE_GET (external
->p_align
);
3293 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3295 Elf64_External_Phdr
* phdrs
;
3296 Elf64_External_Phdr
* external
;
3297 Elf_Internal_Phdr
* internal
;
3300 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3301 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3302 _("program headers"));
3306 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3307 i
< elf_header
.e_phnum
;
3308 i
++, internal
++, external
++)
3310 internal
->p_type
= BYTE_GET (external
->p_type
);
3311 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3312 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3313 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3314 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3315 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3316 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3317 internal
->p_align
= BYTE_GET (external
->p_align
);
3325 /* Returns 1 if the program headers were read into `program_headers'. */
3328 get_program_headers (FILE * file
)
3330 Elf_Internal_Phdr
* phdrs
;
3332 /* Check cache of prior read. */
3333 if (program_headers
!= NULL
)
3336 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3340 error (_("Out of memory\n"));
3345 ? get_32bit_program_headers (file
, phdrs
)
3346 : get_64bit_program_headers (file
, phdrs
))
3348 program_headers
= phdrs
;
3356 /* Returns 1 if the program headers were loaded. */
3359 process_program_headers (FILE * file
)
3361 Elf_Internal_Phdr
* segment
;
3364 if (elf_header
.e_phnum
== 0)
3367 printf (_("\nThere are no program headers in this file.\n"));
3371 if (do_segments
&& !do_header
)
3373 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3374 printf (_("Entry point "));
3375 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3376 printf (_("\nThere are %d program headers, starting at offset "),
3377 elf_header
.e_phnum
);
3378 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3382 if (! get_program_headers (file
))
3387 if (elf_header
.e_phnum
> 1)
3388 printf (_("\nProgram Headers:\n"));
3390 printf (_("\nProgram Headers:\n"));
3394 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3397 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3401 (_(" Type Offset VirtAddr PhysAddr\n"));
3403 (_(" FileSiz MemSiz Flags Align\n"));
3410 for (i
= 0, segment
= program_headers
;
3411 i
< elf_header
.e_phnum
;
3416 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3420 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3421 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3422 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3423 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3424 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3426 (segment
->p_flags
& PF_R
? 'R' : ' '),
3427 (segment
->p_flags
& PF_W
? 'W' : ' '),
3428 (segment
->p_flags
& PF_X
? 'E' : ' '));
3429 printf ("%#lx", (unsigned long) segment
->p_align
);
3433 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3434 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3437 print_vma (segment
->p_offset
, FULL_HEX
);
3441 print_vma (segment
->p_vaddr
, FULL_HEX
);
3443 print_vma (segment
->p_paddr
, FULL_HEX
);
3446 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3447 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3450 print_vma (segment
->p_filesz
, FULL_HEX
);
3454 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3455 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3458 print_vma (segment
->p_offset
, FULL_HEX
);
3462 (segment
->p_flags
& PF_R
? 'R' : ' '),
3463 (segment
->p_flags
& PF_W
? 'W' : ' '),
3464 (segment
->p_flags
& PF_X
? 'E' : ' '));
3466 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3467 printf ("%#lx", (unsigned long) segment
->p_align
);
3470 print_vma (segment
->p_align
, PREFIX_HEX
);
3475 print_vma (segment
->p_offset
, FULL_HEX
);
3477 print_vma (segment
->p_vaddr
, FULL_HEX
);
3479 print_vma (segment
->p_paddr
, FULL_HEX
);
3481 print_vma (segment
->p_filesz
, FULL_HEX
);
3483 print_vma (segment
->p_memsz
, FULL_HEX
);
3485 (segment
->p_flags
& PF_R
? 'R' : ' '),
3486 (segment
->p_flags
& PF_W
? 'W' : ' '),
3487 (segment
->p_flags
& PF_X
? 'E' : ' '));
3488 print_vma (segment
->p_align
, HEX
);
3492 switch (segment
->p_type
)
3496 error (_("more than one dynamic segment\n"));
3498 /* By default, assume that the .dynamic section is the first
3499 section in the DYNAMIC segment. */
3500 dynamic_addr
= segment
->p_offset
;
3501 dynamic_size
= segment
->p_filesz
;
3503 /* Try to locate the .dynamic section. If there is
3504 a section header table, we can easily locate it. */
3505 if (section_headers
!= NULL
)
3507 Elf_Internal_Shdr
* sec
;
3509 sec
= find_section (".dynamic");
3510 if (sec
== NULL
|| sec
->sh_size
== 0)
3512 error (_("no .dynamic section in the dynamic segment\n"));
3516 if (sec
->sh_type
== SHT_NOBITS
)
3522 dynamic_addr
= sec
->sh_offset
;
3523 dynamic_size
= sec
->sh_size
;
3525 if (dynamic_addr
< segment
->p_offset
3526 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3527 warn (_("the .dynamic section is not contained"
3528 " within the dynamic segment\n"));
3529 else if (dynamic_addr
> segment
->p_offset
)
3530 warn (_("the .dynamic section is not the first section"
3531 " in the dynamic segment.\n"));
3536 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3538 error (_("Unable to find program interpreter name\n"));
3542 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3544 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3545 error (_("Internal error: failed to create format string to display program interpreter\n"));
3547 program_interpreter
[0] = 0;
3548 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3549 error (_("Unable to read program interpreter name\n"));
3552 printf (_("\n [Requesting program interpreter: %s]"),
3553 program_interpreter
);
3559 putc ('\n', stdout
);
3562 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3564 printf (_("\n Section to Segment mapping:\n"));
3565 printf (_(" Segment Sections...\n"));
3567 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3570 Elf_Internal_Shdr
* section
;
3572 segment
= program_headers
+ i
;
3573 section
= section_headers
+ 1;
3575 printf (" %2.2d ", i
);
3577 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3579 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3580 printf ("%s ", SECTION_NAME (section
));
3591 /* Find the file offset corresponding to VMA by using the program headers. */
3594 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3596 Elf_Internal_Phdr
* seg
;
3598 if (! get_program_headers (file
))
3600 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3604 for (seg
= program_headers
;
3605 seg
< program_headers
+ elf_header
.e_phnum
;
3608 if (seg
->p_type
!= PT_LOAD
)
3611 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3612 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3613 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3616 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3617 (unsigned long) vma
);
3623 get_32bit_section_headers (FILE * file
, unsigned int num
)
3625 Elf32_External_Shdr
* shdrs
;
3626 Elf_Internal_Shdr
* internal
;
3629 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3630 elf_header
.e_shentsize
, num
, _("section headers"));
3634 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3636 if (section_headers
== NULL
)
3638 error (_("Out of memory\n"));
3642 for (i
= 0, internal
= section_headers
;
3646 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3647 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3648 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3649 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3650 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3651 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3652 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3653 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3654 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3655 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3664 get_64bit_section_headers (FILE * file
, unsigned int num
)
3666 Elf64_External_Shdr
* shdrs
;
3667 Elf_Internal_Shdr
* internal
;
3670 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3671 elf_header
.e_shentsize
, num
, _("section headers"));
3675 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3677 if (section_headers
== NULL
)
3679 error (_("Out of memory\n"));
3683 for (i
= 0, internal
= section_headers
;
3687 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3688 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3689 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3690 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3691 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3692 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3693 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3694 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3695 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3696 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3704 static Elf_Internal_Sym
*
3705 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3707 unsigned long number
;
3708 Elf32_External_Sym
* esyms
;
3709 Elf_External_Sym_Shndx
* shndx
;
3710 Elf_Internal_Sym
* isyms
;
3711 Elf_Internal_Sym
* psym
;
3714 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3720 if (symtab_shndx_hdr
!= NULL
3721 && (symtab_shndx_hdr
->sh_link
3722 == (unsigned long) (section
- section_headers
)))
3724 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3725 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3733 number
= section
->sh_size
/ section
->sh_entsize
;
3734 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3738 error (_("Out of memory\n"));
3745 for (j
= 0, psym
= isyms
;
3749 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3750 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3751 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3752 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3753 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3755 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3756 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3757 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3758 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3759 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3769 static Elf_Internal_Sym
*
3770 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3772 unsigned long number
;
3773 Elf64_External_Sym
* esyms
;
3774 Elf_External_Sym_Shndx
* shndx
;
3775 Elf_Internal_Sym
* isyms
;
3776 Elf_Internal_Sym
* psym
;
3779 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3785 if (symtab_shndx_hdr
!= NULL
3786 && (symtab_shndx_hdr
->sh_link
3787 == (unsigned long) (section
- section_headers
)))
3789 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3790 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3798 number
= section
->sh_size
/ section
->sh_entsize
;
3799 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3803 error (_("Out of memory\n"));
3810 for (j
= 0, psym
= isyms
;
3814 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3815 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3816 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3817 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3818 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3820 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3821 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3822 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3823 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3824 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3835 get_elf_section_flags (bfd_vma sh_flags
)
3837 static char buff
[1024];
3839 int field_size
= is_32bit_elf
? 8 : 16;
3840 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3841 bfd_vma os_flags
= 0;
3842 bfd_vma proc_flags
= 0;
3843 bfd_vma unknown_flags
= 0;
3857 { "LINK ORDER", 10 },
3858 { "OS NONCONF", 10 },
3861 /* IA-64 specific. */
3864 /* IA-64 OpenVMS specific. */
3865 { "VMS_GLOBAL", 10 },
3866 { "VMS_OVERLAID", 12 },
3867 { "VMS_SHARED", 10 },
3868 { "VMS_VECTOR", 10 },
3869 { "VMS_ALLOC_64BIT", 15 },
3870 { "VMS_PROTECTED", 13}
3873 if (do_section_details
)
3875 sprintf (buff
, "[%*.*lx]: ",
3876 field_size
, field_size
, (unsigned long) sh_flags
);
3877 p
+= field_size
+ 4;
3884 flag
= sh_flags
& - sh_flags
;
3887 if (do_section_details
)
3891 case SHF_WRITE
: index
= 0; break;
3892 case SHF_ALLOC
: index
= 1; break;
3893 case SHF_EXECINSTR
: index
= 2; break;
3894 case SHF_MERGE
: index
= 3; break;
3895 case SHF_STRINGS
: index
= 4; break;
3896 case SHF_INFO_LINK
: index
= 5; break;
3897 case SHF_LINK_ORDER
: index
= 6; break;
3898 case SHF_OS_NONCONFORMING
: index
= 7; break;
3899 case SHF_GROUP
: index
= 8; break;
3900 case SHF_TLS
: index
= 9; break;
3904 if (elf_header
.e_machine
== EM_IA_64
)
3906 if (flag
== SHF_IA_64_SHORT
)
3908 else if (flag
== SHF_IA_64_NORECOV
)
3911 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3914 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3915 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3916 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3917 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3918 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3919 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3929 if (p
!= buff
+ field_size
+ 4)
3931 if (size
< (10 + 2))
3938 size
-= flags
[index
].len
;
3939 p
= stpcpy (p
, flags
[index
].str
);
3941 else if (flag
& SHF_MASKOS
)
3943 else if (flag
& SHF_MASKPROC
)
3946 unknown_flags
|= flag
;
3952 case SHF_WRITE
: *p
= 'W'; break;
3953 case SHF_ALLOC
: *p
= 'A'; break;
3954 case SHF_EXECINSTR
: *p
= 'X'; break;
3955 case SHF_MERGE
: *p
= 'M'; break;
3956 case SHF_STRINGS
: *p
= 'S'; break;
3957 case SHF_INFO_LINK
: *p
= 'I'; break;
3958 case SHF_LINK_ORDER
: *p
= 'L'; break;
3959 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3960 case SHF_GROUP
: *p
= 'G'; break;
3961 case SHF_TLS
: *p
= 'T'; break;
3964 if (elf_header
.e_machine
== EM_X86_64
3965 && flag
== SHF_X86_64_LARGE
)
3967 else if (flag
& SHF_MASKOS
)
3970 sh_flags
&= ~ SHF_MASKOS
;
3972 else if (flag
& SHF_MASKPROC
)
3975 sh_flags
&= ~ SHF_MASKPROC
;
3985 if (do_section_details
)
3989 size
-= 5 + field_size
;
3990 if (p
!= buff
+ field_size
+ 4)
3998 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3999 (unsigned long) os_flags
);
4000 p
+= 5 + field_size
;
4004 size
-= 7 + field_size
;
4005 if (p
!= buff
+ field_size
+ 4)
4013 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4014 (unsigned long) proc_flags
);
4015 p
+= 7 + field_size
;
4019 size
-= 10 + field_size
;
4020 if (p
!= buff
+ field_size
+ 4)
4028 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4029 (unsigned long) unknown_flags
);
4030 p
+= 10 + field_size
;
4039 process_section_headers (FILE * file
)
4041 Elf_Internal_Shdr
* section
;
4044 section_headers
= NULL
;
4046 if (elf_header
.e_shnum
== 0)
4049 printf (_("\nThere are no sections in this file.\n"));
4054 if (do_sections
&& !do_header
)
4055 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4056 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4060 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4063 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4066 /* Read in the string table, so that we have names to display. */
4067 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4068 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4070 section
= section_headers
+ elf_header
.e_shstrndx
;
4072 if (section
->sh_size
!= 0)
4074 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4075 1, section
->sh_size
, _("string table"));
4077 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4081 /* Scan the sections for the dynamic symbol table
4082 and dynamic string table and debug sections. */
4083 dynamic_symbols
= NULL
;
4084 dynamic_strings
= NULL
;
4085 dynamic_syminfo
= NULL
;
4086 symtab_shndx_hdr
= NULL
;
4088 eh_addr_size
= is_32bit_elf
? 4 : 8;
4089 switch (elf_header
.e_machine
)
4092 case EM_MIPS_RS3_LE
:
4093 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4094 FDE addresses. However, the ABI also has a semi-official ILP32
4095 variant for which the normal FDE address size rules apply.
4097 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4098 section, where XX is the size of longs in bits. Unfortunately,
4099 earlier compilers provided no way of distinguishing ILP32 objects
4100 from LP64 objects, so if there's any doubt, we should assume that
4101 the official LP64 form is being used. */
4102 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4103 && find_section (".gcc_compiled_long32") == NULL
)
4109 switch (elf_header
.e_flags
& EF_H8_MACH
)
4111 case E_H8_MACH_H8300
:
4112 case E_H8_MACH_H8300HN
:
4113 case E_H8_MACH_H8300SN
:
4114 case E_H8_MACH_H8300SXN
:
4117 case E_H8_MACH_H8300H
:
4118 case E_H8_MACH_H8300S
:
4119 case E_H8_MACH_H8300SX
:
4127 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4129 case EF_M32C_CPU_M16C
:
4136 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4139 size_t expected_entsize \
4140 = is_32bit_elf ? size32 : size64; \
4141 if (section->sh_entsize != expected_entsize) \
4142 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4143 i, (unsigned long int) section->sh_entsize, \
4144 (unsigned long int) expected_entsize); \
4145 section->sh_entsize = expected_entsize; \
4148 #define CHECK_ENTSIZE(section, i, type) \
4149 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4150 sizeof (Elf64_External_##type))
4152 for (i
= 0, section
= section_headers
;
4153 i
< elf_header
.e_shnum
;
4156 char * name
= SECTION_NAME (section
);
4158 if (section
->sh_type
== SHT_DYNSYM
)
4160 if (dynamic_symbols
!= NULL
)
4162 error (_("File contains multiple dynamic symbol tables\n"));
4166 CHECK_ENTSIZE (section
, i
, Sym
);
4167 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4168 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4170 else if (section
->sh_type
== SHT_STRTAB
4171 && streq (name
, ".dynstr"))
4173 if (dynamic_strings
!= NULL
)
4175 error (_("File contains multiple dynamic string tables\n"));
4179 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4180 1, section
->sh_size
, _("dynamic strings"));
4181 dynamic_strings_length
= section
->sh_size
;
4183 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4185 if (symtab_shndx_hdr
!= NULL
)
4187 error (_("File contains multiple symtab shndx tables\n"));
4190 symtab_shndx_hdr
= section
;
4192 else if (section
->sh_type
== SHT_SYMTAB
)
4193 CHECK_ENTSIZE (section
, i
, Sym
);
4194 else if (section
->sh_type
== SHT_GROUP
)
4195 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4196 else if (section
->sh_type
== SHT_REL
)
4197 CHECK_ENTSIZE (section
, i
, Rel
);
4198 else if (section
->sh_type
== SHT_RELA
)
4199 CHECK_ENTSIZE (section
, i
, Rela
);
4200 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4201 || do_debug_lines
|| do_debug_pubnames
4202 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4203 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4204 && (const_strneq (name
, ".debug_")
4205 || const_strneq (name
, ".zdebug_")))
4208 name
+= sizeof (".zdebug_") - 1;
4210 name
+= sizeof (".debug_") - 1;
4213 || (do_debug_info
&& streq (name
, "info"))
4214 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4215 || (do_debug_lines
&& streq (name
, "line"))
4216 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4217 || (do_debug_aranges
&& streq (name
, "aranges"))
4218 || (do_debug_ranges
&& streq (name
, "ranges"))
4219 || (do_debug_frames
&& streq (name
, "frame"))
4220 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4221 || (do_debug_str
&& streq (name
, "str"))
4222 || (do_debug_loc
&& streq (name
, "loc"))
4224 request_dump_bynumber (i
, DEBUG_DUMP
);
4226 /* Linkonce section to be combined with .debug_info at link time. */
4227 else if ((do_debugging
|| do_debug_info
)
4228 && const_strneq (name
, ".gnu.linkonce.wi."))
4229 request_dump_bynumber (i
, DEBUG_DUMP
);
4230 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4231 request_dump_bynumber (i
, DEBUG_DUMP
);
4237 if (elf_header
.e_shnum
> 1)
4238 printf (_("\nSection Headers:\n"));
4240 printf (_("\nSection Header:\n"));
4244 if (do_section_details
)
4246 printf (_(" [Nr] Name\n"));
4247 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4251 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4255 if (do_section_details
)
4257 printf (_(" [Nr] Name\n"));
4258 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4262 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4266 if (do_section_details
)
4268 printf (_(" [Nr] Name\n"));
4269 printf (_(" Type Address Offset Link\n"));
4270 printf (_(" Size EntSize Info Align\n"));
4274 printf (_(" [Nr] Name Type Address Offset\n"));
4275 printf (_(" Size EntSize Flags Link Info Align\n"));
4279 if (do_section_details
)
4280 printf (_(" Flags\n"));
4282 for (i
= 0, section
= section_headers
;
4283 i
< elf_header
.e_shnum
;
4286 if (do_section_details
)
4288 printf (" [%2u] %s\n",
4290 SECTION_NAME (section
));
4291 if (is_32bit_elf
|| do_wide
)
4292 printf (" %-15.15s ",
4293 get_section_type_name (section
->sh_type
));
4296 printf ((do_wide
? " [%2u] %-17s %-15s "
4297 : " [%2u] %-17.17s %-15.15s "),
4299 SECTION_NAME (section
),
4300 get_section_type_name (section
->sh_type
));
4304 print_vma (section
->sh_addr
, LONG_HEX
);
4306 printf ( " %6.6lx %6.6lx %2.2lx",
4307 (unsigned long) section
->sh_offset
,
4308 (unsigned long) section
->sh_size
,
4309 (unsigned long) section
->sh_entsize
);
4311 if (do_section_details
)
4312 fputs (" ", stdout
);
4314 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4316 printf ("%2u %3u %2lu\n",
4319 (unsigned long) section
->sh_addralign
);
4323 print_vma (section
->sh_addr
, LONG_HEX
);
4325 if ((long) section
->sh_offset
== section
->sh_offset
)
4326 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4330 print_vma (section
->sh_offset
, LONG_HEX
);
4333 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4334 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4338 print_vma (section
->sh_size
, LONG_HEX
);
4341 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4342 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4346 print_vma (section
->sh_entsize
, LONG_HEX
);
4349 if (do_section_details
)
4350 fputs (" ", stdout
);
4352 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4354 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4356 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4357 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4360 print_vma (section
->sh_addralign
, DEC
);
4364 else if (do_section_details
)
4366 printf (" %-15.15s ",
4367 get_section_type_name (section
->sh_type
));
4368 print_vma (section
->sh_addr
, LONG_HEX
);
4369 if ((long) section
->sh_offset
== section
->sh_offset
)
4370 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4374 print_vma (section
->sh_offset
, LONG_HEX
);
4376 printf (" %u\n ", section
->sh_link
);
4377 print_vma (section
->sh_size
, LONG_HEX
);
4379 print_vma (section
->sh_entsize
, LONG_HEX
);
4381 printf (" %-16u %lu\n",
4383 (unsigned long) section
->sh_addralign
);
4388 print_vma (section
->sh_addr
, LONG_HEX
);
4389 if ((long) section
->sh_offset
== section
->sh_offset
)
4390 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4394 print_vma (section
->sh_offset
, LONG_HEX
);
4397 print_vma (section
->sh_size
, LONG_HEX
);
4399 print_vma (section
->sh_entsize
, LONG_HEX
);
4401 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4403 printf (" %2u %3u %lu\n",
4406 (unsigned long) section
->sh_addralign
);
4409 if (do_section_details
)
4410 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4413 if (!do_section_details
)
4414 printf (_("Key to Flags:\n\
4415 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4416 I (info), L (link order), G (group), x (unknown)\n\
4417 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4423 get_group_flags (unsigned int flags
)
4425 static char buff
[32];
4432 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4439 process_section_groups (FILE * file
)
4441 Elf_Internal_Shdr
* section
;
4443 struct group
* group
;
4444 Elf_Internal_Shdr
* symtab_sec
;
4445 Elf_Internal_Shdr
* strtab_sec
;
4446 Elf_Internal_Sym
* symtab
;
4450 /* Don't process section groups unless needed. */
4451 if (!do_unwind
&& !do_section_groups
)
4454 if (elf_header
.e_shnum
== 0)
4456 if (do_section_groups
)
4457 printf (_("\nThere are no sections in this file.\n"));
4462 if (section_headers
== NULL
)
4464 error (_("Section headers are not available!\n"));
4468 section_headers_groups
= calloc (elf_header
.e_shnum
,
4469 sizeof (struct group
*));
4471 if (section_headers_groups
== NULL
)
4473 error (_("Out of memory\n"));
4477 /* Scan the sections for the group section. */
4479 for (i
= 0, section
= section_headers
;
4480 i
< elf_header
.e_shnum
;
4482 if (section
->sh_type
== SHT_GROUP
)
4485 if (group_count
== 0)
4487 if (do_section_groups
)
4488 printf (_("\nThere are no section groups in this file.\n"));
4493 section_groups
= calloc (group_count
, sizeof (struct group
));
4495 if (section_groups
== NULL
)
4497 error (_("Out of memory\n"));
4506 for (i
= 0, section
= section_headers
, group
= section_groups
;
4507 i
< elf_header
.e_shnum
;
4510 if (section
->sh_type
== SHT_GROUP
)
4512 char * name
= SECTION_NAME (section
);
4514 unsigned char * start
;
4515 unsigned char * indices
;
4516 unsigned int entry
, j
, size
;
4517 Elf_Internal_Shdr
* sec
;
4518 Elf_Internal_Sym
* sym
;
4520 /* Get the symbol table. */
4521 if (section
->sh_link
>= elf_header
.e_shnum
4522 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4525 error (_("Bad sh_link in group section `%s'\n"), name
);
4529 if (symtab_sec
!= sec
)
4534 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4537 sym
= symtab
+ section
->sh_info
;
4539 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4541 if (sym
->st_shndx
== 0
4542 || sym
->st_shndx
>= elf_header
.e_shnum
)
4544 error (_("Bad sh_info in group section `%s'\n"), name
);
4548 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4557 /* Get the string table. */
4558 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4567 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4572 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4573 1, strtab_sec
->sh_size
,
4575 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4577 group_name
= sym
->st_name
< strtab_size
4578 ? strtab
+ sym
->st_name
: "<corrupt>";
4581 start
= get_data (NULL
, file
, section
->sh_offset
,
4582 1, section
->sh_size
, _("section data"));
4585 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4586 entry
= byte_get (indices
, 4);
4589 if (do_section_groups
)
4591 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4592 get_group_flags (entry
), i
, name
, group_name
, size
);
4594 printf (_(" [Index] Name\n"));
4597 group
->group_index
= i
;
4599 for (j
= 0; j
< size
; j
++)
4601 struct group_list
* g
;
4603 entry
= byte_get (indices
, 4);
4606 if (entry
>= elf_header
.e_shnum
)
4608 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4609 entry
, i
, elf_header
.e_shnum
- 1);
4613 if (section_headers_groups
[entry
] != NULL
)
4617 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4619 section_headers_groups
[entry
]->group_index
);
4624 /* Intel C/C++ compiler may put section 0 in a
4625 section group. We just warn it the first time
4626 and ignore it afterwards. */
4627 static int warned
= 0;
4630 error (_("section 0 in group section [%5u]\n"),
4631 section_headers_groups
[entry
]->group_index
);
4637 section_headers_groups
[entry
] = group
;
4639 if (do_section_groups
)
4641 sec
= section_headers
+ entry
;
4642 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4645 g
= xmalloc (sizeof (struct group_list
));
4646 g
->section_index
= entry
;
4647 g
->next
= group
->root
;
4671 } dynamic_relocations
[] =
4673 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4674 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4675 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4678 /* Process the reloc section. */
4681 process_relocs (FILE * file
)
4683 unsigned long rel_size
;
4684 unsigned long rel_offset
;
4690 if (do_using_dynamic
)
4694 int has_dynamic_reloc
;
4697 has_dynamic_reloc
= 0;
4699 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4701 is_rela
= dynamic_relocations
[i
].rela
;
4702 name
= dynamic_relocations
[i
].name
;
4703 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4704 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4706 has_dynamic_reloc
|= rel_size
;
4708 if (is_rela
== UNKNOWN
)
4710 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4711 switch (dynamic_info
[DT_PLTREL
])
4725 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4726 name
, rel_offset
, rel_size
);
4728 dump_relocations (file
,
4729 offset_from_vma (file
, rel_offset
, rel_size
),
4731 dynamic_symbols
, num_dynamic_syms
,
4732 dynamic_strings
, dynamic_strings_length
, is_rela
);
4736 if (! has_dynamic_reloc
)
4737 printf (_("\nThere are no dynamic relocations in this file.\n"));
4741 Elf_Internal_Shdr
* section
;
4745 for (i
= 0, section
= section_headers
;
4746 i
< elf_header
.e_shnum
;
4749 if ( section
->sh_type
!= SHT_RELA
4750 && section
->sh_type
!= SHT_REL
)
4753 rel_offset
= section
->sh_offset
;
4754 rel_size
= section
->sh_size
;
4758 Elf_Internal_Shdr
* strsec
;
4761 printf (_("\nRelocation section "));
4763 if (string_table
== NULL
)
4764 printf ("%d", section
->sh_name
);
4766 printf (_("'%s'"), SECTION_NAME (section
));
4768 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4769 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4771 is_rela
= section
->sh_type
== SHT_RELA
;
4773 if (section
->sh_link
!= 0
4774 && section
->sh_link
< elf_header
.e_shnum
)
4776 Elf_Internal_Shdr
* symsec
;
4777 Elf_Internal_Sym
* symtab
;
4778 unsigned long nsyms
;
4779 unsigned long strtablen
= 0;
4780 char * strtab
= NULL
;
4782 symsec
= section_headers
+ section
->sh_link
;
4783 if (symsec
->sh_type
!= SHT_SYMTAB
4784 && symsec
->sh_type
!= SHT_DYNSYM
)
4787 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4788 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4793 if (symsec
->sh_link
!= 0
4794 && symsec
->sh_link
< elf_header
.e_shnum
)
4796 strsec
= section_headers
+ symsec
->sh_link
;
4798 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4801 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4804 dump_relocations (file
, rel_offset
, rel_size
,
4805 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4811 dump_relocations (file
, rel_offset
, rel_size
,
4812 NULL
, 0, NULL
, 0, is_rela
);
4819 printf (_("\nThere are no relocations in this file.\n"));
4825 /* Process the unwind section. */
4827 #include "unwind-ia64.h"
4829 /* An absolute address consists of a section and an offset. If the
4830 section is NULL, the offset itself is the address, otherwise, the
4831 address equals to LOAD_ADDRESS(section) + offset. */
4835 unsigned short section
;
4839 #define ABSADDR(a) \
4841 ? section_headers [(a).section].sh_addr + (a).offset \
4844 struct ia64_unw_aux_info
4846 struct ia64_unw_table_entry
4848 struct absaddr start
;
4850 struct absaddr info
;
4852 *table
; /* Unwind table. */
4853 unsigned long table_len
; /* Length of unwind table. */
4854 unsigned char * info
; /* Unwind info. */
4855 unsigned long info_size
; /* Size of unwind info. */
4856 bfd_vma info_addr
; /* starting address of unwind info. */
4857 bfd_vma seg_base
; /* Starting address of segment. */
4858 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4859 unsigned long nsyms
; /* Number of symbols. */
4860 char * strtab
; /* The string table. */
4861 unsigned long strtab_size
; /* Size of string table. */
4865 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4866 unsigned long nsyms
,
4867 const char * strtab
,
4868 unsigned long strtab_size
,
4869 struct absaddr addr
,
4870 const char ** symname
,
4873 bfd_vma dist
= 0x100000;
4874 Elf_Internal_Sym
* sym
;
4875 Elf_Internal_Sym
* best
= NULL
;
4878 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4880 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4881 && sym
->st_name
!= 0
4882 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4883 && addr
.offset
>= sym
->st_value
4884 && addr
.offset
- sym
->st_value
< dist
)
4887 dist
= addr
.offset
- sym
->st_value
;
4894 *symname
= (best
->st_name
>= strtab_size
4895 ? "<corrupt>" : strtab
+ best
->st_name
);
4900 *offset
= addr
.offset
;
4904 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
4906 struct ia64_unw_table_entry
* tp
;
4909 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4913 const unsigned char * dp
;
4914 const unsigned char * head
;
4915 const char * procname
;
4917 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4918 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4920 fputs ("\n<", stdout
);
4924 fputs (procname
, stdout
);
4927 printf ("+%lx", (unsigned long) offset
);
4930 fputs (">: [", stdout
);
4931 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4932 fputc ('-', stdout
);
4933 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4934 printf ("], info at +0x%lx\n",
4935 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4937 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4938 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4940 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4941 (unsigned) UNW_VER (stamp
),
4942 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4943 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4944 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4945 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4947 if (UNW_VER (stamp
) != 1)
4949 printf ("\tUnknown version.\n");
4954 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4955 dp
= unw_decode (dp
, in_body
, & in_body
);
4960 slurp_ia64_unwind_table (FILE * file
,
4961 struct ia64_unw_aux_info
* aux
,
4962 Elf_Internal_Shdr
* sec
)
4964 unsigned long size
, nrelas
, i
;
4965 Elf_Internal_Phdr
* seg
;
4966 struct ia64_unw_table_entry
* tep
;
4967 Elf_Internal_Shdr
* relsec
;
4968 Elf_Internal_Rela
* rela
;
4969 Elf_Internal_Rela
* rp
;
4970 unsigned char * table
;
4972 Elf_Internal_Sym
* sym
;
4973 const char * relname
;
4975 /* First, find the starting address of the segment that includes
4978 if (elf_header
.e_phnum
)
4980 if (! get_program_headers (file
))
4983 for (seg
= program_headers
;
4984 seg
< program_headers
+ elf_header
.e_phnum
;
4987 if (seg
->p_type
!= PT_LOAD
)
4990 if (sec
->sh_addr
>= seg
->p_vaddr
4991 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4993 aux
->seg_base
= seg
->p_vaddr
;
4999 /* Second, build the unwind table from the contents of the unwind section: */
5000 size
= sec
->sh_size
;
5001 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5005 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5007 for (tp
= table
; tp
< table
+ size
; ++tep
)
5009 tep
->start
.section
= SHN_UNDEF
;
5010 tep
->end
.section
= SHN_UNDEF
;
5011 tep
->info
.section
= SHN_UNDEF
;
5012 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5013 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5014 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5015 tep
->start
.offset
+= aux
->seg_base
;
5016 tep
->end
.offset
+= aux
->seg_base
;
5017 tep
->info
.offset
+= aux
->seg_base
;
5021 /* Third, apply any relocations to the unwind table: */
5022 for (relsec
= section_headers
;
5023 relsec
< section_headers
+ elf_header
.e_shnum
;
5026 if (relsec
->sh_type
!= SHT_RELA
5027 || relsec
->sh_info
>= elf_header
.e_shnum
5028 || section_headers
+ relsec
->sh_info
!= sec
)
5031 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5035 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5037 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5038 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5040 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5042 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5046 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5048 switch (rp
->r_offset
/eh_addr_size
% 3)
5051 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5052 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5055 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5056 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5059 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5060 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5070 aux
->table_len
= size
/ (3 * eh_addr_size
);
5075 ia64_process_unwind (FILE * file
)
5077 Elf_Internal_Shdr
* sec
;
5078 Elf_Internal_Shdr
* unwsec
= NULL
;
5079 Elf_Internal_Shdr
* strsec
;
5080 unsigned long i
, unwcount
= 0, unwstart
= 0;
5081 struct ia64_unw_aux_info aux
;
5083 memset (& aux
, 0, sizeof (aux
));
5085 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5087 if (sec
->sh_type
== SHT_SYMTAB
5088 && sec
->sh_link
< elf_header
.e_shnum
)
5090 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5091 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5093 strsec
= section_headers
+ sec
->sh_link
;
5094 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5095 1, strsec
->sh_size
, _("string table"));
5096 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5098 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5103 printf (_("\nThere are no unwind sections in this file.\n"));
5105 while (unwcount
-- > 0)
5110 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5111 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5112 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5119 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5121 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5123 /* We need to find which section group it is in. */
5124 struct group_list
* g
= section_headers_groups
[i
]->root
;
5126 for (; g
!= NULL
; g
= g
->next
)
5128 sec
= section_headers
+ g
->section_index
;
5130 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5135 i
= elf_header
.e_shnum
;
5137 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5139 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5140 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5141 suffix
= SECTION_NAME (unwsec
) + len
;
5142 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5144 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5145 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5150 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5151 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5152 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5153 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5155 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5156 suffix
= SECTION_NAME (unwsec
) + len
;
5157 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5159 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5160 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5164 if (i
== elf_header
.e_shnum
)
5166 printf (_("\nCould not find unwind info section for "));
5168 if (string_table
== NULL
)
5169 printf ("%d", unwsec
->sh_name
);
5171 printf (_("'%s'"), SECTION_NAME (unwsec
));
5175 aux
.info_size
= sec
->sh_size
;
5176 aux
.info_addr
= sec
->sh_addr
;
5177 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5180 printf (_("\nUnwind section "));
5182 if (string_table
== NULL
)
5183 printf ("%d", unwsec
->sh_name
);
5185 printf (_("'%s'"), SECTION_NAME (unwsec
));
5187 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5188 (unsigned long) unwsec
->sh_offset
,
5189 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5191 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5193 if (aux
.table_len
> 0)
5194 dump_ia64_unwind (& aux
);
5197 free ((char *) aux
.table
);
5199 free ((char *) aux
.info
);
5208 free ((char *) aux
.strtab
);
5213 struct hppa_unw_aux_info
5215 struct hppa_unw_table_entry
5217 struct absaddr start
;
5219 unsigned int Cannot_unwind
:1; /* 0 */
5220 unsigned int Millicode
:1; /* 1 */
5221 unsigned int Millicode_save_sr0
:1; /* 2 */
5222 unsigned int Region_description
:2; /* 3..4 */
5223 unsigned int reserved1
:1; /* 5 */
5224 unsigned int Entry_SR
:1; /* 6 */
5225 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5226 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5227 unsigned int Args_stored
:1; /* 16 */
5228 unsigned int Variable_Frame
:1; /* 17 */
5229 unsigned int Separate_Package_Body
:1; /* 18 */
5230 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5231 unsigned int Stack_Overflow_Check
:1; /* 20 */
5232 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5233 unsigned int Ada_Region
:1; /* 22 */
5234 unsigned int cxx_info
:1; /* 23 */
5235 unsigned int cxx_try_catch
:1; /* 24 */
5236 unsigned int sched_entry_seq
:1; /* 25 */
5237 unsigned int reserved2
:1; /* 26 */
5238 unsigned int Save_SP
:1; /* 27 */
5239 unsigned int Save_RP
:1; /* 28 */
5240 unsigned int Save_MRP_in_frame
:1; /* 29 */
5241 unsigned int extn_ptr_defined
:1; /* 30 */
5242 unsigned int Cleanup_defined
:1; /* 31 */
5244 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5245 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5246 unsigned int Large_frame
:1; /* 2 */
5247 unsigned int Pseudo_SP_Set
:1; /* 3 */
5248 unsigned int reserved4
:1; /* 4 */
5249 unsigned int Total_frame_size
:27; /* 5..31 */
5251 *table
; /* Unwind table. */
5252 unsigned long table_len
; /* Length of unwind table. */
5253 bfd_vma seg_base
; /* Starting address of segment. */
5254 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5255 unsigned long nsyms
; /* Number of symbols. */
5256 char * strtab
; /* The string table. */
5257 unsigned long strtab_size
; /* Size of string table. */
5261 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5263 struct hppa_unw_table_entry
* tp
;
5265 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5268 const char * procname
;
5270 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5271 aux
->strtab_size
, tp
->start
, &procname
,
5274 fputs ("\n<", stdout
);
5278 fputs (procname
, stdout
);
5281 printf ("+%lx", (unsigned long) offset
);
5284 fputs (">: [", stdout
);
5285 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5286 fputc ('-', stdout
);
5287 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5290 #define PF(_m) if (tp->_m) printf (#_m " ");
5291 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5294 PF(Millicode_save_sr0
);
5295 /* PV(Region_description); */
5301 PF(Separate_Package_Body
);
5302 PF(Frame_Extension_Millicode
);
5303 PF(Stack_Overflow_Check
);
5304 PF(Two_Instruction_SP_Increment
);
5308 PF(sched_entry_seq
);
5311 PF(Save_MRP_in_frame
);
5312 PF(extn_ptr_defined
);
5313 PF(Cleanup_defined
);
5314 PF(MPE_XL_interrupt_marker
);
5315 PF(HP_UX_interrupt_marker
);
5318 PV(Total_frame_size
);
5327 slurp_hppa_unwind_table (FILE * file
,
5328 struct hppa_unw_aux_info
* aux
,
5329 Elf_Internal_Shdr
* sec
)
5331 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5332 Elf_Internal_Phdr
* seg
;
5333 struct hppa_unw_table_entry
* tep
;
5334 Elf_Internal_Shdr
* relsec
;
5335 Elf_Internal_Rela
* rela
;
5336 Elf_Internal_Rela
* rp
;
5337 unsigned char * table
;
5339 Elf_Internal_Sym
* sym
;
5340 const char * relname
;
5342 /* First, find the starting address of the segment that includes
5345 if (elf_header
.e_phnum
)
5347 if (! get_program_headers (file
))
5350 for (seg
= program_headers
;
5351 seg
< program_headers
+ elf_header
.e_phnum
;
5354 if (seg
->p_type
!= PT_LOAD
)
5357 if (sec
->sh_addr
>= seg
->p_vaddr
5358 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5360 aux
->seg_base
= seg
->p_vaddr
;
5366 /* Second, build the unwind table from the contents of the unwind
5368 size
= sec
->sh_size
;
5369 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5374 nentries
= size
/ unw_ent_size
;
5375 size
= unw_ent_size
* nentries
;
5377 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5379 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5381 unsigned int tmp1
, tmp2
;
5383 tep
->start
.section
= SHN_UNDEF
;
5384 tep
->end
.section
= SHN_UNDEF
;
5386 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5387 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5388 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5389 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5391 tep
->start
.offset
+= aux
->seg_base
;
5392 tep
->end
.offset
+= aux
->seg_base
;
5394 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5395 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5396 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5397 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5398 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5399 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5400 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5401 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5402 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5403 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5404 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5405 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5406 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5407 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5408 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5409 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5410 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5411 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5412 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5413 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5414 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5415 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5416 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5417 tep
->Cleanup_defined
= tmp1
& 0x1;
5419 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5420 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5421 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5422 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5423 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5424 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5428 /* Third, apply any relocations to the unwind table. */
5429 for (relsec
= section_headers
;
5430 relsec
< section_headers
+ elf_header
.e_shnum
;
5433 if (relsec
->sh_type
!= SHT_RELA
5434 || relsec
->sh_info
>= elf_header
.e_shnum
5435 || section_headers
+ relsec
->sh_info
!= sec
)
5438 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5442 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5444 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5445 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5447 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5448 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5450 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5454 i
= rp
->r_offset
/ unw_ent_size
;
5456 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5459 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5460 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5463 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5464 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5474 aux
->table_len
= nentries
;
5480 hppa_process_unwind (FILE * file
)
5482 struct hppa_unw_aux_info aux
;
5483 Elf_Internal_Shdr
* unwsec
= NULL
;
5484 Elf_Internal_Shdr
* strsec
;
5485 Elf_Internal_Shdr
* sec
;
5488 memset (& aux
, 0, sizeof (aux
));
5490 if (string_table
== NULL
)
5493 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5495 if (sec
->sh_type
== SHT_SYMTAB
5496 && sec
->sh_link
< elf_header
.e_shnum
)
5498 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5499 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5501 strsec
= section_headers
+ sec
->sh_link
;
5502 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5503 1, strsec
->sh_size
, _("string table"));
5504 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5506 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5511 printf (_("\nThere are no unwind sections in this file.\n"));
5513 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5515 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5517 printf (_("\nUnwind section "));
5518 printf (_("'%s'"), SECTION_NAME (sec
));
5520 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5521 (unsigned long) sec
->sh_offset
,
5522 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5524 slurp_hppa_unwind_table (file
, &aux
, sec
);
5525 if (aux
.table_len
> 0)
5526 dump_hppa_unwind (&aux
);
5529 free ((char *) aux
.table
);
5537 free ((char *) aux
.strtab
);
5543 process_unwind (FILE * file
)
5545 struct unwind_handler
5548 int (* handler
)(FILE *);
5551 { EM_IA_64
, ia64_process_unwind
},
5552 { EM_PARISC
, hppa_process_unwind
},
5560 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5561 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5562 return handlers
[i
].handler (file
);
5564 printf (_("\nThere are no unwind sections in this file.\n"));
5569 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5571 switch (entry
->d_tag
)
5574 if (entry
->d_un
.d_val
== 0)
5578 static const char * opts
[] =
5580 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5581 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5582 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5583 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5588 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5589 if (entry
->d_un
.d_val
& (1 << cnt
))
5591 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5598 case DT_MIPS_IVERSION
:
5599 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5600 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5602 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5605 case DT_MIPS_TIME_STAMP
:
5610 time_t time
= entry
->d_un
.d_val
;
5611 tmp
= gmtime (&time
);
5612 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5613 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5614 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5615 printf ("Time Stamp: %s\n", timebuf
);
5619 case DT_MIPS_RLD_VERSION
:
5620 case DT_MIPS_LOCAL_GOTNO
:
5621 case DT_MIPS_CONFLICTNO
:
5622 case DT_MIPS_LIBLISTNO
:
5623 case DT_MIPS_SYMTABNO
:
5624 case DT_MIPS_UNREFEXTNO
:
5625 case DT_MIPS_HIPAGENO
:
5626 case DT_MIPS_DELTA_CLASS_NO
:
5627 case DT_MIPS_DELTA_INSTANCE_NO
:
5628 case DT_MIPS_DELTA_RELOC_NO
:
5629 case DT_MIPS_DELTA_SYM_NO
:
5630 case DT_MIPS_DELTA_CLASSSYM_NO
:
5631 case DT_MIPS_COMPACT_SIZE
:
5632 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5636 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5642 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5644 switch (entry
->d_tag
)
5646 case DT_HP_DLD_FLAGS
:
5655 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5656 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5657 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5658 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5659 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5660 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5661 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5662 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5663 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5664 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5665 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5666 { DT_HP_GST
, "HP_GST" },
5667 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5668 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5669 { DT_HP_NODELETE
, "HP_NODELETE" },
5670 { DT_HP_GROUP
, "HP_GROUP" },
5671 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5675 bfd_vma val
= entry
->d_un
.d_val
;
5677 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5678 if (val
& flags
[cnt
].bit
)
5682 fputs (flags
[cnt
].str
, stdout
);
5684 val
^= flags
[cnt
].bit
;
5687 if (val
!= 0 || first
)
5691 print_vma (val
, HEX
);
5697 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5704 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5706 switch (entry
->d_tag
)
5708 case DT_IA_64_PLT_RESERVE
:
5709 /* First 3 slots reserved. */
5710 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5712 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5716 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5723 get_32bit_dynamic_section (FILE * file
)
5725 Elf32_External_Dyn
* edyn
;
5726 Elf32_External_Dyn
* ext
;
5727 Elf_Internal_Dyn
* entry
;
5729 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5730 _("dynamic section"));
5734 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5735 might not have the luxury of section headers. Look for the DT_NULL
5736 terminator to determine the number of entries. */
5737 for (ext
= edyn
, dynamic_nent
= 0;
5738 (char *) ext
< (char *) edyn
+ dynamic_size
;
5742 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5746 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5747 if (dynamic_section
== NULL
)
5749 error (_("Out of memory\n"));
5754 for (ext
= edyn
, entry
= dynamic_section
;
5755 entry
< dynamic_section
+ dynamic_nent
;
5758 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5759 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5768 get_64bit_dynamic_section (FILE * file
)
5770 Elf64_External_Dyn
* edyn
;
5771 Elf64_External_Dyn
* ext
;
5772 Elf_Internal_Dyn
* entry
;
5774 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5775 _("dynamic section"));
5779 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5780 might not have the luxury of section headers. Look for the DT_NULL
5781 terminator to determine the number of entries. */
5782 for (ext
= edyn
, dynamic_nent
= 0;
5783 (char *) ext
< (char *) edyn
+ dynamic_size
;
5787 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5791 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5792 if (dynamic_section
== NULL
)
5794 error (_("Out of memory\n"));
5799 for (ext
= edyn
, entry
= dynamic_section
;
5800 entry
< dynamic_section
+ dynamic_nent
;
5803 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5804 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5813 print_dynamic_flags (bfd_vma flags
)
5821 flag
= flags
& - flags
;
5831 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5832 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5833 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5834 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5835 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5836 default: fputs ("unknown", stdout
); break;
5842 /* Parse and display the contents of the dynamic section. */
5845 process_dynamic_section (FILE * file
)
5847 Elf_Internal_Dyn
* entry
;
5849 if (dynamic_size
== 0)
5852 printf (_("\nThere is no dynamic section in this file.\n"));
5859 if (! get_32bit_dynamic_section (file
))
5862 else if (! get_64bit_dynamic_section (file
))
5865 /* Find the appropriate symbol table. */
5866 if (dynamic_symbols
== NULL
)
5868 for (entry
= dynamic_section
;
5869 entry
< dynamic_section
+ dynamic_nent
;
5872 Elf_Internal_Shdr section
;
5874 if (entry
->d_tag
!= DT_SYMTAB
)
5877 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5879 /* Since we do not know how big the symbol table is,
5880 we default to reading in the entire file (!) and
5881 processing that. This is overkill, I know, but it
5883 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5885 if (archive_file_offset
!= 0)
5886 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5889 if (fseek (file
, 0, SEEK_END
))
5890 error (_("Unable to seek to end of file!\n"));
5892 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5896 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5898 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5900 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5901 if (num_dynamic_syms
< 1)
5903 error (_("Unable to determine the number of symbols to load\n"));
5907 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5911 /* Similarly find a string table. */
5912 if (dynamic_strings
== NULL
)
5914 for (entry
= dynamic_section
;
5915 entry
< dynamic_section
+ dynamic_nent
;
5918 unsigned long offset
;
5921 if (entry
->d_tag
!= DT_STRTAB
)
5924 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5926 /* Since we do not know how big the string table is,
5927 we default to reading in the entire file (!) and
5928 processing that. This is overkill, I know, but it
5931 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5933 if (archive_file_offset
!= 0)
5934 str_tab_len
= archive_file_size
- offset
;
5937 if (fseek (file
, 0, SEEK_END
))
5938 error (_("Unable to seek to end of file\n"));
5939 str_tab_len
= ftell (file
) - offset
;
5942 if (str_tab_len
< 1)
5945 (_("Unable to determine the length of the dynamic string table\n"));
5949 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5950 _("dynamic string table"));
5951 dynamic_strings_length
= str_tab_len
;
5956 /* And find the syminfo section if available. */
5957 if (dynamic_syminfo
== NULL
)
5959 unsigned long syminsz
= 0;
5961 for (entry
= dynamic_section
;
5962 entry
< dynamic_section
+ dynamic_nent
;
5965 if (entry
->d_tag
== DT_SYMINENT
)
5967 /* Note: these braces are necessary to avoid a syntax
5968 error from the SunOS4 C compiler. */
5969 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5971 else if (entry
->d_tag
== DT_SYMINSZ
)
5972 syminsz
= entry
->d_un
.d_val
;
5973 else if (entry
->d_tag
== DT_SYMINFO
)
5974 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5978 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5980 Elf_External_Syminfo
* extsyminfo
;
5981 Elf_External_Syminfo
* extsym
;
5982 Elf_Internal_Syminfo
* syminfo
;
5984 /* There is a syminfo section. Read the data. */
5985 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5986 syminsz
, _("symbol information"));
5990 dynamic_syminfo
= malloc (syminsz
);
5991 if (dynamic_syminfo
== NULL
)
5993 error (_("Out of memory\n"));
5997 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5998 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5999 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6000 ++syminfo
, ++extsym
)
6002 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6003 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6010 if (do_dynamic
&& dynamic_addr
)
6011 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6012 dynamic_addr
, dynamic_nent
);
6014 printf (_(" Tag Type Name/Value\n"));
6016 for (entry
= dynamic_section
;
6017 entry
< dynamic_section
+ dynamic_nent
;
6025 print_vma (entry
->d_tag
, FULL_HEX
);
6026 dtype
= get_dynamic_type (entry
->d_tag
);
6027 printf (" (%s)%*s", dtype
,
6028 ((is_32bit_elf
? 27 : 19)
6029 - (int) strlen (dtype
)),
6033 switch (entry
->d_tag
)
6037 print_dynamic_flags (entry
->d_un
.d_val
);
6047 switch (entry
->d_tag
)
6050 printf (_("Auxiliary library"));
6054 printf (_("Filter library"));
6058 printf (_("Configuration file"));
6062 printf (_("Dependency audit library"));
6066 printf (_("Audit library"));
6070 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6071 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6075 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6084 printf (_("Flags:"));
6086 if (entry
->d_un
.d_val
== 0)
6087 printf (_(" None\n"));
6090 unsigned long int val
= entry
->d_un
.d_val
;
6092 if (val
& DTF_1_PARINIT
)
6094 printf (" PARINIT");
6095 val
^= DTF_1_PARINIT
;
6097 if (val
& DTF_1_CONFEXP
)
6099 printf (" CONFEXP");
6100 val
^= DTF_1_CONFEXP
;
6103 printf (" %lx", val
);
6112 printf (_("Flags:"));
6114 if (entry
->d_un
.d_val
== 0)
6115 printf (_(" None\n"));
6118 unsigned long int val
= entry
->d_un
.d_val
;
6120 if (val
& DF_P1_LAZYLOAD
)
6122 printf (" LAZYLOAD");
6123 val
^= DF_P1_LAZYLOAD
;
6125 if (val
& DF_P1_GROUPPERM
)
6127 printf (" GROUPPERM");
6128 val
^= DF_P1_GROUPPERM
;
6131 printf (" %lx", val
);
6140 printf (_("Flags:"));
6141 if (entry
->d_un
.d_val
== 0)
6142 printf (_(" None\n"));
6145 unsigned long int val
= entry
->d_un
.d_val
;
6152 if (val
& DF_1_GLOBAL
)
6157 if (val
& DF_1_GROUP
)
6162 if (val
& DF_1_NODELETE
)
6164 printf (" NODELETE");
6165 val
^= DF_1_NODELETE
;
6167 if (val
& DF_1_LOADFLTR
)
6169 printf (" LOADFLTR");
6170 val
^= DF_1_LOADFLTR
;
6172 if (val
& DF_1_INITFIRST
)
6174 printf (" INITFIRST");
6175 val
^= DF_1_INITFIRST
;
6177 if (val
& DF_1_NOOPEN
)
6182 if (val
& DF_1_ORIGIN
)
6187 if (val
& DF_1_DIRECT
)
6192 if (val
& DF_1_TRANS
)
6197 if (val
& DF_1_INTERPOSE
)
6199 printf (" INTERPOSE");
6200 val
^= DF_1_INTERPOSE
;
6202 if (val
& DF_1_NODEFLIB
)
6204 printf (" NODEFLIB");
6205 val
^= DF_1_NODEFLIB
;
6207 if (val
& DF_1_NODUMP
)
6212 if (val
& DF_1_CONLFAT
)
6214 printf (" CONLFAT");
6215 val
^= DF_1_CONLFAT
;
6218 printf (" %lx", val
);
6225 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6227 puts (get_dynamic_type (entry
->d_un
.d_val
));
6247 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6253 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6254 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6260 switch (entry
->d_tag
)
6263 printf (_("Shared library: [%s]"), name
);
6265 if (streq (name
, program_interpreter
))
6266 printf (_(" program interpreter"));
6270 printf (_("Library soname: [%s]"), name
);
6274 printf (_("Library rpath: [%s]"), name
);
6278 printf (_("Library runpath: [%s]"), name
);
6282 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6287 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6300 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6304 case DT_INIT_ARRAYSZ
:
6305 case DT_FINI_ARRAYSZ
:
6306 case DT_GNU_CONFLICTSZ
:
6307 case DT_GNU_LIBLISTSZ
:
6310 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6311 printf (" (bytes)\n");
6321 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6334 if (entry
->d_tag
== DT_USED
6335 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6337 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6341 printf (_("Not needed object: [%s]\n"), name
);
6346 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6352 /* The value of this entry is ignored. */
6357 case DT_GNU_PRELINKED
:
6361 time_t time
= entry
->d_un
.d_val
;
6363 tmp
= gmtime (&time
);
6364 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6365 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6366 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6372 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6375 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6381 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6382 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6387 switch (elf_header
.e_machine
)
6390 case EM_MIPS_RS3_LE
:
6391 dynamic_section_mips_val (entry
);
6394 dynamic_section_parisc_val (entry
);
6397 dynamic_section_ia64_val (entry
);
6400 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6412 get_ver_flags (unsigned int flags
)
6414 static char buff
[32];
6421 if (flags
& VER_FLG_BASE
)
6422 strcat (buff
, "BASE ");
6424 if (flags
& VER_FLG_WEAK
)
6426 if (flags
& VER_FLG_BASE
)
6427 strcat (buff
, "| ");
6429 strcat (buff
, "WEAK ");
6432 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6433 strcat (buff
, "| <unknown>");
6438 /* Display the contents of the version sections. */
6441 process_version_sections (FILE * file
)
6443 Elf_Internal_Shdr
* section
;
6450 for (i
= 0, section
= section_headers
;
6451 i
< elf_header
.e_shnum
;
6454 switch (section
->sh_type
)
6456 case SHT_GNU_verdef
:
6458 Elf_External_Verdef
* edefs
;
6466 (_("\nVersion definition section '%s' contains %u entries:\n"),
6467 SECTION_NAME (section
), section
->sh_info
);
6469 printf (_(" Addr: 0x"));
6470 printf_vma (section
->sh_addr
);
6471 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6472 (unsigned long) section
->sh_offset
, section
->sh_link
,
6473 section
->sh_link
< elf_header
.e_shnum
6474 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6477 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6479 _("version definition section"));
6480 endbuf
= (char *) edefs
+ section
->sh_size
;
6484 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6487 Elf_External_Verdef
* edef
;
6488 Elf_Internal_Verdef ent
;
6489 Elf_External_Verdaux
* eaux
;
6490 Elf_Internal_Verdaux aux
;
6494 vstart
= ((char *) edefs
) + idx
;
6495 if (vstart
+ sizeof (*edef
) > endbuf
)
6498 edef
= (Elf_External_Verdef
*) vstart
;
6500 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6501 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6502 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6503 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6504 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6505 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6506 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6508 printf (_(" %#06x: Rev: %d Flags: %s"),
6509 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6511 printf (_(" Index: %d Cnt: %d "),
6512 ent
.vd_ndx
, ent
.vd_cnt
);
6514 vstart
+= ent
.vd_aux
;
6516 eaux
= (Elf_External_Verdaux
*) vstart
;
6518 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6519 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6521 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6522 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6524 printf (_("Name index: %ld\n"), aux
.vda_name
);
6526 isum
= idx
+ ent
.vd_aux
;
6528 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6530 isum
+= aux
.vda_next
;
6531 vstart
+= aux
.vda_next
;
6533 eaux
= (Elf_External_Verdaux
*) vstart
;
6534 if (vstart
+ sizeof (*eaux
) > endbuf
)
6537 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6538 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6540 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6541 printf (_(" %#06x: Parent %d: %s\n"),
6542 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6544 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6545 isum
, j
, aux
.vda_name
);
6548 printf (_(" Version def aux past end of section\n"));
6552 if (cnt
< section
->sh_info
)
6553 printf (_(" Version definition past end of section\n"));
6559 case SHT_GNU_verneed
:
6561 Elf_External_Verneed
* eneed
;
6568 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6569 SECTION_NAME (section
), section
->sh_info
);
6571 printf (_(" Addr: 0x"));
6572 printf_vma (section
->sh_addr
);
6573 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6574 (unsigned long) section
->sh_offset
, section
->sh_link
,
6575 section
->sh_link
< elf_header
.e_shnum
6576 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6579 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6581 _("version need section"));
6582 endbuf
= (char *) eneed
+ section
->sh_size
;
6586 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6588 Elf_External_Verneed
* entry
;
6589 Elf_Internal_Verneed ent
;
6594 vstart
= ((char *) eneed
) + idx
;
6595 if (vstart
+ sizeof (*entry
) > endbuf
)
6598 entry
= (Elf_External_Verneed
*) vstart
;
6600 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6601 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6602 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6603 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6604 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6606 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6608 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6609 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6611 printf (_(" File: %lx"), ent
.vn_file
);
6613 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6615 vstart
+= ent
.vn_aux
;
6617 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6619 Elf_External_Vernaux
* eaux
;
6620 Elf_Internal_Vernaux aux
;
6622 if (vstart
+ sizeof (*eaux
) > endbuf
)
6624 eaux
= (Elf_External_Vernaux
*) vstart
;
6626 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6627 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6628 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6629 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6630 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6632 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6633 printf (_(" %#06x: Name: %s"),
6634 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6636 printf (_(" %#06x: Name index: %lx"),
6637 isum
, aux
.vna_name
);
6639 printf (_(" Flags: %s Version: %d\n"),
6640 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6642 isum
+= aux
.vna_next
;
6643 vstart
+= aux
.vna_next
;
6646 printf (_(" Version need aux past end of section\n"));
6650 if (cnt
< section
->sh_info
)
6651 printf (_(" Version need past end of section\n"));
6657 case SHT_GNU_versym
:
6659 Elf_Internal_Shdr
* link_section
;
6662 unsigned char * edata
;
6663 unsigned short * data
;
6665 Elf_Internal_Sym
* symbols
;
6666 Elf_Internal_Shdr
* string_sec
;
6669 if (section
->sh_link
>= elf_header
.e_shnum
)
6672 link_section
= section_headers
+ section
->sh_link
;
6673 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6675 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6680 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6682 string_sec
= section_headers
+ link_section
->sh_link
;
6684 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6685 string_sec
->sh_size
, _("version string table"));
6689 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6690 SECTION_NAME (section
), total
);
6692 printf (_(" Addr: "));
6693 printf_vma (section
->sh_addr
);
6694 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6695 (unsigned long) section
->sh_offset
, section
->sh_link
,
6696 SECTION_NAME (link_section
));
6698 off
= offset_from_vma (file
,
6699 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6700 total
* sizeof (short));
6701 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6702 _("version symbol data"));
6709 data
= cmalloc (total
, sizeof (short));
6711 for (cnt
= total
; cnt
--;)
6712 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6717 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6720 int check_def
, check_need
;
6723 printf (" %03x:", cnt
);
6725 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6726 switch (data
[cnt
+ j
])
6729 fputs (_(" 0 (*local*) "), stdout
);
6733 fputs (_(" 1 (*global*) "), stdout
);
6737 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6738 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6742 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6743 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6746 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6753 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6755 Elf_Internal_Verneed ivn
;
6756 unsigned long offset
;
6758 offset
= offset_from_vma
6759 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6760 sizeof (Elf_External_Verneed
));
6764 Elf_Internal_Vernaux ivna
;
6765 Elf_External_Verneed evn
;
6766 Elf_External_Vernaux evna
;
6767 unsigned long a_off
;
6769 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6772 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6773 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6775 a_off
= offset
+ ivn
.vn_aux
;
6779 get_data (&evna
, file
, a_off
, sizeof (evna
),
6780 1, _("version need aux (2)"));
6782 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6783 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6785 a_off
+= ivna
.vna_next
;
6787 while (ivna
.vna_other
!= data
[cnt
+ j
]
6788 && ivna
.vna_next
!= 0);
6790 if (ivna
.vna_other
== data
[cnt
+ j
])
6792 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6794 if (ivna
.vna_name
>= string_sec
->sh_size
)
6795 name
= _("*invalid*");
6797 name
= strtab
+ ivna
.vna_name
;
6798 nn
+= printf ("(%s%-*s",
6800 12 - (int) strlen (name
),
6806 offset
+= ivn
.vn_next
;
6808 while (ivn
.vn_next
);
6811 if (check_def
&& data
[cnt
+ j
] != 0x8001
6812 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6814 Elf_Internal_Verdef ivd
;
6815 Elf_External_Verdef evd
;
6816 unsigned long offset
;
6818 offset
= offset_from_vma
6819 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6824 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6827 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6828 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6830 offset
+= ivd
.vd_next
;
6832 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6833 && ivd
.vd_next
!= 0);
6835 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6837 Elf_External_Verdaux evda
;
6838 Elf_Internal_Verdaux ivda
;
6840 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6842 get_data (&evda
, file
,
6843 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6845 _("version def aux"));
6847 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6849 if (ivda
.vda_name
>= string_sec
->sh_size
)
6850 name
= _("*invalid*");
6852 name
= strtab
+ ivda
.vda_name
;
6853 nn
+= printf ("(%s%-*s",
6855 12 - (int) strlen (name
),
6861 printf ("%*c", 18 - nn
, ' ');
6879 printf (_("\nNo version information found in this file.\n"));
6885 get_symbol_binding (unsigned int binding
)
6887 static char buff
[32];
6891 case STB_LOCAL
: return "LOCAL";
6892 case STB_GLOBAL
: return "GLOBAL";
6893 case STB_WEAK
: return "WEAK";
6895 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6896 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6898 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6899 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6901 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6907 get_symbol_type (unsigned int type
)
6909 static char buff
[32];
6913 case STT_NOTYPE
: return "NOTYPE";
6914 case STT_OBJECT
: return "OBJECT";
6915 case STT_FUNC
: return "FUNC";
6916 case STT_SECTION
: return "SECTION";
6917 case STT_FILE
: return "FILE";
6918 case STT_COMMON
: return "COMMON";
6919 case STT_TLS
: return "TLS";
6920 case STT_RELC
: return "RELC";
6921 case STT_SRELC
: return "SRELC";
6923 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6925 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6926 return "THUMB_FUNC";
6928 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6931 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6932 return "PARISC_MILLI";
6934 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6936 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6938 if (elf_header
.e_machine
== EM_PARISC
)
6940 if (type
== STT_HP_OPAQUE
)
6942 if (type
== STT_HP_STUB
)
6946 if (type
== STT_GNU_IFUNC
6947 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
6948 /* GNU/Linux is still using the default value 0. */
6949 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
6952 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6955 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6961 get_symbol_visibility (unsigned int visibility
)
6965 case STV_DEFAULT
: return "DEFAULT";
6966 case STV_INTERNAL
: return "INTERNAL";
6967 case STV_HIDDEN
: return "HIDDEN";
6968 case STV_PROTECTED
: return "PROTECTED";
6974 get_mips_symbol_other (unsigned int other
)
6978 case STO_OPTIONAL
: return "OPTIONAL";
6979 case STO_MIPS16
: return "MIPS16";
6980 case STO_MIPS_PLT
: return "MIPS PLT";
6981 case STO_MIPS_PIC
: return "MIPS PIC";
6982 default: return NULL
;
6987 get_symbol_other (unsigned int other
)
6989 const char * result
= NULL
;
6990 static char buff
[32];
6995 switch (elf_header
.e_machine
)
6998 result
= get_mips_symbol_other (other
);
7006 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7011 get_symbol_index_type (unsigned int type
)
7013 static char buff
[32];
7017 case SHN_UNDEF
: return "UND";
7018 case SHN_ABS
: return "ABS";
7019 case SHN_COMMON
: return "COM";
7021 if (type
== SHN_IA_64_ANSI_COMMON
7022 && elf_header
.e_machine
== EM_IA_64
7023 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7025 else if (elf_header
.e_machine
== EM_X86_64
7026 && type
== SHN_X86_64_LCOMMON
)
7028 else if (type
== SHN_MIPS_SCOMMON
7029 && elf_header
.e_machine
== EM_MIPS
)
7031 else if (type
== SHN_MIPS_SUNDEFINED
7032 && elf_header
.e_machine
== EM_MIPS
)
7034 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7035 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7036 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7037 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7038 else if (type
>= SHN_LORESERVE
)
7039 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7041 sprintf (buff
, "%3d", type
);
7049 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7051 unsigned char * e_data
;
7054 e_data
= cmalloc (number
, ent_size
);
7058 error (_("Out of memory\n"));
7062 if (fread (e_data
, ent_size
, number
, file
) != number
)
7064 error (_("Unable to read in dynamic data\n"));
7068 i_data
= cmalloc (number
, sizeof (*i_data
));
7072 error (_("Out of memory\n"));
7078 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7086 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7088 Elf_Internal_Sym
* psym
;
7091 psym
= dynamic_symbols
+ si
;
7093 n
= print_vma (si
, DEC_5
);
7095 fputs (" " + n
, stdout
);
7096 printf (" %3lu: ", hn
);
7097 print_vma (psym
->st_value
, LONG_HEX
);
7099 print_vma (psym
->st_size
, DEC_5
);
7101 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7102 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7103 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7104 /* Check to see if any other bits in the st_other field are set.
7105 Note - displaying this information disrupts the layout of the
7106 table being generated, but for the moment this case is very
7108 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7109 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7110 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7111 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7112 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7114 printf (" <corrupt: %14ld>", psym
->st_name
);
7118 /* Dump the symbol table. */
7120 process_symbol_table (FILE * file
)
7122 Elf_Internal_Shdr
* section
;
7123 bfd_vma nbuckets
= 0;
7124 bfd_vma nchains
= 0;
7125 bfd_vma
* buckets
= NULL
;
7126 bfd_vma
* chains
= NULL
;
7127 bfd_vma ngnubuckets
= 0;
7128 bfd_vma
* gnubuckets
= NULL
;
7129 bfd_vma
* gnuchains
= NULL
;
7130 bfd_vma gnusymidx
= 0;
7132 if (! do_syms
&& !do_histogram
)
7135 if (dynamic_info
[DT_HASH
]
7137 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7139 unsigned char nb
[8];
7140 unsigned char nc
[8];
7141 int hash_ent_size
= 4;
7143 if ((elf_header
.e_machine
== EM_ALPHA
7144 || elf_header
.e_machine
== EM_S390
7145 || elf_header
.e_machine
== EM_S390_OLD
)
7146 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7150 (archive_file_offset
7151 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7152 sizeof nb
+ sizeof nc
)),
7155 error (_("Unable to seek to start of dynamic information\n"));
7159 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7161 error (_("Failed to read in number of buckets\n"));
7165 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7167 error (_("Failed to read in number of chains\n"));
7171 nbuckets
= byte_get (nb
, hash_ent_size
);
7172 nchains
= byte_get (nc
, hash_ent_size
);
7174 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7175 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7178 if (buckets
== NULL
|| chains
== NULL
)
7180 if (do_using_dynamic
)
7191 if (dynamic_info_DT_GNU_HASH
7193 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7195 unsigned char nb
[16];
7196 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7197 bfd_vma buckets_vma
;
7200 (archive_file_offset
7201 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7205 error (_("Unable to seek to start of dynamic information\n"));
7209 if (fread (nb
, 16, 1, file
) != 1)
7211 error (_("Failed to read in number of buckets\n"));
7215 ngnubuckets
= byte_get (nb
, 4);
7216 gnusymidx
= byte_get (nb
+ 4, 4);
7217 bitmaskwords
= byte_get (nb
+ 8, 4);
7218 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7220 buckets_vma
+= bitmaskwords
* 4;
7222 buckets_vma
+= bitmaskwords
* 8;
7225 (archive_file_offset
7226 + offset_from_vma (file
, buckets_vma
, 4)),
7229 error (_("Unable to seek to start of dynamic information\n"));
7233 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7235 if (gnubuckets
== NULL
)
7238 for (i
= 0; i
< ngnubuckets
; i
++)
7239 if (gnubuckets
[i
] != 0)
7241 if (gnubuckets
[i
] < gnusymidx
)
7244 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7245 maxchain
= gnubuckets
[i
];
7248 if (maxchain
== 0xffffffff)
7251 maxchain
-= gnusymidx
;
7254 (archive_file_offset
7255 + offset_from_vma (file
, buckets_vma
7256 + 4 * (ngnubuckets
+ maxchain
), 4)),
7259 error (_("Unable to seek to start of dynamic information\n"));
7265 if (fread (nb
, 4, 1, file
) != 1)
7267 error (_("Failed to determine last chain length\n"));
7271 if (maxchain
+ 1 == 0)
7276 while ((byte_get (nb
, 4) & 1) == 0);
7279 (archive_file_offset
7280 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7283 error (_("Unable to seek to start of dynamic information\n"));
7287 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7290 if (gnuchains
== NULL
)
7295 if (do_using_dynamic
)
7300 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7303 && dynamic_strings
!= NULL
)
7307 if (dynamic_info
[DT_HASH
])
7311 printf (_("\nSymbol table for image:\n"));
7313 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7315 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7317 for (hn
= 0; hn
< nbuckets
; hn
++)
7322 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7323 print_dynamic_symbol (si
, hn
);
7327 if (dynamic_info_DT_GNU_HASH
)
7329 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7331 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7333 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7335 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7336 if (gnubuckets
[hn
] != 0)
7338 bfd_vma si
= gnubuckets
[hn
];
7339 bfd_vma off
= si
- gnusymidx
;
7343 print_dynamic_symbol (si
, hn
);
7346 while ((gnuchains
[off
++] & 1) == 0);
7350 else if (do_syms
&& !do_using_dynamic
)
7354 for (i
= 0, section
= section_headers
;
7355 i
< elf_header
.e_shnum
;
7359 char * strtab
= NULL
;
7360 unsigned long int strtab_size
= 0;
7361 Elf_Internal_Sym
* symtab
;
7362 Elf_Internal_Sym
* psym
;
7364 if ( section
->sh_type
!= SHT_SYMTAB
7365 && section
->sh_type
!= SHT_DYNSYM
)
7368 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7369 SECTION_NAME (section
),
7370 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7372 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7374 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7376 symtab
= GET_ELF_SYMBOLS (file
, section
);
7380 if (section
->sh_link
== elf_header
.e_shstrndx
)
7382 strtab
= string_table
;
7383 strtab_size
= string_table_length
;
7385 else if (section
->sh_link
< elf_header
.e_shnum
)
7387 Elf_Internal_Shdr
* string_sec
;
7389 string_sec
= section_headers
+ section
->sh_link
;
7391 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7392 1, string_sec
->sh_size
, _("string table"));
7393 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7396 for (si
= 0, psym
= symtab
;
7397 si
< section
->sh_size
/ section
->sh_entsize
;
7400 printf ("%6d: ", si
);
7401 print_vma (psym
->st_value
, LONG_HEX
);
7403 print_vma (psym
->st_size
, DEC_5
);
7404 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7405 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7406 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7407 /* Check to see if any other bits in the st_other field are set.
7408 Note - displaying this information disrupts the layout of the
7409 table being generated, but for the moment this case is very rare. */
7410 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7411 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7412 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7413 print_symbol (25, psym
->st_name
< strtab_size
7414 ? strtab
+ psym
->st_name
: "<corrupt>");
7416 if (section
->sh_type
== SHT_DYNSYM
&&
7417 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7419 unsigned char data
[2];
7420 unsigned short vers_data
;
7421 unsigned long offset
;
7425 offset
= offset_from_vma
7426 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7427 sizeof data
+ si
* sizeof (vers_data
));
7429 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7430 sizeof (data
), 1, _("version data"));
7432 vers_data
= byte_get (data
, 2);
7434 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7435 && section_headers
[psym
->st_shndx
].sh_type
7438 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7440 if ((vers_data
& 0x8000) || vers_data
> 1)
7442 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7443 && (is_nobits
|| ! check_def
))
7445 Elf_External_Verneed evn
;
7446 Elf_Internal_Verneed ivn
;
7447 Elf_Internal_Vernaux ivna
;
7449 /* We must test both. */
7450 offset
= offset_from_vma
7451 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7456 unsigned long vna_off
;
7458 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7461 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7462 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7464 vna_off
= offset
+ ivn
.vn_aux
;
7468 Elf_External_Vernaux evna
;
7470 get_data (&evna
, file
, vna_off
,
7472 _("version need aux (3)"));
7474 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7475 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7476 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7478 vna_off
+= ivna
.vna_next
;
7480 while (ivna
.vna_other
!= vers_data
7481 && ivna
.vna_next
!= 0);
7483 if (ivna
.vna_other
== vers_data
)
7486 offset
+= ivn
.vn_next
;
7488 while (ivn
.vn_next
!= 0);
7490 if (ivna
.vna_other
== vers_data
)
7493 ivna
.vna_name
< strtab_size
7494 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7498 else if (! is_nobits
)
7499 error (_("bad dynamic symbol\n"));
7506 if (vers_data
!= 0x8001
7507 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7509 Elf_Internal_Verdef ivd
;
7510 Elf_Internal_Verdaux ivda
;
7511 Elf_External_Verdaux evda
;
7512 unsigned long offset
;
7514 offset
= offset_from_vma
7516 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7517 sizeof (Elf_External_Verdef
));
7521 Elf_External_Verdef evd
;
7523 get_data (&evd
, file
, offset
, sizeof (evd
),
7524 1, _("version def"));
7526 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7527 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7528 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7530 offset
+= ivd
.vd_next
;
7532 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7533 && ivd
.vd_next
!= 0);
7535 offset
-= ivd
.vd_next
;
7536 offset
+= ivd
.vd_aux
;
7538 get_data (&evda
, file
, offset
, sizeof (evda
),
7539 1, _("version def aux"));
7541 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7543 if (psym
->st_name
!= ivda
.vda_name
)
7544 printf ((vers_data
& 0x8000)
7546 ivda
.vda_name
< strtab_size
7547 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7557 if (strtab
!= string_table
)
7563 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7565 if (do_histogram
&& buckets
!= NULL
)
7567 unsigned long * lengths
;
7568 unsigned long * counts
;
7571 unsigned long maxlength
= 0;
7572 unsigned long nzero_counts
= 0;
7573 unsigned long nsyms
= 0;
7575 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7576 (unsigned long) nbuckets
);
7577 printf (_(" Length Number %% of total Coverage\n"));
7579 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7580 if (lengths
== NULL
)
7582 error (_("Out of memory\n"));
7585 for (hn
= 0; hn
< nbuckets
; ++hn
)
7587 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7590 if (maxlength
< ++lengths
[hn
])
7595 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7598 error (_("Out of memory\n"));
7602 for (hn
= 0; hn
< nbuckets
; ++hn
)
7603 ++counts
[lengths
[hn
]];
7608 printf (" 0 %-10lu (%5.1f%%)\n",
7609 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7610 for (i
= 1; i
<= maxlength
; ++i
)
7612 nzero_counts
+= counts
[i
] * i
;
7613 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7614 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7615 (nzero_counts
* 100.0) / nsyms
);
7623 if (buckets
!= NULL
)
7629 if (do_histogram
&& gnubuckets
!= NULL
)
7631 unsigned long * lengths
;
7632 unsigned long * counts
;
7634 unsigned long maxlength
= 0;
7635 unsigned long nzero_counts
= 0;
7636 unsigned long nsyms
= 0;
7638 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7639 if (lengths
== NULL
)
7641 error (_("Out of memory\n"));
7645 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7646 (unsigned long) ngnubuckets
);
7647 printf (_(" Length Number %% of total Coverage\n"));
7649 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7650 if (gnubuckets
[hn
] != 0)
7652 bfd_vma off
, length
= 1;
7654 for (off
= gnubuckets
[hn
] - gnusymidx
;
7655 (gnuchains
[off
] & 1) == 0; ++off
)
7657 lengths
[hn
] = length
;
7658 if (length
> maxlength
)
7663 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7666 error (_("Out of memory\n"));
7670 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7671 ++counts
[lengths
[hn
]];
7673 if (ngnubuckets
> 0)
7676 printf (" 0 %-10lu (%5.1f%%)\n",
7677 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7678 for (j
= 1; j
<= maxlength
; ++j
)
7680 nzero_counts
+= counts
[j
] * j
;
7681 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7682 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7683 (nzero_counts
* 100.0) / nsyms
);
7697 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7701 if (dynamic_syminfo
== NULL
7703 /* No syminfo, this is ok. */
7706 /* There better should be a dynamic symbol section. */
7707 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7711 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7712 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7714 printf (_(" Num: Name BoundTo Flags\n"));
7715 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7717 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7719 printf ("%4d: ", i
);
7720 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7721 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7723 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7726 switch (dynamic_syminfo
[i
].si_boundto
)
7728 case SYMINFO_BT_SELF
:
7729 fputs ("SELF ", stdout
);
7731 case SYMINFO_BT_PARENT
:
7732 fputs ("PARENT ", stdout
);
7735 if (dynamic_syminfo
[i
].si_boundto
> 0
7736 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7737 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7739 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7743 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7747 if (flags
& SYMINFO_FLG_DIRECT
)
7749 if (flags
& SYMINFO_FLG_PASSTHRU
)
7750 printf (" PASSTHRU");
7751 if (flags
& SYMINFO_FLG_COPY
)
7753 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7754 printf (" LAZYLOAD");
7762 #ifdef SUPPORT_DISASSEMBLY
7764 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
7766 printf (_("\nAssembly dump of section %s\n"),
7767 SECTION_NAME (section
));
7769 /* XXX -- to be done --- XXX */
7776 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
7778 Elf_Internal_Shdr
* relsec
;
7779 bfd_size_type num_bytes
;
7784 char * name
= SECTION_NAME (section
);
7785 bfd_boolean some_strings_shown
;
7787 num_bytes
= section
->sh_size
;
7789 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7791 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7795 addr
= section
->sh_addr
;
7797 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7802 printf (_("\nString dump of section '%s':\n"), name
);
7804 /* If the section being dumped has relocations against it the user might
7805 be expecting these relocations to have been applied. Check for this
7806 case and issue a warning message in order to avoid confusion.
7807 FIXME: Maybe we ought to have an option that dumps a section with
7809 for (relsec
= section_headers
;
7810 relsec
< section_headers
+ elf_header
.e_shnum
;
7813 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7814 || relsec
->sh_info
>= elf_header
.e_shnum
7815 || section_headers
+ relsec
->sh_info
!= section
7816 || relsec
->sh_size
== 0
7817 || relsec
->sh_link
>= elf_header
.e_shnum
)
7820 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7825 end
= start
+ num_bytes
;
7826 some_strings_shown
= FALSE
;
7830 while (!ISPRINT (* data
))
7837 printf (" [%6tx] %s\n", data
- start
, data
);
7839 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7841 data
+= strlen (data
);
7842 some_strings_shown
= TRUE
;
7846 if (! some_strings_shown
)
7847 printf (_(" No strings found in this section."));
7857 dump_section_as_bytes (Elf_Internal_Shdr
* section
, FILE * file
)
7859 Elf_Internal_Shdr
* relsec
;
7860 bfd_size_type bytes
;
7862 unsigned char * data
;
7863 unsigned char * start
;
7865 bytes
= section
->sh_size
;
7867 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7869 printf (_("\nSection '%s' has no data to dump.\n"),
7870 SECTION_NAME (section
));
7874 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7876 addr
= section
->sh_addr
;
7878 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7883 /* If the section being dumped has relocations against it the user might
7884 be expecting these relocations to have been applied. Check for this
7885 case and issue a warning message in order to avoid confusion.
7886 FIXME: Maybe we ought to have an option that dumps a section with
7888 for (relsec
= section_headers
;
7889 relsec
< section_headers
+ elf_header
.e_shnum
;
7892 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7893 || relsec
->sh_info
>= elf_header
.e_shnum
7894 || section_headers
+ relsec
->sh_info
!= section
7895 || relsec
->sh_size
== 0
7896 || relsec
->sh_link
>= elf_header
.e_shnum
)
7899 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7911 lbytes
= (bytes
> 16 ? 16 : bytes
);
7913 printf (" 0x%8.8lx ", (unsigned long) addr
);
7915 for (j
= 0; j
< 16; j
++)
7918 printf ("%2.2x", data
[j
]);
7926 for (j
= 0; j
< lbytes
; j
++)
7929 if (k
>= ' ' && k
< 0x7f)
7948 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7949 DWARF debug sections. This is a target specific test. Note - we do not
7950 go through the whole including-target-headers-multiple-times route, (as
7951 we have already done with <elf/h8.h>) because this would become very
7952 messy and even then this function would have to contain target specific
7953 information (the names of the relocs instead of their numeric values).
7954 FIXME: This is not the correct way to solve this problem. The proper way
7955 is to have target specific reloc sizing and typing functions created by
7956 the reloc-macros.h header, in the same way that it already creates the
7957 reloc naming functions. */
7960 is_32bit_abs_reloc (unsigned int reloc_type
)
7962 switch (elf_header
.e_machine
)
7966 return reloc_type
== 1; /* R_386_32. */
7968 return reloc_type
== 1; /* R_68K_32. */
7970 return reloc_type
== 1; /* R_860_32. */
7972 return reloc_type
== 1; /* XXX Is this right ? */
7974 return reloc_type
== 1; /* R_ARC_32. */
7976 return reloc_type
== 2; /* R_ARM_ABS32 */
7979 return reloc_type
== 1;
7981 return reloc_type
== 0x12; /* R_byte4_data. */
7983 return reloc_type
== 3; /* R_CRIS_32. */
7986 return reloc_type
== 3; /* R_CR16_NUM32. */
7988 return reloc_type
== 15; /* R_CRX_NUM32. */
7990 return reloc_type
== 1;
7991 case EM_CYGNUS_D10V
:
7993 return reloc_type
== 6; /* R_D10V_32. */
7994 case EM_CYGNUS_D30V
:
7996 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7998 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7999 case EM_CYGNUS_FR30
:
8001 return reloc_type
== 3; /* R_FR30_32. */
8005 return reloc_type
== 1; /* R_H8_DIR32. */
8007 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8010 return reloc_type
== 2; /* R_IP2K_32. */
8012 return reloc_type
== 2; /* R_IQ2000_32. */
8013 case EM_LATTICEMICO32
:
8014 return reloc_type
== 3; /* R_LM32_32. */
8017 return reloc_type
== 3; /* R_M32C_32. */
8019 return reloc_type
== 34; /* R_M32R_32_RELA. */
8021 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8023 return reloc_type
== 4; /* R_MEP_32. */
8025 return reloc_type
== 2; /* R_MIPS_32. */
8027 return reloc_type
== 4; /* R_MMIX_32. */
8028 case EM_CYGNUS_MN10200
:
8030 return reloc_type
== 1; /* R_MN10200_32. */
8031 case EM_CYGNUS_MN10300
:
8033 return reloc_type
== 1; /* R_MN10300_32. */
8036 return reloc_type
== 1; /* R_MSP43_32. */
8038 return reloc_type
== 2; /* R_MT_32. */
8039 case EM_ALTERA_NIOS2
:
8041 return reloc_type
== 1; /* R_NIOS_32. */
8044 return reloc_type
== 1; /* R_OR32_32. */
8046 return reloc_type
== 1; /* R_PARISC_DIR32. */
8049 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8051 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8053 return reloc_type
== 1; /* R_PPC_ADDR32. */
8055 return reloc_type
== 1; /* R_I370_ADDR31. */
8058 return reloc_type
== 4; /* R_S390_32. */
8060 return reloc_type
== 8; /* R_SCORE_ABS32. */
8062 return reloc_type
== 1; /* R_SH_DIR32. */
8063 case EM_SPARC32PLUS
:
8066 return reloc_type
== 3 /* R_SPARC_32. */
8067 || reloc_type
== 23; /* R_SPARC_UA32. */
8069 return reloc_type
== 6; /* R_SPU_ADDR32 */
8070 case EM_CYGNUS_V850
:
8072 return reloc_type
== 6; /* R_V850_ABS32. */
8074 return reloc_type
== 1; /* R_VAX_32. */
8076 return reloc_type
== 10; /* R_X86_64_32. */
8078 return reloc_type
== 1; /* R_XSTROMY16_32. */
8081 return reloc_type
== 1; /* R_XTENSA_32. */
8084 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8085 elf_header
.e_machine
);
8090 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8091 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8094 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8096 switch (elf_header
.e_machine
)
8100 return reloc_type
== 2; /* R_386_PC32. */
8102 return reloc_type
== 4; /* R_68K_PC32. */
8104 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8106 return reloc_type
== 3; /* R_ARM_REL32 */
8108 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8110 return reloc_type
== 26; /* R_PPC_REL32. */
8112 return reloc_type
== 26; /* R_PPC64_REL32. */
8115 return reloc_type
== 5; /* R_390_PC32. */
8117 return reloc_type
== 2; /* R_SH_REL32. */
8118 case EM_SPARC32PLUS
:
8121 return reloc_type
== 6; /* R_SPARC_DISP32. */
8123 return reloc_type
== 13; /* R_SPU_REL32. */
8125 return reloc_type
== 2; /* R_X86_64_PC32. */
8128 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8130 /* Do not abort or issue an error message here. Not all targets use
8131 pc-relative 32-bit relocs in their DWARF debug information and we
8132 have already tested for target coverage in is_32bit_abs_reloc. A
8133 more helpful warning message will be generated by
8134 debug_apply_relocations anyway, so just return. */
8139 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8140 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8143 is_64bit_abs_reloc (unsigned int reloc_type
)
8145 switch (elf_header
.e_machine
)
8148 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8150 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8152 return reloc_type
== 80; /* R_PARISC_DIR64. */
8154 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8155 case EM_SPARC32PLUS
:
8158 return reloc_type
== 54; /* R_SPARC_UA64. */
8160 return reloc_type
== 1; /* R_X86_64_64. */
8163 return reloc_type
== 22; /* R_S390_64 */
8165 return reloc_type
== 18; /* R_MIPS_64 */
8171 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8172 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8175 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8177 switch (elf_header
.e_machine
)
8180 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8182 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8184 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8186 return reloc_type
== 44; /* R_PPC64_REL64 */
8187 case EM_SPARC32PLUS
:
8190 return reloc_type
== 46; /* R_SPARC_DISP64 */
8192 return reloc_type
== 24; /* R_X86_64_PC64 */
8195 return reloc_type
== 23; /* R_S390_PC64 */
8201 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8202 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8205 is_16bit_abs_reloc (unsigned int reloc_type
)
8207 switch (elf_header
.e_machine
)
8211 return reloc_type
== 4; /* R_AVR_16. */
8212 case EM_CYGNUS_D10V
:
8214 return reloc_type
== 3; /* R_D10V_16. */
8218 return reloc_type
== R_H8_DIR16
;
8221 return reloc_type
== 1; /* R_IP2K_16. */
8224 return reloc_type
== 1; /* R_M32C_16 */
8227 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8228 case EM_ALTERA_NIOS2
:
8230 return reloc_type
== 9; /* R_NIOS_16. */
8236 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8237 relocation entries (possibly formerly used for SHT_GROUP sections). */
8240 is_none_reloc (unsigned int reloc_type
)
8242 switch (elf_header
.e_machine
)
8244 case EM_68K
: /* R_68K_NONE. */
8245 case EM_386
: /* R_386_NONE. */
8246 case EM_SPARC32PLUS
:
8248 case EM_SPARC
: /* R_SPARC_NONE. */
8249 case EM_MIPS
: /* R_MIPS_NONE. */
8250 case EM_PARISC
: /* R_PARISC_NONE. */
8251 case EM_ALPHA
: /* R_ALPHA_NONE. */
8252 case EM_PPC
: /* R_PPC_NONE. */
8253 case EM_PPC64
: /* R_PPC64_NONE. */
8254 case EM_ARM
: /* R_ARM_NONE. */
8255 case EM_IA_64
: /* R_IA64_NONE. */
8256 case EM_SH
: /* R_SH_NONE. */
8258 case EM_S390
: /* R_390_NONE. */
8259 case EM_CRIS
: /* R_CRIS_NONE. */
8260 case EM_X86_64
: /* R_X86_64_NONE. */
8261 case EM_MN10300
: /* R_MN10300_NONE. */
8262 case EM_M32R
: /* R_M32R_NONE. */
8263 return reloc_type
== 0;
8268 /* Uncompresses a section that was compressed using zlib, in place.
8269 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8272 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8275 /* These are just to quiet gcc. */
8280 dwarf_size_type compressed_size
= *size
;
8281 unsigned char * compressed_buffer
= *buffer
;
8282 dwarf_size_type uncompressed_size
;
8283 unsigned char * uncompressed_buffer
;
8286 dwarf_size_type header_size
= 12;
8288 /* Read the zlib header. In this case, it should be "ZLIB" followed
8289 by the uncompressed section size, 8 bytes in big-endian order. */
8290 if (compressed_size
< header_size
8291 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8294 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8295 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8296 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8297 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8298 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8299 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8300 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8301 uncompressed_size
+= compressed_buffer
[11];
8303 /* It is possible the section consists of several compressed
8304 buffers concatenated together, so we uncompress in a loop. */
8308 strm
.avail_in
= compressed_size
- header_size
;
8309 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8310 strm
.avail_out
= uncompressed_size
;
8311 uncompressed_buffer
= xmalloc (uncompressed_size
);
8313 rc
= inflateInit (& strm
);
8314 while (strm
.avail_in
> 0)
8318 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8319 + (uncompressed_size
- strm
.avail_out
));
8320 rc
= inflate (&strm
, Z_FINISH
);
8321 if (rc
!= Z_STREAM_END
)
8323 rc
= inflateReset (& strm
);
8325 rc
= inflateEnd (& strm
);
8327 || strm
.avail_out
!= 0)
8330 free (compressed_buffer
);
8331 *buffer
= uncompressed_buffer
;
8332 *size
= uncompressed_size
;
8336 free (uncompressed_buffer
);
8338 #endif /* HAVE_ZLIB_H */
8341 /* Check to see if the given reloc needs to be handled in a target specific
8342 manner. If so then process the reloc and return TRUE otherwise return
8346 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
8347 unsigned char * start
,
8348 Elf_Internal_Sym
* symtab
)
8350 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
8352 switch (elf_header
.e_machine
)
8355 case EM_CYGNUS_MN10300
:
8357 static Elf_Internal_Sym
* saved_sym
= NULL
;
8361 case 34: /* R_MN10300_ALIGN */
8363 case 33: /* R_MN10300_SYM_DIFF */
8364 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
8366 case 1: /* R_MN10300_32 */
8367 if (saved_sym
!= NULL
)
8371 value
= reloc
->r_addend
8372 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
8373 - saved_sym
->st_value
);
8375 byte_put (start
+ reloc
->r_offset
, value
, 4);
8389 /* Apply relocations to a debug section. */
8392 debug_apply_relocations (void * file
,
8393 Elf_Internal_Shdr
* section
,
8394 unsigned char * start
)
8396 Elf_Internal_Shdr
* relsec
;
8397 unsigned char * end
= start
+ section
->sh_size
;
8399 if (elf_header
.e_type
!= ET_REL
)
8402 /* Find the reloc section associated with the debug section. */
8403 for (relsec
= section_headers
;
8404 relsec
< section_headers
+ elf_header
.e_shnum
;
8407 bfd_boolean is_rela
;
8408 unsigned long num_relocs
;
8409 Elf_Internal_Rela
* relocs
;
8410 Elf_Internal_Rela
* rp
;
8411 Elf_Internal_Shdr
* symsec
;
8412 Elf_Internal_Sym
* symtab
;
8413 Elf_Internal_Sym
* sym
;
8415 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8416 || relsec
->sh_info
>= elf_header
.e_shnum
8417 || section_headers
+ relsec
->sh_info
!= section
8418 || relsec
->sh_size
== 0
8419 || relsec
->sh_link
>= elf_header
.e_shnum
)
8422 is_rela
= relsec
->sh_type
== SHT_RELA
;
8426 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8427 & relocs
, & num_relocs
))
8432 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8433 & relocs
, & num_relocs
))
8437 /* SH uses RELA but uses in place value instead of the addend field. */
8438 if (elf_header
.e_machine
== EM_SH
)
8441 symsec
= section_headers
+ relsec
->sh_link
;
8442 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8444 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8447 unsigned int reloc_type
;
8448 unsigned int reloc_size
;
8449 unsigned char * loc
;
8451 reloc_type
= get_reloc_type (rp
->r_info
);
8453 if (target_specific_reloc_handling (rp
, start
, symtab
))
8455 else if (is_none_reloc (reloc_type
))
8457 else if (is_32bit_abs_reloc (reloc_type
)
8458 || is_32bit_pcrel_reloc (reloc_type
))
8460 else if (is_64bit_abs_reloc (reloc_type
)
8461 || is_64bit_pcrel_reloc (reloc_type
))
8463 else if (is_16bit_abs_reloc (reloc_type
))
8467 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8468 reloc_type
, SECTION_NAME (section
));
8472 loc
= start
+ rp
->r_offset
;
8473 if ((loc
+ reloc_size
) > end
)
8475 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8476 (unsigned long) rp
->r_offset
,
8477 SECTION_NAME (section
));
8481 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8483 /* If the reloc has a symbol associated with it,
8484 make sure that it is of an appropriate type.
8486 Relocations against symbols without type can happen.
8487 Gcc -feliminate-dwarf2-dups may generate symbols
8488 without type for debug info.
8490 Icc generates relocations against function symbols
8491 instead of local labels.
8493 Relocations against object symbols can happen, eg when
8494 referencing a global array. For an example of this see
8495 the _clz.o binary in libgcc.a. */
8497 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8499 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8500 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8501 (long int)(rp
- relocs
),
8502 SECTION_NAME (relsec
));
8506 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8508 if (is_32bit_pcrel_reloc (reloc_type
)
8509 || is_64bit_pcrel_reloc (reloc_type
))
8511 /* On HPPA, all pc-relative relocations are biased by 8. */
8512 if (elf_header
.e_machine
== EM_PARISC
)
8514 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8518 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8528 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8529 Elf_Internal_Shdr
* sec
, void * file
)
8531 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8533 int section_is_compressed
;
8535 /* If it is already loaded, do nothing. */
8536 if (section
->start
!= NULL
)
8539 section_is_compressed
= section
->name
== section
->compressed_name
;
8541 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8542 section
->address
= sec
->sh_addr
;
8543 section
->size
= sec
->sh_size
;
8544 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8546 if (section
->start
== NULL
)
8549 if (section_is_compressed
)
8550 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8553 if (debug_displays
[debug
].relocate
)
8554 debug_apply_relocations (file
, sec
, section
->start
);
8560 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8562 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8563 Elf_Internal_Shdr
* sec
;
8565 /* Locate the debug section. */
8566 sec
= find_section (section
->uncompressed_name
);
8568 section
->name
= section
->uncompressed_name
;
8571 sec
= find_section (section
->compressed_name
);
8573 section
->name
= section
->compressed_name
;
8578 return load_specific_debug_section (debug
, sec
, file
);
8582 free_debug_section (enum dwarf_section_display_enum debug
)
8584 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8586 if (section
->start
== NULL
)
8589 free ((char *) section
->start
);
8590 section
->start
= NULL
;
8591 section
->address
= 0;
8596 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8598 char * name
= SECTION_NAME (section
);
8599 bfd_size_type length
;
8601 enum dwarf_section_display_enum i
;
8603 length
= section
->sh_size
;
8606 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8609 if (section
->sh_type
== SHT_NOBITS
)
8611 /* There is no point in dumping the contents of a debugging section
8612 which has the NOBITS type - the bits in the file will be random.
8613 This can happen when a file containing a .eh_frame section is
8614 stripped with the --only-keep-debug command line option. */
8615 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8619 if (const_strneq (name
, ".gnu.linkonce.wi."))
8620 name
= ".debug_info";
8622 /* See if we know how to display the contents of this section. */
8623 for (i
= 0; i
< max
; i
++)
8624 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8625 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8627 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8628 int secondary
= (section
!= find_section (name
));
8631 free_debug_section (i
);
8633 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8634 sec
->name
= sec
->uncompressed_name
;
8636 sec
->name
= sec
->compressed_name
;
8637 if (load_specific_debug_section (i
, section
, file
))
8639 result
&= debug_displays
[i
].display (sec
, file
);
8641 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8642 free_debug_section (i
);
8650 printf (_("Unrecognized debug section: %s\n"), name
);
8657 /* Set DUMP_SECTS for all sections where dumps were requested
8658 based on section name. */
8661 initialise_dumps_byname (void)
8663 struct dump_list_entry
* cur
;
8665 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8670 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8671 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8673 request_dump_bynumber (i
, cur
->type
);
8678 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8684 process_section_contents (FILE * file
)
8686 Elf_Internal_Shdr
* section
;
8692 initialise_dumps_byname ();
8694 for (i
= 0, section
= section_headers
;
8695 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8698 #ifdef SUPPORT_DISASSEMBLY
8699 if (dump_sects
[i
] & DISASS_DUMP
)
8700 disassemble_section (section
, file
);
8702 if (dump_sects
[i
] & HEX_DUMP
)
8703 dump_section_as_bytes (section
, file
);
8705 if (dump_sects
[i
] & DEBUG_DUMP
)
8706 display_debug_section (section
, file
);
8708 if (dump_sects
[i
] & STRING_DUMP
)
8709 dump_section_as_strings (section
, file
);
8712 /* Check to see if the user requested a
8713 dump of a section that does not exist. */
8714 while (i
++ < num_dump_sects
)
8716 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8720 process_mips_fpe_exception (int mask
)
8725 if (mask
& OEX_FPU_INEX
)
8726 fputs ("INEX", stdout
), first
= 0;
8727 if (mask
& OEX_FPU_UFLO
)
8728 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8729 if (mask
& OEX_FPU_OFLO
)
8730 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8731 if (mask
& OEX_FPU_DIV0
)
8732 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8733 if (mask
& OEX_FPU_INVAL
)
8734 printf ("%sINVAL", first
? "" : "|");
8737 fputs ("0", stdout
);
8740 /* ARM EABI attributes section. */
8745 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8747 const char ** table
;
8748 } arm_attr_public_tag
;
8750 static const char * arm_attr_tag_CPU_arch
[] =
8751 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8752 "v6K", "v7", "v6-M", "v6S-M"};
8753 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8754 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8755 {"No", "Thumb-1", "Thumb-2"};
8756 static const char * arm_attr_tag_VFP_arch
[] =
8757 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8758 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8759 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8760 static const char * arm_attr_tag_PCS_config
[] =
8761 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8762 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8763 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8764 {"V6", "SB", "TLS", "Unused"};
8765 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8766 {"Absolute", "PC-relative", "SB-relative", "None"};
8767 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8768 {"Absolute", "PC-relative", "None"};
8769 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8770 {"None", "direct", "GOT-indirect"};
8771 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8772 {"None", "??? 1", "2", "??? 3", "4"};
8773 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8774 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8775 {"Unused", "Needed", "Sign only"};
8776 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8777 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8778 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8779 {"Unused", "Finite", "RTABI", "IEEE 754"};
8780 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8781 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8782 {"No", "Yes, except leaf SP", "Yes"};
8783 static const char * arm_attr_tag_ABI_enum_size
[] =
8784 {"Unused", "small", "int", "forced to int"};
8785 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8786 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8787 static const char * arm_attr_tag_ABI_VFP_args
[] =
8788 {"AAPCS", "VFP registers", "custom"};
8789 static const char * arm_attr_tag_ABI_WMMX_args
[] =
8790 {"AAPCS", "WMMX registers", "custom"};
8791 static const char * arm_attr_tag_ABI_optimization_goals
[] =
8792 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8793 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8794 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
8795 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8796 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8797 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8798 static const char * arm_attr_tag_VFP_HP_extension
[] =
8799 {"Not Allowed", "Allowed"};
8800 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
8801 {"None", "IEEE 754", "Alternative Format"};
8802 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8803 static const char * arm_attr_tag_Virtualization_use
[] =
8804 {"Not Allowed", "Allowed"};
8805 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8807 #define LOOKUP(id, name) \
8808 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8809 static arm_attr_public_tag arm_attr_public_tags
[] =
8811 {4, "CPU_raw_name", 1, NULL
},
8812 {5, "CPU_name", 1, NULL
},
8813 LOOKUP(6, CPU_arch
),
8814 {7, "CPU_arch_profile", 0, NULL
},
8815 LOOKUP(8, ARM_ISA_use
),
8816 LOOKUP(9, THUMB_ISA_use
),
8817 LOOKUP(10, VFP_arch
),
8818 LOOKUP(11, WMMX_arch
),
8819 LOOKUP(12, Advanced_SIMD_arch
),
8820 LOOKUP(13, PCS_config
),
8821 LOOKUP(14, ABI_PCS_R9_use
),
8822 LOOKUP(15, ABI_PCS_RW_data
),
8823 LOOKUP(16, ABI_PCS_RO_data
),
8824 LOOKUP(17, ABI_PCS_GOT_use
),
8825 LOOKUP(18, ABI_PCS_wchar_t
),
8826 LOOKUP(19, ABI_FP_rounding
),
8827 LOOKUP(20, ABI_FP_denormal
),
8828 LOOKUP(21, ABI_FP_exceptions
),
8829 LOOKUP(22, ABI_FP_user_exceptions
),
8830 LOOKUP(23, ABI_FP_number_model
),
8831 LOOKUP(24, ABI_align8_needed
),
8832 LOOKUP(25, ABI_align8_preserved
),
8833 LOOKUP(26, ABI_enum_size
),
8834 LOOKUP(27, ABI_HardFP_use
),
8835 LOOKUP(28, ABI_VFP_args
),
8836 LOOKUP(29, ABI_WMMX_args
),
8837 LOOKUP(30, ABI_optimization_goals
),
8838 LOOKUP(31, ABI_FP_optimization_goals
),
8839 {32, "compatibility", 0, NULL
},
8840 LOOKUP(34, CPU_unaligned_access
),
8841 LOOKUP(36, VFP_HP_extension
),
8842 LOOKUP(38, ABI_FP_16bit_format
),
8843 {64, "nodefaults", 0, NULL
},
8844 {65, "also_compatible_with", 0, NULL
},
8845 LOOKUP(66, T2EE_use
),
8846 {67, "conformance", 1, NULL
},
8847 LOOKUP(68, Virtualization_use
),
8848 LOOKUP(70, MPextension_use
)
8852 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8856 read_uleb128 (unsigned char * p
, unsigned int * plen
)
8870 val
|= ((unsigned int)c
& 0x7f) << shift
;
8879 static unsigned char *
8880 display_arm_attribute (unsigned char * p
)
8885 arm_attr_public_tag
* attr
;
8889 tag
= read_uleb128 (p
, &len
);
8892 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
8894 if (arm_attr_public_tags
[i
].tag
== tag
)
8896 attr
= &arm_attr_public_tags
[i
];
8903 printf (" Tag_%s: ", attr
->name
);
8909 case 7: /* Tag_CPU_arch_profile. */
8910 val
= read_uleb128 (p
, &len
);
8914 case 0: printf ("None\n"); break;
8915 case 'A': printf ("Application\n"); break;
8916 case 'R': printf ("Realtime\n"); break;
8917 case 'M': printf ("Microcontroller\n"); break;
8918 default: printf ("??? (%d)\n", val
); break;
8922 case 32: /* Tag_compatibility. */
8923 val
= read_uleb128 (p
, &len
);
8925 printf ("flag = %d, vendor = %s\n", val
, p
);
8926 p
+= strlen ((char *) p
) + 1;
8929 case 64: /* Tag_nodefaults. */
8934 case 65: /* Tag_also_compatible_with. */
8935 val
= read_uleb128 (p
, &len
);
8937 if (val
== 6 /* Tag_CPU_arch. */)
8939 val
= read_uleb128 (p
, &len
);
8941 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
8942 printf ("??? (%d)\n", val
);
8944 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
8948 while (*(p
++) != '\0' /* NUL terminator. */);
8962 assert (attr
->type
& 0x80);
8963 val
= read_uleb128 (p
, &len
);
8965 type
= attr
->type
& 0x7f;
8967 printf ("??? (%d)\n", val
);
8969 printf ("%s\n", attr
->table
[val
]);
8976 type
= 1; /* String. */
8978 type
= 2; /* uleb128. */
8979 printf (" Tag_unknown_%d: ", tag
);
8984 printf ("\"%s\"\n", p
);
8985 p
+= strlen ((char *) p
) + 1;
8989 val
= read_uleb128 (p
, &len
);
8991 printf ("%d (0x%x)\n", val
, val
);
8997 static unsigned char *
8998 display_gnu_attribute (unsigned char * p
,
8999 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9006 tag
= read_uleb128 (p
, &len
);
9009 /* Tag_compatibility is the only generic GNU attribute defined at
9013 val
= read_uleb128 (p
, &len
);
9015 printf ("flag = %d, vendor = %s\n", val
, p
);
9016 p
+= strlen ((char *) p
) + 1;
9020 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9021 return display_proc_gnu_attribute (p
, tag
);
9024 type
= 1; /* String. */
9026 type
= 2; /* uleb128. */
9027 printf (" Tag_unknown_%d: ", tag
);
9031 printf ("\"%s\"\n", p
);
9032 p
+= strlen ((char *) p
) + 1;
9036 val
= read_uleb128 (p
, &len
);
9038 printf ("%d (0x%x)\n", val
, val
);
9044 static unsigned char *
9045 display_power_gnu_attribute (unsigned char * p
, int tag
)
9051 if (tag
== Tag_GNU_Power_ABI_FP
)
9053 val
= read_uleb128 (p
, &len
);
9055 printf (" Tag_GNU_Power_ABI_FP: ");
9060 printf ("Hard or soft float\n");
9063 printf ("Hard float\n");
9066 printf ("Soft float\n");
9069 printf ("Single-precision hard float\n");
9072 printf ("??? (%d)\n", val
);
9078 if (tag
== Tag_GNU_Power_ABI_Vector
)
9080 val
= read_uleb128 (p
, &len
);
9082 printf (" Tag_GNU_Power_ABI_Vector: ");
9089 printf ("Generic\n");
9092 printf ("AltiVec\n");
9098 printf ("??? (%d)\n", val
);
9104 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9106 val
= read_uleb128 (p
, &len
);
9108 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9118 printf ("Memory\n");
9121 printf ("??? (%d)\n", val
);
9128 type
= 1; /* String. */
9130 type
= 2; /* uleb128. */
9131 printf (" Tag_unknown_%d: ", tag
);
9135 printf ("\"%s\"\n", p
);
9136 p
+= strlen ((char *) p
) + 1;
9140 val
= read_uleb128 (p
, &len
);
9142 printf ("%d (0x%x)\n", val
, val
);
9148 static unsigned char *
9149 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9155 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9157 val
= read_uleb128 (p
, &len
);
9159 printf (" Tag_GNU_MIPS_ABI_FP: ");
9164 printf ("Hard or soft float\n");
9167 printf ("Hard float (-mdouble-float)\n");
9170 printf ("Hard float (-msingle-float)\n");
9173 printf ("Soft float\n");
9176 printf ("64-bit float (-mips32r2 -mfp64)\n");
9179 printf ("??? (%d)\n", val
);
9186 type
= 1; /* String. */
9188 type
= 2; /* uleb128. */
9189 printf (" Tag_unknown_%d: ", tag
);
9193 printf ("\"%s\"\n", p
);
9194 p
+= strlen ((char *) p
) + 1;
9198 val
= read_uleb128 (p
, &len
);
9200 printf ("%d (0x%x)\n", val
, val
);
9207 process_attributes (FILE * file
,
9208 const char * public_name
,
9209 unsigned int proc_type
,
9210 unsigned char * (* display_pub_attribute
) (unsigned char *),
9211 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9213 Elf_Internal_Shdr
* sect
;
9214 unsigned char * contents
;
9216 unsigned char * end
;
9217 bfd_vma section_len
;
9221 /* Find the section header so that we get the size. */
9222 for (i
= 0, sect
= section_headers
;
9223 i
< elf_header
.e_shnum
;
9226 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9229 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9231 if (contents
== NULL
)
9237 len
= sect
->sh_size
- 1;
9243 bfd_boolean public_section
;
9244 bfd_boolean gnu_section
;
9246 section_len
= byte_get (p
, 4);
9249 if (section_len
> len
)
9251 printf (_("ERROR: Bad section length (%d > %d)\n"),
9252 (int) section_len
, (int) len
);
9257 printf ("Attribute Section: %s\n", p
);
9259 if (public_name
&& streq ((char *) p
, public_name
))
9260 public_section
= TRUE
;
9262 public_section
= FALSE
;
9264 if (streq ((char *) p
, "gnu"))
9267 gnu_section
= FALSE
;
9269 namelen
= strlen ((char *) p
) + 1;
9271 section_len
-= namelen
+ 4;
9273 while (section_len
> 0)
9279 size
= byte_get (p
, 4);
9280 if (size
> section_len
)
9282 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9283 (int) size
, (int) section_len
);
9287 section_len
-= size
;
9294 printf ("File Attributes\n");
9297 printf ("Section Attributes:");
9300 printf ("Symbol Attributes:");
9306 val
= read_uleb128 (p
, &i
);
9310 printf (" %d", val
);
9315 printf ("Unknown tag: %d\n", tag
);
9316 public_section
= FALSE
;
9323 p
= display_pub_attribute (p
);
9325 else if (gnu_section
)
9328 p
= display_gnu_attribute (p
,
9329 display_proc_gnu_attribute
);
9333 /* ??? Do something sensible, like dump hex. */
9334 printf (" Unknown section contexts\n");
9341 printf (_("Unknown format '%c'\n"), *p
);
9349 process_arm_specific (FILE * file
)
9351 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9352 display_arm_attribute
, NULL
);
9356 process_power_specific (FILE * file
)
9358 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9359 display_power_gnu_attribute
);
9362 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9363 Print the Address, Access and Initial fields of an entry at VMA ADDR
9364 and return the VMA of the next entry. */
9367 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9370 print_vma (addr
, LONG_HEX
);
9372 if (addr
< pltgot
+ 0xfff0)
9373 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9375 printf ("%10s", "");
9378 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9383 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9384 print_vma (entry
, LONG_HEX
);
9386 return addr
+ (is_32bit_elf
? 4 : 8);
9389 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9390 PLTGOT. Print the Address and Initial fields of an entry at VMA
9391 ADDR and return the VMA of the next entry. */
9394 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9397 print_vma (addr
, LONG_HEX
);
9400 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9405 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9406 print_vma (entry
, LONG_HEX
);
9408 return addr
+ (is_32bit_elf
? 4 : 8);
9412 process_mips_specific (FILE * file
)
9414 Elf_Internal_Dyn
* entry
;
9415 size_t liblist_offset
= 0;
9416 size_t liblistno
= 0;
9417 size_t conflictsno
= 0;
9418 size_t options_offset
= 0;
9419 size_t conflicts_offset
= 0;
9420 size_t pltrelsz
= 0;
9423 bfd_vma mips_pltgot
= 0;
9425 bfd_vma local_gotno
= 0;
9427 bfd_vma symtabno
= 0;
9429 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9430 display_mips_gnu_attribute
);
9432 /* We have a lot of special sections. Thanks SGI! */
9433 if (dynamic_section
== NULL
)
9434 /* No information available. */
9437 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9438 switch (entry
->d_tag
)
9440 case DT_MIPS_LIBLIST
:
9442 = offset_from_vma (file
, entry
->d_un
.d_val
,
9443 liblistno
* sizeof (Elf32_External_Lib
));
9445 case DT_MIPS_LIBLISTNO
:
9446 liblistno
= entry
->d_un
.d_val
;
9448 case DT_MIPS_OPTIONS
:
9449 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9451 case DT_MIPS_CONFLICT
:
9453 = offset_from_vma (file
, entry
->d_un
.d_val
,
9454 conflictsno
* sizeof (Elf32_External_Conflict
));
9456 case DT_MIPS_CONFLICTNO
:
9457 conflictsno
= entry
->d_un
.d_val
;
9460 pltgot
= entry
->d_un
.d_ptr
;
9462 case DT_MIPS_LOCAL_GOTNO
:
9463 local_gotno
= entry
->d_un
.d_val
;
9465 case DT_MIPS_GOTSYM
:
9466 gotsym
= entry
->d_un
.d_val
;
9468 case DT_MIPS_SYMTABNO
:
9469 symtabno
= entry
->d_un
.d_val
;
9471 case DT_MIPS_PLTGOT
:
9472 mips_pltgot
= entry
->d_un
.d_ptr
;
9475 pltrel
= entry
->d_un
.d_val
;
9478 pltrelsz
= entry
->d_un
.d_val
;
9481 jmprel
= entry
->d_un
.d_ptr
;
9487 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9489 Elf32_External_Lib
* elib
;
9492 elib
= get_data (NULL
, file
, liblist_offset
,
9493 liblistno
, sizeof (Elf32_External_Lib
),
9497 printf ("\nSection '.liblist' contains %lu entries:\n",
9498 (unsigned long) liblistno
);
9499 fputs (" Library Time Stamp Checksum Version Flags\n",
9502 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9509 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9510 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9511 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9512 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9513 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9515 tmp
= gmtime (&time
);
9516 snprintf (timebuf
, sizeof (timebuf
),
9517 "%04u-%02u-%02uT%02u:%02u:%02u",
9518 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9519 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9521 printf ("%3lu: ", (unsigned long) cnt
);
9522 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9523 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9525 printf ("<corrupt: %9ld>", liblist
.l_name
);
9526 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9529 if (liblist
.l_flags
== 0)
9540 { " EXACT_MATCH", LL_EXACT_MATCH
},
9541 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9542 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9543 { " EXPORTS", LL_EXPORTS
},
9544 { " DELAY_LOAD", LL_DELAY_LOAD
},
9545 { " DELTA", LL_DELTA
}
9547 int flags
= liblist
.l_flags
;
9550 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9551 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9553 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9554 flags
^= l_flags_vals
[fcnt
].bit
;
9557 printf (" %#x", (unsigned int) flags
);
9567 if (options_offset
!= 0)
9569 Elf_External_Options
* eopt
;
9570 Elf_Internal_Shdr
* sect
= section_headers
;
9571 Elf_Internal_Options
* iopt
;
9572 Elf_Internal_Options
* option
;
9576 /* Find the section header so that we get the size. */
9577 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9580 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9584 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9587 error (_("Out of memory\n"));
9594 while (offset
< sect
->sh_size
)
9596 Elf_External_Options
* eoption
;
9598 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9600 option
->kind
= BYTE_GET (eoption
->kind
);
9601 option
->size
= BYTE_GET (eoption
->size
);
9602 option
->section
= BYTE_GET (eoption
->section
);
9603 option
->info
= BYTE_GET (eoption
->info
);
9605 offset
+= option
->size
;
9611 printf (_("\nSection '%s' contains %d entries:\n"),
9612 SECTION_NAME (sect
), cnt
);
9620 switch (option
->kind
)
9623 /* This shouldn't happen. */
9624 printf (" NULL %d %lx", option
->section
, option
->info
);
9627 printf (" REGINFO ");
9628 if (elf_header
.e_machine
== EM_MIPS
)
9631 Elf32_External_RegInfo
* ereg
;
9632 Elf32_RegInfo reginfo
;
9634 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9635 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9636 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9637 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9638 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9639 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9640 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9642 printf ("GPR %08lx GP 0x%lx\n",
9644 (unsigned long) reginfo
.ri_gp_value
);
9645 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9646 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9647 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9652 Elf64_External_RegInfo
* ereg
;
9653 Elf64_Internal_RegInfo reginfo
;
9655 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9656 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9657 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9658 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9659 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9660 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9661 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9663 printf ("GPR %08lx GP 0x",
9664 reginfo
.ri_gprmask
);
9665 printf_vma (reginfo
.ri_gp_value
);
9668 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9669 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9670 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9674 case ODK_EXCEPTIONS
:
9675 fputs (" EXCEPTIONS fpe_min(", stdout
);
9676 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9677 fputs (") fpe_max(", stdout
);
9678 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9679 fputs (")", stdout
);
9681 if (option
->info
& OEX_PAGE0
)
9682 fputs (" PAGE0", stdout
);
9683 if (option
->info
& OEX_SMM
)
9684 fputs (" SMM", stdout
);
9685 if (option
->info
& OEX_FPDBUG
)
9686 fputs (" FPDBUG", stdout
);
9687 if (option
->info
& OEX_DISMISS
)
9688 fputs (" DISMISS", stdout
);
9691 fputs (" PAD ", stdout
);
9692 if (option
->info
& OPAD_PREFIX
)
9693 fputs (" PREFIX", stdout
);
9694 if (option
->info
& OPAD_POSTFIX
)
9695 fputs (" POSTFIX", stdout
);
9696 if (option
->info
& OPAD_SYMBOL
)
9697 fputs (" SYMBOL", stdout
);
9700 fputs (" HWPATCH ", stdout
);
9701 if (option
->info
& OHW_R4KEOP
)
9702 fputs (" R4KEOP", stdout
);
9703 if (option
->info
& OHW_R8KPFETCH
)
9704 fputs (" R8KPFETCH", stdout
);
9705 if (option
->info
& OHW_R5KEOP
)
9706 fputs (" R5KEOP", stdout
);
9707 if (option
->info
& OHW_R5KCVTL
)
9708 fputs (" R5KCVTL", stdout
);
9711 fputs (" FILL ", stdout
);
9712 /* XXX Print content of info word? */
9715 fputs (" TAGS ", stdout
);
9716 /* XXX Print content of info word? */
9719 fputs (" HWAND ", stdout
);
9720 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9721 fputs (" R4KEOP_CHECKED", stdout
);
9722 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9723 fputs (" R4KEOP_CLEAN", stdout
);
9726 fputs (" HWOR ", stdout
);
9727 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9728 fputs (" R4KEOP_CHECKED", stdout
);
9729 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9730 fputs (" R4KEOP_CLEAN", stdout
);
9733 printf (" GP_GROUP %#06lx self-contained %#06lx",
9734 option
->info
& OGP_GROUP
,
9735 (option
->info
& OGP_SELF
) >> 16);
9738 printf (" IDENT %#06lx self-contained %#06lx",
9739 option
->info
& OGP_GROUP
,
9740 (option
->info
& OGP_SELF
) >> 16);
9743 /* This shouldn't happen. */
9744 printf (" %3d ??? %d %lx",
9745 option
->kind
, option
->section
, option
->info
);
9749 len
= sizeof (* eopt
);
9750 while (len
< option
->size
)
9751 if (((char *) option
)[len
] >= ' '
9752 && ((char *) option
)[len
] < 0x7f)
9753 printf ("%c", ((char *) option
)[len
++]);
9755 printf ("\\%03o", ((char *) option
)[len
++]);
9757 fputs ("\n", stdout
);
9765 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9767 Elf32_Conflict
* iconf
;
9770 if (dynamic_symbols
== NULL
)
9772 error (_("conflict list found without a dynamic symbol table\n"));
9776 iconf
= cmalloc (conflictsno
, sizeof (* iconf
));
9779 error (_("Out of memory\n"));
9785 Elf32_External_Conflict
* econf32
;
9787 econf32
= get_data (NULL
, file
, conflicts_offset
,
9788 conflictsno
, sizeof (* econf32
), _("conflict"));
9792 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9793 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9799 Elf64_External_Conflict
* econf64
;
9801 econf64
= get_data (NULL
, file
, conflicts_offset
,
9802 conflictsno
, sizeof (* econf64
), _("conflict"));
9806 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9807 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9812 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9813 (unsigned long) conflictsno
);
9814 puts (_(" Num: Index Value Name"));
9816 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9818 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9820 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9821 print_vma (psym
->st_value
, FULL_HEX
);
9823 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9824 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9826 printf ("<corrupt: %14ld>", psym
->st_name
);
9833 if (pltgot
!= 0 && local_gotno
!= 0)
9835 bfd_vma entry
, local_end
, global_end
;
9837 unsigned char * data
;
9841 addr_size
= (is_32bit_elf
? 4 : 8);
9842 local_end
= pltgot
+ local_gotno
* addr_size
;
9843 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9845 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9846 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9847 printf (_("\nPrimary GOT:\n"));
9848 printf (_(" Canonical gp value: "));
9849 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9852 printf (_(" Reserved entries:\n"));
9853 printf (_(" %*s %10s %*s Purpose\n"),
9854 addr_size
* 2, "Address", "Access",
9855 addr_size
* 2, "Initial");
9856 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9857 printf (" Lazy resolver\n");
9859 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9860 >> (addr_size
* 8 - 1)) != 0)
9862 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9863 printf (" Module pointer (GNU extension)\n");
9867 if (entry
< local_end
)
9869 printf (_(" Local entries:\n"));
9870 printf (_(" %*s %10s %*s\n"),
9871 addr_size
* 2, "Address", "Access",
9872 addr_size
* 2, "Initial");
9873 while (entry
< local_end
)
9875 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9881 if (gotsym
< symtabno
)
9885 printf (_(" Global entries:\n"));
9886 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9887 addr_size
* 2, "Address", "Access",
9888 addr_size
* 2, "Initial",
9889 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9890 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9891 for (i
= gotsym
; i
< symtabno
; i
++)
9893 Elf_Internal_Sym
* psym
;
9895 psym
= dynamic_symbols
+ i
;
9896 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9898 print_vma (psym
->st_value
, LONG_HEX
);
9899 printf (" %-7s %3s ",
9900 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9901 get_symbol_index_type (psym
->st_shndx
));
9902 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9903 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9905 printf ("<corrupt: %14ld>", psym
->st_name
);
9915 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9918 size_t offset
, rel_offset
;
9919 unsigned long count
, i
;
9920 unsigned char * data
;
9921 int addr_size
, sym_width
;
9922 Elf_Internal_Rela
* rels
;
9924 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9925 if (pltrel
== DT_RELA
)
9927 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9932 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9936 entry
= mips_pltgot
;
9937 addr_size
= (is_32bit_elf
? 4 : 8);
9938 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9940 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9941 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9942 printf (_("\nPLT GOT:\n\n"));
9943 printf (_(" Reserved entries:\n"));
9944 printf (_(" %*s %*s Purpose\n"),
9945 addr_size
* 2, "Address", addr_size
* 2, "Initial");
9946 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9947 printf (" PLT lazy resolver\n");
9948 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9949 printf (" Module pointer\n");
9952 printf (_(" Entries:\n"));
9953 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9954 addr_size
* 2, "Address",
9955 addr_size
* 2, "Initial",
9956 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9957 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
9958 for (i
= 0; i
< count
; i
++)
9960 Elf_Internal_Sym
* psym
;
9962 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
9963 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9965 print_vma (psym
->st_value
, LONG_HEX
);
9966 printf (" %-7s %3s ",
9967 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9968 get_symbol_index_type (psym
->st_shndx
));
9969 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9970 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9972 printf ("<corrupt: %14ld>", psym
->st_name
);
9986 process_gnu_liblist (FILE * file
)
9988 Elf_Internal_Shdr
* section
;
9989 Elf_Internal_Shdr
* string_sec
;
9990 Elf32_External_Lib
* elib
;
9999 for (i
= 0, section
= section_headers
;
10000 i
< elf_header
.e_shnum
;
10003 switch (section
->sh_type
)
10005 case SHT_GNU_LIBLIST
:
10006 if (section
->sh_link
>= elf_header
.e_shnum
)
10009 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10014 string_sec
= section_headers
+ section
->sh_link
;
10016 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10017 string_sec
->sh_size
, _("liblist string table"));
10018 strtab_size
= string_sec
->sh_size
;
10021 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10027 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10028 SECTION_NAME (section
),
10029 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10031 puts (" Library Time Stamp Checksum Version Flags");
10033 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10041 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10042 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10043 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10044 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10045 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10047 tmp
= gmtime (&time
);
10048 snprintf (timebuf
, sizeof (timebuf
),
10049 "%04u-%02u-%02uT%02u:%02u:%02u",
10050 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10051 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10053 printf ("%3lu: ", (unsigned long) cnt
);
10055 printf ("%-20s", liblist
.l_name
< strtab_size
10056 ? strtab
+ liblist
.l_name
: "<corrupt>");
10058 printf ("%-20.20s", liblist
.l_name
< strtab_size
10059 ? strtab
+ liblist
.l_name
: "<corrupt>");
10060 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10061 liblist
.l_version
, liblist
.l_flags
);
10071 static const char *
10072 get_note_type (unsigned e_type
)
10074 static char buff
[64];
10076 if (elf_header
.e_type
== ET_CORE
)
10080 return _("NT_AUXV (auxiliary vector)");
10082 return _("NT_PRSTATUS (prstatus structure)");
10084 return _("NT_FPREGSET (floating point registers)");
10086 return _("NT_PRPSINFO (prpsinfo structure)");
10087 case NT_TASKSTRUCT
:
10088 return _("NT_TASKSTRUCT (task structure)");
10090 return _("NT_PRXFPREG (user_xfpregs structure)");
10092 return _("NT_PPC_VMX (ppc Altivec registers)");
10094 return _("NT_PPC_VSX (ppc VSX registers)");
10096 return _("NT_PSTATUS (pstatus structure)");
10098 return _("NT_FPREGS (floating point registers)");
10100 return _("NT_PSINFO (psinfo structure)");
10102 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10104 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10105 case NT_WIN32PSTATUS
:
10106 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10114 return _("NT_VERSION (version)");
10116 return _("NT_ARCH (architecture)");
10121 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10125 static const char *
10126 get_gnu_elf_note_type (unsigned e_type
)
10128 static char buff
[64];
10132 case NT_GNU_ABI_TAG
:
10133 return _("NT_GNU_ABI_TAG (ABI version tag)");
10135 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10136 case NT_GNU_BUILD_ID
:
10137 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10138 case NT_GNU_GOLD_VERSION
:
10139 return _("NT_GNU_GOLD_VERSION (gold version)");
10144 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10148 static const char *
10149 get_netbsd_elfcore_note_type (unsigned e_type
)
10151 static char buff
[64];
10153 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10155 /* NetBSD core "procinfo" structure. */
10156 return _("NetBSD procinfo structure");
10159 /* As of Jan 2002 there are no other machine-independent notes
10160 defined for NetBSD core files. If the note type is less
10161 than the start of the machine-dependent note types, we don't
10164 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10166 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10170 switch (elf_header
.e_machine
)
10172 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10173 and PT_GETFPREGS == mach+2. */
10178 case EM_SPARC32PLUS
:
10182 case NT_NETBSDCORE_FIRSTMACH
+0:
10183 return _("PT_GETREGS (reg structure)");
10184 case NT_NETBSDCORE_FIRSTMACH
+2:
10185 return _("PT_GETFPREGS (fpreg structure)");
10191 /* On all other arch's, PT_GETREGS == mach+1 and
10192 PT_GETFPREGS == mach+3. */
10196 case NT_NETBSDCORE_FIRSTMACH
+1:
10197 return _("PT_GETREGS (reg structure)");
10198 case NT_NETBSDCORE_FIRSTMACH
+3:
10199 return _("PT_GETFPREGS (fpreg structure)");
10205 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10206 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10210 /* Note that by the ELF standard, the name field is already null byte
10211 terminated, and namesz includes the terminating null byte.
10212 I.E. the value of namesz for the name "FSF" is 4.
10214 If the value of namesz is zero, there is no name present. */
10216 process_note (Elf_Internal_Note
* pnote
)
10218 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10221 if (pnote
->namesz
== 0)
10222 /* If there is no note name, then use the default set of
10223 note type strings. */
10224 nt
= get_note_type (pnote
->type
);
10226 else if (const_strneq (pnote
->namedata
, "GNU"))
10227 /* GNU-specific object file notes. */
10228 nt
= get_gnu_elf_note_type (pnote
->type
);
10230 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10231 /* NetBSD-specific core file notes. */
10232 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10234 else if (strneq (pnote
->namedata
, "SPU/", 4))
10236 /* SPU-specific core file notes. */
10237 nt
= pnote
->namedata
+ 4;
10242 /* Don't recognize this note name; just use the default set of
10243 note type strings. */
10244 nt
= get_note_type (pnote
->type
);
10246 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10252 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10254 Elf_External_Note
* pnotes
;
10255 Elf_External_Note
* external
;
10261 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10267 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10268 (unsigned long) offset
, (unsigned long) length
);
10269 printf (_(" Owner\t\tData size\tDescription\n"));
10271 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10273 Elf_External_Note
* next
;
10274 Elf_Internal_Note inote
;
10275 char * temp
= NULL
;
10277 inote
.type
= BYTE_GET (external
->type
);
10278 inote
.namesz
= BYTE_GET (external
->namesz
);
10279 inote
.namedata
= external
->name
;
10280 inote
.descsz
= BYTE_GET (external
->descsz
);
10281 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10282 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10284 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10286 if (((char *) next
) > (((char *) pnotes
) + length
))
10288 warn (_("corrupt note found at offset %lx into core notes\n"),
10289 (unsigned long) ((char *) external
- (char *) pnotes
));
10290 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10291 inote
.type
, inote
.namesz
, inote
.descsz
);
10297 /* Verify that name is null terminated. It appears that at least
10298 one version of Linux (RedHat 6.0) generates corefiles that don't
10299 comply with the ELF spec by failing to include the null byte in
10301 if (inote
.namedata
[inote
.namesz
] != '\0')
10303 temp
= malloc (inote
.namesz
+ 1);
10307 error (_("Out of memory\n"));
10312 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10313 temp
[inote
.namesz
] = 0;
10315 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10316 inote
.namedata
= temp
;
10319 res
&= process_note (& inote
);
10334 process_corefile_note_segments (FILE * file
)
10336 Elf_Internal_Phdr
* segment
;
10340 if (! get_program_headers (file
))
10343 for (i
= 0, segment
= program_headers
;
10344 i
< elf_header
.e_phnum
;
10347 if (segment
->p_type
== PT_NOTE
)
10348 res
&= process_corefile_note_segment (file
,
10349 (bfd_vma
) segment
->p_offset
,
10350 (bfd_vma
) segment
->p_filesz
);
10357 process_note_sections (FILE * file
)
10359 Elf_Internal_Shdr
* section
;
10363 for (i
= 0, section
= section_headers
;
10364 i
< elf_header
.e_shnum
;
10366 if (section
->sh_type
== SHT_NOTE
)
10367 res
&= process_corefile_note_segment (file
,
10368 (bfd_vma
) section
->sh_offset
,
10369 (bfd_vma
) section
->sh_size
);
10375 process_notes (FILE * file
)
10377 /* If we have not been asked to display the notes then do nothing. */
10381 if (elf_header
.e_type
!= ET_CORE
)
10382 return process_note_sections (file
);
10384 /* No program headers means no NOTE segment. */
10385 if (elf_header
.e_phnum
> 0)
10386 return process_corefile_note_segments (file
);
10388 printf (_("No note segments present in the core file.\n"));
10393 process_arch_specific (FILE * file
)
10398 switch (elf_header
.e_machine
)
10401 return process_arm_specific (file
);
10403 case EM_MIPS_RS3_LE
:
10404 return process_mips_specific (file
);
10407 return process_power_specific (file
);
10416 get_file_header (FILE * file
)
10418 /* Read in the identity array. */
10419 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10422 /* Determine how to read the rest of the header. */
10423 switch (elf_header
.e_ident
[EI_DATA
])
10425 default: /* fall through */
10426 case ELFDATANONE
: /* fall through */
10428 byte_get
= byte_get_little_endian
;
10429 byte_put
= byte_put_little_endian
;
10432 byte_get
= byte_get_big_endian
;
10433 byte_put
= byte_put_big_endian
;
10437 /* For now we only support 32 bit and 64 bit ELF files. */
10438 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10440 /* Read in the rest of the header. */
10443 Elf32_External_Ehdr ehdr32
;
10445 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10448 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10449 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10450 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10451 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10452 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10453 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10454 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10455 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10456 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10457 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10458 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10459 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10460 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10464 Elf64_External_Ehdr ehdr64
;
10466 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10467 we will not be able to cope with the 64bit data found in
10468 64 ELF files. Detect this now and abort before we start
10469 overwriting things. */
10470 if (sizeof (bfd_vma
) < 8)
10472 error (_("This instance of readelf has been built without support for a\n\
10473 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10477 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10480 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10481 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10482 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10483 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10484 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10485 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10486 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10487 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10488 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10489 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10490 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10491 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10492 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10495 if (elf_header
.e_shoff
)
10497 /* There may be some extensions in the first section header. Don't
10498 bomb if we can't read it. */
10500 get_32bit_section_headers (file
, 1);
10502 get_64bit_section_headers (file
, 1);
10508 /* Process one ELF object file according to the command line options.
10509 This file may actually be stored in an archive. The file is
10510 positioned at the start of the ELF object. */
10513 process_object (char * file_name
, FILE * file
)
10517 if (! get_file_header (file
))
10519 error (_("%s: Failed to read file header\n"), file_name
);
10523 /* Initialise per file variables. */
10524 for (i
= ARRAY_SIZE (version_info
); i
--;)
10525 version_info
[i
] = 0;
10527 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10528 dynamic_info
[i
] = 0;
10530 /* Process the file. */
10532 printf (_("\nFile: %s\n"), file_name
);
10534 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10535 Note we do this even if cmdline_dump_sects is empty because we
10536 must make sure that the dump_sets array is zeroed out before each
10537 object file is processed. */
10538 if (num_dump_sects
> num_cmdline_dump_sects
)
10539 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10541 if (num_cmdline_dump_sects
> 0)
10543 if (num_dump_sects
== 0)
10544 /* A sneaky way of allocating the dump_sects array. */
10545 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10547 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10548 memcpy (dump_sects
, cmdline_dump_sects
,
10549 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10552 if (! process_file_header ())
10555 if (! process_section_headers (file
))
10557 /* Without loaded section headers we cannot process lots of
10559 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10561 if (! do_using_dynamic
)
10562 do_syms
= do_reloc
= 0;
10565 if (! process_section_groups (file
))
10567 /* Without loaded section groups we cannot process unwind. */
10571 if (process_program_headers (file
))
10572 process_dynamic_section (file
);
10574 process_relocs (file
);
10576 process_unwind (file
);
10578 process_symbol_table (file
);
10580 process_syminfo (file
);
10582 process_version_sections (file
);
10584 process_section_contents (file
);
10586 process_notes (file
);
10588 process_gnu_liblist (file
);
10590 process_arch_specific (file
);
10592 if (program_headers
)
10594 free (program_headers
);
10595 program_headers
= NULL
;
10598 if (section_headers
)
10600 free (section_headers
);
10601 section_headers
= NULL
;
10606 free (string_table
);
10607 string_table
= NULL
;
10608 string_table_length
= 0;
10611 if (dynamic_strings
)
10613 free (dynamic_strings
);
10614 dynamic_strings
= NULL
;
10615 dynamic_strings_length
= 0;
10618 if (dynamic_symbols
)
10620 free (dynamic_symbols
);
10621 dynamic_symbols
= NULL
;
10622 num_dynamic_syms
= 0;
10625 if (dynamic_syminfo
)
10627 free (dynamic_syminfo
);
10628 dynamic_syminfo
= NULL
;
10631 if (section_headers_groups
)
10633 free (section_headers_groups
);
10634 section_headers_groups
= NULL
;
10637 if (section_groups
)
10639 struct group_list
* g
;
10640 struct group_list
* next
;
10642 for (i
= 0; i
< group_count
; i
++)
10644 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10651 free (section_groups
);
10652 section_groups
= NULL
;
10655 free_debug_memory ();
10660 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10661 to the path name of the thin archive itself if necessary. Always returns
10662 a pointer to malloc'ed memory. */
10665 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10667 char * member_file_name
;
10668 const char * base_name
= lbasename (file_name
);
10670 /* This is a proxy entry for a thin archive member.
10671 If the extended name table contains an absolute path
10672 name, or if the archive is in the current directory,
10673 use the path name as given. Otherwise, we need to
10674 find the member relative to the directory where the
10675 archive is located. */
10676 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10678 member_file_name
= malloc (name_len
+ 1);
10679 if (member_file_name
== NULL
)
10681 error (_("Out of memory\n"));
10684 memcpy (member_file_name
, name
, name_len
);
10685 member_file_name
[name_len
] = '\0';
10689 /* Concatenate the path components of the archive file name
10690 to the relative path name from the extended name table. */
10691 size_t prefix_len
= base_name
- file_name
;
10692 member_file_name
= malloc (prefix_len
+ name_len
+ 1);
10693 if (member_file_name
== NULL
)
10695 error (_("Out of memory\n"));
10698 memcpy (member_file_name
, file_name
, prefix_len
);
10699 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10700 member_file_name
[prefix_len
+ name_len
] = '\0';
10702 return member_file_name
;
10705 /* Structure to hold information about an archive file. */
10707 struct archive_info
10709 char * file_name
; /* Archive file name. */
10710 FILE * file
; /* Open file descriptor. */
10711 unsigned long index_num
; /* Number of symbols in table. */
10712 unsigned long * index_array
; /* The array of member offsets. */
10713 char * sym_table
; /* The symbol table. */
10714 unsigned long sym_size
; /* Size of the symbol table. */
10715 char * longnames
; /* The long file names table. */
10716 unsigned long longnames_size
; /* Size of the long file names table. */
10717 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10718 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10719 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10720 struct ar_hdr arhdr
; /* Current archive header. */
10723 /* Read the symbol table and long-name table from an archive. */
10726 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10727 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10730 unsigned long size
;
10732 arch
->file_name
= strdup (file_name
);
10734 arch
->index_num
= 0;
10735 arch
->index_array
= NULL
;
10736 arch
->sym_table
= NULL
;
10737 arch
->sym_size
= 0;
10738 arch
->longnames
= NULL
;
10739 arch
->longnames_size
= 0;
10740 arch
->nested_member_origin
= 0;
10741 arch
->is_thin_archive
= is_thin_archive
;
10742 arch
->next_arhdr_offset
= SARMAG
;
10744 /* Read the first archive member header. */
10745 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10747 error (_("%s: failed to seek to first archive header\n"), file_name
);
10750 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10751 if (got
!= sizeof arch
->arhdr
)
10756 error (_("%s: failed to read archive header\n"), file_name
);
10760 /* See if this is the archive symbol table. */
10761 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10762 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10764 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10765 size
= size
+ (size
& 1);
10767 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10772 /* A buffer used to hold numbers read in from an archive index.
10773 These are always 4 bytes long and stored in big-endian format. */
10774 #define SIZEOF_AR_INDEX_NUMBERS 4
10775 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10776 unsigned char * index_buffer
;
10778 /* Check the size of the archive index. */
10779 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10781 error (_("%s: the archive index is empty\n"), file_name
);
10785 /* Read the numer of entries in the archive index. */
10786 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10787 if (got
!= sizeof (integer_buffer
))
10789 error (_("%s: failed to read archive index\n"), file_name
);
10792 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10793 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10795 /* Read in the archive index. */
10796 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10798 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10799 file_name
, arch
->index_num
);
10802 index_buffer
= malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10803 if (index_buffer
== NULL
)
10805 error (_("Out of memory whilst trying to read archive symbol index\n"));
10808 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
10809 if (got
!= arch
->index_num
)
10811 free (index_buffer
);
10812 error (_("%s: failed to read archive index\n"), file_name
);
10815 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10817 /* Convert the index numbers into the host's numeric format. */
10818 arch
->index_array
= malloc (arch
->index_num
* sizeof (* arch
->index_array
));
10819 if (arch
->index_array
== NULL
)
10821 free (index_buffer
);
10822 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10826 for (i
= 0; i
< arch
->index_num
; i
++)
10827 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10828 SIZEOF_AR_INDEX_NUMBERS
);
10829 free (index_buffer
);
10831 /* The remaining space in the header is taken up by the symbol table. */
10834 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10837 arch
->sym_table
= malloc (size
);
10838 arch
->sym_size
= size
;
10839 if (arch
->sym_table
== NULL
)
10841 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10844 got
= fread (arch
->sym_table
, 1, size
, file
);
10847 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10853 if (fseek (file
, size
, SEEK_CUR
) != 0)
10855 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10860 /* Read the next archive header. */
10861 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10862 if (got
!= sizeof arch
->arhdr
)
10866 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10870 else if (read_symbols
)
10871 printf (_("%s has no archive index\n"), file_name
);
10873 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
10875 /* This is the archive string table holding long member names. */
10876 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10877 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
10879 arch
->longnames
= malloc (arch
->longnames_size
);
10880 if (arch
->longnames
== NULL
)
10882 error (_("Out of memory reading long symbol names in archive\n"));
10886 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
10888 free (arch
->longnames
);
10889 arch
->longnames
= NULL
;
10890 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10894 if ((arch
->longnames_size
& 1) != 0)
10901 /* Release the memory used for the archive information. */
10904 release_archive (struct archive_info
* arch
)
10906 if (arch
->file_name
!= NULL
)
10907 free (arch
->file_name
);
10908 if (arch
->index_array
!= NULL
)
10909 free (arch
->index_array
);
10910 if (arch
->sym_table
!= NULL
)
10911 free (arch
->sym_table
);
10912 if (arch
->longnames
!= NULL
)
10913 free (arch
->longnames
);
10916 /* Open and setup a nested archive, if not already open. */
10919 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
10921 FILE * member_file
;
10923 /* Have we already setup this archive? */
10924 if (nested_arch
->file_name
!= NULL
10925 && streq (nested_arch
->file_name
, member_file_name
))
10928 /* Close previous file and discard cached information. */
10929 if (nested_arch
->file
!= NULL
)
10930 fclose (nested_arch
->file
);
10931 release_archive (nested_arch
);
10933 member_file
= fopen (member_file_name
, "rb");
10934 if (member_file
== NULL
)
10936 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
10940 get_archive_member_name_at (struct archive_info
* arch
,
10941 unsigned long offset
,
10942 struct archive_info
* nested_arch
);
10944 /* Get the name of an archive member from the current archive header.
10945 For simple names, this will modify the ar_name field of the current
10946 archive header. For long names, it will return a pointer to the
10947 longnames table. For nested archives, it will open the nested archive
10948 and get the name recursively. NESTED_ARCH is a single-entry cache so
10949 we don't keep rereading the same information from a nested archive. */
10952 get_archive_member_name (struct archive_info
* arch
,
10953 struct archive_info
* nested_arch
)
10955 unsigned long j
, k
;
10957 if (arch
->arhdr
.ar_name
[0] == '/')
10959 /* We have a long name. */
10961 char * member_file_name
;
10962 char * member_name
;
10964 arch
->nested_member_origin
= 0;
10965 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
10966 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
10967 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
10969 while ((j
< arch
->longnames_size
)
10970 && (arch
->longnames
[j
] != '\n')
10971 && (arch
->longnames
[j
] != '\0'))
10973 if (arch
->longnames
[j
-1] == '/')
10975 arch
->longnames
[j
] = '\0';
10977 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
10978 return arch
->longnames
+ k
;
10980 /* This is a proxy for a member of a nested archive.
10981 Find the name of the member in that archive. */
10982 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
10983 if (member_file_name
!= NULL
10984 && setup_nested_archive (nested_arch
, member_file_name
) == 0
10985 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
10987 free (member_file_name
);
10988 return member_name
;
10990 free (member_file_name
);
10992 /* Last resort: just return the name of the nested archive. */
10993 return arch
->longnames
+ k
;
10996 /* We have a normal (short) name. */
10998 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11000 arch
->arhdr
.ar_name
[j
] = '\0';
11001 return arch
->arhdr
.ar_name
;
11004 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11007 get_archive_member_name_at (struct archive_info
* arch
,
11008 unsigned long offset
,
11009 struct archive_info
* nested_arch
)
11013 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11015 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11018 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11019 if (got
!= sizeof arch
->arhdr
)
11021 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11024 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11026 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11030 return get_archive_member_name (arch
, nested_arch
);
11033 /* Construct a string showing the name of the archive member, qualified
11034 with the name of the containing archive file. For thin archives, we
11035 use square brackets to denote the indirection. For nested archives,
11036 we show the qualified name of the external member inside the square
11037 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11040 make_qualified_name (struct archive_info
* arch
,
11041 struct archive_info
* nested_arch
,
11042 char * member_name
)
11047 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11048 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11049 len
+= strlen (nested_arch
->file_name
) + 2;
11051 name
= malloc (len
);
11054 error (_("Out of memory\n"));
11058 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11059 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11060 else if (arch
->is_thin_archive
)
11061 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11063 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11068 /* Process an ELF archive.
11069 On entry the file is positioned just after the ARMAG string. */
11072 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11074 struct archive_info arch
;
11075 struct archive_info nested_arch
;
11077 size_t file_name_size
;
11082 /* The ARCH structure is used to hold information about this archive. */
11083 arch
.file_name
= NULL
;
11085 arch
.index_array
= NULL
;
11086 arch
.sym_table
= NULL
;
11087 arch
.longnames
= NULL
;
11089 /* The NESTED_ARCH structure is used as a single-item cache of information
11090 about a nested archive (when members of a thin archive reside within
11091 another regular archive file). */
11092 nested_arch
.file_name
= NULL
;
11093 nested_arch
.file
= NULL
;
11094 nested_arch
.index_array
= NULL
;
11095 nested_arch
.sym_table
= NULL
;
11096 nested_arch
.longnames
= NULL
;
11098 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11104 if (do_archive_index
)
11106 if (arch
.sym_table
== NULL
)
11107 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11111 unsigned long current_pos
;
11113 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11114 file_name
, arch
.index_num
, arch
.sym_size
);
11115 current_pos
= ftell (file
);
11117 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11119 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11121 char * member_name
;
11123 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11125 if (member_name
!= NULL
)
11127 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11129 if (qualified_name
!= NULL
)
11131 printf (_("Binary %s contains:\n"), qualified_name
);
11132 free (qualified_name
);
11137 if (l
>= arch
.sym_size
)
11139 error (_("%s: end of the symbol table reached before the end of the index\n"),
11143 printf ("\t%s\n", arch
.sym_table
+ l
);
11144 l
+= strlen (arch
.sym_table
+ l
) + 1;
11149 if (l
< arch
.sym_size
)
11150 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11153 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11155 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11161 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11162 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11163 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11164 && !do_section_groups
)
11166 ret
= 0; /* Archive index only. */
11171 file_name_size
= strlen (file_name
);
11178 char * qualified_name
;
11180 /* Read the next archive header. */
11181 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11183 error (_("%s: failed to seek to next archive header\n"), file_name
);
11186 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11187 if (got
!= sizeof arch
.arhdr
)
11191 error (_("%s: failed to read archive header\n"), file_name
);
11195 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11197 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11202 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11204 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11205 if (archive_file_size
& 01)
11206 ++archive_file_size
;
11208 name
= get_archive_member_name (&arch
, &nested_arch
);
11211 error (_("%s: bad archive file name\n"), file_name
);
11215 namelen
= strlen (name
);
11217 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11218 if (qualified_name
== NULL
)
11220 error (_("%s: bad archive file name\n"), file_name
);
11225 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11227 /* This is a proxy for an external member of a thin archive. */
11228 FILE * member_file
;
11229 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11230 if (member_file_name
== NULL
)
11236 member_file
= fopen (member_file_name
, "rb");
11237 if (member_file
== NULL
)
11239 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11240 free (member_file_name
);
11245 archive_file_offset
= arch
.nested_member_origin
;
11247 ret
|= process_object (qualified_name
, member_file
);
11249 fclose (member_file
);
11250 free (member_file_name
);
11252 else if (is_thin_archive
)
11254 /* This is a proxy for a member of a nested archive. */
11255 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11257 /* The nested archive file will have been opened and setup by
11258 get_archive_member_name. */
11259 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11261 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11266 ret
|= process_object (qualified_name
, nested_arch
.file
);
11270 archive_file_offset
= arch
.next_arhdr_offset
;
11271 arch
.next_arhdr_offset
+= archive_file_size
;
11273 ret
|= process_object (qualified_name
, file
);
11276 free (qualified_name
);
11280 if (nested_arch
.file
!= NULL
)
11281 fclose (nested_arch
.file
);
11282 release_archive (&nested_arch
);
11283 release_archive (&arch
);
11289 process_file (char * file_name
)
11292 struct stat statbuf
;
11293 char armag
[SARMAG
];
11296 if (stat (file_name
, &statbuf
) < 0)
11298 if (errno
== ENOENT
)
11299 error (_("'%s': No such file\n"), file_name
);
11301 error (_("Could not locate '%s'. System error message: %s\n"),
11302 file_name
, strerror (errno
));
11306 if (! S_ISREG (statbuf
.st_mode
))
11308 error (_("'%s' is not an ordinary file\n"), file_name
);
11312 file
= fopen (file_name
, "rb");
11315 error (_("Input file '%s' is not readable.\n"), file_name
);
11319 if (fread (armag
, SARMAG
, 1, file
) != 1)
11321 error (_("%s: Failed to read file's magic number\n"), file_name
);
11326 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11327 ret
= process_archive (file_name
, file
, FALSE
);
11328 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11329 ret
= process_archive (file_name
, file
, TRUE
);
11332 if (do_archive_index
)
11333 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11337 archive_file_size
= archive_file_offset
= 0;
11338 ret
= process_object (file_name
, file
);
11346 #ifdef SUPPORT_DISASSEMBLY
11347 /* Needed by the i386 disassembler. For extra credit, someone could
11348 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11352 print_address (unsigned int addr
, FILE * outfile
)
11354 fprintf (outfile
,"0x%8.8x", addr
);
11357 /* Needed by the i386 disassembler. */
11359 db_task_printsym (unsigned int addr
)
11361 print_address (addr
, stderr
);
11366 main (int argc
, char ** argv
)
11370 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11371 setlocale (LC_MESSAGES
, "");
11373 #if defined (HAVE_SETLOCALE)
11374 setlocale (LC_CTYPE
, "");
11376 bindtextdomain (PACKAGE
, LOCALEDIR
);
11377 textdomain (PACKAGE
);
11379 expandargv (&argc
, &argv
);
11381 parse_args (argc
, argv
);
11383 if (num_dump_sects
> 0)
11385 /* Make a copy of the dump_sects array. */
11386 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
11387 if (cmdline_dump_sects
== NULL
)
11388 error (_("Out of memory allocating dump request table.\n"));
11391 memcpy (cmdline_dump_sects
, dump_sects
,
11392 num_dump_sects
* sizeof (* dump_sects
));
11393 num_cmdline_dump_sects
= num_dump_sects
;
11397 if (optind
< (argc
- 1))
11401 while (optind
< argc
)
11402 err
|= process_file (argv
[optind
++]);
11404 if (dump_sects
!= NULL
)
11406 if (cmdline_dump_sects
!= NULL
)
11407 free (cmdline_dump_sects
);