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 print_vma (psym
->st_value
, LONG_HEX
);
1243 printf (is_32bit_elf
? " " : " ");
1245 if (psym
->st_name
== 0)
1247 const char * sec_name
= "<null>";
1250 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1252 if (psym
->st_shndx
< elf_header
.e_shnum
)
1254 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1255 else if (psym
->st_shndx
== SHN_ABS
)
1257 else if (psym
->st_shndx
== SHN_COMMON
)
1258 sec_name
= "COMMON";
1259 else if (elf_header
.e_machine
== EM_MIPS
1260 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1261 sec_name
= "SCOMMON";
1262 else if (elf_header
.e_machine
== EM_MIPS
1263 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1264 sec_name
= "SUNDEF";
1265 else if (elf_header
.e_machine
== EM_X86_64
1266 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1267 sec_name
= "LARGE_COMMON";
1268 else if (elf_header
.e_machine
== EM_IA_64
1269 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1270 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1271 sec_name
= "ANSI_COM";
1272 else if (elf_header
.e_machine
== EM_IA_64
1273 && (elf_header
.e_ident
[EI_OSABI
]
1274 == ELFOSABI_OPENVMS
)
1275 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1276 sec_name
= "VMS_SYMVEC";
1279 sprintf (name_buf
, "<section 0x%x>",
1280 (unsigned int) psym
->st_shndx
);
1281 sec_name
= name_buf
;
1284 print_symbol (22, sec_name
);
1286 else if (strtab
== NULL
)
1287 printf (_("<string table index: %3ld>"), psym
->st_name
);
1288 else if (psym
->st_name
>= strtablen
)
1289 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1291 print_symbol (22, strtab
+ psym
->st_name
);
1295 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1298 printf (" - %lx", - offset
);
1300 printf (" + %lx", offset
);
1306 printf ("%*c", is_32bit_elf
?
1307 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1308 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1311 if (elf_header
.e_machine
== EM_SPARCV9
1313 && streq (rtype
, "R_SPARC_OLO10"))
1314 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1319 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1321 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1322 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1323 const char * rtype2
= elf_mips_reloc_type (type2
);
1324 const char * rtype3
= elf_mips_reloc_type (type3
);
1326 printf (" Type2: ");
1329 printf (_("unrecognized: %-7lx"),
1330 (unsigned long) type2
& 0xffffffff);
1332 printf ("%-17.17s", rtype2
);
1334 printf ("\n Type3: ");
1337 printf (_("unrecognized: %-7lx"),
1338 (unsigned long) type3
& 0xffffffff);
1340 printf ("%-17.17s", rtype3
);
1351 get_mips_dynamic_type (unsigned long type
)
1355 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1356 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1357 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1358 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1359 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1360 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1361 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1362 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1363 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1364 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1365 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1366 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1367 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1368 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1369 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1370 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1371 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1372 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1373 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1374 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1375 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1376 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1377 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1378 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1379 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1380 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1381 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1382 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1383 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1384 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1385 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1386 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1387 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1388 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1389 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1390 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1391 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1392 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1393 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1394 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1395 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1396 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1397 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1398 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1399 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1406 get_sparc64_dynamic_type (unsigned long type
)
1410 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1417 get_ppc_dynamic_type (unsigned long type
)
1421 case DT_PPC_GOT
: return "PPC_GOT";
1428 get_ppc64_dynamic_type (unsigned long type
)
1432 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1433 case DT_PPC64_OPD
: return "PPC64_OPD";
1434 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1441 get_parisc_dynamic_type (unsigned long type
)
1445 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1446 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1447 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1448 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1449 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1450 case DT_HP_PREINIT
: return "HP_PREINIT";
1451 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1452 case DT_HP_NEEDED
: return "HP_NEEDED";
1453 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1454 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1455 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1456 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1457 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1458 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1459 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1460 case DT_HP_FILTERED
: return "HP_FILTERED";
1461 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1462 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1463 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1464 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1465 case DT_PLT
: return "PLT";
1466 case DT_PLT_SIZE
: return "PLT_SIZE";
1467 case DT_DLT
: return "DLT";
1468 case DT_DLT_SIZE
: return "DLT_SIZE";
1475 get_ia64_dynamic_type (unsigned long type
)
1479 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1480 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1481 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1482 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1483 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1484 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1485 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1486 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1487 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1488 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1489 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1490 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1491 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1492 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1493 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1494 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1495 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1496 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1497 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1498 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1499 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1500 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1501 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1502 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1503 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1504 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1505 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1506 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1507 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1508 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1509 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1516 get_alpha_dynamic_type (unsigned long type
)
1520 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1527 get_score_dynamic_type (unsigned long type
)
1531 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1532 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1533 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1534 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1535 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1536 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1544 get_dynamic_type (unsigned long type
)
1546 static char buff
[64];
1550 case DT_NULL
: return "NULL";
1551 case DT_NEEDED
: return "NEEDED";
1552 case DT_PLTRELSZ
: return "PLTRELSZ";
1553 case DT_PLTGOT
: return "PLTGOT";
1554 case DT_HASH
: return "HASH";
1555 case DT_STRTAB
: return "STRTAB";
1556 case DT_SYMTAB
: return "SYMTAB";
1557 case DT_RELA
: return "RELA";
1558 case DT_RELASZ
: return "RELASZ";
1559 case DT_RELAENT
: return "RELAENT";
1560 case DT_STRSZ
: return "STRSZ";
1561 case DT_SYMENT
: return "SYMENT";
1562 case DT_INIT
: return "INIT";
1563 case DT_FINI
: return "FINI";
1564 case DT_SONAME
: return "SONAME";
1565 case DT_RPATH
: return "RPATH";
1566 case DT_SYMBOLIC
: return "SYMBOLIC";
1567 case DT_REL
: return "REL";
1568 case DT_RELSZ
: return "RELSZ";
1569 case DT_RELENT
: return "RELENT";
1570 case DT_PLTREL
: return "PLTREL";
1571 case DT_DEBUG
: return "DEBUG";
1572 case DT_TEXTREL
: return "TEXTREL";
1573 case DT_JMPREL
: return "JMPREL";
1574 case DT_BIND_NOW
: return "BIND_NOW";
1575 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1576 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1577 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1578 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1579 case DT_RUNPATH
: return "RUNPATH";
1580 case DT_FLAGS
: return "FLAGS";
1582 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1583 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1585 case DT_CHECKSUM
: return "CHECKSUM";
1586 case DT_PLTPADSZ
: return "PLTPADSZ";
1587 case DT_MOVEENT
: return "MOVEENT";
1588 case DT_MOVESZ
: return "MOVESZ";
1589 case DT_FEATURE
: return "FEATURE";
1590 case DT_POSFLAG_1
: return "POSFLAG_1";
1591 case DT_SYMINSZ
: return "SYMINSZ";
1592 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1594 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1595 case DT_CONFIG
: return "CONFIG";
1596 case DT_DEPAUDIT
: return "DEPAUDIT";
1597 case DT_AUDIT
: return "AUDIT";
1598 case DT_PLTPAD
: return "PLTPAD";
1599 case DT_MOVETAB
: return "MOVETAB";
1600 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1602 case DT_VERSYM
: return "VERSYM";
1604 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1605 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1606 case DT_RELACOUNT
: return "RELACOUNT";
1607 case DT_RELCOUNT
: return "RELCOUNT";
1608 case DT_FLAGS_1
: return "FLAGS_1";
1609 case DT_VERDEF
: return "VERDEF";
1610 case DT_VERDEFNUM
: return "VERDEFNUM";
1611 case DT_VERNEED
: return "VERNEED";
1612 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1614 case DT_AUXILIARY
: return "AUXILIARY";
1615 case DT_USED
: return "USED";
1616 case DT_FILTER
: return "FILTER";
1618 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1619 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1620 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1621 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1622 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1623 case DT_GNU_HASH
: return "GNU_HASH";
1626 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1628 const char * result
;
1630 switch (elf_header
.e_machine
)
1633 case EM_MIPS_RS3_LE
:
1634 result
= get_mips_dynamic_type (type
);
1637 result
= get_sparc64_dynamic_type (type
);
1640 result
= get_ppc_dynamic_type (type
);
1643 result
= get_ppc64_dynamic_type (type
);
1646 result
= get_ia64_dynamic_type (type
);
1649 result
= get_alpha_dynamic_type (type
);
1652 result
= get_score_dynamic_type (type
);
1662 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1664 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1665 || (elf_header
.e_machine
== EM_PARISC
1666 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1668 const char * result
;
1670 switch (elf_header
.e_machine
)
1673 result
= get_parisc_dynamic_type (type
);
1676 result
= get_ia64_dynamic_type (type
);
1686 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1690 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1697 get_file_type (unsigned e_type
)
1699 static char buff
[32];
1703 case ET_NONE
: return _("NONE (None)");
1704 case ET_REL
: return _("REL (Relocatable file)");
1705 case ET_EXEC
: return _("EXEC (Executable file)");
1706 case ET_DYN
: return _("DYN (Shared object file)");
1707 case ET_CORE
: return _("CORE (Core file)");
1710 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1711 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1712 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1713 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1715 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1721 get_machine_name (unsigned e_machine
)
1723 static char buff
[64]; /* XXX */
1727 case EM_NONE
: return _("None");
1728 case EM_M32
: return "WE32100";
1729 case EM_SPARC
: return "Sparc";
1730 case EM_SPU
: return "SPU";
1731 case EM_386
: return "Intel 80386";
1732 case EM_68K
: return "MC68000";
1733 case EM_88K
: return "MC88000";
1734 case EM_486
: return "Intel 80486";
1735 case EM_860
: return "Intel 80860";
1736 case EM_MIPS
: return "MIPS R3000";
1737 case EM_S370
: return "IBM System/370";
1738 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1739 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1740 case EM_PARISC
: return "HPPA";
1741 case EM_PPC_OLD
: return "Power PC (old)";
1742 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1743 case EM_960
: return "Intel 90860";
1744 case EM_PPC
: return "PowerPC";
1745 case EM_PPC64
: return "PowerPC64";
1746 case EM_V800
: return "NEC V800";
1747 case EM_FR20
: return "Fujitsu FR20";
1748 case EM_RH32
: return "TRW RH32";
1749 case EM_MCORE
: return "MCORE";
1750 case EM_ARM
: return "ARM";
1751 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1752 case EM_SH
: return "Renesas / SuperH SH";
1753 case EM_SPARCV9
: return "Sparc v9";
1754 case EM_TRICORE
: return "Siemens Tricore";
1755 case EM_ARC
: return "ARC";
1756 case EM_H8_300
: return "Renesas H8/300";
1757 case EM_H8_300H
: return "Renesas H8/300H";
1758 case EM_H8S
: return "Renesas H8S";
1759 case EM_H8_500
: return "Renesas H8/500";
1760 case EM_IA_64
: return "Intel IA-64";
1761 case EM_MIPS_X
: return "Stanford MIPS-X";
1762 case EM_COLDFIRE
: return "Motorola Coldfire";
1763 case EM_68HC12
: return "Motorola M68HC12";
1764 case EM_ALPHA
: return "Alpha";
1765 case EM_CYGNUS_D10V
:
1766 case EM_D10V
: return "d10v";
1767 case EM_CYGNUS_D30V
:
1768 case EM_D30V
: return "d30v";
1769 case EM_CYGNUS_M32R
:
1770 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1771 case EM_CYGNUS_V850
:
1772 case EM_V850
: return "NEC v850";
1773 case EM_CYGNUS_MN10300
:
1774 case EM_MN10300
: return "mn10300";
1775 case EM_CYGNUS_MN10200
:
1776 case EM_MN10200
: return "mn10200";
1777 case EM_CYGNUS_FR30
:
1778 case EM_FR30
: return "Fujitsu FR30";
1779 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1781 case EM_PJ
: return "picoJava";
1782 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1783 case EM_PCP
: return "Siemens PCP";
1784 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1785 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1786 case EM_STARCORE
: return "Motorola Star*Core processor";
1787 case EM_ME16
: return "Toyota ME16 processor";
1788 case EM_ST100
: return "STMicroelectronics ST100 processor";
1789 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1790 case EM_FX66
: return "Siemens FX66 microcontroller";
1791 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1792 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1793 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1794 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1795 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1796 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1797 case EM_SVX
: return "Silicon Graphics SVx";
1798 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1799 case EM_VAX
: return "Digital VAX";
1801 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1802 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1803 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1804 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1805 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1806 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1807 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1808 case EM_PRISM
: return "Vitesse Prism";
1809 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1811 case EM_S390
: return "IBM S/390";
1812 case EM_SCORE
: return "SUNPLUS S+Core";
1813 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1815 case EM_OR32
: return "OpenRISC";
1816 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1817 case EM_DLX
: return "OpenDLX";
1819 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1820 case EM_IQ2000
: return "Vitesse IQ2000";
1822 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1823 case EM_LATTICEMICO32
: return "Lattice Mico32";
1825 case EM_M32C
: return "Renesas M32c";
1826 case EM_MT
: return "Morpho Techologies MT processor";
1827 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1828 case EM_NIOS32
: return "Altera Nios";
1829 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1830 case EM_XC16X
: return "Infineon Technologies xc16x";
1831 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1833 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1835 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1841 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1846 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1847 e_flags
&= ~ EF_ARM_EABIMASK
;
1849 /* Handle "generic" ARM flags. */
1850 if (e_flags
& EF_ARM_RELEXEC
)
1852 strcat (buf
, ", relocatable executable");
1853 e_flags
&= ~ EF_ARM_RELEXEC
;
1856 if (e_flags
& EF_ARM_HASENTRY
)
1858 strcat (buf
, ", has entry point");
1859 e_flags
&= ~ EF_ARM_HASENTRY
;
1862 /* Now handle EABI specific flags. */
1866 strcat (buf
, ", <unrecognized EABI>");
1871 case EF_ARM_EABI_VER1
:
1872 strcat (buf
, ", Version1 EABI");
1877 /* Process flags one bit at a time. */
1878 flag
= e_flags
& - e_flags
;
1883 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1884 strcat (buf
, ", sorted symbol tables");
1894 case EF_ARM_EABI_VER2
:
1895 strcat (buf
, ", Version2 EABI");
1900 /* Process flags one bit at a time. */
1901 flag
= e_flags
& - e_flags
;
1906 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1907 strcat (buf
, ", sorted symbol tables");
1910 case EF_ARM_DYNSYMSUSESEGIDX
:
1911 strcat (buf
, ", dynamic symbols use segment index");
1914 case EF_ARM_MAPSYMSFIRST
:
1915 strcat (buf
, ", mapping symbols precede others");
1925 case EF_ARM_EABI_VER3
:
1926 strcat (buf
, ", Version3 EABI");
1929 case EF_ARM_EABI_VER4
:
1930 strcat (buf
, ", Version4 EABI");
1933 case EF_ARM_EABI_VER5
:
1934 strcat (buf
, ", Version5 EABI");
1940 /* Process flags one bit at a time. */
1941 flag
= e_flags
& - e_flags
;
1947 strcat (buf
, ", BE8");
1951 strcat (buf
, ", LE8");
1961 case EF_ARM_EABI_UNKNOWN
:
1962 strcat (buf
, ", GNU EABI");
1967 /* Process flags one bit at a time. */
1968 flag
= e_flags
& - e_flags
;
1973 case EF_ARM_INTERWORK
:
1974 strcat (buf
, ", interworking enabled");
1977 case EF_ARM_APCS_26
:
1978 strcat (buf
, ", uses APCS/26");
1981 case EF_ARM_APCS_FLOAT
:
1982 strcat (buf
, ", uses APCS/float");
1986 strcat (buf
, ", position independent");
1990 strcat (buf
, ", 8 bit structure alignment");
1993 case EF_ARM_NEW_ABI
:
1994 strcat (buf
, ", uses new ABI");
1997 case EF_ARM_OLD_ABI
:
1998 strcat (buf
, ", uses old ABI");
2001 case EF_ARM_SOFT_FLOAT
:
2002 strcat (buf
, ", software FP");
2005 case EF_ARM_VFP_FLOAT
:
2006 strcat (buf
, ", VFP");
2009 case EF_ARM_MAVERICK_FLOAT
:
2010 strcat (buf
, ", Maverick FP");
2021 strcat (buf
,", <unknown>");
2025 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2027 static char buf
[1024];
2039 decode_ARM_machine_flags (e_flags
, buf
);
2043 switch (e_flags
& EF_FRV_CPU_MASK
)
2045 case EF_FRV_CPU_GENERIC
:
2049 strcat (buf
, ", fr???");
2052 case EF_FRV_CPU_FR300
:
2053 strcat (buf
, ", fr300");
2056 case EF_FRV_CPU_FR400
:
2057 strcat (buf
, ", fr400");
2059 case EF_FRV_CPU_FR405
:
2060 strcat (buf
, ", fr405");
2063 case EF_FRV_CPU_FR450
:
2064 strcat (buf
, ", fr450");
2067 case EF_FRV_CPU_FR500
:
2068 strcat (buf
, ", fr500");
2070 case EF_FRV_CPU_FR550
:
2071 strcat (buf
, ", fr550");
2074 case EF_FRV_CPU_SIMPLE
:
2075 strcat (buf
, ", simple");
2077 case EF_FRV_CPU_TOMCAT
:
2078 strcat (buf
, ", tomcat");
2084 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2085 strcat (buf
, ", m68000");
2086 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2087 strcat (buf
, ", cpu32");
2088 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2089 strcat (buf
, ", fido_a");
2092 char const * isa
= _("unknown");
2093 char const * mac
= _("unknown mac");
2094 char const * additional
= NULL
;
2096 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2098 case EF_M68K_CF_ISA_A_NODIV
:
2100 additional
= ", nodiv";
2102 case EF_M68K_CF_ISA_A
:
2105 case EF_M68K_CF_ISA_A_PLUS
:
2108 case EF_M68K_CF_ISA_B_NOUSP
:
2110 additional
= ", nousp";
2112 case EF_M68K_CF_ISA_B
:
2116 strcat (buf
, ", cf, isa ");
2119 strcat (buf
, additional
);
2120 if (e_flags
& EF_M68K_CF_FLOAT
)
2121 strcat (buf
, ", float");
2122 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2127 case EF_M68K_CF_MAC
:
2130 case EF_M68K_CF_EMAC
:
2143 if (e_flags
& EF_PPC_EMB
)
2144 strcat (buf
, ", emb");
2146 if (e_flags
& EF_PPC_RELOCATABLE
)
2147 strcat (buf
, ", relocatable");
2149 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2150 strcat (buf
, ", relocatable-lib");
2154 case EM_CYGNUS_V850
:
2155 switch (e_flags
& EF_V850_ARCH
)
2158 strcat (buf
, ", v850e1");
2161 strcat (buf
, ", v850e");
2164 strcat (buf
, ", v850");
2167 strcat (buf
, ", unknown v850 architecture variant");
2173 case EM_CYGNUS_M32R
:
2174 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2175 strcat (buf
, ", m32r");
2179 case EM_MIPS_RS3_LE
:
2180 if (e_flags
& EF_MIPS_NOREORDER
)
2181 strcat (buf
, ", noreorder");
2183 if (e_flags
& EF_MIPS_PIC
)
2184 strcat (buf
, ", pic");
2186 if (e_flags
& EF_MIPS_CPIC
)
2187 strcat (buf
, ", cpic");
2189 if (e_flags
& EF_MIPS_UCODE
)
2190 strcat (buf
, ", ugen_reserved");
2192 if (e_flags
& EF_MIPS_ABI2
)
2193 strcat (buf
, ", abi2");
2195 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2196 strcat (buf
, ", odk first");
2198 if (e_flags
& EF_MIPS_32BITMODE
)
2199 strcat (buf
, ", 32bitmode");
2201 switch ((e_flags
& EF_MIPS_MACH
))
2203 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2204 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2205 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2206 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2207 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2208 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2209 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2210 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2211 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2212 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2213 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2214 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2215 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2216 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2218 /* We simply ignore the field in this case to avoid confusion:
2219 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2222 default: strcat (buf
, ", unknown CPU"); break;
2225 switch ((e_flags
& EF_MIPS_ABI
))
2227 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2228 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2229 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2230 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2232 /* We simply ignore the field in this case to avoid confusion:
2233 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2234 This means it is likely to be an o32 file, but not for
2237 default: strcat (buf
, ", unknown ABI"); break;
2240 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2241 strcat (buf
, ", mdmx");
2243 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2244 strcat (buf
, ", mips16");
2246 switch ((e_flags
& EF_MIPS_ARCH
))
2248 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2249 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2250 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2251 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2252 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2253 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2254 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2255 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2256 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2257 default: strcat (buf
, ", unknown ISA"); break;
2263 switch ((e_flags
& EF_SH_MACH_MASK
))
2265 case EF_SH1
: strcat (buf
, ", sh1"); break;
2266 case EF_SH2
: strcat (buf
, ", sh2"); break;
2267 case EF_SH3
: strcat (buf
, ", sh3"); break;
2268 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2269 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2270 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2271 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2272 case EF_SH4
: strcat (buf
, ", sh4"); break;
2273 case EF_SH5
: strcat (buf
, ", sh5"); break;
2274 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2275 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2276 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2277 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2278 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2279 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2280 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2281 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2282 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2283 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2284 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2285 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2286 default: strcat (buf
, ", unknown ISA"); break;
2292 if (e_flags
& EF_SPARC_32PLUS
)
2293 strcat (buf
, ", v8+");
2295 if (e_flags
& EF_SPARC_SUN_US1
)
2296 strcat (buf
, ", ultrasparcI");
2298 if (e_flags
& EF_SPARC_SUN_US3
)
2299 strcat (buf
, ", ultrasparcIII");
2301 if (e_flags
& EF_SPARC_HAL_R1
)
2302 strcat (buf
, ", halr1");
2304 if (e_flags
& EF_SPARC_LEDATA
)
2305 strcat (buf
, ", ledata");
2307 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2308 strcat (buf
, ", tso");
2310 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2311 strcat (buf
, ", pso");
2313 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2314 strcat (buf
, ", rmo");
2318 switch (e_flags
& EF_PARISC_ARCH
)
2320 case EFA_PARISC_1_0
:
2321 strcpy (buf
, ", PA-RISC 1.0");
2323 case EFA_PARISC_1_1
:
2324 strcpy (buf
, ", PA-RISC 1.1");
2326 case EFA_PARISC_2_0
:
2327 strcpy (buf
, ", PA-RISC 2.0");
2332 if (e_flags
& EF_PARISC_TRAPNIL
)
2333 strcat (buf
, ", trapnil");
2334 if (e_flags
& EF_PARISC_EXT
)
2335 strcat (buf
, ", ext");
2336 if (e_flags
& EF_PARISC_LSB
)
2337 strcat (buf
, ", lsb");
2338 if (e_flags
& EF_PARISC_WIDE
)
2339 strcat (buf
, ", wide");
2340 if (e_flags
& EF_PARISC_NO_KABP
)
2341 strcat (buf
, ", no kabp");
2342 if (e_flags
& EF_PARISC_LAZYSWAP
)
2343 strcat (buf
, ", lazyswap");
2348 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2349 strcat (buf
, ", new calling convention");
2351 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2352 strcat (buf
, ", gnu calling convention");
2356 if ((e_flags
& EF_IA_64_ABI64
))
2357 strcat (buf
, ", 64-bit");
2359 strcat (buf
, ", 32-bit");
2360 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2361 strcat (buf
, ", reduced fp model");
2362 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2363 strcat (buf
, ", no function descriptors, constant gp");
2364 else if ((e_flags
& EF_IA_64_CONS_GP
))
2365 strcat (buf
, ", constant gp");
2366 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2367 strcat (buf
, ", absolute");
2371 if ((e_flags
& EF_VAX_NONPIC
))
2372 strcat (buf
, ", non-PIC");
2373 if ((e_flags
& EF_VAX_DFLOAT
))
2374 strcat (buf
, ", D-Float");
2375 if ((e_flags
& EF_VAX_GFLOAT
))
2376 strcat (buf
, ", G-Float");
2385 get_osabi_name (unsigned int osabi
)
2387 static char buff
[32];
2391 case ELFOSABI_NONE
: return "UNIX - System V";
2392 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2393 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2394 case ELFOSABI_LINUX
: return "UNIX - Linux";
2395 case ELFOSABI_HURD
: return "GNU/Hurd";
2396 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2397 case ELFOSABI_AIX
: return "UNIX - AIX";
2398 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2399 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2400 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2401 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2402 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2403 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2404 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2405 case ELFOSABI_AROS
: return "AROS";
2406 case ELFOSABI_STANDALONE
: return _("Standalone App");
2407 case ELFOSABI_ARM
: return "ARM";
2409 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2415 get_arm_segment_type (unsigned long type
)
2429 get_mips_segment_type (unsigned long type
)
2433 case PT_MIPS_REGINFO
:
2435 case PT_MIPS_RTPROC
:
2437 case PT_MIPS_OPTIONS
:
2447 get_parisc_segment_type (unsigned long type
)
2451 case PT_HP_TLS
: return "HP_TLS";
2452 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2453 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2454 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2455 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2456 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2457 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2458 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2459 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2460 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2461 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2462 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2463 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2464 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2465 case PT_HP_STACK
: return "HP_STACK";
2466 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2467 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2468 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2469 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2478 get_ia64_segment_type (unsigned long type
)
2482 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2483 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2484 case PT_HP_TLS
: return "HP_TLS";
2485 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2486 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2487 case PT_IA_64_HP_STACK
: return "HP_STACK";
2496 get_segment_type (unsigned long p_type
)
2498 static char buff
[32];
2502 case PT_NULL
: return "NULL";
2503 case PT_LOAD
: return "LOAD";
2504 case PT_DYNAMIC
: return "DYNAMIC";
2505 case PT_INTERP
: return "INTERP";
2506 case PT_NOTE
: return "NOTE";
2507 case PT_SHLIB
: return "SHLIB";
2508 case PT_PHDR
: return "PHDR";
2509 case PT_TLS
: return "TLS";
2511 case PT_GNU_EH_FRAME
:
2512 return "GNU_EH_FRAME";
2513 case PT_GNU_STACK
: return "GNU_STACK";
2514 case PT_GNU_RELRO
: return "GNU_RELRO";
2517 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2519 const char * result
;
2521 switch (elf_header
.e_machine
)
2524 result
= get_arm_segment_type (p_type
);
2527 case EM_MIPS_RS3_LE
:
2528 result
= get_mips_segment_type (p_type
);
2531 result
= get_parisc_segment_type (p_type
);
2534 result
= get_ia64_segment_type (p_type
);
2544 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2546 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2548 const char * result
;
2550 switch (elf_header
.e_machine
)
2553 result
= get_parisc_segment_type (p_type
);
2556 result
= get_ia64_segment_type (p_type
);
2566 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2569 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2576 get_mips_section_type_name (unsigned int sh_type
)
2580 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2581 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2582 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2583 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2584 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2585 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2586 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2587 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2588 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2589 case SHT_MIPS_RELD
: return "MIPS_RELD";
2590 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2591 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2592 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2593 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2594 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2595 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2596 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2597 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2598 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2599 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2600 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2601 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2602 case SHT_MIPS_LINE
: return "MIPS_LINE";
2603 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2604 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2605 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2606 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2607 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2608 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2609 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2610 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2611 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2612 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2613 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2614 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2615 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2616 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2617 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2618 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2626 get_parisc_section_type_name (unsigned int sh_type
)
2630 case SHT_PARISC_EXT
: return "PARISC_EXT";
2631 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2632 case SHT_PARISC_DOC
: return "PARISC_DOC";
2633 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2634 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2635 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2636 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2644 get_ia64_section_type_name (unsigned int sh_type
)
2646 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2647 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2648 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2652 case SHT_IA_64_EXT
: return "IA_64_EXT";
2653 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2654 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2655 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2656 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2657 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2658 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2659 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2660 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2661 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2669 get_x86_64_section_type_name (unsigned int sh_type
)
2673 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2681 get_arm_section_type_name (unsigned int sh_type
)
2687 case SHT_ARM_PREEMPTMAP
:
2688 return "ARM_PREEMPTMAP";
2689 case SHT_ARM_ATTRIBUTES
:
2690 return "ARM_ATTRIBUTES";
2698 get_section_type_name (unsigned int sh_type
)
2700 static char buff
[32];
2704 case SHT_NULL
: return "NULL";
2705 case SHT_PROGBITS
: return "PROGBITS";
2706 case SHT_SYMTAB
: return "SYMTAB";
2707 case SHT_STRTAB
: return "STRTAB";
2708 case SHT_RELA
: return "RELA";
2709 case SHT_HASH
: return "HASH";
2710 case SHT_DYNAMIC
: return "DYNAMIC";
2711 case SHT_NOTE
: return "NOTE";
2712 case SHT_NOBITS
: return "NOBITS";
2713 case SHT_REL
: return "REL";
2714 case SHT_SHLIB
: return "SHLIB";
2715 case SHT_DYNSYM
: return "DYNSYM";
2716 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2717 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2718 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2719 case SHT_GNU_HASH
: return "GNU_HASH";
2720 case SHT_GROUP
: return "GROUP";
2721 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2722 case SHT_GNU_verdef
: return "VERDEF";
2723 case SHT_GNU_verneed
: return "VERNEED";
2724 case SHT_GNU_versym
: return "VERSYM";
2725 case 0x6ffffff0: return "VERSYM";
2726 case 0x6ffffffc: return "VERDEF";
2727 case 0x7ffffffd: return "AUXILIARY";
2728 case 0x7fffffff: return "FILTER";
2729 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2732 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2734 const char * result
;
2736 switch (elf_header
.e_machine
)
2739 case EM_MIPS_RS3_LE
:
2740 result
= get_mips_section_type_name (sh_type
);
2743 result
= get_parisc_section_type_name (sh_type
);
2746 result
= get_ia64_section_type_name (sh_type
);
2749 result
= get_x86_64_section_type_name (sh_type
);
2752 result
= get_arm_section_type_name (sh_type
);
2762 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2764 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2766 const char * result
;
2768 switch (elf_header
.e_machine
)
2771 result
= get_ia64_section_type_name (sh_type
);
2781 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2783 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2784 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2786 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2792 #define OPTION_DEBUG_DUMP 512
2794 static struct option options
[] =
2796 {"all", no_argument
, 0, 'a'},
2797 {"file-header", no_argument
, 0, 'h'},
2798 {"program-headers", no_argument
, 0, 'l'},
2799 {"headers", no_argument
, 0, 'e'},
2800 {"histogram", no_argument
, 0, 'I'},
2801 {"segments", no_argument
, 0, 'l'},
2802 {"sections", no_argument
, 0, 'S'},
2803 {"section-headers", no_argument
, 0, 'S'},
2804 {"section-groups", no_argument
, 0, 'g'},
2805 {"section-details", no_argument
, 0, 't'},
2806 {"full-section-name",no_argument
, 0, 'N'},
2807 {"symbols", no_argument
, 0, 's'},
2808 {"syms", no_argument
, 0, 's'},
2809 {"relocs", no_argument
, 0, 'r'},
2810 {"notes", no_argument
, 0, 'n'},
2811 {"dynamic", no_argument
, 0, 'd'},
2812 {"arch-specific", no_argument
, 0, 'A'},
2813 {"version-info", no_argument
, 0, 'V'},
2814 {"use-dynamic", no_argument
, 0, 'D'},
2815 {"unwind", no_argument
, 0, 'u'},
2816 {"archive-index", no_argument
, 0, 'c'},
2817 {"hex-dump", required_argument
, 0, 'x'},
2818 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2819 {"string-dump", required_argument
, 0, 'p'},
2820 #ifdef SUPPORT_DISASSEMBLY
2821 {"instruction-dump", required_argument
, 0, 'i'},
2824 {"version", no_argument
, 0, 'v'},
2825 {"wide", no_argument
, 0, 'W'},
2826 {"help", no_argument
, 0, 'H'},
2827 {0, no_argument
, 0, 0}
2831 usage (FILE * stream
)
2833 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2834 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2835 fprintf (stream
, _(" Options are:\n\
2836 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2837 -h --file-header Display the ELF file header\n\
2838 -l --program-headers Display the program headers\n\
2839 --segments An alias for --program-headers\n\
2840 -S --section-headers Display the sections' header\n\
2841 --sections An alias for --section-headers\n\
2842 -g --section-groups Display the section groups\n\
2843 -t --section-details Display the section details\n\
2844 -e --headers Equivalent to: -h -l -S\n\
2845 -s --syms Display the symbol table\n\
2846 --symbols An alias for --syms\n\
2847 -n --notes Display the core notes (if present)\n\
2848 -r --relocs Display the relocations (if present)\n\
2849 -u --unwind Display the unwind info (if present)\n\
2850 -d --dynamic Display the dynamic section (if present)\n\
2851 -V --version-info Display the version sections (if present)\n\
2852 -A --arch-specific Display architecture specific information (if any).\n\
2853 -c --archive-index Display the symbol/file index in an archive\n\
2854 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2855 -x --hex-dump=<number|name>\n\
2856 Dump the contents of section <number|name> as bytes\n\
2857 -p --string-dump=<number|name>\n\
2858 Dump the contents of section <number|name> as strings\n\
2859 -w[lLiaprmfFsoR] or\n\
2860 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2861 Display the contents of DWARF2 debug sections\n"));
2862 #ifdef SUPPORT_DISASSEMBLY
2863 fprintf (stream
, _("\
2864 -i --instruction-dump=<number|name>\n\
2865 Disassemble the contents of section <number|name>\n"));
2867 fprintf (stream
, _("\
2868 -I --histogram Display histogram of bucket list lengths\n\
2869 -W --wide Allow output width to exceed 80 characters\n\
2870 @<file> Read options from <file>\n\
2871 -H --help Display this information\n\
2872 -v --version Display the version number of readelf\n"));
2874 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2875 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2877 exit (stream
== stdout
? 0 : 1);
2880 /* Record the fact that the user wants the contents of section number
2881 SECTION to be displayed using the method(s) encoded as flags bits
2882 in TYPE. Note, TYPE can be zero if we are creating the array for
2886 request_dump_bynumber (unsigned int section
, dump_type type
)
2888 if (section
>= num_dump_sects
)
2890 dump_type
* new_dump_sects
;
2892 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2894 if (new_dump_sects
== NULL
)
2895 error (_("Out of memory allocating dump request table.\n"));
2898 /* Copy current flag settings. */
2899 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2903 dump_sects
= new_dump_sects
;
2904 num_dump_sects
= section
+ 1;
2909 dump_sects
[section
] |= type
;
2914 /* Request a dump by section name. */
2917 request_dump_byname (const char * section
, dump_type type
)
2919 struct dump_list_entry
* new_request
;
2921 new_request
= malloc (sizeof (struct dump_list_entry
));
2923 error (_("Out of memory allocating dump request table.\n"));
2925 new_request
->name
= strdup (section
);
2926 if (!new_request
->name
)
2927 error (_("Out of memory allocating dump request table.\n"));
2929 new_request
->type
= type
;
2931 new_request
->next
= dump_sects_byname
;
2932 dump_sects_byname
= new_request
;
2936 parse_args (int argc
, char ** argv
)
2943 while ((c
= getopt_long
2944 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
2965 do_section_groups
++;
2973 do_section_groups
++;
2978 do_section_details
++;
3023 section
= strtoul (optarg
, & cp
, 0);
3024 if (! *cp
&& section
>= 0)
3025 request_dump_bynumber (section
, HEX_DUMP
);
3027 request_dump_byname (optarg
, HEX_DUMP
);
3031 section
= strtoul (optarg
, & cp
, 0);
3032 if (! *cp
&& section
>= 0)
3033 request_dump_bynumber (section
, STRING_DUMP
);
3035 request_dump_byname (optarg
, STRING_DUMP
);
3042 dwarf_select_sections_all ();
3047 dwarf_select_sections_by_letters (optarg
);
3050 case OPTION_DEBUG_DUMP
:
3057 dwarf_select_sections_by_names (optarg
);
3060 #ifdef SUPPORT_DISASSEMBLY
3063 section
= strtoul (optarg
, & cp
, 0);
3064 if (! *cp
&& section
>= 0)
3065 request_dump_bynumber (section
, DISASS_DUMP
);
3067 request_dump_byname (optarg
, DISASS_DUMP
);
3070 print_version (program_name
);
3079 /* xgettext:c-format */
3080 error (_("Invalid option '-%c'\n"), c
);
3087 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3088 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3089 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3090 && !do_section_groups
&& !do_archive_index
)
3094 warn (_("Nothing to do.\n"));
3100 get_elf_class (unsigned int elf_class
)
3102 static char buff
[32];
3106 case ELFCLASSNONE
: return _("none");
3107 case ELFCLASS32
: return "ELF32";
3108 case ELFCLASS64
: return "ELF64";
3110 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3116 get_data_encoding (unsigned int encoding
)
3118 static char buff
[32];
3122 case ELFDATANONE
: return _("none");
3123 case ELFDATA2LSB
: return _("2's complement, little endian");
3124 case ELFDATA2MSB
: return _("2's complement, big endian");
3126 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3131 /* Decode the data held in 'elf_header'. */
3134 process_file_header (void)
3136 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3137 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3138 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3139 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3142 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3146 init_dwarf_regnames (elf_header
.e_machine
);
3152 printf (_("ELF Header:\n"));
3153 printf (_(" Magic: "));
3154 for (i
= 0; i
< EI_NIDENT
; i
++)
3155 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3157 printf (_(" Class: %s\n"),
3158 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3159 printf (_(" Data: %s\n"),
3160 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3161 printf (_(" Version: %d %s\n"),
3162 elf_header
.e_ident
[EI_VERSION
],
3163 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3165 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3168 printf (_(" OS/ABI: %s\n"),
3169 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3170 printf (_(" ABI Version: %d\n"),
3171 elf_header
.e_ident
[EI_ABIVERSION
]);
3172 printf (_(" Type: %s\n"),
3173 get_file_type (elf_header
.e_type
));
3174 printf (_(" Machine: %s\n"),
3175 get_machine_name (elf_header
.e_machine
));
3176 printf (_(" Version: 0x%lx\n"),
3177 (unsigned long) elf_header
.e_version
);
3179 printf (_(" Entry point address: "));
3180 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3181 printf (_("\n Start of program headers: "));
3182 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3183 printf (_(" (bytes into file)\n Start of section headers: "));
3184 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3185 printf (_(" (bytes into file)\n"));
3187 printf (_(" Flags: 0x%lx%s\n"),
3188 (unsigned long) elf_header
.e_flags
,
3189 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3190 printf (_(" Size of this header: %ld (bytes)\n"),
3191 (long) elf_header
.e_ehsize
);
3192 printf (_(" Size of program headers: %ld (bytes)\n"),
3193 (long) elf_header
.e_phentsize
);
3194 printf (_(" Number of program headers: %ld\n"),
3195 (long) elf_header
.e_phnum
);
3196 printf (_(" Size of section headers: %ld (bytes)\n"),
3197 (long) elf_header
.e_shentsize
);
3198 printf (_(" Number of section headers: %ld"),
3199 (long) elf_header
.e_shnum
);
3200 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3201 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3202 putc ('\n', stdout
);
3203 printf (_(" Section header string table index: %ld"),
3204 (long) elf_header
.e_shstrndx
);
3205 if (section_headers
!= NULL
3206 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3207 printf (" (%u)", section_headers
[0].sh_link
);
3208 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3209 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3210 printf (" <corrupt: out of range>");
3211 putc ('\n', stdout
);
3214 if (section_headers
!= NULL
)
3216 if (elf_header
.e_shnum
== SHN_UNDEF
)
3217 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3218 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3219 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3220 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3221 elf_header
.e_shstrndx
= SHN_UNDEF
;
3222 free (section_headers
);
3223 section_headers
= NULL
;
3231 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3233 Elf32_External_Phdr
* phdrs
;
3234 Elf32_External_Phdr
* external
;
3235 Elf_Internal_Phdr
* internal
;
3238 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3239 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3240 _("program headers"));
3244 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3245 i
< elf_header
.e_phnum
;
3246 i
++, internal
++, external
++)
3248 internal
->p_type
= BYTE_GET (external
->p_type
);
3249 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3250 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3251 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3252 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3253 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3254 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3255 internal
->p_align
= BYTE_GET (external
->p_align
);
3264 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3266 Elf64_External_Phdr
* phdrs
;
3267 Elf64_External_Phdr
* external
;
3268 Elf_Internal_Phdr
* internal
;
3271 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3272 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3273 _("program headers"));
3277 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3278 i
< elf_header
.e_phnum
;
3279 i
++, internal
++, external
++)
3281 internal
->p_type
= BYTE_GET (external
->p_type
);
3282 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3283 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3284 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3285 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3286 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3287 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3288 internal
->p_align
= BYTE_GET (external
->p_align
);
3296 /* Returns 1 if the program headers were read into `program_headers'. */
3299 get_program_headers (FILE * file
)
3301 Elf_Internal_Phdr
* phdrs
;
3303 /* Check cache of prior read. */
3304 if (program_headers
!= NULL
)
3307 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3311 error (_("Out of memory\n"));
3316 ? get_32bit_program_headers (file
, phdrs
)
3317 : get_64bit_program_headers (file
, phdrs
))
3319 program_headers
= phdrs
;
3327 /* Returns 1 if the program headers were loaded. */
3330 process_program_headers (FILE * file
)
3332 Elf_Internal_Phdr
* segment
;
3335 if (elf_header
.e_phnum
== 0)
3338 printf (_("\nThere are no program headers in this file.\n"));
3342 if (do_segments
&& !do_header
)
3344 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3345 printf (_("Entry point "));
3346 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3347 printf (_("\nThere are %d program headers, starting at offset "),
3348 elf_header
.e_phnum
);
3349 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3353 if (! get_program_headers (file
))
3358 if (elf_header
.e_phnum
> 1)
3359 printf (_("\nProgram Headers:\n"));
3361 printf (_("\nProgram Headers:\n"));
3365 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3368 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3372 (_(" Type Offset VirtAddr PhysAddr\n"));
3374 (_(" FileSiz MemSiz Flags Align\n"));
3381 for (i
= 0, segment
= program_headers
;
3382 i
< elf_header
.e_phnum
;
3387 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3391 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3392 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3393 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3394 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3395 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3397 (segment
->p_flags
& PF_R
? 'R' : ' '),
3398 (segment
->p_flags
& PF_W
? 'W' : ' '),
3399 (segment
->p_flags
& PF_X
? 'E' : ' '));
3400 printf ("%#lx", (unsigned long) segment
->p_align
);
3404 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3405 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3408 print_vma (segment
->p_offset
, FULL_HEX
);
3412 print_vma (segment
->p_vaddr
, FULL_HEX
);
3414 print_vma (segment
->p_paddr
, FULL_HEX
);
3417 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3418 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3421 print_vma (segment
->p_filesz
, FULL_HEX
);
3425 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3426 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3429 print_vma (segment
->p_offset
, FULL_HEX
);
3433 (segment
->p_flags
& PF_R
? 'R' : ' '),
3434 (segment
->p_flags
& PF_W
? 'W' : ' '),
3435 (segment
->p_flags
& PF_X
? 'E' : ' '));
3437 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3438 printf ("%#lx", (unsigned long) segment
->p_align
);
3441 print_vma (segment
->p_align
, PREFIX_HEX
);
3446 print_vma (segment
->p_offset
, FULL_HEX
);
3448 print_vma (segment
->p_vaddr
, FULL_HEX
);
3450 print_vma (segment
->p_paddr
, FULL_HEX
);
3452 print_vma (segment
->p_filesz
, FULL_HEX
);
3454 print_vma (segment
->p_memsz
, FULL_HEX
);
3456 (segment
->p_flags
& PF_R
? 'R' : ' '),
3457 (segment
->p_flags
& PF_W
? 'W' : ' '),
3458 (segment
->p_flags
& PF_X
? 'E' : ' '));
3459 print_vma (segment
->p_align
, HEX
);
3463 switch (segment
->p_type
)
3467 error (_("more than one dynamic segment\n"));
3469 /* By default, assume that the .dynamic section is the first
3470 section in the DYNAMIC segment. */
3471 dynamic_addr
= segment
->p_offset
;
3472 dynamic_size
= segment
->p_filesz
;
3474 /* Try to locate the .dynamic section. If there is
3475 a section header table, we can easily locate it. */
3476 if (section_headers
!= NULL
)
3478 Elf_Internal_Shdr
* sec
;
3480 sec
= find_section (".dynamic");
3481 if (sec
== NULL
|| sec
->sh_size
== 0)
3483 error (_("no .dynamic section in the dynamic segment\n"));
3487 if (sec
->sh_type
== SHT_NOBITS
)
3493 dynamic_addr
= sec
->sh_offset
;
3494 dynamic_size
= sec
->sh_size
;
3496 if (dynamic_addr
< segment
->p_offset
3497 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3498 warn (_("the .dynamic section is not contained"
3499 " within the dynamic segment\n"));
3500 else if (dynamic_addr
> segment
->p_offset
)
3501 warn (_("the .dynamic section is not the first section"
3502 " in the dynamic segment.\n"));
3507 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3509 error (_("Unable to find program interpreter name\n"));
3513 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3515 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3516 error (_("Internal error: failed to create format string to display program interpreter\n"));
3518 program_interpreter
[0] = 0;
3519 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3520 error (_("Unable to read program interpreter name\n"));
3523 printf (_("\n [Requesting program interpreter: %s]"),
3524 program_interpreter
);
3530 putc ('\n', stdout
);
3533 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3535 printf (_("\n Section to Segment mapping:\n"));
3536 printf (_(" Segment Sections...\n"));
3538 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3541 Elf_Internal_Shdr
* section
;
3543 segment
= program_headers
+ i
;
3544 section
= section_headers
+ 1;
3546 printf (" %2.2d ", i
);
3548 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3550 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3551 printf ("%s ", SECTION_NAME (section
));
3562 /* Find the file offset corresponding to VMA by using the program headers. */
3565 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3567 Elf_Internal_Phdr
* seg
;
3569 if (! get_program_headers (file
))
3571 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3575 for (seg
= program_headers
;
3576 seg
< program_headers
+ elf_header
.e_phnum
;
3579 if (seg
->p_type
!= PT_LOAD
)
3582 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3583 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3584 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3587 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3588 (unsigned long) vma
);
3594 get_32bit_section_headers (FILE * file
, unsigned int num
)
3596 Elf32_External_Shdr
* shdrs
;
3597 Elf_Internal_Shdr
* internal
;
3600 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3601 elf_header
.e_shentsize
, num
, _("section headers"));
3605 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3607 if (section_headers
== NULL
)
3609 error (_("Out of memory\n"));
3613 for (i
= 0, internal
= section_headers
;
3617 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3618 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3619 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3620 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3621 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3622 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3623 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3624 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3625 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3626 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3635 get_64bit_section_headers (FILE * file
, unsigned int num
)
3637 Elf64_External_Shdr
* shdrs
;
3638 Elf_Internal_Shdr
* internal
;
3641 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3642 elf_header
.e_shentsize
, num
, _("section headers"));
3646 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3648 if (section_headers
== NULL
)
3650 error (_("Out of memory\n"));
3654 for (i
= 0, internal
= section_headers
;
3658 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3659 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3660 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3661 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3662 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3663 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3664 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3665 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3666 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3667 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3675 static Elf_Internal_Sym
*
3676 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3678 unsigned long number
;
3679 Elf32_External_Sym
* esyms
;
3680 Elf_External_Sym_Shndx
* shndx
;
3681 Elf_Internal_Sym
* isyms
;
3682 Elf_Internal_Sym
* psym
;
3685 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3691 if (symtab_shndx_hdr
!= NULL
3692 && (symtab_shndx_hdr
->sh_link
3693 == (unsigned long) (section
- section_headers
)))
3695 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3696 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3704 number
= section
->sh_size
/ section
->sh_entsize
;
3705 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3709 error (_("Out of memory\n"));
3716 for (j
= 0, psym
= isyms
;
3720 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3721 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3722 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3723 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3724 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3726 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3727 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3728 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3729 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3730 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3740 static Elf_Internal_Sym
*
3741 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3743 unsigned long number
;
3744 Elf64_External_Sym
* esyms
;
3745 Elf_External_Sym_Shndx
* shndx
;
3746 Elf_Internal_Sym
* isyms
;
3747 Elf_Internal_Sym
* psym
;
3750 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3756 if (symtab_shndx_hdr
!= NULL
3757 && (symtab_shndx_hdr
->sh_link
3758 == (unsigned long) (section
- section_headers
)))
3760 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3761 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3769 number
= section
->sh_size
/ section
->sh_entsize
;
3770 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3774 error (_("Out of memory\n"));
3781 for (j
= 0, psym
= isyms
;
3785 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3786 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3787 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3788 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3789 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3791 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3792 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3793 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3794 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3795 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3806 get_elf_section_flags (bfd_vma sh_flags
)
3808 static char buff
[1024];
3810 int field_size
= is_32bit_elf
? 8 : 16;
3811 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3812 bfd_vma os_flags
= 0;
3813 bfd_vma proc_flags
= 0;
3814 bfd_vma unknown_flags
= 0;
3828 { "LINK ORDER", 10 },
3829 { "OS NONCONF", 10 },
3832 /* IA-64 specific. */
3835 /* IA-64 OpenVMS specific. */
3836 { "VMS_GLOBAL", 10 },
3837 { "VMS_OVERLAID", 12 },
3838 { "VMS_SHARED", 10 },
3839 { "VMS_VECTOR", 10 },
3840 { "VMS_ALLOC_64BIT", 15 },
3841 { "VMS_PROTECTED", 13}
3844 if (do_section_details
)
3846 sprintf (buff
, "[%*.*lx]: ",
3847 field_size
, field_size
, (unsigned long) sh_flags
);
3848 p
+= field_size
+ 4;
3855 flag
= sh_flags
& - sh_flags
;
3858 if (do_section_details
)
3862 case SHF_WRITE
: index
= 0; break;
3863 case SHF_ALLOC
: index
= 1; break;
3864 case SHF_EXECINSTR
: index
= 2; break;
3865 case SHF_MERGE
: index
= 3; break;
3866 case SHF_STRINGS
: index
= 4; break;
3867 case SHF_INFO_LINK
: index
= 5; break;
3868 case SHF_LINK_ORDER
: index
= 6; break;
3869 case SHF_OS_NONCONFORMING
: index
= 7; break;
3870 case SHF_GROUP
: index
= 8; break;
3871 case SHF_TLS
: index
= 9; break;
3875 if (elf_header
.e_machine
== EM_IA_64
)
3877 if (flag
== SHF_IA_64_SHORT
)
3879 else if (flag
== SHF_IA_64_NORECOV
)
3882 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3885 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3886 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3887 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3888 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3889 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3890 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3900 if (p
!= buff
+ field_size
+ 4)
3902 if (size
< (10 + 2))
3909 size
-= flags
[index
].len
;
3910 p
= stpcpy (p
, flags
[index
].str
);
3912 else if (flag
& SHF_MASKOS
)
3914 else if (flag
& SHF_MASKPROC
)
3917 unknown_flags
|= flag
;
3923 case SHF_WRITE
: *p
= 'W'; break;
3924 case SHF_ALLOC
: *p
= 'A'; break;
3925 case SHF_EXECINSTR
: *p
= 'X'; break;
3926 case SHF_MERGE
: *p
= 'M'; break;
3927 case SHF_STRINGS
: *p
= 'S'; break;
3928 case SHF_INFO_LINK
: *p
= 'I'; break;
3929 case SHF_LINK_ORDER
: *p
= 'L'; break;
3930 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3931 case SHF_GROUP
: *p
= 'G'; break;
3932 case SHF_TLS
: *p
= 'T'; break;
3935 if (elf_header
.e_machine
== EM_X86_64
3936 && flag
== SHF_X86_64_LARGE
)
3938 else if (flag
& SHF_MASKOS
)
3941 sh_flags
&= ~ SHF_MASKOS
;
3943 else if (flag
& SHF_MASKPROC
)
3946 sh_flags
&= ~ SHF_MASKPROC
;
3956 if (do_section_details
)
3960 size
-= 5 + field_size
;
3961 if (p
!= buff
+ field_size
+ 4)
3969 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3970 (unsigned long) os_flags
);
3971 p
+= 5 + field_size
;
3975 size
-= 7 + field_size
;
3976 if (p
!= buff
+ field_size
+ 4)
3984 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3985 (unsigned long) proc_flags
);
3986 p
+= 7 + field_size
;
3990 size
-= 10 + field_size
;
3991 if (p
!= buff
+ field_size
+ 4)
3999 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4000 (unsigned long) unknown_flags
);
4001 p
+= 10 + field_size
;
4010 process_section_headers (FILE * file
)
4012 Elf_Internal_Shdr
* section
;
4015 section_headers
= NULL
;
4017 if (elf_header
.e_shnum
== 0)
4020 printf (_("\nThere are no sections in this file.\n"));
4025 if (do_sections
&& !do_header
)
4026 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4027 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4031 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4034 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4037 /* Read in the string table, so that we have names to display. */
4038 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4039 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4041 section
= section_headers
+ elf_header
.e_shstrndx
;
4043 if (section
->sh_size
!= 0)
4045 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4046 1, section
->sh_size
, _("string table"));
4048 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4052 /* Scan the sections for the dynamic symbol table
4053 and dynamic string table and debug sections. */
4054 dynamic_symbols
= NULL
;
4055 dynamic_strings
= NULL
;
4056 dynamic_syminfo
= NULL
;
4057 symtab_shndx_hdr
= NULL
;
4059 eh_addr_size
= is_32bit_elf
? 4 : 8;
4060 switch (elf_header
.e_machine
)
4063 case EM_MIPS_RS3_LE
:
4064 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4065 FDE addresses. However, the ABI also has a semi-official ILP32
4066 variant for which the normal FDE address size rules apply.
4068 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4069 section, where XX is the size of longs in bits. Unfortunately,
4070 earlier compilers provided no way of distinguishing ILP32 objects
4071 from LP64 objects, so if there's any doubt, we should assume that
4072 the official LP64 form is being used. */
4073 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4074 && find_section (".gcc_compiled_long32") == NULL
)
4080 switch (elf_header
.e_flags
& EF_H8_MACH
)
4082 case E_H8_MACH_H8300
:
4083 case E_H8_MACH_H8300HN
:
4084 case E_H8_MACH_H8300SN
:
4085 case E_H8_MACH_H8300SXN
:
4088 case E_H8_MACH_H8300H
:
4089 case E_H8_MACH_H8300S
:
4090 case E_H8_MACH_H8300SX
:
4098 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4100 case EF_M32C_CPU_M16C
:
4107 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4110 size_t expected_entsize \
4111 = is_32bit_elf ? size32 : size64; \
4112 if (section->sh_entsize != expected_entsize) \
4113 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4114 i, (unsigned long int) section->sh_entsize, \
4115 (unsigned long int) expected_entsize); \
4116 section->sh_entsize = expected_entsize; \
4119 #define CHECK_ENTSIZE(section, i, type) \
4120 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4121 sizeof (Elf64_External_##type))
4123 for (i
= 0, section
= section_headers
;
4124 i
< elf_header
.e_shnum
;
4127 char * name
= SECTION_NAME (section
);
4129 if (section
->sh_type
== SHT_DYNSYM
)
4131 if (dynamic_symbols
!= NULL
)
4133 error (_("File contains multiple dynamic symbol tables\n"));
4137 CHECK_ENTSIZE (section
, i
, Sym
);
4138 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4139 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4141 else if (section
->sh_type
== SHT_STRTAB
4142 && streq (name
, ".dynstr"))
4144 if (dynamic_strings
!= NULL
)
4146 error (_("File contains multiple dynamic string tables\n"));
4150 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4151 1, section
->sh_size
, _("dynamic strings"));
4152 dynamic_strings_length
= section
->sh_size
;
4154 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4156 if (symtab_shndx_hdr
!= NULL
)
4158 error (_("File contains multiple symtab shndx tables\n"));
4161 symtab_shndx_hdr
= section
;
4163 else if (section
->sh_type
== SHT_SYMTAB
)
4164 CHECK_ENTSIZE (section
, i
, Sym
);
4165 else if (section
->sh_type
== SHT_GROUP
)
4166 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4167 else if (section
->sh_type
== SHT_REL
)
4168 CHECK_ENTSIZE (section
, i
, Rel
);
4169 else if (section
->sh_type
== SHT_RELA
)
4170 CHECK_ENTSIZE (section
, i
, Rela
);
4171 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4172 || do_debug_lines
|| do_debug_pubnames
4173 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4174 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4175 && (const_strneq (name
, ".debug_")
4176 || const_strneq (name
, ".zdebug_")))
4179 name
+= sizeof (".zdebug_") - 1;
4181 name
+= sizeof (".debug_") - 1;
4184 || (do_debug_info
&& streq (name
, "info"))
4185 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4186 || (do_debug_lines
&& streq (name
, "line"))
4187 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4188 || (do_debug_aranges
&& streq (name
, "aranges"))
4189 || (do_debug_ranges
&& streq (name
, "ranges"))
4190 || (do_debug_frames
&& streq (name
, "frame"))
4191 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4192 || (do_debug_str
&& streq (name
, "str"))
4193 || (do_debug_loc
&& streq (name
, "loc"))
4195 request_dump_bynumber (i
, DEBUG_DUMP
);
4197 /* Linkonce section to be combined with .debug_info at link time. */
4198 else if ((do_debugging
|| do_debug_info
)
4199 && const_strneq (name
, ".gnu.linkonce.wi."))
4200 request_dump_bynumber (i
, DEBUG_DUMP
);
4201 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4202 request_dump_bynumber (i
, DEBUG_DUMP
);
4208 if (elf_header
.e_shnum
> 1)
4209 printf (_("\nSection Headers:\n"));
4211 printf (_("\nSection Header:\n"));
4215 if (do_section_details
)
4217 printf (_(" [Nr] Name\n"));
4218 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4222 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4226 if (do_section_details
)
4228 printf (_(" [Nr] Name\n"));
4229 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4233 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4237 if (do_section_details
)
4239 printf (_(" [Nr] Name\n"));
4240 printf (_(" Type Address Offset Link\n"));
4241 printf (_(" Size EntSize Info Align\n"));
4245 printf (_(" [Nr] Name Type Address Offset\n"));
4246 printf (_(" Size EntSize Flags Link Info Align\n"));
4250 if (do_section_details
)
4251 printf (_(" Flags\n"));
4253 for (i
= 0, section
= section_headers
;
4254 i
< elf_header
.e_shnum
;
4257 if (do_section_details
)
4259 printf (" [%2u] %s\n",
4261 SECTION_NAME (section
));
4262 if (is_32bit_elf
|| do_wide
)
4263 printf (" %-15.15s ",
4264 get_section_type_name (section
->sh_type
));
4267 printf ((do_wide
? " [%2u] %-17s %-15s "
4268 : " [%2u] %-17.17s %-15.15s "),
4270 SECTION_NAME (section
),
4271 get_section_type_name (section
->sh_type
));
4275 print_vma (section
->sh_addr
, LONG_HEX
);
4277 printf ( " %6.6lx %6.6lx %2.2lx",
4278 (unsigned long) section
->sh_offset
,
4279 (unsigned long) section
->sh_size
,
4280 (unsigned long) section
->sh_entsize
);
4282 if (do_section_details
)
4283 fputs (" ", stdout
);
4285 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4287 printf ("%2u %3u %2lu\n",
4290 (unsigned long) section
->sh_addralign
);
4294 print_vma (section
->sh_addr
, LONG_HEX
);
4296 if ((long) section
->sh_offset
== section
->sh_offset
)
4297 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4301 print_vma (section
->sh_offset
, LONG_HEX
);
4304 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4305 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4309 print_vma (section
->sh_size
, LONG_HEX
);
4312 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4313 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4317 print_vma (section
->sh_entsize
, LONG_HEX
);
4320 if (do_section_details
)
4321 fputs (" ", stdout
);
4323 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4325 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4327 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4328 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4331 print_vma (section
->sh_addralign
, DEC
);
4335 else if (do_section_details
)
4337 printf (" %-15.15s ",
4338 get_section_type_name (section
->sh_type
));
4339 print_vma (section
->sh_addr
, LONG_HEX
);
4340 if ((long) section
->sh_offset
== section
->sh_offset
)
4341 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4345 print_vma (section
->sh_offset
, LONG_HEX
);
4347 printf (" %u\n ", section
->sh_link
);
4348 print_vma (section
->sh_size
, LONG_HEX
);
4350 print_vma (section
->sh_entsize
, LONG_HEX
);
4352 printf (" %-16u %lu\n",
4354 (unsigned long) section
->sh_addralign
);
4359 print_vma (section
->sh_addr
, LONG_HEX
);
4360 if ((long) section
->sh_offset
== section
->sh_offset
)
4361 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4365 print_vma (section
->sh_offset
, LONG_HEX
);
4368 print_vma (section
->sh_size
, LONG_HEX
);
4370 print_vma (section
->sh_entsize
, LONG_HEX
);
4372 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4374 printf (" %2u %3u %lu\n",
4377 (unsigned long) section
->sh_addralign
);
4380 if (do_section_details
)
4381 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4384 if (!do_section_details
)
4385 printf (_("Key to Flags:\n\
4386 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4387 I (info), L (link order), G (group), x (unknown)\n\
4388 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4394 get_group_flags (unsigned int flags
)
4396 static char buff
[32];
4403 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4410 process_section_groups (FILE * file
)
4412 Elf_Internal_Shdr
* section
;
4414 struct group
* group
;
4415 Elf_Internal_Shdr
* symtab_sec
;
4416 Elf_Internal_Shdr
* strtab_sec
;
4417 Elf_Internal_Sym
* symtab
;
4421 /* Don't process section groups unless needed. */
4422 if (!do_unwind
&& !do_section_groups
)
4425 if (elf_header
.e_shnum
== 0)
4427 if (do_section_groups
)
4428 printf (_("\nThere are no sections in this file.\n"));
4433 if (section_headers
== NULL
)
4435 error (_("Section headers are not available!\n"));
4439 section_headers_groups
= calloc (elf_header
.e_shnum
,
4440 sizeof (struct group
*));
4442 if (section_headers_groups
== NULL
)
4444 error (_("Out of memory\n"));
4448 /* Scan the sections for the group section. */
4450 for (i
= 0, section
= section_headers
;
4451 i
< elf_header
.e_shnum
;
4453 if (section
->sh_type
== SHT_GROUP
)
4456 if (group_count
== 0)
4458 if (do_section_groups
)
4459 printf (_("\nThere are no section groups in this file.\n"));
4464 section_groups
= calloc (group_count
, sizeof (struct group
));
4466 if (section_groups
== NULL
)
4468 error (_("Out of memory\n"));
4477 for (i
= 0, section
= section_headers
, group
= section_groups
;
4478 i
< elf_header
.e_shnum
;
4481 if (section
->sh_type
== SHT_GROUP
)
4483 char * name
= SECTION_NAME (section
);
4485 unsigned char * start
;
4486 unsigned char * indices
;
4487 unsigned int entry
, j
, size
;
4488 Elf_Internal_Shdr
* sec
;
4489 Elf_Internal_Sym
* sym
;
4491 /* Get the symbol table. */
4492 if (section
->sh_link
>= elf_header
.e_shnum
4493 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4496 error (_("Bad sh_link in group section `%s'\n"), name
);
4500 if (symtab_sec
!= sec
)
4505 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4508 sym
= symtab
+ section
->sh_info
;
4510 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4512 if (sym
->st_shndx
== 0
4513 || sym
->st_shndx
>= elf_header
.e_shnum
)
4515 error (_("Bad sh_info in group section `%s'\n"), name
);
4519 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4528 /* Get the string table. */
4529 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4538 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4543 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4544 1, strtab_sec
->sh_size
,
4546 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4548 group_name
= sym
->st_name
< strtab_size
4549 ? strtab
+ sym
->st_name
: "<corrupt>";
4552 start
= get_data (NULL
, file
, section
->sh_offset
,
4553 1, section
->sh_size
, _("section data"));
4556 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4557 entry
= byte_get (indices
, 4);
4560 if (do_section_groups
)
4562 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4563 get_group_flags (entry
), i
, name
, group_name
, size
);
4565 printf (_(" [Index] Name\n"));
4568 group
->group_index
= i
;
4570 for (j
= 0; j
< size
; j
++)
4572 struct group_list
* g
;
4574 entry
= byte_get (indices
, 4);
4577 if (entry
>= elf_header
.e_shnum
)
4579 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4580 entry
, i
, elf_header
.e_shnum
- 1);
4584 if (section_headers_groups
[entry
] != NULL
)
4588 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4590 section_headers_groups
[entry
]->group_index
);
4595 /* Intel C/C++ compiler may put section 0 in a
4596 section group. We just warn it the first time
4597 and ignore it afterwards. */
4598 static int warned
= 0;
4601 error (_("section 0 in group section [%5u]\n"),
4602 section_headers_groups
[entry
]->group_index
);
4608 section_headers_groups
[entry
] = group
;
4610 if (do_section_groups
)
4612 sec
= section_headers
+ entry
;
4613 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4616 g
= xmalloc (sizeof (struct group_list
));
4617 g
->section_index
= entry
;
4618 g
->next
= group
->root
;
4642 } dynamic_relocations
[] =
4644 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4645 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4646 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4649 /* Process the reloc section. */
4652 process_relocs (FILE * file
)
4654 unsigned long rel_size
;
4655 unsigned long rel_offset
;
4661 if (do_using_dynamic
)
4665 int has_dynamic_reloc
;
4668 has_dynamic_reloc
= 0;
4670 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4672 is_rela
= dynamic_relocations
[i
].rela
;
4673 name
= dynamic_relocations
[i
].name
;
4674 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4675 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4677 has_dynamic_reloc
|= rel_size
;
4679 if (is_rela
== UNKNOWN
)
4681 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4682 switch (dynamic_info
[DT_PLTREL
])
4696 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4697 name
, rel_offset
, rel_size
);
4699 dump_relocations (file
,
4700 offset_from_vma (file
, rel_offset
, rel_size
),
4702 dynamic_symbols
, num_dynamic_syms
,
4703 dynamic_strings
, dynamic_strings_length
, is_rela
);
4707 if (! has_dynamic_reloc
)
4708 printf (_("\nThere are no dynamic relocations in this file.\n"));
4712 Elf_Internal_Shdr
* section
;
4716 for (i
= 0, section
= section_headers
;
4717 i
< elf_header
.e_shnum
;
4720 if ( section
->sh_type
!= SHT_RELA
4721 && section
->sh_type
!= SHT_REL
)
4724 rel_offset
= section
->sh_offset
;
4725 rel_size
= section
->sh_size
;
4729 Elf_Internal_Shdr
* strsec
;
4732 printf (_("\nRelocation section "));
4734 if (string_table
== NULL
)
4735 printf ("%d", section
->sh_name
);
4737 printf (_("'%s'"), SECTION_NAME (section
));
4739 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4740 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4742 is_rela
= section
->sh_type
== SHT_RELA
;
4744 if (section
->sh_link
!= 0
4745 && section
->sh_link
< elf_header
.e_shnum
)
4747 Elf_Internal_Shdr
* symsec
;
4748 Elf_Internal_Sym
* symtab
;
4749 unsigned long nsyms
;
4750 unsigned long strtablen
= 0;
4751 char * strtab
= NULL
;
4753 symsec
= section_headers
+ section
->sh_link
;
4754 if (symsec
->sh_type
!= SHT_SYMTAB
4755 && symsec
->sh_type
!= SHT_DYNSYM
)
4758 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4759 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4764 if (symsec
->sh_link
!= 0
4765 && symsec
->sh_link
< elf_header
.e_shnum
)
4767 strsec
= section_headers
+ symsec
->sh_link
;
4769 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4772 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4775 dump_relocations (file
, rel_offset
, rel_size
,
4776 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4782 dump_relocations (file
, rel_offset
, rel_size
,
4783 NULL
, 0, NULL
, 0, is_rela
);
4790 printf (_("\nThere are no relocations in this file.\n"));
4796 /* Process the unwind section. */
4798 #include "unwind-ia64.h"
4800 /* An absolute address consists of a section and an offset. If the
4801 section is NULL, the offset itself is the address, otherwise, the
4802 address equals to LOAD_ADDRESS(section) + offset. */
4806 unsigned short section
;
4810 #define ABSADDR(a) \
4812 ? section_headers [(a).section].sh_addr + (a).offset \
4815 struct ia64_unw_aux_info
4817 struct ia64_unw_table_entry
4819 struct absaddr start
;
4821 struct absaddr info
;
4823 *table
; /* Unwind table. */
4824 unsigned long table_len
; /* Length of unwind table. */
4825 unsigned char * info
; /* Unwind info. */
4826 unsigned long info_size
; /* Size of unwind info. */
4827 bfd_vma info_addr
; /* starting address of unwind info. */
4828 bfd_vma seg_base
; /* Starting address of segment. */
4829 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4830 unsigned long nsyms
; /* Number of symbols. */
4831 char * strtab
; /* The string table. */
4832 unsigned long strtab_size
; /* Size of string table. */
4836 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4837 unsigned long nsyms
,
4838 const char * strtab
,
4839 unsigned long strtab_size
,
4840 struct absaddr addr
,
4841 const char ** symname
,
4844 bfd_vma dist
= 0x100000;
4845 Elf_Internal_Sym
* sym
;
4846 Elf_Internal_Sym
* best
= NULL
;
4849 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4851 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4852 && sym
->st_name
!= 0
4853 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4854 && addr
.offset
>= sym
->st_value
4855 && addr
.offset
- sym
->st_value
< dist
)
4858 dist
= addr
.offset
- sym
->st_value
;
4865 *symname
= (best
->st_name
>= strtab_size
4866 ? "<corrupt>" : strtab
+ best
->st_name
);
4871 *offset
= addr
.offset
;
4875 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
4877 struct ia64_unw_table_entry
* tp
;
4880 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4884 const unsigned char * dp
;
4885 const unsigned char * head
;
4886 const char * procname
;
4888 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4889 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4891 fputs ("\n<", stdout
);
4895 fputs (procname
, stdout
);
4898 printf ("+%lx", (unsigned long) offset
);
4901 fputs (">: [", stdout
);
4902 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4903 fputc ('-', stdout
);
4904 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4905 printf ("], info at +0x%lx\n",
4906 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4908 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4909 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4911 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4912 (unsigned) UNW_VER (stamp
),
4913 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4914 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4915 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4916 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4918 if (UNW_VER (stamp
) != 1)
4920 printf ("\tUnknown version.\n");
4925 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4926 dp
= unw_decode (dp
, in_body
, & in_body
);
4931 slurp_ia64_unwind_table (FILE * file
,
4932 struct ia64_unw_aux_info
* aux
,
4933 Elf_Internal_Shdr
* sec
)
4935 unsigned long size
, nrelas
, i
;
4936 Elf_Internal_Phdr
* seg
;
4937 struct ia64_unw_table_entry
* tep
;
4938 Elf_Internal_Shdr
* relsec
;
4939 Elf_Internal_Rela
* rela
;
4940 Elf_Internal_Rela
* rp
;
4941 unsigned char * table
;
4943 Elf_Internal_Sym
* sym
;
4944 const char * relname
;
4946 /* First, find the starting address of the segment that includes
4949 if (elf_header
.e_phnum
)
4951 if (! get_program_headers (file
))
4954 for (seg
= program_headers
;
4955 seg
< program_headers
+ elf_header
.e_phnum
;
4958 if (seg
->p_type
!= PT_LOAD
)
4961 if (sec
->sh_addr
>= seg
->p_vaddr
4962 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4964 aux
->seg_base
= seg
->p_vaddr
;
4970 /* Second, build the unwind table from the contents of the unwind section: */
4971 size
= sec
->sh_size
;
4972 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4976 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4978 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4980 tep
->start
.section
= SHN_UNDEF
;
4981 tep
->end
.section
= SHN_UNDEF
;
4982 tep
->info
.section
= SHN_UNDEF
;
4985 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4986 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4987 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4991 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4992 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4993 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4995 tep
->start
.offset
+= aux
->seg_base
;
4996 tep
->end
.offset
+= aux
->seg_base
;
4997 tep
->info
.offset
+= aux
->seg_base
;
5001 /* Third, apply any relocations to the unwind table: */
5002 for (relsec
= section_headers
;
5003 relsec
< section_headers
+ elf_header
.e_shnum
;
5006 if (relsec
->sh_type
!= SHT_RELA
5007 || relsec
->sh_info
>= elf_header
.e_shnum
5008 || section_headers
+ relsec
->sh_info
!= sec
)
5011 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5015 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5017 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5018 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5020 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5022 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5026 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5028 switch (rp
->r_offset
/eh_addr_size
% 3)
5031 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5032 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5035 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5036 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5039 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5040 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5050 aux
->table_len
= size
/ (3 * eh_addr_size
);
5055 ia64_process_unwind (FILE * file
)
5057 Elf_Internal_Shdr
* sec
;
5058 Elf_Internal_Shdr
* unwsec
= NULL
;
5059 Elf_Internal_Shdr
* strsec
;
5060 unsigned long i
, unwcount
= 0, unwstart
= 0;
5061 struct ia64_unw_aux_info aux
;
5063 memset (& aux
, 0, sizeof (aux
));
5065 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5067 if (sec
->sh_type
== SHT_SYMTAB
5068 && sec
->sh_link
< elf_header
.e_shnum
)
5070 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5071 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5073 strsec
= section_headers
+ sec
->sh_link
;
5074 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5075 1, strsec
->sh_size
, _("string table"));
5076 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5078 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5083 printf (_("\nThere are no unwind sections in this file.\n"));
5085 while (unwcount
-- > 0)
5090 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5091 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5092 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5099 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5101 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5103 /* We need to find which section group it is in. */
5104 struct group_list
* g
= section_headers_groups
[i
]->root
;
5106 for (; g
!= NULL
; g
= g
->next
)
5108 sec
= section_headers
+ g
->section_index
;
5110 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5115 i
= elf_header
.e_shnum
;
5117 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5119 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5120 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5121 suffix
= SECTION_NAME (unwsec
) + len
;
5122 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5124 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5125 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5130 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5131 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5132 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5133 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5135 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5136 suffix
= SECTION_NAME (unwsec
) + len
;
5137 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5139 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5140 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5144 if (i
== elf_header
.e_shnum
)
5146 printf (_("\nCould not find unwind info section for "));
5148 if (string_table
== NULL
)
5149 printf ("%d", unwsec
->sh_name
);
5151 printf (_("'%s'"), SECTION_NAME (unwsec
));
5155 aux
.info_size
= sec
->sh_size
;
5156 aux
.info_addr
= sec
->sh_addr
;
5157 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5160 printf (_("\nUnwind section "));
5162 if (string_table
== NULL
)
5163 printf ("%d", unwsec
->sh_name
);
5165 printf (_("'%s'"), SECTION_NAME (unwsec
));
5167 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5168 (unsigned long) unwsec
->sh_offset
,
5169 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5171 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5173 if (aux
.table_len
> 0)
5174 dump_ia64_unwind (& aux
);
5177 free ((char *) aux
.table
);
5179 free ((char *) aux
.info
);
5188 free ((char *) aux
.strtab
);
5193 struct hppa_unw_aux_info
5195 struct hppa_unw_table_entry
5197 struct absaddr start
;
5199 unsigned int Cannot_unwind
:1; /* 0 */
5200 unsigned int Millicode
:1; /* 1 */
5201 unsigned int Millicode_save_sr0
:1; /* 2 */
5202 unsigned int Region_description
:2; /* 3..4 */
5203 unsigned int reserved1
:1; /* 5 */
5204 unsigned int Entry_SR
:1; /* 6 */
5205 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5206 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5207 unsigned int Args_stored
:1; /* 16 */
5208 unsigned int Variable_Frame
:1; /* 17 */
5209 unsigned int Separate_Package_Body
:1; /* 18 */
5210 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5211 unsigned int Stack_Overflow_Check
:1; /* 20 */
5212 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5213 unsigned int Ada_Region
:1; /* 22 */
5214 unsigned int cxx_info
:1; /* 23 */
5215 unsigned int cxx_try_catch
:1; /* 24 */
5216 unsigned int sched_entry_seq
:1; /* 25 */
5217 unsigned int reserved2
:1; /* 26 */
5218 unsigned int Save_SP
:1; /* 27 */
5219 unsigned int Save_RP
:1; /* 28 */
5220 unsigned int Save_MRP_in_frame
:1; /* 29 */
5221 unsigned int extn_ptr_defined
:1; /* 30 */
5222 unsigned int Cleanup_defined
:1; /* 31 */
5224 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5225 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5226 unsigned int Large_frame
:1; /* 2 */
5227 unsigned int Pseudo_SP_Set
:1; /* 3 */
5228 unsigned int reserved4
:1; /* 4 */
5229 unsigned int Total_frame_size
:27; /* 5..31 */
5231 *table
; /* Unwind table. */
5232 unsigned long table_len
; /* Length of unwind table. */
5233 bfd_vma seg_base
; /* Starting address of segment. */
5234 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5235 unsigned long nsyms
; /* Number of symbols. */
5236 char * strtab
; /* The string table. */
5237 unsigned long strtab_size
; /* Size of string table. */
5241 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5243 struct hppa_unw_table_entry
* tp
;
5245 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5248 const char * procname
;
5250 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5251 aux
->strtab_size
, tp
->start
, &procname
,
5254 fputs ("\n<", stdout
);
5258 fputs (procname
, stdout
);
5261 printf ("+%lx", (unsigned long) offset
);
5264 fputs (">: [", stdout
);
5265 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5266 fputc ('-', stdout
);
5267 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5270 #define PF(_m) if (tp->_m) printf (#_m " ");
5271 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5274 PF(Millicode_save_sr0
);
5275 /* PV(Region_description); */
5281 PF(Separate_Package_Body
);
5282 PF(Frame_Extension_Millicode
);
5283 PF(Stack_Overflow_Check
);
5284 PF(Two_Instruction_SP_Increment
);
5288 PF(sched_entry_seq
);
5291 PF(Save_MRP_in_frame
);
5292 PF(extn_ptr_defined
);
5293 PF(Cleanup_defined
);
5294 PF(MPE_XL_interrupt_marker
);
5295 PF(HP_UX_interrupt_marker
);
5298 PV(Total_frame_size
);
5307 slurp_hppa_unwind_table (FILE * file
,
5308 struct hppa_unw_aux_info
* aux
,
5309 Elf_Internal_Shdr
* sec
)
5311 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5312 Elf_Internal_Phdr
* seg
;
5313 struct hppa_unw_table_entry
* tep
;
5314 Elf_Internal_Shdr
* relsec
;
5315 Elf_Internal_Rela
* rela
;
5316 Elf_Internal_Rela
* rp
;
5317 unsigned char * table
;
5319 Elf_Internal_Sym
* sym
;
5320 const char * relname
;
5322 /* First, find the starting address of the segment that includes
5325 if (elf_header
.e_phnum
)
5327 if (! get_program_headers (file
))
5330 for (seg
= program_headers
;
5331 seg
< program_headers
+ elf_header
.e_phnum
;
5334 if (seg
->p_type
!= PT_LOAD
)
5337 if (sec
->sh_addr
>= seg
->p_vaddr
5338 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5340 aux
->seg_base
= seg
->p_vaddr
;
5346 /* Second, build the unwind table from the contents of the unwind
5348 size
= sec
->sh_size
;
5349 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5354 nentries
= size
/ unw_ent_size
;
5355 size
= unw_ent_size
* nentries
;
5357 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5359 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5361 unsigned int tmp1
, tmp2
;
5363 tep
->start
.section
= SHN_UNDEF
;
5364 tep
->end
.section
= SHN_UNDEF
;
5366 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5367 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5368 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5369 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5371 tep
->start
.offset
+= aux
->seg_base
;
5372 tep
->end
.offset
+= aux
->seg_base
;
5374 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5375 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5376 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5377 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5378 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5379 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5380 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5381 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5382 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5383 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5384 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5385 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5386 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5387 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5388 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5389 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5390 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5391 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5392 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5393 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5394 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5395 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5396 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5397 tep
->Cleanup_defined
= tmp1
& 0x1;
5399 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5400 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5401 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5402 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5403 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5404 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5408 /* Third, apply any relocations to the unwind table. */
5409 for (relsec
= section_headers
;
5410 relsec
< section_headers
+ elf_header
.e_shnum
;
5413 if (relsec
->sh_type
!= SHT_RELA
5414 || relsec
->sh_info
>= elf_header
.e_shnum
5415 || section_headers
+ relsec
->sh_info
!= sec
)
5418 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5422 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5424 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5425 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5427 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5428 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5430 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5434 i
= rp
->r_offset
/ unw_ent_size
;
5436 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5439 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5440 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5443 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5444 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5454 aux
->table_len
= nentries
;
5460 hppa_process_unwind (FILE * file
)
5462 struct hppa_unw_aux_info aux
;
5463 Elf_Internal_Shdr
* unwsec
= NULL
;
5464 Elf_Internal_Shdr
* strsec
;
5465 Elf_Internal_Shdr
* sec
;
5468 memset (& aux
, 0, sizeof (aux
));
5470 if (string_table
== NULL
)
5473 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5475 if (sec
->sh_type
== SHT_SYMTAB
5476 && sec
->sh_link
< elf_header
.e_shnum
)
5478 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5479 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5481 strsec
= section_headers
+ sec
->sh_link
;
5482 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5483 1, strsec
->sh_size
, _("string table"));
5484 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5486 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5491 printf (_("\nThere are no unwind sections in this file.\n"));
5493 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5495 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5497 printf (_("\nUnwind section "));
5498 printf (_("'%s'"), SECTION_NAME (sec
));
5500 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5501 (unsigned long) sec
->sh_offset
,
5502 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5504 slurp_hppa_unwind_table (file
, &aux
, sec
);
5505 if (aux
.table_len
> 0)
5506 dump_hppa_unwind (&aux
);
5509 free ((char *) aux
.table
);
5517 free ((char *) aux
.strtab
);
5523 process_unwind (FILE * file
)
5525 struct unwind_handler
5528 int (* handler
)(FILE *);
5531 { EM_IA_64
, ia64_process_unwind
},
5532 { EM_PARISC
, hppa_process_unwind
},
5540 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5541 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5542 return handlers
[i
].handler (file
);
5544 printf (_("\nThere are no unwind sections in this file.\n"));
5549 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5551 switch (entry
->d_tag
)
5554 if (entry
->d_un
.d_val
== 0)
5558 static const char * opts
[] =
5560 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5561 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5562 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5563 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5568 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5569 if (entry
->d_un
.d_val
& (1 << cnt
))
5571 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5578 case DT_MIPS_IVERSION
:
5579 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5580 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5582 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5585 case DT_MIPS_TIME_STAMP
:
5590 time_t time
= entry
->d_un
.d_val
;
5591 tmp
= gmtime (&time
);
5592 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5593 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5594 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5595 printf ("Time Stamp: %s\n", timebuf
);
5599 case DT_MIPS_RLD_VERSION
:
5600 case DT_MIPS_LOCAL_GOTNO
:
5601 case DT_MIPS_CONFLICTNO
:
5602 case DT_MIPS_LIBLISTNO
:
5603 case DT_MIPS_SYMTABNO
:
5604 case DT_MIPS_UNREFEXTNO
:
5605 case DT_MIPS_HIPAGENO
:
5606 case DT_MIPS_DELTA_CLASS_NO
:
5607 case DT_MIPS_DELTA_INSTANCE_NO
:
5608 case DT_MIPS_DELTA_RELOC_NO
:
5609 case DT_MIPS_DELTA_SYM_NO
:
5610 case DT_MIPS_DELTA_CLASSSYM_NO
:
5611 case DT_MIPS_COMPACT_SIZE
:
5612 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5616 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5622 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5624 switch (entry
->d_tag
)
5626 case DT_HP_DLD_FLAGS
:
5635 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5636 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5637 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5638 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5639 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5640 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5641 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5642 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5643 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5644 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5645 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5646 { DT_HP_GST
, "HP_GST" },
5647 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5648 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5649 { DT_HP_NODELETE
, "HP_NODELETE" },
5650 { DT_HP_GROUP
, "HP_GROUP" },
5651 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5655 bfd_vma val
= entry
->d_un
.d_val
;
5657 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5658 if (val
& flags
[cnt
].bit
)
5662 fputs (flags
[cnt
].str
, stdout
);
5664 val
^= flags
[cnt
].bit
;
5667 if (val
!= 0 || first
)
5671 print_vma (val
, HEX
);
5677 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5684 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5686 switch (entry
->d_tag
)
5688 case DT_IA_64_PLT_RESERVE
:
5689 /* First 3 slots reserved. */
5690 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5692 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5696 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5703 get_32bit_dynamic_section (FILE * file
)
5705 Elf32_External_Dyn
* edyn
;
5706 Elf32_External_Dyn
* ext
;
5707 Elf_Internal_Dyn
* entry
;
5709 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5710 _("dynamic section"));
5714 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5715 might not have the luxury of section headers. Look for the DT_NULL
5716 terminator to determine the number of entries. */
5717 for (ext
= edyn
, dynamic_nent
= 0;
5718 (char *) ext
< (char *) edyn
+ dynamic_size
;
5722 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5726 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5727 if (dynamic_section
== NULL
)
5729 error (_("Out of memory\n"));
5734 for (ext
= edyn
, entry
= dynamic_section
;
5735 entry
< dynamic_section
+ dynamic_nent
;
5738 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5739 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5748 get_64bit_dynamic_section (FILE * file
)
5750 Elf64_External_Dyn
* edyn
;
5751 Elf64_External_Dyn
* ext
;
5752 Elf_Internal_Dyn
* entry
;
5754 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5755 _("dynamic section"));
5759 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5760 might not have the luxury of section headers. Look for the DT_NULL
5761 terminator to determine the number of entries. */
5762 for (ext
= edyn
, dynamic_nent
= 0;
5763 (char *) ext
< (char *) edyn
+ dynamic_size
;
5767 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5771 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5772 if (dynamic_section
== NULL
)
5774 error (_("Out of memory\n"));
5779 for (ext
= edyn
, entry
= dynamic_section
;
5780 entry
< dynamic_section
+ dynamic_nent
;
5783 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5784 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5793 print_dynamic_flags (bfd_vma flags
)
5801 flag
= flags
& - flags
;
5811 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5812 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5813 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5814 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5815 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5816 default: fputs ("unknown", stdout
); break;
5822 /* Parse and display the contents of the dynamic section. */
5825 process_dynamic_section (FILE * file
)
5827 Elf_Internal_Dyn
* entry
;
5829 if (dynamic_size
== 0)
5832 printf (_("\nThere is no dynamic section in this file.\n"));
5839 if (! get_32bit_dynamic_section (file
))
5842 else if (! get_64bit_dynamic_section (file
))
5845 /* Find the appropriate symbol table. */
5846 if (dynamic_symbols
== NULL
)
5848 for (entry
= dynamic_section
;
5849 entry
< dynamic_section
+ dynamic_nent
;
5852 Elf_Internal_Shdr section
;
5854 if (entry
->d_tag
!= DT_SYMTAB
)
5857 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5859 /* Since we do not know how big the symbol table is,
5860 we default to reading in the entire file (!) and
5861 processing that. This is overkill, I know, but it
5863 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5865 if (archive_file_offset
!= 0)
5866 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5869 if (fseek (file
, 0, SEEK_END
))
5870 error (_("Unable to seek to end of file!\n"));
5872 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5876 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5878 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5880 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5881 if (num_dynamic_syms
< 1)
5883 error (_("Unable to determine the number of symbols to load\n"));
5887 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5891 /* Similarly find a string table. */
5892 if (dynamic_strings
== NULL
)
5894 for (entry
= dynamic_section
;
5895 entry
< dynamic_section
+ dynamic_nent
;
5898 unsigned long offset
;
5901 if (entry
->d_tag
!= DT_STRTAB
)
5904 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5906 /* Since we do not know how big the string table is,
5907 we default to reading in the entire file (!) and
5908 processing that. This is overkill, I know, but it
5911 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5913 if (archive_file_offset
!= 0)
5914 str_tab_len
= archive_file_size
- offset
;
5917 if (fseek (file
, 0, SEEK_END
))
5918 error (_("Unable to seek to end of file\n"));
5919 str_tab_len
= ftell (file
) - offset
;
5922 if (str_tab_len
< 1)
5925 (_("Unable to determine the length of the dynamic string table\n"));
5929 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5930 _("dynamic string table"));
5931 dynamic_strings_length
= str_tab_len
;
5936 /* And find the syminfo section if available. */
5937 if (dynamic_syminfo
== NULL
)
5939 unsigned long syminsz
= 0;
5941 for (entry
= dynamic_section
;
5942 entry
< dynamic_section
+ dynamic_nent
;
5945 if (entry
->d_tag
== DT_SYMINENT
)
5947 /* Note: these braces are necessary to avoid a syntax
5948 error from the SunOS4 C compiler. */
5949 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5951 else if (entry
->d_tag
== DT_SYMINSZ
)
5952 syminsz
= entry
->d_un
.d_val
;
5953 else if (entry
->d_tag
== DT_SYMINFO
)
5954 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5958 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5960 Elf_External_Syminfo
* extsyminfo
;
5961 Elf_External_Syminfo
* extsym
;
5962 Elf_Internal_Syminfo
* syminfo
;
5964 /* There is a syminfo section. Read the data. */
5965 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5966 syminsz
, _("symbol information"));
5970 dynamic_syminfo
= malloc (syminsz
);
5971 if (dynamic_syminfo
== NULL
)
5973 error (_("Out of memory\n"));
5977 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5978 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5979 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5980 ++syminfo
, ++extsym
)
5982 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5983 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5990 if (do_dynamic
&& dynamic_addr
)
5991 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5992 dynamic_addr
, dynamic_nent
);
5994 printf (_(" Tag Type Name/Value\n"));
5996 for (entry
= dynamic_section
;
5997 entry
< dynamic_section
+ dynamic_nent
;
6005 print_vma (entry
->d_tag
, FULL_HEX
);
6006 dtype
= get_dynamic_type (entry
->d_tag
);
6007 printf (" (%s)%*s", dtype
,
6008 ((is_32bit_elf
? 27 : 19)
6009 - (int) strlen (dtype
)),
6013 switch (entry
->d_tag
)
6017 print_dynamic_flags (entry
->d_un
.d_val
);
6027 switch (entry
->d_tag
)
6030 printf (_("Auxiliary library"));
6034 printf (_("Filter library"));
6038 printf (_("Configuration file"));
6042 printf (_("Dependency audit library"));
6046 printf (_("Audit library"));
6050 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6051 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6055 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6064 printf (_("Flags:"));
6066 if (entry
->d_un
.d_val
== 0)
6067 printf (_(" None\n"));
6070 unsigned long int val
= entry
->d_un
.d_val
;
6072 if (val
& DTF_1_PARINIT
)
6074 printf (" PARINIT");
6075 val
^= DTF_1_PARINIT
;
6077 if (val
& DTF_1_CONFEXP
)
6079 printf (" CONFEXP");
6080 val
^= DTF_1_CONFEXP
;
6083 printf (" %lx", val
);
6092 printf (_("Flags:"));
6094 if (entry
->d_un
.d_val
== 0)
6095 printf (_(" None\n"));
6098 unsigned long int val
= entry
->d_un
.d_val
;
6100 if (val
& DF_P1_LAZYLOAD
)
6102 printf (" LAZYLOAD");
6103 val
^= DF_P1_LAZYLOAD
;
6105 if (val
& DF_P1_GROUPPERM
)
6107 printf (" GROUPPERM");
6108 val
^= DF_P1_GROUPPERM
;
6111 printf (" %lx", val
);
6120 printf (_("Flags:"));
6121 if (entry
->d_un
.d_val
== 0)
6122 printf (_(" None\n"));
6125 unsigned long int val
= entry
->d_un
.d_val
;
6132 if (val
& DF_1_GLOBAL
)
6137 if (val
& DF_1_GROUP
)
6142 if (val
& DF_1_NODELETE
)
6144 printf (" NODELETE");
6145 val
^= DF_1_NODELETE
;
6147 if (val
& DF_1_LOADFLTR
)
6149 printf (" LOADFLTR");
6150 val
^= DF_1_LOADFLTR
;
6152 if (val
& DF_1_INITFIRST
)
6154 printf (" INITFIRST");
6155 val
^= DF_1_INITFIRST
;
6157 if (val
& DF_1_NOOPEN
)
6162 if (val
& DF_1_ORIGIN
)
6167 if (val
& DF_1_DIRECT
)
6172 if (val
& DF_1_TRANS
)
6177 if (val
& DF_1_INTERPOSE
)
6179 printf (" INTERPOSE");
6180 val
^= DF_1_INTERPOSE
;
6182 if (val
& DF_1_NODEFLIB
)
6184 printf (" NODEFLIB");
6185 val
^= DF_1_NODEFLIB
;
6187 if (val
& DF_1_NODUMP
)
6192 if (val
& DF_1_CONLFAT
)
6194 printf (" CONLFAT");
6195 val
^= DF_1_CONLFAT
;
6198 printf (" %lx", val
);
6205 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6207 puts (get_dynamic_type (entry
->d_un
.d_val
));
6227 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6233 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6234 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6240 switch (entry
->d_tag
)
6243 printf (_("Shared library: [%s]"), name
);
6245 if (streq (name
, program_interpreter
))
6246 printf (_(" program interpreter"));
6250 printf (_("Library soname: [%s]"), name
);
6254 printf (_("Library rpath: [%s]"), name
);
6258 printf (_("Library runpath: [%s]"), name
);
6262 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6267 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6280 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6284 case DT_INIT_ARRAYSZ
:
6285 case DT_FINI_ARRAYSZ
:
6286 case DT_GNU_CONFLICTSZ
:
6287 case DT_GNU_LIBLISTSZ
:
6290 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6291 printf (" (bytes)\n");
6301 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6314 if (entry
->d_tag
== DT_USED
6315 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6317 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6321 printf (_("Not needed object: [%s]\n"), name
);
6326 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6332 /* The value of this entry is ignored. */
6337 case DT_GNU_PRELINKED
:
6341 time_t time
= entry
->d_un
.d_val
;
6343 tmp
= gmtime (&time
);
6344 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6345 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6346 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6352 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6355 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6361 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6362 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6367 switch (elf_header
.e_machine
)
6370 case EM_MIPS_RS3_LE
:
6371 dynamic_section_mips_val (entry
);
6374 dynamic_section_parisc_val (entry
);
6377 dynamic_section_ia64_val (entry
);
6380 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6392 get_ver_flags (unsigned int flags
)
6394 static char buff
[32];
6401 if (flags
& VER_FLG_BASE
)
6402 strcat (buff
, "BASE ");
6404 if (flags
& VER_FLG_WEAK
)
6406 if (flags
& VER_FLG_BASE
)
6407 strcat (buff
, "| ");
6409 strcat (buff
, "WEAK ");
6412 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6413 strcat (buff
, "| <unknown>");
6418 /* Display the contents of the version sections. */
6420 process_version_sections (FILE * file
)
6422 Elf_Internal_Shdr
* section
;
6429 for (i
= 0, section
= section_headers
;
6430 i
< elf_header
.e_shnum
;
6433 switch (section
->sh_type
)
6435 case SHT_GNU_verdef
:
6437 Elf_External_Verdef
* edefs
;
6445 (_("\nVersion definition section '%s' contains %u entries:\n"),
6446 SECTION_NAME (section
), section
->sh_info
);
6448 printf (_(" Addr: 0x"));
6449 printf_vma (section
->sh_addr
);
6450 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6451 (unsigned long) section
->sh_offset
, section
->sh_link
,
6452 section
->sh_link
< elf_header
.e_shnum
6453 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6456 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6458 _("version definition section"));
6459 endbuf
= (char *) edefs
+ section
->sh_size
;
6463 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6466 Elf_External_Verdef
* edef
;
6467 Elf_Internal_Verdef ent
;
6468 Elf_External_Verdaux
* eaux
;
6469 Elf_Internal_Verdaux aux
;
6473 vstart
= ((char *) edefs
) + idx
;
6474 if (vstart
+ sizeof (*edef
) > endbuf
)
6477 edef
= (Elf_External_Verdef
*) vstart
;
6479 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6480 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6481 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6482 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6483 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6484 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6485 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6487 printf (_(" %#06x: Rev: %d Flags: %s"),
6488 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6490 printf (_(" Index: %d Cnt: %d "),
6491 ent
.vd_ndx
, ent
.vd_cnt
);
6493 vstart
+= ent
.vd_aux
;
6495 eaux
= (Elf_External_Verdaux
*) vstart
;
6497 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6498 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6500 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6501 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6503 printf (_("Name index: %ld\n"), aux
.vda_name
);
6505 isum
= idx
+ ent
.vd_aux
;
6507 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6509 isum
+= aux
.vda_next
;
6510 vstart
+= aux
.vda_next
;
6512 eaux
= (Elf_External_Verdaux
*) vstart
;
6513 if (vstart
+ sizeof (*eaux
) > endbuf
)
6516 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6517 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6519 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6520 printf (_(" %#06x: Parent %d: %s\n"),
6521 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6523 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6524 isum
, j
, aux
.vda_name
);
6527 printf (_(" Version def aux past end of section\n"));
6531 if (cnt
< section
->sh_info
)
6532 printf (_(" Version definition past end of section\n"));
6538 case SHT_GNU_verneed
:
6540 Elf_External_Verneed
* eneed
;
6547 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6548 SECTION_NAME (section
), section
->sh_info
);
6550 printf (_(" Addr: 0x"));
6551 printf_vma (section
->sh_addr
);
6552 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6553 (unsigned long) section
->sh_offset
, section
->sh_link
,
6554 section
->sh_link
< elf_header
.e_shnum
6555 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6558 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6560 _("version need section"));
6561 endbuf
= (char *) eneed
+ section
->sh_size
;
6565 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6567 Elf_External_Verneed
* entry
;
6568 Elf_Internal_Verneed ent
;
6573 vstart
= ((char *) eneed
) + idx
;
6574 if (vstart
+ sizeof (*entry
) > endbuf
)
6577 entry
= (Elf_External_Verneed
*) vstart
;
6579 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6580 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6581 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6582 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6583 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6585 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6587 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6588 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6590 printf (_(" File: %lx"), ent
.vn_file
);
6592 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6594 vstart
+= ent
.vn_aux
;
6596 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6598 Elf_External_Vernaux
* eaux
;
6599 Elf_Internal_Vernaux aux
;
6601 if (vstart
+ sizeof (*eaux
) > endbuf
)
6603 eaux
= (Elf_External_Vernaux
*) vstart
;
6605 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6606 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6607 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6608 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6609 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6611 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6612 printf (_(" %#06x: Name: %s"),
6613 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6615 printf (_(" %#06x: Name index: %lx"),
6616 isum
, aux
.vna_name
);
6618 printf (_(" Flags: %s Version: %d\n"),
6619 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6621 isum
+= aux
.vna_next
;
6622 vstart
+= aux
.vna_next
;
6625 printf (_(" Version need aux past end of section\n"));
6629 if (cnt
< section
->sh_info
)
6630 printf (_(" Version need past end of section\n"));
6636 case SHT_GNU_versym
:
6638 Elf_Internal_Shdr
* link_section
;
6641 unsigned char * edata
;
6642 unsigned short * data
;
6644 Elf_Internal_Sym
* symbols
;
6645 Elf_Internal_Shdr
* string_sec
;
6648 if (section
->sh_link
>= elf_header
.e_shnum
)
6651 link_section
= section_headers
+ section
->sh_link
;
6652 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6654 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6659 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6661 string_sec
= section_headers
+ link_section
->sh_link
;
6663 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6664 string_sec
->sh_size
, _("version string table"));
6668 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6669 SECTION_NAME (section
), total
);
6671 printf (_(" Addr: "));
6672 printf_vma (section
->sh_addr
);
6673 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6674 (unsigned long) section
->sh_offset
, section
->sh_link
,
6675 SECTION_NAME (link_section
));
6677 off
= offset_from_vma (file
,
6678 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6679 total
* sizeof (short));
6680 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6681 _("version symbol data"));
6688 data
= cmalloc (total
, sizeof (short));
6690 for (cnt
= total
; cnt
--;)
6691 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6696 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6699 int check_def
, check_need
;
6702 printf (" %03x:", cnt
);
6704 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6705 switch (data
[cnt
+ j
])
6708 fputs (_(" 0 (*local*) "), stdout
);
6712 fputs (_(" 1 (*global*) "), stdout
);
6716 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6717 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6721 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6722 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6725 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6732 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6734 Elf_Internal_Verneed ivn
;
6735 unsigned long offset
;
6737 offset
= offset_from_vma
6738 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6739 sizeof (Elf_External_Verneed
));
6743 Elf_Internal_Vernaux ivna
;
6744 Elf_External_Verneed evn
;
6745 Elf_External_Vernaux evna
;
6746 unsigned long a_off
;
6748 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6751 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6752 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6754 a_off
= offset
+ ivn
.vn_aux
;
6758 get_data (&evna
, file
, a_off
, sizeof (evna
),
6759 1, _("version need aux (2)"));
6761 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6762 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6764 a_off
+= ivna
.vna_next
;
6766 while (ivna
.vna_other
!= data
[cnt
+ j
]
6767 && ivna
.vna_next
!= 0);
6769 if (ivna
.vna_other
== data
[cnt
+ j
])
6771 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6773 if (ivna
.vna_name
>= string_sec
->sh_size
)
6774 name
= _("*invalid*");
6776 name
= strtab
+ ivna
.vna_name
;
6777 nn
+= printf ("(%s%-*s",
6779 12 - (int) strlen (name
),
6785 offset
+= ivn
.vn_next
;
6787 while (ivn
.vn_next
);
6790 if (check_def
&& data
[cnt
+ j
] != 0x8001
6791 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6793 Elf_Internal_Verdef ivd
;
6794 Elf_External_Verdef evd
;
6795 unsigned long offset
;
6797 offset
= offset_from_vma
6798 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6803 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6806 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6807 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6809 offset
+= ivd
.vd_next
;
6811 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6812 && ivd
.vd_next
!= 0);
6814 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6816 Elf_External_Verdaux evda
;
6817 Elf_Internal_Verdaux ivda
;
6819 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6821 get_data (&evda
, file
,
6822 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6824 _("version def aux"));
6826 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6828 if (ivda
.vda_name
>= string_sec
->sh_size
)
6829 name
= _("*invalid*");
6831 name
= strtab
+ ivda
.vda_name
;
6832 nn
+= printf ("(%s%-*s",
6834 12 - (int) strlen (name
),
6840 printf ("%*c", 18 - nn
, ' ');
6858 printf (_("\nNo version information found in this file.\n"));
6864 get_symbol_binding (unsigned int binding
)
6866 static char buff
[32];
6870 case STB_LOCAL
: return "LOCAL";
6871 case STB_GLOBAL
: return "GLOBAL";
6872 case STB_WEAK
: return "WEAK";
6874 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6875 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6877 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6878 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6880 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6886 get_symbol_type (unsigned int type
)
6888 static char buff
[32];
6892 case STT_NOTYPE
: return "NOTYPE";
6893 case STT_OBJECT
: return "OBJECT";
6894 case STT_FUNC
: return "FUNC";
6895 case STT_SECTION
: return "SECTION";
6896 case STT_FILE
: return "FILE";
6897 case STT_COMMON
: return "COMMON";
6898 case STT_TLS
: return "TLS";
6899 case STT_RELC
: return "RELC";
6900 case STT_SRELC
: return "SRELC";
6902 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6904 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6905 return "THUMB_FUNC";
6907 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6910 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6911 return "PARISC_MILLI";
6913 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6915 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6917 if (elf_header
.e_machine
== EM_PARISC
)
6919 if (type
== STT_HP_OPAQUE
)
6921 if (type
== STT_HP_STUB
)
6925 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6928 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6934 get_symbol_visibility (unsigned int visibility
)
6938 case STV_DEFAULT
: return "DEFAULT";
6939 case STV_INTERNAL
: return "INTERNAL";
6940 case STV_HIDDEN
: return "HIDDEN";
6941 case STV_PROTECTED
: return "PROTECTED";
6947 get_mips_symbol_other (unsigned int other
)
6951 case STO_OPTIONAL
: return "OPTIONAL";
6952 case STO_MIPS16
: return "MIPS16";
6953 case STO_MIPS_PLT
: return "MIPS PLT";
6954 case STO_MIPS_PIC
: return "MIPS PIC";
6955 default: return NULL
;
6960 get_symbol_other (unsigned int other
)
6962 const char * result
= NULL
;
6963 static char buff
[32];
6968 switch (elf_header
.e_machine
)
6971 result
= get_mips_symbol_other (other
);
6979 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6984 get_symbol_index_type (unsigned int type
)
6986 static char buff
[32];
6990 case SHN_UNDEF
: return "UND";
6991 case SHN_ABS
: return "ABS";
6992 case SHN_COMMON
: return "COM";
6994 if (type
== SHN_IA_64_ANSI_COMMON
6995 && elf_header
.e_machine
== EM_IA_64
6996 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6998 else if (elf_header
.e_machine
== EM_X86_64
6999 && type
== SHN_X86_64_LCOMMON
)
7001 else if (type
== SHN_MIPS_SCOMMON
7002 && elf_header
.e_machine
== EM_MIPS
)
7004 else if (type
== SHN_MIPS_SUNDEFINED
7005 && elf_header
.e_machine
== EM_MIPS
)
7007 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7008 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7009 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7010 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7011 else if (type
>= SHN_LORESERVE
)
7012 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7014 sprintf (buff
, "%3d", type
);
7022 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7024 unsigned char * e_data
;
7027 e_data
= cmalloc (number
, ent_size
);
7031 error (_("Out of memory\n"));
7035 if (fread (e_data
, ent_size
, number
, file
) != number
)
7037 error (_("Unable to read in dynamic data\n"));
7041 i_data
= cmalloc (number
, sizeof (*i_data
));
7045 error (_("Out of memory\n"));
7051 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7059 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7061 Elf_Internal_Sym
* psym
;
7064 psym
= dynamic_symbols
+ si
;
7066 n
= print_vma (si
, DEC_5
);
7068 fputs (" " + n
, stdout
);
7069 printf (" %3lu: ", hn
);
7070 print_vma (psym
->st_value
, LONG_HEX
);
7072 print_vma (psym
->st_size
, DEC_5
);
7074 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7075 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7076 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7077 /* Check to see if any other bits in the st_other field are set.
7078 Note - displaying this information disrupts the layout of the
7079 table being generated, but for the moment this case is very
7081 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7082 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7083 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7084 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7085 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7087 printf (" <corrupt: %14ld>", psym
->st_name
);
7091 /* Dump the symbol table. */
7093 process_symbol_table (FILE * file
)
7095 Elf_Internal_Shdr
* section
;
7096 bfd_vma nbuckets
= 0;
7097 bfd_vma nchains
= 0;
7098 bfd_vma
* buckets
= NULL
;
7099 bfd_vma
* chains
= NULL
;
7100 bfd_vma ngnubuckets
= 0;
7101 bfd_vma
* gnubuckets
= NULL
;
7102 bfd_vma
* gnuchains
= NULL
;
7103 bfd_vma gnusymidx
= 0;
7105 if (! do_syms
&& !do_histogram
)
7108 if (dynamic_info
[DT_HASH
]
7110 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7112 unsigned char nb
[8];
7113 unsigned char nc
[8];
7114 int hash_ent_size
= 4;
7116 if ((elf_header
.e_machine
== EM_ALPHA
7117 || elf_header
.e_machine
== EM_S390
7118 || elf_header
.e_machine
== EM_S390_OLD
)
7119 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7123 (archive_file_offset
7124 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7125 sizeof nb
+ sizeof nc
)),
7128 error (_("Unable to seek to start of dynamic information\n"));
7132 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7134 error (_("Failed to read in number of buckets\n"));
7138 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7140 error (_("Failed to read in number of chains\n"));
7144 nbuckets
= byte_get (nb
, hash_ent_size
);
7145 nchains
= byte_get (nc
, hash_ent_size
);
7147 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7148 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7150 if (buckets
== NULL
|| chains
== NULL
)
7154 if (dynamic_info_DT_GNU_HASH
7156 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7158 unsigned char nb
[16];
7159 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7160 bfd_vma buckets_vma
;
7163 (archive_file_offset
7164 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7168 error (_("Unable to seek to start of dynamic information\n"));
7172 if (fread (nb
, 16, 1, file
) != 1)
7174 error (_("Failed to read in number of buckets\n"));
7178 ngnubuckets
= byte_get (nb
, 4);
7179 gnusymidx
= byte_get (nb
+ 4, 4);
7180 bitmaskwords
= byte_get (nb
+ 8, 4);
7181 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7183 buckets_vma
+= bitmaskwords
* 4;
7185 buckets_vma
+= bitmaskwords
* 8;
7188 (archive_file_offset
7189 + offset_from_vma (file
, buckets_vma
, 4)),
7192 error (_("Unable to seek to start of dynamic information\n"));
7196 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7198 if (gnubuckets
== NULL
)
7201 for (i
= 0; i
< ngnubuckets
; i
++)
7202 if (gnubuckets
[i
] != 0)
7204 if (gnubuckets
[i
] < gnusymidx
)
7207 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7208 maxchain
= gnubuckets
[i
];
7211 if (maxchain
== 0xffffffff)
7214 maxchain
-= gnusymidx
;
7217 (archive_file_offset
7218 + offset_from_vma (file
, buckets_vma
7219 + 4 * (ngnubuckets
+ maxchain
), 4)),
7222 error (_("Unable to seek to start of dynamic information\n"));
7228 if (fread (nb
, 4, 1, file
) != 1)
7230 error (_("Failed to determine last chain length\n"));
7234 if (maxchain
+ 1 == 0)
7239 while ((byte_get (nb
, 4) & 1) == 0);
7242 (archive_file_offset
7243 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7246 error (_("Unable to seek to start of dynamic information\n"));
7250 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7252 if (gnuchains
== NULL
)
7256 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7259 && dynamic_strings
!= NULL
)
7263 if (dynamic_info
[DT_HASH
])
7267 printf (_("\nSymbol table for image:\n"));
7269 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7271 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7273 for (hn
= 0; hn
< nbuckets
; hn
++)
7278 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7279 print_dynamic_symbol (si
, hn
);
7283 if (dynamic_info_DT_GNU_HASH
)
7285 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7287 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7289 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7291 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7292 if (gnubuckets
[hn
] != 0)
7294 bfd_vma si
= gnubuckets
[hn
];
7295 bfd_vma off
= si
- gnusymidx
;
7299 print_dynamic_symbol (si
, hn
);
7302 while ((gnuchains
[off
++] & 1) == 0);
7306 else if (do_syms
&& !do_using_dynamic
)
7310 for (i
= 0, section
= section_headers
;
7311 i
< elf_header
.e_shnum
;
7315 char * strtab
= NULL
;
7316 unsigned long int strtab_size
= 0;
7317 Elf_Internal_Sym
* symtab
;
7318 Elf_Internal_Sym
* psym
;
7320 if ( section
->sh_type
!= SHT_SYMTAB
7321 && section
->sh_type
!= SHT_DYNSYM
)
7324 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7325 SECTION_NAME (section
),
7326 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7328 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7330 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7332 symtab
= GET_ELF_SYMBOLS (file
, section
);
7336 if (section
->sh_link
== elf_header
.e_shstrndx
)
7338 strtab
= string_table
;
7339 strtab_size
= string_table_length
;
7341 else if (section
->sh_link
< elf_header
.e_shnum
)
7343 Elf_Internal_Shdr
* string_sec
;
7345 string_sec
= section_headers
+ section
->sh_link
;
7347 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7348 1, string_sec
->sh_size
, _("string table"));
7349 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7352 for (si
= 0, psym
= symtab
;
7353 si
< section
->sh_size
/ section
->sh_entsize
;
7356 printf ("%6d: ", si
);
7357 print_vma (psym
->st_value
, LONG_HEX
);
7359 print_vma (psym
->st_size
, DEC_5
);
7360 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7361 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7362 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7363 /* Check to see if any other bits in the st_other field are set.
7364 Note - displaying this information disrupts the layout of the
7365 table being generated, but for the moment this case is very rare. */
7366 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7367 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7368 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7369 print_symbol (25, psym
->st_name
< strtab_size
7370 ? strtab
+ psym
->st_name
: "<corrupt>");
7372 if (section
->sh_type
== SHT_DYNSYM
&&
7373 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7375 unsigned char data
[2];
7376 unsigned short vers_data
;
7377 unsigned long offset
;
7381 offset
= offset_from_vma
7382 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7383 sizeof data
+ si
* sizeof (vers_data
));
7385 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7386 sizeof (data
), 1, _("version data"));
7388 vers_data
= byte_get (data
, 2);
7390 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7391 && section_headers
[psym
->st_shndx
].sh_type
7394 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7396 if ((vers_data
& 0x8000) || vers_data
> 1)
7398 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7399 && (is_nobits
|| ! check_def
))
7401 Elf_External_Verneed evn
;
7402 Elf_Internal_Verneed ivn
;
7403 Elf_Internal_Vernaux ivna
;
7405 /* We must test both. */
7406 offset
= offset_from_vma
7407 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7412 unsigned long vna_off
;
7414 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7417 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7418 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7420 vna_off
= offset
+ ivn
.vn_aux
;
7424 Elf_External_Vernaux evna
;
7426 get_data (&evna
, file
, vna_off
,
7428 _("version need aux (3)"));
7430 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7431 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7432 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7434 vna_off
+= ivna
.vna_next
;
7436 while (ivna
.vna_other
!= vers_data
7437 && ivna
.vna_next
!= 0);
7439 if (ivna
.vna_other
== vers_data
)
7442 offset
+= ivn
.vn_next
;
7444 while (ivn
.vn_next
!= 0);
7446 if (ivna
.vna_other
== vers_data
)
7449 ivna
.vna_name
< strtab_size
7450 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7454 else if (! is_nobits
)
7455 error (_("bad dynamic symbol\n"));
7462 if (vers_data
!= 0x8001
7463 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7465 Elf_Internal_Verdef ivd
;
7466 Elf_Internal_Verdaux ivda
;
7467 Elf_External_Verdaux evda
;
7468 unsigned long offset
;
7470 offset
= offset_from_vma
7472 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7473 sizeof (Elf_External_Verdef
));
7477 Elf_External_Verdef evd
;
7479 get_data (&evd
, file
, offset
, sizeof (evd
),
7480 1, _("version def"));
7482 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7483 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7484 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7486 offset
+= ivd
.vd_next
;
7488 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7489 && ivd
.vd_next
!= 0);
7491 offset
-= ivd
.vd_next
;
7492 offset
+= ivd
.vd_aux
;
7494 get_data (&evda
, file
, offset
, sizeof (evda
),
7495 1, _("version def aux"));
7497 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7499 if (psym
->st_name
!= ivda
.vda_name
)
7500 printf ((vers_data
& 0x8000)
7502 ivda
.vda_name
< strtab_size
7503 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7513 if (strtab
!= string_table
)
7519 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7521 if (do_histogram
&& buckets
!= NULL
)
7523 unsigned long * lengths
;
7524 unsigned long * counts
;
7527 unsigned long maxlength
= 0;
7528 unsigned long nzero_counts
= 0;
7529 unsigned long nsyms
= 0;
7531 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7532 (unsigned long) nbuckets
);
7533 printf (_(" Length Number %% of total Coverage\n"));
7535 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7536 if (lengths
== NULL
)
7538 error (_("Out of memory\n"));
7541 for (hn
= 0; hn
< nbuckets
; ++hn
)
7543 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7546 if (maxlength
< ++lengths
[hn
])
7551 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7554 error (_("Out of memory\n"));
7558 for (hn
= 0; hn
< nbuckets
; ++hn
)
7559 ++counts
[lengths
[hn
]];
7564 printf (" 0 %-10lu (%5.1f%%)\n",
7565 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7566 for (i
= 1; i
<= maxlength
; ++i
)
7568 nzero_counts
+= counts
[i
] * i
;
7569 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7570 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7571 (nzero_counts
* 100.0) / nsyms
);
7579 if (buckets
!= NULL
)
7585 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7587 unsigned long * lengths
;
7588 unsigned long * counts
;
7590 unsigned long maxlength
= 0;
7591 unsigned long nzero_counts
= 0;
7592 unsigned long nsyms
= 0;
7594 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7595 if (lengths
== NULL
)
7597 error (_("Out of memory\n"));
7601 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7602 (unsigned long) ngnubuckets
);
7603 printf (_(" Length Number %% of total Coverage\n"));
7605 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7606 if (gnubuckets
[hn
] != 0)
7608 bfd_vma off
, length
= 1;
7610 for (off
= gnubuckets
[hn
] - gnusymidx
;
7611 (gnuchains
[off
] & 1) == 0; ++off
)
7613 lengths
[hn
] = length
;
7614 if (length
> maxlength
)
7619 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7622 error (_("Out of memory\n"));
7626 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7627 ++counts
[lengths
[hn
]];
7629 if (ngnubuckets
> 0)
7632 printf (" 0 %-10lu (%5.1f%%)\n",
7633 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7634 for (j
= 1; j
<= maxlength
; ++j
)
7636 nzero_counts
+= counts
[j
] * j
;
7637 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7638 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7639 (nzero_counts
* 100.0) / nsyms
);
7653 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7657 if (dynamic_syminfo
== NULL
7659 /* No syminfo, this is ok. */
7662 /* There better should be a dynamic symbol section. */
7663 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7667 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7668 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7670 printf (_(" Num: Name BoundTo Flags\n"));
7671 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7673 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7675 printf ("%4d: ", i
);
7676 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7677 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7679 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7682 switch (dynamic_syminfo
[i
].si_boundto
)
7684 case SYMINFO_BT_SELF
:
7685 fputs ("SELF ", stdout
);
7687 case SYMINFO_BT_PARENT
:
7688 fputs ("PARENT ", stdout
);
7691 if (dynamic_syminfo
[i
].si_boundto
> 0
7692 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7693 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7695 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7699 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7703 if (flags
& SYMINFO_FLG_DIRECT
)
7705 if (flags
& SYMINFO_FLG_PASSTHRU
)
7706 printf (" PASSTHRU");
7707 if (flags
& SYMINFO_FLG_COPY
)
7709 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7710 printf (" LAZYLOAD");
7718 #ifdef SUPPORT_DISASSEMBLY
7720 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
7722 printf (_("\nAssembly dump of section %s\n"),
7723 SECTION_NAME (section
));
7725 /* XXX -- to be done --- XXX */
7732 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
7734 Elf_Internal_Shdr
* relsec
;
7735 bfd_size_type num_bytes
;
7740 char * name
= SECTION_NAME (section
);
7741 bfd_boolean some_strings_shown
;
7743 num_bytes
= section
->sh_size
;
7745 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7747 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7751 addr
= section
->sh_addr
;
7753 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7758 printf (_("\nString dump of section '%s':\n"), name
);
7760 /* If the section being dumped has relocations against it the user might
7761 be expecting these relocations to have been applied. Check for this
7762 case and issue a warning message in order to avoid confusion.
7763 FIXME: Maybe we ought to have an option that dumps a section with
7765 for (relsec
= section_headers
;
7766 relsec
< section_headers
+ elf_header
.e_shnum
;
7769 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7770 || relsec
->sh_info
>= elf_header
.e_shnum
7771 || section_headers
+ relsec
->sh_info
!= section
7772 || relsec
->sh_size
== 0
7773 || relsec
->sh_link
>= elf_header
.e_shnum
)
7776 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7781 end
= start
+ num_bytes
;
7782 some_strings_shown
= FALSE
;
7786 while (!ISPRINT (* data
))
7793 printf (" [%6tx] %s\n", data
- start
, data
);
7795 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7797 data
+= strlen (data
);
7798 some_strings_shown
= TRUE
;
7802 if (! some_strings_shown
)
7803 printf (_(" No strings found in this section."));
7813 dump_section_as_bytes (Elf_Internal_Shdr
* section
, FILE * file
)
7815 Elf_Internal_Shdr
* relsec
;
7816 bfd_size_type bytes
;
7818 unsigned char * data
;
7819 unsigned char * start
;
7821 bytes
= section
->sh_size
;
7823 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7825 printf (_("\nSection '%s' has no data to dump.\n"),
7826 SECTION_NAME (section
));
7830 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7832 addr
= section
->sh_addr
;
7834 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7839 /* If the section being dumped has relocations against it the user might
7840 be expecting these relocations to have been applied. Check for this
7841 case and issue a warning message in order to avoid confusion.
7842 FIXME: Maybe we ought to have an option that dumps a section with
7844 for (relsec
= section_headers
;
7845 relsec
< section_headers
+ elf_header
.e_shnum
;
7848 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7849 || relsec
->sh_info
>= elf_header
.e_shnum
7850 || section_headers
+ relsec
->sh_info
!= section
7851 || relsec
->sh_size
== 0
7852 || relsec
->sh_link
>= elf_header
.e_shnum
)
7855 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7867 lbytes
= (bytes
> 16 ? 16 : bytes
);
7869 printf (" 0x%8.8lx ", (unsigned long) addr
);
7871 for (j
= 0; j
< 16; j
++)
7874 printf ("%2.2x", data
[j
]);
7882 for (j
= 0; j
< lbytes
; j
++)
7885 if (k
>= ' ' && k
< 0x7f)
7904 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7905 DWARF debug sections. This is a target specific test. Note - we do not
7906 go through the whole including-target-headers-multiple-times route, (as
7907 we have already done with <elf/h8.h>) because this would become very
7908 messy and even then this function would have to contain target specific
7909 information (the names of the relocs instead of their numeric values).
7910 FIXME: This is not the correct way to solve this problem. The proper way
7911 is to have target specific reloc sizing and typing functions created by
7912 the reloc-macros.h header, in the same way that it already creates the
7913 reloc naming functions. */
7916 is_32bit_abs_reloc (unsigned int reloc_type
)
7918 switch (elf_header
.e_machine
)
7922 return reloc_type
== 1; /* R_386_32. */
7924 return reloc_type
== 1; /* R_68K_32. */
7926 return reloc_type
== 1; /* R_860_32. */
7928 return reloc_type
== 1; /* XXX Is this right ? */
7930 return reloc_type
== 1; /* R_ARC_32. */
7932 return reloc_type
== 2; /* R_ARM_ABS32 */
7935 return reloc_type
== 1;
7937 return reloc_type
== 0x12; /* R_byte4_data. */
7939 return reloc_type
== 3; /* R_CRIS_32. */
7942 return reloc_type
== 3; /* R_CR16_NUM32. */
7944 return reloc_type
== 15; /* R_CRX_NUM32. */
7946 return reloc_type
== 1;
7947 case EM_CYGNUS_D10V
:
7949 return reloc_type
== 6; /* R_D10V_32. */
7950 case EM_CYGNUS_D30V
:
7952 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7954 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7955 case EM_CYGNUS_FR30
:
7957 return reloc_type
== 3; /* R_FR30_32. */
7961 return reloc_type
== 1; /* R_H8_DIR32. */
7963 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
7966 return reloc_type
== 2; /* R_IP2K_32. */
7968 return reloc_type
== 2; /* R_IQ2000_32. */
7969 case EM_LATTICEMICO32
:
7970 return reloc_type
== 3; /* R_LM32_32. */
7973 return reloc_type
== 3; /* R_M32C_32. */
7975 return reloc_type
== 34; /* R_M32R_32_RELA. */
7977 return reloc_type
== 1; /* R_MCORE_ADDR32. */
7979 return reloc_type
== 4; /* R_MEP_32. */
7981 return reloc_type
== 2; /* R_MIPS_32. */
7983 return reloc_type
== 4; /* R_MMIX_32. */
7984 case EM_CYGNUS_MN10200
:
7986 return reloc_type
== 1; /* R_MN10200_32. */
7987 case EM_CYGNUS_MN10300
:
7989 return reloc_type
== 1; /* R_MN10300_32. */
7992 return reloc_type
== 1; /* R_MSP43_32. */
7994 return reloc_type
== 2; /* R_MT_32. */
7995 case EM_ALTERA_NIOS2
:
7997 return reloc_type
== 1; /* R_NIOS_32. */
8000 return reloc_type
== 1; /* R_OR32_32. */
8002 return reloc_type
== 1; /* R_PARISC_DIR32. */
8005 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8007 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8009 return reloc_type
== 1; /* R_PPC_ADDR32. */
8011 return reloc_type
== 1; /* R_I370_ADDR31. */
8014 return reloc_type
== 4; /* R_S390_32. */
8016 return reloc_type
== 8; /* R_SCORE_ABS32. */
8018 return reloc_type
== 1; /* R_SH_DIR32. */
8019 case EM_SPARC32PLUS
:
8022 return reloc_type
== 3 /* R_SPARC_32. */
8023 || reloc_type
== 23; /* R_SPARC_UA32. */
8025 return reloc_type
== 6; /* R_SPU_ADDR32 */
8026 case EM_CYGNUS_V850
:
8028 return reloc_type
== 6; /* R_V850_ABS32. */
8030 return reloc_type
== 1; /* R_VAX_32. */
8032 return reloc_type
== 10; /* R_X86_64_32. */
8034 return reloc_type
== 1; /* R_XSTROMY16_32. */
8037 return reloc_type
== 1; /* R_XTENSA_32. */
8040 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8041 elf_header
.e_machine
);
8046 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8047 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8050 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8052 switch (elf_header
.e_machine
)
8056 return reloc_type
== 2; /* R_386_PC32. */
8058 return reloc_type
== 4; /* R_68K_PC32. */
8060 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8062 return reloc_type
== 3; /* R_ARM_REL32 */
8064 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8066 return reloc_type
== 26; /* R_PPC_REL32. */
8068 return reloc_type
== 26; /* R_PPC64_REL32. */
8071 return reloc_type
== 5; /* R_390_PC32. */
8073 return reloc_type
== 2; /* R_SH_REL32. */
8074 case EM_SPARC32PLUS
:
8077 return reloc_type
== 6; /* R_SPARC_DISP32. */
8079 return reloc_type
== 13; /* R_SPU_REL32. */
8081 return reloc_type
== 2; /* R_X86_64_PC32. */
8084 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8086 /* Do not abort or issue an error message here. Not all targets use
8087 pc-relative 32-bit relocs in their DWARF debug information and we
8088 have already tested for target coverage in is_32bit_abs_reloc. A
8089 more helpful warning message will be generated by
8090 debug_apply_relocations anyway, so just return. */
8095 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8096 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8099 is_64bit_abs_reloc (unsigned int reloc_type
)
8101 switch (elf_header
.e_machine
)
8104 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8106 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8108 return reloc_type
== 80; /* R_PARISC_DIR64. */
8110 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8111 case EM_SPARC32PLUS
:
8114 return reloc_type
== 54; /* R_SPARC_UA64. */
8116 return reloc_type
== 1; /* R_X86_64_64. */
8119 return reloc_type
== 22; /* R_S390_64 */
8121 return reloc_type
== 18; /* R_MIPS_64 */
8127 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8128 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8131 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8133 switch (elf_header
.e_machine
)
8136 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8138 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8140 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8142 return reloc_type
== 44; /* R_PPC64_REL64 */
8143 case EM_SPARC32PLUS
:
8146 return reloc_type
== 46; /* R_SPARC_DISP64 */
8148 return reloc_type
== 24; /* R_X86_64_PC64 */
8151 return reloc_type
== 23; /* R_S390_PC64 */
8157 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8158 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8161 is_16bit_abs_reloc (unsigned int reloc_type
)
8163 switch (elf_header
.e_machine
)
8167 return reloc_type
== 4; /* R_AVR_16. */
8168 case EM_CYGNUS_D10V
:
8170 return reloc_type
== 3; /* R_D10V_16. */
8174 return reloc_type
== R_H8_DIR16
;
8177 return reloc_type
== 1; /* R_IP2K_16. */
8180 return reloc_type
== 1; /* R_M32C_16 */
8183 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8184 case EM_ALTERA_NIOS2
:
8186 return reloc_type
== 9; /* R_NIOS_16. */
8192 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8193 relocation entries (possibly formerly used for SHT_GROUP sections). */
8196 is_none_reloc (unsigned int reloc_type
)
8198 switch (elf_header
.e_machine
)
8200 case EM_68K
: /* R_68K_NONE. */
8201 case EM_386
: /* R_386_NONE. */
8202 case EM_SPARC32PLUS
:
8204 case EM_SPARC
: /* R_SPARC_NONE. */
8205 case EM_MIPS
: /* R_MIPS_NONE. */
8206 case EM_PARISC
: /* R_PARISC_NONE. */
8207 case EM_ALPHA
: /* R_ALPHA_NONE. */
8208 case EM_PPC
: /* R_PPC_NONE. */
8209 case EM_PPC64
: /* R_PPC64_NONE. */
8210 case EM_ARM
: /* R_ARM_NONE. */
8211 case EM_IA_64
: /* R_IA64_NONE. */
8212 case EM_SH
: /* R_SH_NONE. */
8214 case EM_S390
: /* R_390_NONE. */
8215 case EM_CRIS
: /* R_CRIS_NONE. */
8216 case EM_X86_64
: /* R_X86_64_NONE. */
8217 case EM_MN10300
: /* R_MN10300_NONE. */
8218 case EM_M32R
: /* R_M32R_NONE. */
8219 return reloc_type
== 0;
8224 /* Uncompresses a section that was compressed using zlib, in place.
8225 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8228 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8231 /* These are just to quiet gcc. */
8236 dwarf_size_type compressed_size
= *size
;
8237 unsigned char * compressed_buffer
= *buffer
;
8238 dwarf_size_type uncompressed_size
;
8239 unsigned char * uncompressed_buffer
;
8242 dwarf_size_type header_size
= 12;
8244 /* Read the zlib header. In this case, it should be "ZLIB" followed
8245 by the uncompressed section size, 8 bytes in big-endian order. */
8246 if (compressed_size
< header_size
8247 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8250 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8251 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8252 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8253 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8254 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8255 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8256 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8257 uncompressed_size
+= compressed_buffer
[11];
8259 /* It is possible the section consists of several compressed
8260 buffers concatenated together, so we uncompress in a loop. */
8264 strm
.avail_in
= compressed_size
- header_size
;
8265 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8266 strm
.avail_out
= uncompressed_size
;
8267 uncompressed_buffer
= xmalloc (uncompressed_size
);
8269 rc
= inflateInit (& strm
);
8270 while (strm
.avail_in
> 0)
8274 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8275 + (uncompressed_size
- strm
.avail_out
));
8276 rc
= inflate (&strm
, Z_FINISH
);
8277 if (rc
!= Z_STREAM_END
)
8279 rc
= inflateReset (& strm
);
8281 rc
= inflateEnd (& strm
);
8283 || strm
.avail_out
!= 0)
8286 free (compressed_buffer
);
8287 *buffer
= uncompressed_buffer
;
8288 *size
= uncompressed_size
;
8292 free (uncompressed_buffer
);
8294 #endif /* HAVE_ZLIB_H */
8297 /* Apply relocations to a debug section. */
8300 debug_apply_relocations (void * file
,
8301 Elf_Internal_Shdr
* section
,
8302 unsigned char * start
)
8304 Elf_Internal_Shdr
* relsec
;
8305 unsigned char * end
= start
+ section
->sh_size
;
8307 if (elf_header
.e_type
!= ET_REL
)
8310 /* Find the reloc section associated with the debug section. */
8311 for (relsec
= section_headers
;
8312 relsec
< section_headers
+ elf_header
.e_shnum
;
8315 bfd_boolean is_rela
;
8316 unsigned long num_relocs
;
8317 Elf_Internal_Rela
* relocs
;
8318 Elf_Internal_Rela
* rp
;
8319 Elf_Internal_Shdr
* symsec
;
8320 Elf_Internal_Sym
* symtab
;
8321 Elf_Internal_Sym
* sym
;
8323 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8324 || relsec
->sh_info
>= elf_header
.e_shnum
8325 || section_headers
+ relsec
->sh_info
!= section
8326 || relsec
->sh_size
== 0
8327 || relsec
->sh_link
>= elf_header
.e_shnum
)
8330 is_rela
= relsec
->sh_type
== SHT_RELA
;
8334 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8335 & relocs
, & num_relocs
))
8340 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8341 & relocs
, & num_relocs
))
8345 /* SH uses RELA but uses in place value instead of the addend field. */
8346 if (elf_header
.e_machine
== EM_SH
)
8349 symsec
= section_headers
+ relsec
->sh_link
;
8350 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8352 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8355 unsigned int reloc_type
;
8356 unsigned int reloc_size
;
8357 unsigned char * loc
;
8359 reloc_type
= get_reloc_type (rp
->r_info
);
8361 if (is_none_reloc (reloc_type
))
8364 if (is_32bit_abs_reloc (reloc_type
)
8365 || is_32bit_pcrel_reloc (reloc_type
))
8367 else if (is_64bit_abs_reloc (reloc_type
)
8368 || is_64bit_pcrel_reloc (reloc_type
))
8370 else if (is_16bit_abs_reloc (reloc_type
))
8374 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8375 reloc_type
, SECTION_NAME (section
));
8379 loc
= start
+ rp
->r_offset
;
8380 if ((loc
+ reloc_size
) > end
)
8382 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8383 (unsigned long) rp
->r_offset
,
8384 SECTION_NAME (section
));
8388 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8390 /* If the reloc has a symbol associated with it,
8391 make sure that it is of an appropriate type.
8393 Relocations against symbols without type can happen.
8394 Gcc -feliminate-dwarf2-dups may generate symbols
8395 without type for debug info.
8397 Icc generates relocations against function symbols
8398 instead of local labels.
8400 Relocations against object symbols can happen, eg when
8401 referencing a global array. For an example of this see
8402 the _clz.o binary in libgcc.a. */
8404 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8406 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8407 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8408 (long int)(rp
- relocs
),
8409 SECTION_NAME (relsec
));
8413 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8415 if (is_32bit_pcrel_reloc (reloc_type
)
8416 || is_64bit_pcrel_reloc (reloc_type
))
8418 /* On HPPA, all pc-relative relocations are biased by 8. */
8419 if (elf_header
.e_machine
== EM_PARISC
)
8421 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8425 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8435 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8436 Elf_Internal_Shdr
* sec
, void * file
)
8438 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8440 int section_is_compressed
;
8442 /* If it is already loaded, do nothing. */
8443 if (section
->start
!= NULL
)
8446 section_is_compressed
= section
->name
== section
->compressed_name
;
8448 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8449 section
->address
= sec
->sh_addr
;
8450 section
->size
= sec
->sh_size
;
8451 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8453 if (section
->start
== NULL
)
8456 if (section_is_compressed
)
8457 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8460 if (debug_displays
[debug
].relocate
)
8461 debug_apply_relocations (file
, sec
, section
->start
);
8467 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8469 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8470 Elf_Internal_Shdr
* sec
;
8472 /* Locate the debug section. */
8473 sec
= find_section (section
->uncompressed_name
);
8475 section
->name
= section
->uncompressed_name
;
8478 sec
= find_section (section
->compressed_name
);
8480 section
->name
= section
->compressed_name
;
8485 return load_specific_debug_section (debug
, sec
, file
);
8489 free_debug_section (enum dwarf_section_display_enum debug
)
8491 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8493 if (section
->start
== NULL
)
8496 free ((char *) section
->start
);
8497 section
->start
= NULL
;
8498 section
->address
= 0;
8503 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8505 char * name
= SECTION_NAME (section
);
8506 bfd_size_type length
;
8508 enum dwarf_section_display_enum i
;
8510 length
= section
->sh_size
;
8513 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8517 if (const_strneq (name
, ".gnu.linkonce.wi."))
8518 name
= ".debug_info";
8520 /* See if we know how to display the contents of this section. */
8521 for (i
= 0; i
< max
; i
++)
8522 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8523 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8525 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8526 int secondary
= (section
!= find_section (name
));
8529 free_debug_section (i
);
8531 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8532 sec
->name
= sec
->uncompressed_name
;
8534 sec
->name
= sec
->compressed_name
;
8535 if (load_specific_debug_section (i
, section
, file
))
8537 result
&= debug_displays
[i
].display (sec
, file
);
8539 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8540 free_debug_section (i
);
8548 printf (_("Unrecognized debug section: %s\n"), name
);
8555 /* Set DUMP_SECTS for all sections where dumps were requested
8556 based on section name. */
8559 initialise_dumps_byname (void)
8561 struct dump_list_entry
* cur
;
8563 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8568 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8569 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8571 request_dump_bynumber (i
, cur
->type
);
8576 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8582 process_section_contents (FILE * file
)
8584 Elf_Internal_Shdr
* section
;
8590 initialise_dumps_byname ();
8592 for (i
= 0, section
= section_headers
;
8593 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8596 #ifdef SUPPORT_DISASSEMBLY
8597 if (dump_sects
[i
] & DISASS_DUMP
)
8598 disassemble_section (section
, file
);
8600 if (dump_sects
[i
] & HEX_DUMP
)
8601 dump_section_as_bytes (section
, file
);
8603 if (dump_sects
[i
] & DEBUG_DUMP
)
8604 display_debug_section (section
, file
);
8606 if (dump_sects
[i
] & STRING_DUMP
)
8607 dump_section_as_strings (section
, file
);
8610 /* Check to see if the user requested a
8611 dump of a section that does not exist. */
8612 while (i
++ < num_dump_sects
)
8614 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8618 process_mips_fpe_exception (int mask
)
8623 if (mask
& OEX_FPU_INEX
)
8624 fputs ("INEX", stdout
), first
= 0;
8625 if (mask
& OEX_FPU_UFLO
)
8626 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8627 if (mask
& OEX_FPU_OFLO
)
8628 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8629 if (mask
& OEX_FPU_DIV0
)
8630 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8631 if (mask
& OEX_FPU_INVAL
)
8632 printf ("%sINVAL", first
? "" : "|");
8635 fputs ("0", stdout
);
8638 /* ARM EABI attributes section. */
8643 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8645 const char ** table
;
8646 } arm_attr_public_tag
;
8648 static const char * arm_attr_tag_CPU_arch
[] =
8649 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8650 "v6K", "v7", "v6-M", "v6S-M"};
8651 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8652 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8653 {"No", "Thumb-1", "Thumb-2"};
8654 static const char * arm_attr_tag_VFP_arch
[] =
8655 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8656 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8657 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8658 static const char * arm_attr_tag_PCS_config
[] =
8659 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8660 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8661 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8662 {"V6", "SB", "TLS", "Unused"};
8663 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8664 {"Absolute", "PC-relative", "SB-relative", "None"};
8665 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8666 {"Absolute", "PC-relative", "None"};
8667 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8668 {"None", "direct", "GOT-indirect"};
8669 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8670 {"None", "??? 1", "2", "??? 3", "4"};
8671 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8672 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8673 {"Unused", "Needed", "Sign only"};
8674 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8675 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8676 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8677 {"Unused", "Finite", "RTABI", "IEEE 754"};
8678 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8679 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8680 {"No", "Yes, except leaf SP", "Yes"};
8681 static const char * arm_attr_tag_ABI_enum_size
[] =
8682 {"Unused", "small", "int", "forced to int"};
8683 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8684 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8685 static const char * arm_attr_tag_ABI_VFP_args
[] =
8686 {"AAPCS", "VFP registers", "custom"};
8687 static const char * arm_attr_tag_ABI_WMMX_args
[] =
8688 {"AAPCS", "WMMX registers", "custom"};
8689 static const char * arm_attr_tag_ABI_optimization_goals
[] =
8690 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8691 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8692 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
8693 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8694 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8695 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8696 static const char * arm_attr_tag_VFP_HP_extension
[] =
8697 {"Not Allowed", "Allowed"};
8698 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
8699 {"None", "IEEE 754", "Alternative Format"};
8700 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8701 static const char * arm_attr_tag_Virtualization_use
[] =
8702 {"Not Allowed", "Allowed"};
8703 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8705 #define LOOKUP(id, name) \
8706 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8707 static arm_attr_public_tag arm_attr_public_tags
[] =
8709 {4, "CPU_raw_name", 1, NULL
},
8710 {5, "CPU_name", 1, NULL
},
8711 LOOKUP(6, CPU_arch
),
8712 {7, "CPU_arch_profile", 0, NULL
},
8713 LOOKUP(8, ARM_ISA_use
),
8714 LOOKUP(9, THUMB_ISA_use
),
8715 LOOKUP(10, VFP_arch
),
8716 LOOKUP(11, WMMX_arch
),
8717 LOOKUP(12, Advanced_SIMD_arch
),
8718 LOOKUP(13, PCS_config
),
8719 LOOKUP(14, ABI_PCS_R9_use
),
8720 LOOKUP(15, ABI_PCS_RW_data
),
8721 LOOKUP(16, ABI_PCS_RO_data
),
8722 LOOKUP(17, ABI_PCS_GOT_use
),
8723 LOOKUP(18, ABI_PCS_wchar_t
),
8724 LOOKUP(19, ABI_FP_rounding
),
8725 LOOKUP(20, ABI_FP_denormal
),
8726 LOOKUP(21, ABI_FP_exceptions
),
8727 LOOKUP(22, ABI_FP_user_exceptions
),
8728 LOOKUP(23, ABI_FP_number_model
),
8729 LOOKUP(24, ABI_align8_needed
),
8730 LOOKUP(25, ABI_align8_preserved
),
8731 LOOKUP(26, ABI_enum_size
),
8732 LOOKUP(27, ABI_HardFP_use
),
8733 LOOKUP(28, ABI_VFP_args
),
8734 LOOKUP(29, ABI_WMMX_args
),
8735 LOOKUP(30, ABI_optimization_goals
),
8736 LOOKUP(31, ABI_FP_optimization_goals
),
8737 {32, "compatibility", 0, NULL
},
8738 LOOKUP(34, CPU_unaligned_access
),
8739 LOOKUP(36, VFP_HP_extension
),
8740 LOOKUP(38, ABI_FP_16bit_format
),
8741 {64, "nodefaults", 0, NULL
},
8742 {65, "also_compatible_with", 0, NULL
},
8743 LOOKUP(66, T2EE_use
),
8744 {67, "conformance", 1, NULL
},
8745 LOOKUP(68, Virtualization_use
),
8746 LOOKUP(70, MPextension_use
)
8750 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8754 read_uleb128 (unsigned char * p
, unsigned int * plen
)
8768 val
|= ((unsigned int)c
& 0x7f) << shift
;
8777 static unsigned char *
8778 display_arm_attribute (unsigned char * p
)
8783 arm_attr_public_tag
* attr
;
8787 tag
= read_uleb128 (p
, &len
);
8790 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
8792 if (arm_attr_public_tags
[i
].tag
== tag
)
8794 attr
= &arm_attr_public_tags
[i
];
8801 printf (" Tag_%s: ", attr
->name
);
8807 case 7: /* Tag_CPU_arch_profile. */
8808 val
= read_uleb128 (p
, &len
);
8812 case 0: printf ("None\n"); break;
8813 case 'A': printf ("Application\n"); break;
8814 case 'R': printf ("Realtime\n"); break;
8815 case 'M': printf ("Microcontroller\n"); break;
8816 default: printf ("??? (%d)\n", val
); break;
8820 case 32: /* Tag_compatibility. */
8821 val
= read_uleb128 (p
, &len
);
8823 printf ("flag = %d, vendor = %s\n", val
, p
);
8824 p
+= strlen ((char *) p
) + 1;
8827 case 64: /* Tag_nodefaults. */
8832 case 65: /* Tag_also_compatible_with. */
8833 val
= read_uleb128 (p
, &len
);
8835 if (val
== 6 /* Tag_CPU_arch. */)
8837 val
= read_uleb128 (p
, &len
);
8839 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
8840 printf ("??? (%d)\n", val
);
8842 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
8846 while (*(p
++) != '\0' /* NUL terminator. */);
8860 assert (attr
->type
& 0x80);
8861 val
= read_uleb128 (p
, &len
);
8863 type
= attr
->type
& 0x7f;
8865 printf ("??? (%d)\n", val
);
8867 printf ("%s\n", attr
->table
[val
]);
8874 type
= 1; /* String. */
8876 type
= 2; /* uleb128. */
8877 printf (" Tag_unknown_%d: ", tag
);
8882 printf ("\"%s\"\n", p
);
8883 p
+= strlen ((char *) p
) + 1;
8887 val
= read_uleb128 (p
, &len
);
8889 printf ("%d (0x%x)\n", val
, val
);
8895 static unsigned char *
8896 display_gnu_attribute (unsigned char * p
,
8897 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8904 tag
= read_uleb128 (p
, &len
);
8907 /* Tag_compatibility is the only generic GNU attribute defined at
8911 val
= read_uleb128 (p
, &len
);
8913 printf ("flag = %d, vendor = %s\n", val
, p
);
8914 p
+= strlen ((char *) p
) + 1;
8918 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8919 return display_proc_gnu_attribute (p
, tag
);
8922 type
= 1; /* String. */
8924 type
= 2; /* uleb128. */
8925 printf (" Tag_unknown_%d: ", tag
);
8929 printf ("\"%s\"\n", p
);
8930 p
+= strlen ((char *) p
) + 1;
8934 val
= read_uleb128 (p
, &len
);
8936 printf ("%d (0x%x)\n", val
, val
);
8942 static unsigned char *
8943 display_power_gnu_attribute (unsigned char * p
, int tag
)
8949 if (tag
== Tag_GNU_Power_ABI_FP
)
8951 val
= read_uleb128 (p
, &len
);
8953 printf (" Tag_GNU_Power_ABI_FP: ");
8958 printf ("Hard or soft float\n");
8961 printf ("Hard float\n");
8964 printf ("Soft float\n");
8967 printf ("Single-precision hard float\n");
8970 printf ("??? (%d)\n", val
);
8976 if (tag
== Tag_GNU_Power_ABI_Vector
)
8978 val
= read_uleb128 (p
, &len
);
8980 printf (" Tag_GNU_Power_ABI_Vector: ");
8987 printf ("Generic\n");
8990 printf ("AltiVec\n");
8996 printf ("??? (%d)\n", val
);
9002 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9004 val
= read_uleb128 (p
, &len
);
9006 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9016 printf ("Memory\n");
9019 printf ("??? (%d)\n", val
);
9026 type
= 1; /* String. */
9028 type
= 2; /* uleb128. */
9029 printf (" Tag_unknown_%d: ", tag
);
9033 printf ("\"%s\"\n", p
);
9034 p
+= strlen ((char *) p
) + 1;
9038 val
= read_uleb128 (p
, &len
);
9040 printf ("%d (0x%x)\n", val
, val
);
9046 static unsigned char *
9047 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9053 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9055 val
= read_uleb128 (p
, &len
);
9057 printf (" Tag_GNU_MIPS_ABI_FP: ");
9062 printf ("Hard or soft float\n");
9065 printf ("Hard float (-mdouble-float)\n");
9068 printf ("Hard float (-msingle-float)\n");
9071 printf ("Soft float\n");
9074 printf ("64-bit float (-mips32r2 -mfp64)\n");
9077 printf ("??? (%d)\n", val
);
9084 type
= 1; /* String. */
9086 type
= 2; /* uleb128. */
9087 printf (" Tag_unknown_%d: ", tag
);
9091 printf ("\"%s\"\n", p
);
9092 p
+= strlen ((char *) p
) + 1;
9096 val
= read_uleb128 (p
, &len
);
9098 printf ("%d (0x%x)\n", val
, val
);
9105 process_attributes (FILE * file
,
9106 const char * public_name
,
9107 unsigned int proc_type
,
9108 unsigned char * (* display_pub_attribute
) (unsigned char *),
9109 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9111 Elf_Internal_Shdr
* sect
;
9112 unsigned char * contents
;
9114 unsigned char * end
;
9115 bfd_vma section_len
;
9119 /* Find the section header so that we get the size. */
9120 for (i
= 0, sect
= section_headers
;
9121 i
< elf_header
.e_shnum
;
9124 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9127 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9129 if (contents
== NULL
)
9135 len
= sect
->sh_size
- 1;
9141 bfd_boolean public_section
;
9142 bfd_boolean gnu_section
;
9144 section_len
= byte_get (p
, 4);
9147 if (section_len
> len
)
9149 printf (_("ERROR: Bad section length (%d > %d)\n"),
9150 (int) section_len
, (int) len
);
9155 printf ("Attribute Section: %s\n", p
);
9157 if (public_name
&& streq ((char *) p
, public_name
))
9158 public_section
= TRUE
;
9160 public_section
= FALSE
;
9162 if (streq ((char *) p
, "gnu"))
9165 gnu_section
= FALSE
;
9167 namelen
= strlen ((char *) p
) + 1;
9169 section_len
-= namelen
+ 4;
9171 while (section_len
> 0)
9177 size
= byte_get (p
, 4);
9178 if (size
> section_len
)
9180 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9181 (int) size
, (int) section_len
);
9185 section_len
-= size
;
9192 printf ("File Attributes\n");
9195 printf ("Section Attributes:");
9198 printf ("Symbol Attributes:");
9204 val
= read_uleb128 (p
, &i
);
9208 printf (" %d", val
);
9213 printf ("Unknown tag: %d\n", tag
);
9214 public_section
= FALSE
;
9221 p
= display_pub_attribute (p
);
9223 else if (gnu_section
)
9226 p
= display_gnu_attribute (p
,
9227 display_proc_gnu_attribute
);
9231 /* ??? Do something sensible, like dump hex. */
9232 printf (" Unknown section contexts\n");
9239 printf (_("Unknown format '%c'\n"), *p
);
9247 process_arm_specific (FILE * file
)
9249 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9250 display_arm_attribute
, NULL
);
9254 process_power_specific (FILE * file
)
9256 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9257 display_power_gnu_attribute
);
9260 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9261 Print the Address, Access and Initial fields of an entry at VMA ADDR
9262 and return the VMA of the next entry. */
9265 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9268 print_vma (addr
, LONG_HEX
);
9270 if (addr
< pltgot
+ 0xfff0)
9271 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9273 printf ("%10s", "");
9276 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9281 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9282 print_vma (entry
, LONG_HEX
);
9284 return addr
+ (is_32bit_elf
? 4 : 8);
9287 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9288 PLTGOT. Print the Address and Initial fields of an entry at VMA
9289 ADDR and return the VMA of the next entry. */
9292 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9295 print_vma (addr
, LONG_HEX
);
9298 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9303 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9304 print_vma (entry
, LONG_HEX
);
9306 return addr
+ (is_32bit_elf
? 4 : 8);
9310 process_mips_specific (FILE * file
)
9312 Elf_Internal_Dyn
* entry
;
9313 size_t liblist_offset
= 0;
9314 size_t liblistno
= 0;
9315 size_t conflictsno
= 0;
9316 size_t options_offset
= 0;
9317 size_t conflicts_offset
= 0;
9318 size_t pltrelsz
= 0;
9321 bfd_vma mips_pltgot
= 0;
9323 bfd_vma local_gotno
= 0;
9325 bfd_vma symtabno
= 0;
9327 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9328 display_mips_gnu_attribute
);
9330 /* We have a lot of special sections. Thanks SGI! */
9331 if (dynamic_section
== NULL
)
9332 /* No information available. */
9335 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9336 switch (entry
->d_tag
)
9338 case DT_MIPS_LIBLIST
:
9340 = offset_from_vma (file
, entry
->d_un
.d_val
,
9341 liblistno
* sizeof (Elf32_External_Lib
));
9343 case DT_MIPS_LIBLISTNO
:
9344 liblistno
= entry
->d_un
.d_val
;
9346 case DT_MIPS_OPTIONS
:
9347 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9349 case DT_MIPS_CONFLICT
:
9351 = offset_from_vma (file
, entry
->d_un
.d_val
,
9352 conflictsno
* sizeof (Elf32_External_Conflict
));
9354 case DT_MIPS_CONFLICTNO
:
9355 conflictsno
= entry
->d_un
.d_val
;
9358 pltgot
= entry
->d_un
.d_ptr
;
9360 case DT_MIPS_LOCAL_GOTNO
:
9361 local_gotno
= entry
->d_un
.d_val
;
9363 case DT_MIPS_GOTSYM
:
9364 gotsym
= entry
->d_un
.d_val
;
9366 case DT_MIPS_SYMTABNO
:
9367 symtabno
= entry
->d_un
.d_val
;
9369 case DT_MIPS_PLTGOT
:
9370 mips_pltgot
= entry
->d_un
.d_ptr
;
9373 pltrel
= entry
->d_un
.d_val
;
9376 pltrelsz
= entry
->d_un
.d_val
;
9379 jmprel
= entry
->d_un
.d_ptr
;
9385 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9387 Elf32_External_Lib
* elib
;
9390 elib
= get_data (NULL
, file
, liblist_offset
,
9391 liblistno
, sizeof (Elf32_External_Lib
),
9395 printf ("\nSection '.liblist' contains %lu entries:\n",
9396 (unsigned long) liblistno
);
9397 fputs (" Library Time Stamp Checksum Version Flags\n",
9400 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9407 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9408 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9409 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9410 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9411 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9413 tmp
= gmtime (&time
);
9414 snprintf (timebuf
, sizeof (timebuf
),
9415 "%04u-%02u-%02uT%02u:%02u:%02u",
9416 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9417 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9419 printf ("%3lu: ", (unsigned long) cnt
);
9420 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9421 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9423 printf ("<corrupt: %9ld>", liblist
.l_name
);
9424 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9427 if (liblist
.l_flags
== 0)
9438 { " EXACT_MATCH", LL_EXACT_MATCH
},
9439 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9440 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9441 { " EXPORTS", LL_EXPORTS
},
9442 { " DELAY_LOAD", LL_DELAY_LOAD
},
9443 { " DELTA", LL_DELTA
}
9445 int flags
= liblist
.l_flags
;
9448 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9449 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9451 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9452 flags
^= l_flags_vals
[fcnt
].bit
;
9455 printf (" %#x", (unsigned int) flags
);
9465 if (options_offset
!= 0)
9467 Elf_External_Options
* eopt
;
9468 Elf_Internal_Shdr
* sect
= section_headers
;
9469 Elf_Internal_Options
* iopt
;
9470 Elf_Internal_Options
* option
;
9474 /* Find the section header so that we get the size. */
9475 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9478 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9482 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9485 error (_("Out of memory\n"));
9492 while (offset
< sect
->sh_size
)
9494 Elf_External_Options
* eoption
;
9496 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9498 option
->kind
= BYTE_GET (eoption
->kind
);
9499 option
->size
= BYTE_GET (eoption
->size
);
9500 option
->section
= BYTE_GET (eoption
->section
);
9501 option
->info
= BYTE_GET (eoption
->info
);
9503 offset
+= option
->size
;
9509 printf (_("\nSection '%s' contains %d entries:\n"),
9510 SECTION_NAME (sect
), cnt
);
9518 switch (option
->kind
)
9521 /* This shouldn't happen. */
9522 printf (" NULL %d %lx", option
->section
, option
->info
);
9525 printf (" REGINFO ");
9526 if (elf_header
.e_machine
== EM_MIPS
)
9529 Elf32_External_RegInfo
* ereg
;
9530 Elf32_RegInfo reginfo
;
9532 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9533 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9534 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9535 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9536 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9537 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9538 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9540 printf ("GPR %08lx GP 0x%lx\n",
9542 (unsigned long) reginfo
.ri_gp_value
);
9543 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9544 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9545 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9550 Elf64_External_RegInfo
* ereg
;
9551 Elf64_Internal_RegInfo reginfo
;
9553 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9554 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9555 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9556 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9557 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9558 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9559 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9561 printf ("GPR %08lx GP 0x",
9562 reginfo
.ri_gprmask
);
9563 printf_vma (reginfo
.ri_gp_value
);
9566 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9567 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9568 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9572 case ODK_EXCEPTIONS
:
9573 fputs (" EXCEPTIONS fpe_min(", stdout
);
9574 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9575 fputs (") fpe_max(", stdout
);
9576 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9577 fputs (")", stdout
);
9579 if (option
->info
& OEX_PAGE0
)
9580 fputs (" PAGE0", stdout
);
9581 if (option
->info
& OEX_SMM
)
9582 fputs (" SMM", stdout
);
9583 if (option
->info
& OEX_FPDBUG
)
9584 fputs (" FPDBUG", stdout
);
9585 if (option
->info
& OEX_DISMISS
)
9586 fputs (" DISMISS", stdout
);
9589 fputs (" PAD ", stdout
);
9590 if (option
->info
& OPAD_PREFIX
)
9591 fputs (" PREFIX", stdout
);
9592 if (option
->info
& OPAD_POSTFIX
)
9593 fputs (" POSTFIX", stdout
);
9594 if (option
->info
& OPAD_SYMBOL
)
9595 fputs (" SYMBOL", stdout
);
9598 fputs (" HWPATCH ", stdout
);
9599 if (option
->info
& OHW_R4KEOP
)
9600 fputs (" R4KEOP", stdout
);
9601 if (option
->info
& OHW_R8KPFETCH
)
9602 fputs (" R8KPFETCH", stdout
);
9603 if (option
->info
& OHW_R5KEOP
)
9604 fputs (" R5KEOP", stdout
);
9605 if (option
->info
& OHW_R5KCVTL
)
9606 fputs (" R5KCVTL", stdout
);
9609 fputs (" FILL ", stdout
);
9610 /* XXX Print content of info word? */
9613 fputs (" TAGS ", stdout
);
9614 /* XXX Print content of info word? */
9617 fputs (" HWAND ", stdout
);
9618 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9619 fputs (" R4KEOP_CHECKED", stdout
);
9620 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9621 fputs (" R4KEOP_CLEAN", stdout
);
9624 fputs (" HWOR ", stdout
);
9625 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9626 fputs (" R4KEOP_CHECKED", stdout
);
9627 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9628 fputs (" R4KEOP_CLEAN", stdout
);
9631 printf (" GP_GROUP %#06lx self-contained %#06lx",
9632 option
->info
& OGP_GROUP
,
9633 (option
->info
& OGP_SELF
) >> 16);
9636 printf (" IDENT %#06lx self-contained %#06lx",
9637 option
->info
& OGP_GROUP
,
9638 (option
->info
& OGP_SELF
) >> 16);
9641 /* This shouldn't happen. */
9642 printf (" %3d ??? %d %lx",
9643 option
->kind
, option
->section
, option
->info
);
9647 len
= sizeof (* eopt
);
9648 while (len
< option
->size
)
9649 if (((char *) option
)[len
] >= ' '
9650 && ((char *) option
)[len
] < 0x7f)
9651 printf ("%c", ((char *) option
)[len
++]);
9653 printf ("\\%03o", ((char *) option
)[len
++]);
9655 fputs ("\n", stdout
);
9663 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9665 Elf32_Conflict
* iconf
;
9668 if (dynamic_symbols
== NULL
)
9670 error (_("conflict list found without a dynamic symbol table\n"));
9674 iconf
= cmalloc (conflictsno
, sizeof (* iconf
));
9677 error (_("Out of memory\n"));
9683 Elf32_External_Conflict
* econf32
;
9685 econf32
= get_data (NULL
, file
, conflicts_offset
,
9686 conflictsno
, sizeof (* econf32
), _("conflict"));
9690 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9691 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9697 Elf64_External_Conflict
* econf64
;
9699 econf64
= get_data (NULL
, file
, conflicts_offset
,
9700 conflictsno
, sizeof (* econf64
), _("conflict"));
9704 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9705 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9710 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9711 (unsigned long) conflictsno
);
9712 puts (_(" Num: Index Value Name"));
9714 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9716 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9718 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9719 print_vma (psym
->st_value
, FULL_HEX
);
9721 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9722 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9724 printf ("<corrupt: %14ld>", psym
->st_name
);
9731 if (pltgot
!= 0 && local_gotno
!= 0)
9733 bfd_vma entry
, local_end
, global_end
;
9735 unsigned char * data
;
9739 addr_size
= (is_32bit_elf
? 4 : 8);
9740 local_end
= pltgot
+ local_gotno
* addr_size
;
9741 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9743 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9744 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9745 printf (_("\nPrimary GOT:\n"));
9746 printf (_(" Canonical gp value: "));
9747 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9750 printf (_(" Reserved entries:\n"));
9751 printf (_(" %*s %10s %*s Purpose\n"),
9752 addr_size
* 2, "Address", "Access",
9753 addr_size
* 2, "Initial");
9754 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9755 printf (" Lazy resolver\n");
9757 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9758 >> (addr_size
* 8 - 1)) != 0)
9760 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9761 printf (" Module pointer (GNU extension)\n");
9765 if (entry
< local_end
)
9767 printf (_(" Local entries:\n"));
9768 printf (_(" %*s %10s %*s\n"),
9769 addr_size
* 2, "Address", "Access",
9770 addr_size
* 2, "Initial");
9771 while (entry
< local_end
)
9773 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9779 if (gotsym
< symtabno
)
9783 printf (_(" Global entries:\n"));
9784 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9785 addr_size
* 2, "Address", "Access",
9786 addr_size
* 2, "Initial",
9787 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9788 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9789 for (i
= gotsym
; i
< symtabno
; i
++)
9791 Elf_Internal_Sym
* psym
;
9793 psym
= dynamic_symbols
+ i
;
9794 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9796 print_vma (psym
->st_value
, LONG_HEX
);
9797 printf (" %-7s %3s ",
9798 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9799 get_symbol_index_type (psym
->st_shndx
));
9800 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9801 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9803 printf ("<corrupt: %14ld>", psym
->st_name
);
9813 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9816 size_t offset
, rel_offset
;
9817 unsigned long count
, i
;
9818 unsigned char * data
;
9819 int addr_size
, sym_width
;
9820 Elf_Internal_Rela
* rels
;
9822 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9823 if (pltrel
== DT_RELA
)
9825 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9830 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9834 entry
= mips_pltgot
;
9835 addr_size
= (is_32bit_elf
? 4 : 8);
9836 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9838 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9839 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9840 printf (_("\nPLT GOT:\n\n"));
9841 printf (_(" Reserved entries:\n"));
9842 printf (_(" %*s %*s Purpose\n"),
9843 addr_size
* 2, "Address", addr_size
* 2, "Initial");
9844 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9845 printf (" PLT lazy resolver\n");
9846 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9847 printf (" Module pointer\n");
9850 printf (_(" Entries:\n"));
9851 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9852 addr_size
* 2, "Address",
9853 addr_size
* 2, "Initial",
9854 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9855 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
9856 for (i
= 0; i
< count
; i
++)
9858 Elf_Internal_Sym
* psym
;
9860 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
9861 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9863 print_vma (psym
->st_value
, LONG_HEX
);
9864 printf (" %-7s %3s ",
9865 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9866 get_symbol_index_type (psym
->st_shndx
));
9867 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9868 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9870 printf ("<corrupt: %14ld>", psym
->st_name
);
9884 process_gnu_liblist (FILE * file
)
9886 Elf_Internal_Shdr
* section
;
9887 Elf_Internal_Shdr
* string_sec
;
9888 Elf32_External_Lib
* elib
;
9897 for (i
= 0, section
= section_headers
;
9898 i
< elf_header
.e_shnum
;
9901 switch (section
->sh_type
)
9903 case SHT_GNU_LIBLIST
:
9904 if (section
->sh_link
>= elf_header
.e_shnum
)
9907 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9912 string_sec
= section_headers
+ section
->sh_link
;
9914 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9915 string_sec
->sh_size
, _("liblist string table"));
9916 strtab_size
= string_sec
->sh_size
;
9919 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9925 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9926 SECTION_NAME (section
),
9927 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9929 puts (" Library Time Stamp Checksum Version Flags");
9931 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9939 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9940 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9941 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9942 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9943 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9945 tmp
= gmtime (&time
);
9946 snprintf (timebuf
, sizeof (timebuf
),
9947 "%04u-%02u-%02uT%02u:%02u:%02u",
9948 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9949 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9951 printf ("%3lu: ", (unsigned long) cnt
);
9953 printf ("%-20s", liblist
.l_name
< strtab_size
9954 ? strtab
+ liblist
.l_name
: "<corrupt>");
9956 printf ("%-20.20s", liblist
.l_name
< strtab_size
9957 ? strtab
+ liblist
.l_name
: "<corrupt>");
9958 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9959 liblist
.l_version
, liblist
.l_flags
);
9970 get_note_type (unsigned e_type
)
9972 static char buff
[64];
9974 if (elf_header
.e_type
== ET_CORE
)
9978 return _("NT_AUXV (auxiliary vector)");
9980 return _("NT_PRSTATUS (prstatus structure)");
9982 return _("NT_FPREGSET (floating point registers)");
9984 return _("NT_PRPSINFO (prpsinfo structure)");
9986 return _("NT_TASKSTRUCT (task structure)");
9988 return _("NT_PRXFPREG (user_xfpregs structure)");
9990 return _("NT_PPC_VMX (ppc Altivec registers)");
9992 return _("NT_PPC_VSX (ppc VSX registers)");
9994 return _("NT_PSTATUS (pstatus structure)");
9996 return _("NT_FPREGS (floating point registers)");
9998 return _("NT_PSINFO (psinfo structure)");
10000 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10002 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10003 case NT_WIN32PSTATUS
:
10004 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10012 return _("NT_VERSION (version)");
10014 return _("NT_ARCH (architecture)");
10019 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10023 static const char *
10024 get_gnu_elf_note_type (unsigned e_type
)
10026 static char buff
[64];
10030 case NT_GNU_ABI_TAG
:
10031 return _("NT_GNU_ABI_TAG (ABI version tag)");
10033 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10034 case NT_GNU_BUILD_ID
:
10035 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10036 case NT_GNU_GOLD_VERSION
:
10037 return _("NT_GNU_GOLD_VERSION (gold version)");
10042 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10046 static const char *
10047 get_netbsd_elfcore_note_type (unsigned e_type
)
10049 static char buff
[64];
10051 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10053 /* NetBSD core "procinfo" structure. */
10054 return _("NetBSD procinfo structure");
10057 /* As of Jan 2002 there are no other machine-independent notes
10058 defined for NetBSD core files. If the note type is less
10059 than the start of the machine-dependent note types, we don't
10062 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10064 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10068 switch (elf_header
.e_machine
)
10070 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10071 and PT_GETFPREGS == mach+2. */
10076 case EM_SPARC32PLUS
:
10080 case NT_NETBSDCORE_FIRSTMACH
+0:
10081 return _("PT_GETREGS (reg structure)");
10082 case NT_NETBSDCORE_FIRSTMACH
+2:
10083 return _("PT_GETFPREGS (fpreg structure)");
10089 /* On all other arch's, PT_GETREGS == mach+1 and
10090 PT_GETFPREGS == mach+3. */
10094 case NT_NETBSDCORE_FIRSTMACH
+1:
10095 return _("PT_GETREGS (reg structure)");
10096 case NT_NETBSDCORE_FIRSTMACH
+3:
10097 return _("PT_GETFPREGS (fpreg structure)");
10103 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10104 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10108 /* Note that by the ELF standard, the name field is already null byte
10109 terminated, and namesz includes the terminating null byte.
10110 I.E. the value of namesz for the name "FSF" is 4.
10112 If the value of namesz is zero, there is no name present. */
10114 process_note (Elf_Internal_Note
* pnote
)
10116 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10119 if (pnote
->namesz
== 0)
10120 /* If there is no note name, then use the default set of
10121 note type strings. */
10122 nt
= get_note_type (pnote
->type
);
10124 else if (const_strneq (pnote
->namedata
, "GNU"))
10125 /* GNU-specific object file notes. */
10126 nt
= get_gnu_elf_note_type (pnote
->type
);
10128 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10129 /* NetBSD-specific core file notes. */
10130 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10132 else if (strneq (pnote
->namedata
, "SPU/", 4))
10134 /* SPU-specific core file notes. */
10135 nt
= pnote
->namedata
+ 4;
10140 /* Don't recognize this note name; just use the default set of
10141 note type strings. */
10142 nt
= get_note_type (pnote
->type
);
10144 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10150 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10152 Elf_External_Note
* pnotes
;
10153 Elf_External_Note
* external
;
10159 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10165 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10166 (unsigned long) offset
, (unsigned long) length
);
10167 printf (_(" Owner\t\tData size\tDescription\n"));
10169 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10171 Elf_External_Note
* next
;
10172 Elf_Internal_Note inote
;
10173 char * temp
= NULL
;
10175 inote
.type
= BYTE_GET (external
->type
);
10176 inote
.namesz
= BYTE_GET (external
->namesz
);
10177 inote
.namedata
= external
->name
;
10178 inote
.descsz
= BYTE_GET (external
->descsz
);
10179 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10180 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10182 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10184 if (((char *) next
) > (((char *) pnotes
) + length
))
10186 warn (_("corrupt note found at offset %lx into core notes\n"),
10187 (unsigned long) ((char *) external
- (char *) pnotes
));
10188 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10189 inote
.type
, inote
.namesz
, inote
.descsz
);
10195 /* Verify that name is null terminated. It appears that at least
10196 one version of Linux (RedHat 6.0) generates corefiles that don't
10197 comply with the ELF spec by failing to include the null byte in
10199 if (inote
.namedata
[inote
.namesz
] != '\0')
10201 temp
= malloc (inote
.namesz
+ 1);
10205 error (_("Out of memory\n"));
10210 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10211 temp
[inote
.namesz
] = 0;
10213 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10214 inote
.namedata
= temp
;
10217 res
&= process_note (& inote
);
10232 process_corefile_note_segments (FILE * file
)
10234 Elf_Internal_Phdr
* segment
;
10238 if (! get_program_headers (file
))
10241 for (i
= 0, segment
= program_headers
;
10242 i
< elf_header
.e_phnum
;
10245 if (segment
->p_type
== PT_NOTE
)
10246 res
&= process_corefile_note_segment (file
,
10247 (bfd_vma
) segment
->p_offset
,
10248 (bfd_vma
) segment
->p_filesz
);
10255 process_note_sections (FILE * file
)
10257 Elf_Internal_Shdr
* section
;
10261 for (i
= 0, section
= section_headers
;
10262 i
< elf_header
.e_shnum
;
10264 if (section
->sh_type
== SHT_NOTE
)
10265 res
&= process_corefile_note_segment (file
,
10266 (bfd_vma
) section
->sh_offset
,
10267 (bfd_vma
) section
->sh_size
);
10273 process_notes (FILE * file
)
10275 /* If we have not been asked to display the notes then do nothing. */
10279 if (elf_header
.e_type
!= ET_CORE
)
10280 return process_note_sections (file
);
10282 /* No program headers means no NOTE segment. */
10283 if (elf_header
.e_phnum
> 0)
10284 return process_corefile_note_segments (file
);
10286 printf (_("No note segments present in the core file.\n"));
10291 process_arch_specific (FILE * file
)
10296 switch (elf_header
.e_machine
)
10299 return process_arm_specific (file
);
10301 case EM_MIPS_RS3_LE
:
10302 return process_mips_specific (file
);
10305 return process_power_specific (file
);
10314 get_file_header (FILE * file
)
10316 /* Read in the identity array. */
10317 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10320 /* Determine how to read the rest of the header. */
10321 switch (elf_header
.e_ident
[EI_DATA
])
10323 default: /* fall through */
10324 case ELFDATANONE
: /* fall through */
10326 byte_get
= byte_get_little_endian
;
10327 byte_put
= byte_put_little_endian
;
10330 byte_get
= byte_get_big_endian
;
10331 byte_put
= byte_put_big_endian
;
10335 /* For now we only support 32 bit and 64 bit ELF files. */
10336 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10338 /* Read in the rest of the header. */
10341 Elf32_External_Ehdr ehdr32
;
10343 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10346 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10347 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10348 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10349 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10350 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10351 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10352 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10353 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10354 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10355 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10356 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10357 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10358 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10362 Elf64_External_Ehdr ehdr64
;
10364 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10365 we will not be able to cope with the 64bit data found in
10366 64 ELF files. Detect this now and abort before we start
10367 overwriting things. */
10368 if (sizeof (bfd_vma
) < 8)
10370 error (_("This instance of readelf has been built without support for a\n\
10371 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10375 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10378 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10379 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10380 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10381 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10382 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10383 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10384 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10385 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10386 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10387 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10388 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10389 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10390 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10393 if (elf_header
.e_shoff
)
10395 /* There may be some extensions in the first section header. Don't
10396 bomb if we can't read it. */
10398 get_32bit_section_headers (file
, 1);
10400 get_64bit_section_headers (file
, 1);
10406 /* Process one ELF object file according to the command line options.
10407 This file may actually be stored in an archive. The file is
10408 positioned at the start of the ELF object. */
10411 process_object (char * file_name
, FILE * file
)
10415 if (! get_file_header (file
))
10417 error (_("%s: Failed to read file header\n"), file_name
);
10421 /* Initialise per file variables. */
10422 for (i
= ARRAY_SIZE (version_info
); i
--;)
10423 version_info
[i
] = 0;
10425 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10426 dynamic_info
[i
] = 0;
10428 /* Process the file. */
10430 printf (_("\nFile: %s\n"), file_name
);
10432 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10433 Note we do this even if cmdline_dump_sects is empty because we
10434 must make sure that the dump_sets array is zeroed out before each
10435 object file is processed. */
10436 if (num_dump_sects
> num_cmdline_dump_sects
)
10437 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10439 if (num_cmdline_dump_sects
> 0)
10441 if (num_dump_sects
== 0)
10442 /* A sneaky way of allocating the dump_sects array. */
10443 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10445 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10446 memcpy (dump_sects
, cmdline_dump_sects
,
10447 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10450 if (! process_file_header ())
10453 if (! process_section_headers (file
))
10455 /* Without loaded section headers we cannot process lots of
10457 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10459 if (! do_using_dynamic
)
10460 do_syms
= do_reloc
= 0;
10463 if (! process_section_groups (file
))
10465 /* Without loaded section groups we cannot process unwind. */
10469 if (process_program_headers (file
))
10470 process_dynamic_section (file
);
10472 process_relocs (file
);
10474 process_unwind (file
);
10476 process_symbol_table (file
);
10478 process_syminfo (file
);
10480 process_version_sections (file
);
10482 process_section_contents (file
);
10484 process_notes (file
);
10486 process_gnu_liblist (file
);
10488 process_arch_specific (file
);
10490 if (program_headers
)
10492 free (program_headers
);
10493 program_headers
= NULL
;
10496 if (section_headers
)
10498 free (section_headers
);
10499 section_headers
= NULL
;
10504 free (string_table
);
10505 string_table
= NULL
;
10506 string_table_length
= 0;
10509 if (dynamic_strings
)
10511 free (dynamic_strings
);
10512 dynamic_strings
= NULL
;
10513 dynamic_strings_length
= 0;
10516 if (dynamic_symbols
)
10518 free (dynamic_symbols
);
10519 dynamic_symbols
= NULL
;
10520 num_dynamic_syms
= 0;
10523 if (dynamic_syminfo
)
10525 free (dynamic_syminfo
);
10526 dynamic_syminfo
= NULL
;
10529 if (section_headers_groups
)
10531 free (section_headers_groups
);
10532 section_headers_groups
= NULL
;
10535 if (section_groups
)
10537 struct group_list
* g
;
10538 struct group_list
* next
;
10540 for (i
= 0; i
< group_count
; i
++)
10542 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10549 free (section_groups
);
10550 section_groups
= NULL
;
10553 free_debug_memory ();
10558 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10559 to the path name of the thin archive itself if necessary. Always returns
10560 a pointer to malloc'ed memory. */
10563 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10565 char * member_file_name
;
10566 const char * base_name
= lbasename (file_name
);
10568 /* This is a proxy entry for a thin archive member.
10569 If the extended name table contains an absolute path
10570 name, or if the archive is in the current directory,
10571 use the path name as given. Otherwise, we need to
10572 find the member relative to the directory where the
10573 archive is located. */
10574 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10576 member_file_name
= malloc (name_len
+ 1);
10577 if (member_file_name
== NULL
)
10579 error (_("Out of memory\n"));
10582 memcpy (member_file_name
, name
, name_len
);
10583 member_file_name
[name_len
] = '\0';
10587 /* Concatenate the path components of the archive file name
10588 to the relative path name from the extended name table. */
10589 size_t prefix_len
= base_name
- file_name
;
10590 member_file_name
= malloc (prefix_len
+ name_len
+ 1);
10591 if (member_file_name
== NULL
)
10593 error (_("Out of memory\n"));
10596 memcpy (member_file_name
, file_name
, prefix_len
);
10597 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10598 member_file_name
[prefix_len
+ name_len
] = '\0';
10600 return member_file_name
;
10603 /* Structure to hold information about an archive file. */
10605 struct archive_info
10607 char * file_name
; /* Archive file name. */
10608 FILE * file
; /* Open file descriptor. */
10609 unsigned long index_num
; /* Number of symbols in table. */
10610 unsigned long * index_array
; /* The array of member offsets. */
10611 char * sym_table
; /* The symbol table. */
10612 unsigned long sym_size
; /* Size of the symbol table. */
10613 char * longnames
; /* The long file names table. */
10614 unsigned long longnames_size
; /* Size of the long file names table. */
10615 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10616 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10617 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10618 struct ar_hdr arhdr
; /* Current archive header. */
10621 /* Read the symbol table and long-name table from an archive. */
10624 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10625 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10628 unsigned long size
;
10630 arch
->file_name
= strdup (file_name
);
10632 arch
->index_num
= 0;
10633 arch
->index_array
= NULL
;
10634 arch
->sym_table
= NULL
;
10635 arch
->sym_size
= 0;
10636 arch
->longnames
= NULL
;
10637 arch
->longnames_size
= 0;
10638 arch
->nested_member_origin
= 0;
10639 arch
->is_thin_archive
= is_thin_archive
;
10640 arch
->next_arhdr_offset
= SARMAG
;
10642 /* Read the first archive member header. */
10643 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10645 error (_("%s: failed to seek to first archive header\n"), file_name
);
10648 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10649 if (got
!= sizeof arch
->arhdr
)
10654 error (_("%s: failed to read archive header\n"), file_name
);
10658 /* See if this is the archive symbol table. */
10659 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10660 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10662 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10663 size
= size
+ (size
& 1);
10665 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10670 /* A buffer used to hold numbers read in from an archive index.
10671 These are always 4 bytes long and stored in big-endian format. */
10672 #define SIZEOF_AR_INDEX_NUMBERS 4
10673 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10674 unsigned char * index_buffer
;
10676 /* Check the size of the archive index. */
10677 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10679 error (_("%s: the archive index is empty\n"), file_name
);
10683 /* Read the numer of entries in the archive index. */
10684 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10685 if (got
!= sizeof (integer_buffer
))
10687 error (_("%s: failed to read archive index\n"), file_name
);
10690 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10691 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10693 /* Read in the archive index. */
10694 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10696 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10697 file_name
, arch
->index_num
);
10700 index_buffer
= malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10701 if (index_buffer
== NULL
)
10703 error (_("Out of memory whilst trying to read archive symbol index\n"));
10706 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
10707 if (got
!= arch
->index_num
)
10709 free (index_buffer
);
10710 error (_("%s: failed to read archive index\n"), file_name
);
10713 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10715 /* Convert the index numbers into the host's numeric format. */
10716 arch
->index_array
= malloc (arch
->index_num
* sizeof (* arch
->index_array
));
10717 if (arch
->index_array
== NULL
)
10719 free (index_buffer
);
10720 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10724 for (i
= 0; i
< arch
->index_num
; i
++)
10725 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10726 SIZEOF_AR_INDEX_NUMBERS
);
10727 free (index_buffer
);
10729 /* The remaining space in the header is taken up by the symbol table. */
10732 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10735 arch
->sym_table
= malloc (size
);
10736 arch
->sym_size
= size
;
10737 if (arch
->sym_table
== NULL
)
10739 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10742 got
= fread (arch
->sym_table
, 1, size
, file
);
10745 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10751 if (fseek (file
, size
, SEEK_CUR
) != 0)
10753 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10758 /* Read the next archive header. */
10759 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10760 if (got
!= sizeof arch
->arhdr
)
10764 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10768 else if (read_symbols
)
10769 printf (_("%s has no archive index\n"), file_name
);
10771 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
10773 /* This is the archive string table holding long member names. */
10774 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10775 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
10777 arch
->longnames
= malloc (arch
->longnames_size
);
10778 if (arch
->longnames
== NULL
)
10780 error (_("Out of memory reading long symbol names in archive\n"));
10784 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
10786 free (arch
->longnames
);
10787 arch
->longnames
= NULL
;
10788 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10792 if ((arch
->longnames_size
& 1) != 0)
10799 /* Release the memory used for the archive information. */
10802 release_archive (struct archive_info
* arch
)
10804 if (arch
->file_name
!= NULL
)
10805 free (arch
->file_name
);
10806 if (arch
->index_array
!= NULL
)
10807 free (arch
->index_array
);
10808 if (arch
->sym_table
!= NULL
)
10809 free (arch
->sym_table
);
10810 if (arch
->longnames
!= NULL
)
10811 free (arch
->longnames
);
10814 /* Open and setup a nested archive, if not already open. */
10817 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
10819 FILE * member_file
;
10821 /* Have we already setup this archive? */
10822 if (nested_arch
->file_name
!= NULL
10823 && streq (nested_arch
->file_name
, member_file_name
))
10826 /* Close previous file and discard cached information. */
10827 if (nested_arch
->file
!= NULL
)
10828 fclose (nested_arch
->file
);
10829 release_archive (nested_arch
);
10831 member_file
= fopen (member_file_name
, "rb");
10832 if (member_file
== NULL
)
10834 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
10838 get_archive_member_name_at (struct archive_info
* arch
,
10839 unsigned long offset
,
10840 struct archive_info
* nested_arch
);
10842 /* Get the name of an archive member from the current archive header.
10843 For simple names, this will modify the ar_name field of the current
10844 archive header. For long names, it will return a pointer to the
10845 longnames table. For nested archives, it will open the nested archive
10846 and get the name recursively. NESTED_ARCH is a single-entry cache so
10847 we don't keep rereading the same information from a nested archive. */
10850 get_archive_member_name (struct archive_info
* arch
,
10851 struct archive_info
* nested_arch
)
10853 unsigned long j
, k
;
10855 if (arch
->arhdr
.ar_name
[0] == '/')
10857 /* We have a long name. */
10859 char * member_file_name
;
10860 char * member_name
;
10862 arch
->nested_member_origin
= 0;
10863 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
10864 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
10865 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
10867 while ((j
< arch
->longnames_size
)
10868 && (arch
->longnames
[j
] != '\n')
10869 && (arch
->longnames
[j
] != '\0'))
10871 if (arch
->longnames
[j
-1] == '/')
10873 arch
->longnames
[j
] = '\0';
10875 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
10876 return arch
->longnames
+ k
;
10878 /* This is a proxy for a member of a nested archive.
10879 Find the name of the member in that archive. */
10880 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
10881 if (member_file_name
!= NULL
10882 && setup_nested_archive (nested_arch
, member_file_name
) == 0
10883 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
10885 free (member_file_name
);
10886 return member_name
;
10888 free (member_file_name
);
10890 /* Last resort: just return the name of the nested archive. */
10891 return arch
->longnames
+ k
;
10894 /* We have a normal (short) name. */
10896 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
10898 arch
->arhdr
.ar_name
[j
] = '\0';
10899 return arch
->arhdr
.ar_name
;
10902 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
10905 get_archive_member_name_at (struct archive_info
* arch
,
10906 unsigned long offset
,
10907 struct archive_info
* nested_arch
)
10911 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
10913 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
10916 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
10917 if (got
!= sizeof arch
->arhdr
)
10919 error (_("%s: failed to read archive header\n"), arch
->file_name
);
10922 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
10924 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
10928 return get_archive_member_name (arch
, nested_arch
);
10931 /* Construct a string showing the name of the archive member, qualified
10932 with the name of the containing archive file. For thin archives, we
10933 use square brackets to denote the indirection. For nested archives,
10934 we show the qualified name of the external member inside the square
10935 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
10938 make_qualified_name (struct archive_info
* arch
,
10939 struct archive_info
* nested_arch
,
10940 char * member_name
)
10945 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
10946 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
10947 len
+= strlen (nested_arch
->file_name
) + 2;
10949 name
= malloc (len
);
10952 error (_("Out of memory\n"));
10956 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
10957 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
10958 else if (arch
->is_thin_archive
)
10959 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
10961 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
10966 /* Process an ELF archive.
10967 On entry the file is positioned just after the ARMAG string. */
10970 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
10972 struct archive_info arch
;
10973 struct archive_info nested_arch
;
10975 size_t file_name_size
;
10980 /* The ARCH structure is used to hold information about this archive. */
10981 arch
.file_name
= NULL
;
10983 arch
.index_array
= NULL
;
10984 arch
.sym_table
= NULL
;
10985 arch
.longnames
= NULL
;
10987 /* The NESTED_ARCH structure is used as a single-item cache of information
10988 about a nested archive (when members of a thin archive reside within
10989 another regular archive file). */
10990 nested_arch
.file_name
= NULL
;
10991 nested_arch
.file
= NULL
;
10992 nested_arch
.index_array
= NULL
;
10993 nested_arch
.sym_table
= NULL
;
10994 nested_arch
.longnames
= NULL
;
10996 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11002 if (do_archive_index
)
11004 if (arch
.sym_table
== NULL
)
11005 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11009 unsigned long current_pos
;
11011 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11012 file_name
, arch
.index_num
, arch
.sym_size
);
11013 current_pos
= ftell (file
);
11015 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11017 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11019 char * member_name
;
11021 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11023 if (member_name
!= NULL
)
11025 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11027 if (qualified_name
!= NULL
)
11029 printf (_("Binary %s contains:\n"), qualified_name
);
11030 free (qualified_name
);
11035 if (l
>= arch
.sym_size
)
11037 error (_("%s: end of the symbol table reached before the end of the index\n"),
11041 printf ("\t%s\n", arch
.sym_table
+ l
);
11042 l
+= strlen (arch
.sym_table
+ l
) + 1;
11047 if (l
< arch
.sym_size
)
11048 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11051 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11053 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11059 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11060 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11061 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11062 && !do_section_groups
)
11064 ret
= 0; /* Archive index only. */
11069 file_name_size
= strlen (file_name
);
11076 char * qualified_name
;
11078 /* Read the next archive header. */
11079 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11081 error (_("%s: failed to seek to next archive header\n"), file_name
);
11084 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11085 if (got
!= sizeof arch
.arhdr
)
11089 error (_("%s: failed to read archive header\n"), file_name
);
11093 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11095 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11100 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11102 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11103 if (archive_file_size
& 01)
11104 ++archive_file_size
;
11106 name
= get_archive_member_name (&arch
, &nested_arch
);
11109 error (_("%s: bad archive file name\n"), file_name
);
11113 namelen
= strlen (name
);
11115 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11116 if (qualified_name
== NULL
)
11118 error (_("%s: bad archive file name\n"), file_name
);
11123 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11125 /* This is a proxy for an external member of a thin archive. */
11126 FILE * member_file
;
11127 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11128 if (member_file_name
== NULL
)
11134 member_file
= fopen (member_file_name
, "rb");
11135 if (member_file
== NULL
)
11137 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11138 free (member_file_name
);
11143 archive_file_offset
= arch
.nested_member_origin
;
11145 ret
|= process_object (qualified_name
, member_file
);
11147 fclose (member_file
);
11148 free (member_file_name
);
11150 else if (is_thin_archive
)
11152 /* This is a proxy for a member of a nested archive. */
11153 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11155 /* The nested archive file will have been opened and setup by
11156 get_archive_member_name. */
11157 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11159 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11164 ret
|= process_object (qualified_name
, nested_arch
.file
);
11168 archive_file_offset
= arch
.next_arhdr_offset
;
11169 arch
.next_arhdr_offset
+= archive_file_size
;
11171 ret
|= process_object (qualified_name
, file
);
11174 free (qualified_name
);
11178 if (nested_arch
.file
!= NULL
)
11179 fclose (nested_arch
.file
);
11180 release_archive (&nested_arch
);
11181 release_archive (&arch
);
11187 process_file (char * file_name
)
11190 struct stat statbuf
;
11191 char armag
[SARMAG
];
11194 if (stat (file_name
, &statbuf
) < 0)
11196 if (errno
== ENOENT
)
11197 error (_("'%s': No such file\n"), file_name
);
11199 error (_("Could not locate '%s'. System error message: %s\n"),
11200 file_name
, strerror (errno
));
11204 if (! S_ISREG (statbuf
.st_mode
))
11206 error (_("'%s' is not an ordinary file\n"), file_name
);
11210 file
= fopen (file_name
, "rb");
11213 error (_("Input file '%s' is not readable.\n"), file_name
);
11217 if (fread (armag
, SARMAG
, 1, file
) != 1)
11219 error (_("%s: Failed to read file's magic number\n"), file_name
);
11224 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11225 ret
= process_archive (file_name
, file
, FALSE
);
11226 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11227 ret
= process_archive (file_name
, file
, TRUE
);
11230 if (do_archive_index
)
11231 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11235 archive_file_size
= archive_file_offset
= 0;
11236 ret
= process_object (file_name
, file
);
11244 #ifdef SUPPORT_DISASSEMBLY
11245 /* Needed by the i386 disassembler. For extra credit, someone could
11246 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11250 print_address (unsigned int addr
, FILE * outfile
)
11252 fprintf (outfile
,"0x%8.8x", addr
);
11255 /* Needed by the i386 disassembler. */
11257 db_task_printsym (unsigned int addr
)
11259 print_address (addr
, stderr
);
11264 main (int argc
, char ** argv
)
11268 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11269 setlocale (LC_MESSAGES
, "");
11271 #if defined (HAVE_SETLOCALE)
11272 setlocale (LC_CTYPE
, "");
11274 bindtextdomain (PACKAGE
, LOCALEDIR
);
11275 textdomain (PACKAGE
);
11277 expandargv (&argc
, &argv
);
11279 parse_args (argc
, argv
);
11281 if (num_dump_sects
> 0)
11283 /* Make a copy of the dump_sects array. */
11284 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
11285 if (cmdline_dump_sects
== NULL
)
11286 error (_("Out of memory allocating dump request table.\n"));
11289 memcpy (cmdline_dump_sects
, dump_sects
,
11290 num_dump_sects
* sizeof (* dump_sects
));
11291 num_cmdline_dump_sects
= num_dump_sects
;
11295 if (optind
< (argc
- 1))
11299 while (optind
< argc
)
11300 err
|= process_file (argv
[optind
++]);
11302 if (dump_sects
!= NULL
)
11304 if (cmdline_dump_sects
!= NULL
)
11305 free (cmdline_dump_sects
);