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
>= elf_header
.e_shnum
)
3209 printf (" <corrupt: out of range>");
3210 putc ('\n', stdout
);
3213 if (section_headers
!= NULL
)
3215 if (elf_header
.e_shnum
== SHN_UNDEF
)
3216 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3217 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3218 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3219 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3220 elf_header
.e_shstrndx
= SHN_UNDEF
;
3221 free (section_headers
);
3222 section_headers
= NULL
;
3230 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3232 Elf32_External_Phdr
* phdrs
;
3233 Elf32_External_Phdr
* external
;
3234 Elf_Internal_Phdr
* internal
;
3237 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3238 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3239 _("program headers"));
3243 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3244 i
< elf_header
.e_phnum
;
3245 i
++, internal
++, external
++)
3247 internal
->p_type
= BYTE_GET (external
->p_type
);
3248 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3249 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3250 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3251 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3252 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3253 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3254 internal
->p_align
= BYTE_GET (external
->p_align
);
3263 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3265 Elf64_External_Phdr
* phdrs
;
3266 Elf64_External_Phdr
* external
;
3267 Elf_Internal_Phdr
* internal
;
3270 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3271 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3272 _("program headers"));
3276 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3277 i
< elf_header
.e_phnum
;
3278 i
++, internal
++, external
++)
3280 internal
->p_type
= BYTE_GET (external
->p_type
);
3281 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3282 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3283 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3284 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3285 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3286 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3287 internal
->p_align
= BYTE_GET (external
->p_align
);
3295 /* Returns 1 if the program headers were read into `program_headers'. */
3298 get_program_headers (FILE * file
)
3300 Elf_Internal_Phdr
* phdrs
;
3302 /* Check cache of prior read. */
3303 if (program_headers
!= NULL
)
3306 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3310 error (_("Out of memory\n"));
3315 ? get_32bit_program_headers (file
, phdrs
)
3316 : get_64bit_program_headers (file
, phdrs
))
3318 program_headers
= phdrs
;
3326 /* Returns 1 if the program headers were loaded. */
3329 process_program_headers (FILE * file
)
3331 Elf_Internal_Phdr
* segment
;
3334 if (elf_header
.e_phnum
== 0)
3337 printf (_("\nThere are no program headers in this file.\n"));
3341 if (do_segments
&& !do_header
)
3343 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3344 printf (_("Entry point "));
3345 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3346 printf (_("\nThere are %d program headers, starting at offset "),
3347 elf_header
.e_phnum
);
3348 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3352 if (! get_program_headers (file
))
3357 if (elf_header
.e_phnum
> 1)
3358 printf (_("\nProgram Headers:\n"));
3360 printf (_("\nProgram Headers:\n"));
3364 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3367 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3371 (_(" Type Offset VirtAddr PhysAddr\n"));
3373 (_(" FileSiz MemSiz Flags Align\n"));
3380 for (i
= 0, segment
= program_headers
;
3381 i
< elf_header
.e_phnum
;
3386 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3390 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3391 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3392 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3393 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3394 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3396 (segment
->p_flags
& PF_R
? 'R' : ' '),
3397 (segment
->p_flags
& PF_W
? 'W' : ' '),
3398 (segment
->p_flags
& PF_X
? 'E' : ' '));
3399 printf ("%#lx", (unsigned long) segment
->p_align
);
3403 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3404 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3407 print_vma (segment
->p_offset
, FULL_HEX
);
3411 print_vma (segment
->p_vaddr
, FULL_HEX
);
3413 print_vma (segment
->p_paddr
, FULL_HEX
);
3416 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3417 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3420 print_vma (segment
->p_filesz
, FULL_HEX
);
3424 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3425 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3428 print_vma (segment
->p_offset
, FULL_HEX
);
3432 (segment
->p_flags
& PF_R
? 'R' : ' '),
3433 (segment
->p_flags
& PF_W
? 'W' : ' '),
3434 (segment
->p_flags
& PF_X
? 'E' : ' '));
3436 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3437 printf ("%#lx", (unsigned long) segment
->p_align
);
3440 print_vma (segment
->p_align
, PREFIX_HEX
);
3445 print_vma (segment
->p_offset
, FULL_HEX
);
3447 print_vma (segment
->p_vaddr
, FULL_HEX
);
3449 print_vma (segment
->p_paddr
, FULL_HEX
);
3451 print_vma (segment
->p_filesz
, FULL_HEX
);
3453 print_vma (segment
->p_memsz
, FULL_HEX
);
3455 (segment
->p_flags
& PF_R
? 'R' : ' '),
3456 (segment
->p_flags
& PF_W
? 'W' : ' '),
3457 (segment
->p_flags
& PF_X
? 'E' : ' '));
3458 print_vma (segment
->p_align
, HEX
);
3462 switch (segment
->p_type
)
3466 error (_("more than one dynamic segment\n"));
3468 /* By default, assume that the .dynamic section is the first
3469 section in the DYNAMIC segment. */
3470 dynamic_addr
= segment
->p_offset
;
3471 dynamic_size
= segment
->p_filesz
;
3473 /* Try to locate the .dynamic section. If there is
3474 a section header table, we can easily locate it. */
3475 if (section_headers
!= NULL
)
3477 Elf_Internal_Shdr
* sec
;
3479 sec
= find_section (".dynamic");
3480 if (sec
== NULL
|| sec
->sh_size
== 0)
3482 error (_("no .dynamic section in the dynamic segment\n"));
3486 if (sec
->sh_type
== SHT_NOBITS
)
3492 dynamic_addr
= sec
->sh_offset
;
3493 dynamic_size
= sec
->sh_size
;
3495 if (dynamic_addr
< segment
->p_offset
3496 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3497 warn (_("the .dynamic section is not contained"
3498 " within the dynamic segment\n"));
3499 else if (dynamic_addr
> segment
->p_offset
)
3500 warn (_("the .dynamic section is not the first section"
3501 " in the dynamic segment.\n"));
3506 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3508 error (_("Unable to find program interpreter name\n"));
3512 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3514 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3515 error (_("Internal error: failed to create format string to display program interpreter\n"));
3517 program_interpreter
[0] = 0;
3518 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3519 error (_("Unable to read program interpreter name\n"));
3522 printf (_("\n [Requesting program interpreter: %s]"),
3523 program_interpreter
);
3529 putc ('\n', stdout
);
3532 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3534 printf (_("\n Section to Segment mapping:\n"));
3535 printf (_(" Segment Sections...\n"));
3537 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3540 Elf_Internal_Shdr
* section
;
3542 segment
= program_headers
+ i
;
3543 section
= section_headers
+ 1;
3545 printf (" %2.2d ", i
);
3547 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3549 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3550 printf ("%s ", SECTION_NAME (section
));
3561 /* Find the file offset corresponding to VMA by using the program headers. */
3564 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3566 Elf_Internal_Phdr
* seg
;
3568 if (! get_program_headers (file
))
3570 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3574 for (seg
= program_headers
;
3575 seg
< program_headers
+ elf_header
.e_phnum
;
3578 if (seg
->p_type
!= PT_LOAD
)
3581 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3582 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3583 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3586 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3587 (unsigned long) vma
);
3593 get_32bit_section_headers (FILE * file
, unsigned int num
)
3595 Elf32_External_Shdr
* shdrs
;
3596 Elf_Internal_Shdr
* internal
;
3599 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3600 elf_header
.e_shentsize
, num
, _("section headers"));
3604 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3606 if (section_headers
== NULL
)
3608 error (_("Out of memory\n"));
3612 for (i
= 0, internal
= section_headers
;
3616 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3617 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3618 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3619 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3620 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3621 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3622 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3623 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3624 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3625 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3634 get_64bit_section_headers (FILE * file
, unsigned int num
)
3636 Elf64_External_Shdr
* shdrs
;
3637 Elf_Internal_Shdr
* internal
;
3640 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3641 elf_header
.e_shentsize
, num
, _("section headers"));
3645 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3647 if (section_headers
== NULL
)
3649 error (_("Out of memory\n"));
3653 for (i
= 0, internal
= section_headers
;
3657 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3658 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3659 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3660 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3661 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3662 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3663 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3664 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3665 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3666 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3674 static Elf_Internal_Sym
*
3675 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3677 unsigned long number
;
3678 Elf32_External_Sym
* esyms
;
3679 Elf_External_Sym_Shndx
* shndx
;
3680 Elf_Internal_Sym
* isyms
;
3681 Elf_Internal_Sym
* psym
;
3684 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3690 if (symtab_shndx_hdr
!= NULL
3691 && (symtab_shndx_hdr
->sh_link
3692 == (unsigned long) (section
- section_headers
)))
3694 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3695 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3703 number
= section
->sh_size
/ section
->sh_entsize
;
3704 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3708 error (_("Out of memory\n"));
3715 for (j
= 0, psym
= isyms
;
3719 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3720 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3721 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3722 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3723 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3725 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3726 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3727 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3728 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3729 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3739 static Elf_Internal_Sym
*
3740 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3742 unsigned long number
;
3743 Elf64_External_Sym
* esyms
;
3744 Elf_External_Sym_Shndx
* shndx
;
3745 Elf_Internal_Sym
* isyms
;
3746 Elf_Internal_Sym
* psym
;
3749 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3755 if (symtab_shndx_hdr
!= NULL
3756 && (symtab_shndx_hdr
->sh_link
3757 == (unsigned long) (section
- section_headers
)))
3759 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3760 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3768 number
= section
->sh_size
/ section
->sh_entsize
;
3769 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3773 error (_("Out of memory\n"));
3780 for (j
= 0, psym
= isyms
;
3784 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3785 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3786 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3787 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3788 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3790 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3791 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3792 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3793 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3794 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3805 get_elf_section_flags (bfd_vma sh_flags
)
3807 static char buff
[1024];
3809 int field_size
= is_32bit_elf
? 8 : 16;
3810 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3811 bfd_vma os_flags
= 0;
3812 bfd_vma proc_flags
= 0;
3813 bfd_vma unknown_flags
= 0;
3827 { "LINK ORDER", 10 },
3828 { "OS NONCONF", 10 },
3831 /* IA-64 specific. */
3834 /* IA-64 OpenVMS specific. */
3835 { "VMS_GLOBAL", 10 },
3836 { "VMS_OVERLAID", 12 },
3837 { "VMS_SHARED", 10 },
3838 { "VMS_VECTOR", 10 },
3839 { "VMS_ALLOC_64BIT", 15 },
3840 { "VMS_PROTECTED", 13}
3843 if (do_section_details
)
3845 sprintf (buff
, "[%*.*lx]: ",
3846 field_size
, field_size
, (unsigned long) sh_flags
);
3847 p
+= field_size
+ 4;
3854 flag
= sh_flags
& - sh_flags
;
3857 if (do_section_details
)
3861 case SHF_WRITE
: index
= 0; break;
3862 case SHF_ALLOC
: index
= 1; break;
3863 case SHF_EXECINSTR
: index
= 2; break;
3864 case SHF_MERGE
: index
= 3; break;
3865 case SHF_STRINGS
: index
= 4; break;
3866 case SHF_INFO_LINK
: index
= 5; break;
3867 case SHF_LINK_ORDER
: index
= 6; break;
3868 case SHF_OS_NONCONFORMING
: index
= 7; break;
3869 case SHF_GROUP
: index
= 8; break;
3870 case SHF_TLS
: index
= 9; break;
3874 if (elf_header
.e_machine
== EM_IA_64
)
3876 if (flag
== SHF_IA_64_SHORT
)
3878 else if (flag
== SHF_IA_64_NORECOV
)
3881 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3884 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3885 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3886 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3887 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3888 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3889 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3899 if (p
!= buff
+ field_size
+ 4)
3901 if (size
< (10 + 2))
3908 size
-= flags
[index
].len
;
3909 p
= stpcpy (p
, flags
[index
].str
);
3911 else if (flag
& SHF_MASKOS
)
3913 else if (flag
& SHF_MASKPROC
)
3916 unknown_flags
|= flag
;
3922 case SHF_WRITE
: *p
= 'W'; break;
3923 case SHF_ALLOC
: *p
= 'A'; break;
3924 case SHF_EXECINSTR
: *p
= 'X'; break;
3925 case SHF_MERGE
: *p
= 'M'; break;
3926 case SHF_STRINGS
: *p
= 'S'; break;
3927 case SHF_INFO_LINK
: *p
= 'I'; break;
3928 case SHF_LINK_ORDER
: *p
= 'L'; break;
3929 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3930 case SHF_GROUP
: *p
= 'G'; break;
3931 case SHF_TLS
: *p
= 'T'; break;
3934 if (elf_header
.e_machine
== EM_X86_64
3935 && flag
== SHF_X86_64_LARGE
)
3937 else if (flag
& SHF_MASKOS
)
3940 sh_flags
&= ~ SHF_MASKOS
;
3942 else if (flag
& SHF_MASKPROC
)
3945 sh_flags
&= ~ SHF_MASKPROC
;
3955 if (do_section_details
)
3959 size
-= 5 + field_size
;
3960 if (p
!= buff
+ field_size
+ 4)
3968 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3969 (unsigned long) os_flags
);
3970 p
+= 5 + field_size
;
3974 size
-= 7 + field_size
;
3975 if (p
!= buff
+ field_size
+ 4)
3983 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3984 (unsigned long) proc_flags
);
3985 p
+= 7 + field_size
;
3989 size
-= 10 + field_size
;
3990 if (p
!= buff
+ field_size
+ 4)
3998 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3999 (unsigned long) unknown_flags
);
4000 p
+= 10 + field_size
;
4009 process_section_headers (FILE * file
)
4011 Elf_Internal_Shdr
* section
;
4014 section_headers
= NULL
;
4016 if (elf_header
.e_shnum
== 0)
4019 printf (_("\nThere are no sections in this file.\n"));
4024 if (do_sections
&& !do_header
)
4025 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4026 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4030 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4033 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4036 /* Read in the string table, so that we have names to display. */
4037 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4038 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4040 section
= section_headers
+ elf_header
.e_shstrndx
;
4042 if (section
->sh_size
!= 0)
4044 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4045 1, section
->sh_size
, _("string table"));
4047 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4051 /* Scan the sections for the dynamic symbol table
4052 and dynamic string table and debug sections. */
4053 dynamic_symbols
= NULL
;
4054 dynamic_strings
= NULL
;
4055 dynamic_syminfo
= NULL
;
4056 symtab_shndx_hdr
= NULL
;
4058 eh_addr_size
= is_32bit_elf
? 4 : 8;
4059 switch (elf_header
.e_machine
)
4062 case EM_MIPS_RS3_LE
:
4063 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4064 FDE addresses. However, the ABI also has a semi-official ILP32
4065 variant for which the normal FDE address size rules apply.
4067 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4068 section, where XX is the size of longs in bits. Unfortunately,
4069 earlier compilers provided no way of distinguishing ILP32 objects
4070 from LP64 objects, so if there's any doubt, we should assume that
4071 the official LP64 form is being used. */
4072 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4073 && find_section (".gcc_compiled_long32") == NULL
)
4079 switch (elf_header
.e_flags
& EF_H8_MACH
)
4081 case E_H8_MACH_H8300
:
4082 case E_H8_MACH_H8300HN
:
4083 case E_H8_MACH_H8300SN
:
4084 case E_H8_MACH_H8300SXN
:
4087 case E_H8_MACH_H8300H
:
4088 case E_H8_MACH_H8300S
:
4089 case E_H8_MACH_H8300SX
:
4097 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4099 case EF_M32C_CPU_M16C
:
4106 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4109 size_t expected_entsize \
4110 = is_32bit_elf ? size32 : size64; \
4111 if (section->sh_entsize != expected_entsize) \
4112 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4113 i, (unsigned long int) section->sh_entsize, \
4114 (unsigned long int) expected_entsize); \
4115 section->sh_entsize = expected_entsize; \
4118 #define CHECK_ENTSIZE(section, i, type) \
4119 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4120 sizeof (Elf64_External_##type))
4122 for (i
= 0, section
= section_headers
;
4123 i
< elf_header
.e_shnum
;
4126 char * name
= SECTION_NAME (section
);
4128 if (section
->sh_type
== SHT_DYNSYM
)
4130 if (dynamic_symbols
!= NULL
)
4132 error (_("File contains multiple dynamic symbol tables\n"));
4136 CHECK_ENTSIZE (section
, i
, Sym
);
4137 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4138 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4140 else if (section
->sh_type
== SHT_STRTAB
4141 && streq (name
, ".dynstr"))
4143 if (dynamic_strings
!= NULL
)
4145 error (_("File contains multiple dynamic string tables\n"));
4149 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4150 1, section
->sh_size
, _("dynamic strings"));
4151 dynamic_strings_length
= section
->sh_size
;
4153 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4155 if (symtab_shndx_hdr
!= NULL
)
4157 error (_("File contains multiple symtab shndx tables\n"));
4160 symtab_shndx_hdr
= section
;
4162 else if (section
->sh_type
== SHT_SYMTAB
)
4163 CHECK_ENTSIZE (section
, i
, Sym
);
4164 else if (section
->sh_type
== SHT_GROUP
)
4165 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4166 else if (section
->sh_type
== SHT_REL
)
4167 CHECK_ENTSIZE (section
, i
, Rel
);
4168 else if (section
->sh_type
== SHT_RELA
)
4169 CHECK_ENTSIZE (section
, i
, Rela
);
4170 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4171 || do_debug_lines
|| do_debug_pubnames
4172 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4173 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4174 && (const_strneq (name
, ".debug_")
4175 || const_strneq (name
, ".zdebug_")))
4178 name
+= sizeof (".zdebug_") - 1;
4180 name
+= sizeof (".debug_") - 1;
4183 || (do_debug_info
&& streq (name
, "info"))
4184 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4185 || (do_debug_lines
&& streq (name
, "line"))
4186 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4187 || (do_debug_aranges
&& streq (name
, "aranges"))
4188 || (do_debug_ranges
&& streq (name
, "ranges"))
4189 || (do_debug_frames
&& streq (name
, "frame"))
4190 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4191 || (do_debug_str
&& streq (name
, "str"))
4192 || (do_debug_loc
&& streq (name
, "loc"))
4194 request_dump_bynumber (i
, DEBUG_DUMP
);
4196 /* Linkonce section to be combined with .debug_info at link time. */
4197 else if ((do_debugging
|| do_debug_info
)
4198 && const_strneq (name
, ".gnu.linkonce.wi."))
4199 request_dump_bynumber (i
, DEBUG_DUMP
);
4200 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4201 request_dump_bynumber (i
, DEBUG_DUMP
);
4207 if (elf_header
.e_shnum
> 1)
4208 printf (_("\nSection Headers:\n"));
4210 printf (_("\nSection Header:\n"));
4214 if (do_section_details
)
4216 printf (_(" [Nr] Name\n"));
4217 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4221 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4225 if (do_section_details
)
4227 printf (_(" [Nr] Name\n"));
4228 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4232 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4236 if (do_section_details
)
4238 printf (_(" [Nr] Name\n"));
4239 printf (_(" Type Address Offset Link\n"));
4240 printf (_(" Size EntSize Info Align\n"));
4244 printf (_(" [Nr] Name Type Address Offset\n"));
4245 printf (_(" Size EntSize Flags Link Info Align\n"));
4249 if (do_section_details
)
4250 printf (_(" Flags\n"));
4252 for (i
= 0, section
= section_headers
;
4253 i
< elf_header
.e_shnum
;
4256 if (do_section_details
)
4258 printf (" [%2u] %s\n",
4260 SECTION_NAME (section
));
4261 if (is_32bit_elf
|| do_wide
)
4262 printf (" %-15.15s ",
4263 get_section_type_name (section
->sh_type
));
4266 printf ((do_wide
? " [%2u] %-17s %-15s "
4267 : " [%2u] %-17.17s %-15.15s "),
4269 SECTION_NAME (section
),
4270 get_section_type_name (section
->sh_type
));
4274 print_vma (section
->sh_addr
, LONG_HEX
);
4276 printf ( " %6.6lx %6.6lx %2.2lx",
4277 (unsigned long) section
->sh_offset
,
4278 (unsigned long) section
->sh_size
,
4279 (unsigned long) section
->sh_entsize
);
4281 if (do_section_details
)
4282 fputs (" ", stdout
);
4284 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4286 printf ("%2u %3u %2lu\n",
4289 (unsigned long) section
->sh_addralign
);
4293 print_vma (section
->sh_addr
, LONG_HEX
);
4295 if ((long) section
->sh_offset
== section
->sh_offset
)
4296 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4300 print_vma (section
->sh_offset
, LONG_HEX
);
4303 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4304 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4308 print_vma (section
->sh_size
, LONG_HEX
);
4311 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4312 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4316 print_vma (section
->sh_entsize
, LONG_HEX
);
4319 if (do_section_details
)
4320 fputs (" ", stdout
);
4322 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4324 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4326 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4327 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4330 print_vma (section
->sh_addralign
, DEC
);
4334 else if (do_section_details
)
4336 printf (" %-15.15s ",
4337 get_section_type_name (section
->sh_type
));
4338 print_vma (section
->sh_addr
, LONG_HEX
);
4339 if ((long) section
->sh_offset
== section
->sh_offset
)
4340 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4344 print_vma (section
->sh_offset
, LONG_HEX
);
4346 printf (" %u\n ", section
->sh_link
);
4347 print_vma (section
->sh_size
, LONG_HEX
);
4349 print_vma (section
->sh_entsize
, LONG_HEX
);
4351 printf (" %-16u %lu\n",
4353 (unsigned long) section
->sh_addralign
);
4358 print_vma (section
->sh_addr
, LONG_HEX
);
4359 if ((long) section
->sh_offset
== section
->sh_offset
)
4360 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4364 print_vma (section
->sh_offset
, LONG_HEX
);
4367 print_vma (section
->sh_size
, LONG_HEX
);
4369 print_vma (section
->sh_entsize
, LONG_HEX
);
4371 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4373 printf (" %2u %3u %lu\n",
4376 (unsigned long) section
->sh_addralign
);
4379 if (do_section_details
)
4380 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4383 if (!do_section_details
)
4384 printf (_("Key to Flags:\n\
4385 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4386 I (info), L (link order), G (group), x (unknown)\n\
4387 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4393 get_group_flags (unsigned int flags
)
4395 static char buff
[32];
4402 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4409 process_section_groups (FILE * file
)
4411 Elf_Internal_Shdr
* section
;
4413 struct group
* group
;
4414 Elf_Internal_Shdr
* symtab_sec
;
4415 Elf_Internal_Shdr
* strtab_sec
;
4416 Elf_Internal_Sym
* symtab
;
4420 /* Don't process section groups unless needed. */
4421 if (!do_unwind
&& !do_section_groups
)
4424 if (elf_header
.e_shnum
== 0)
4426 if (do_section_groups
)
4427 printf (_("\nThere are no sections in this file.\n"));
4432 if (section_headers
== NULL
)
4434 error (_("Section headers are not available!\n"));
4438 section_headers_groups
= calloc (elf_header
.e_shnum
,
4439 sizeof (struct group
*));
4441 if (section_headers_groups
== NULL
)
4443 error (_("Out of memory\n"));
4447 /* Scan the sections for the group section. */
4449 for (i
= 0, section
= section_headers
;
4450 i
< elf_header
.e_shnum
;
4452 if (section
->sh_type
== SHT_GROUP
)
4455 if (group_count
== 0)
4457 if (do_section_groups
)
4458 printf (_("\nThere are no section groups in this file.\n"));
4463 section_groups
= calloc (group_count
, sizeof (struct group
));
4465 if (section_groups
== NULL
)
4467 error (_("Out of memory\n"));
4476 for (i
= 0, section
= section_headers
, group
= section_groups
;
4477 i
< elf_header
.e_shnum
;
4480 if (section
->sh_type
== SHT_GROUP
)
4482 char * name
= SECTION_NAME (section
);
4484 unsigned char * start
;
4485 unsigned char * indices
;
4486 unsigned int entry
, j
, size
;
4487 Elf_Internal_Shdr
* sec
;
4488 Elf_Internal_Sym
* sym
;
4490 /* Get the symbol table. */
4491 if (section
->sh_link
>= elf_header
.e_shnum
4492 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4495 error (_("Bad sh_link in group section `%s'\n"), name
);
4499 if (symtab_sec
!= sec
)
4504 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4507 sym
= symtab
+ section
->sh_info
;
4509 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4511 if (sym
->st_shndx
== 0
4512 || sym
->st_shndx
>= elf_header
.e_shnum
)
4514 error (_("Bad sh_info in group section `%s'\n"), name
);
4518 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4527 /* Get the string table. */
4528 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4537 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4542 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4543 1, strtab_sec
->sh_size
,
4545 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4547 group_name
= sym
->st_name
< strtab_size
4548 ? strtab
+ sym
->st_name
: "<corrupt>";
4551 start
= get_data (NULL
, file
, section
->sh_offset
,
4552 1, section
->sh_size
, _("section data"));
4555 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4556 entry
= byte_get (indices
, 4);
4559 if (do_section_groups
)
4561 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4562 get_group_flags (entry
), i
, name
, group_name
, size
);
4564 printf (_(" [Index] Name\n"));
4567 group
->group_index
= i
;
4569 for (j
= 0; j
< size
; j
++)
4571 struct group_list
* g
;
4573 entry
= byte_get (indices
, 4);
4576 if (entry
>= elf_header
.e_shnum
)
4578 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4579 entry
, i
, elf_header
.e_shnum
- 1);
4583 if (section_headers_groups
[entry
] != NULL
)
4587 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4589 section_headers_groups
[entry
]->group_index
);
4594 /* Intel C/C++ compiler may put section 0 in a
4595 section group. We just warn it the first time
4596 and ignore it afterwards. */
4597 static int warned
= 0;
4600 error (_("section 0 in group section [%5u]\n"),
4601 section_headers_groups
[entry
]->group_index
);
4607 section_headers_groups
[entry
] = group
;
4609 if (do_section_groups
)
4611 sec
= section_headers
+ entry
;
4612 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4615 g
= xmalloc (sizeof (struct group_list
));
4616 g
->section_index
= entry
;
4617 g
->next
= group
->root
;
4641 } dynamic_relocations
[] =
4643 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4644 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4645 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4648 /* Process the reloc section. */
4651 process_relocs (FILE * file
)
4653 unsigned long rel_size
;
4654 unsigned long rel_offset
;
4660 if (do_using_dynamic
)
4664 int has_dynamic_reloc
;
4667 has_dynamic_reloc
= 0;
4669 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4671 is_rela
= dynamic_relocations
[i
].rela
;
4672 name
= dynamic_relocations
[i
].name
;
4673 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4674 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4676 has_dynamic_reloc
|= rel_size
;
4678 if (is_rela
== UNKNOWN
)
4680 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4681 switch (dynamic_info
[DT_PLTREL
])
4695 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4696 name
, rel_offset
, rel_size
);
4698 dump_relocations (file
,
4699 offset_from_vma (file
, rel_offset
, rel_size
),
4701 dynamic_symbols
, num_dynamic_syms
,
4702 dynamic_strings
, dynamic_strings_length
, is_rela
);
4706 if (! has_dynamic_reloc
)
4707 printf (_("\nThere are no dynamic relocations in this file.\n"));
4711 Elf_Internal_Shdr
* section
;
4715 for (i
= 0, section
= section_headers
;
4716 i
< elf_header
.e_shnum
;
4719 if ( section
->sh_type
!= SHT_RELA
4720 && section
->sh_type
!= SHT_REL
)
4723 rel_offset
= section
->sh_offset
;
4724 rel_size
= section
->sh_size
;
4728 Elf_Internal_Shdr
* strsec
;
4731 printf (_("\nRelocation section "));
4733 if (string_table
== NULL
)
4734 printf ("%d", section
->sh_name
);
4736 printf (_("'%s'"), SECTION_NAME (section
));
4738 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4739 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4741 is_rela
= section
->sh_type
== SHT_RELA
;
4743 if (section
->sh_link
!= 0
4744 && section
->sh_link
< elf_header
.e_shnum
)
4746 Elf_Internal_Shdr
* symsec
;
4747 Elf_Internal_Sym
* symtab
;
4748 unsigned long nsyms
;
4749 unsigned long strtablen
= 0;
4750 char * strtab
= NULL
;
4752 symsec
= section_headers
+ section
->sh_link
;
4753 if (symsec
->sh_type
!= SHT_SYMTAB
4754 && symsec
->sh_type
!= SHT_DYNSYM
)
4757 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4758 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4763 if (symsec
->sh_link
!= 0
4764 && symsec
->sh_link
< elf_header
.e_shnum
)
4766 strsec
= section_headers
+ symsec
->sh_link
;
4768 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4771 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4774 dump_relocations (file
, rel_offset
, rel_size
,
4775 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4781 dump_relocations (file
, rel_offset
, rel_size
,
4782 NULL
, 0, NULL
, 0, is_rela
);
4789 printf (_("\nThere are no relocations in this file.\n"));
4795 /* Process the unwind section. */
4797 #include "unwind-ia64.h"
4799 /* An absolute address consists of a section and an offset. If the
4800 section is NULL, the offset itself is the address, otherwise, the
4801 address equals to LOAD_ADDRESS(section) + offset. */
4805 unsigned short section
;
4809 #define ABSADDR(a) \
4811 ? section_headers [(a).section].sh_addr + (a).offset \
4814 struct ia64_unw_aux_info
4816 struct ia64_unw_table_entry
4818 struct absaddr start
;
4820 struct absaddr info
;
4822 *table
; /* Unwind table. */
4823 unsigned long table_len
; /* Length of unwind table. */
4824 unsigned char * info
; /* Unwind info. */
4825 unsigned long info_size
; /* Size of unwind info. */
4826 bfd_vma info_addr
; /* starting address of unwind info. */
4827 bfd_vma seg_base
; /* Starting address of segment. */
4828 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4829 unsigned long nsyms
; /* Number of symbols. */
4830 char * strtab
; /* The string table. */
4831 unsigned long strtab_size
; /* Size of string table. */
4835 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4836 unsigned long nsyms
,
4837 const char * strtab
,
4838 unsigned long strtab_size
,
4839 struct absaddr addr
,
4840 const char ** symname
,
4843 bfd_vma dist
= 0x100000;
4844 Elf_Internal_Sym
* sym
;
4845 Elf_Internal_Sym
* best
= NULL
;
4848 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4850 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4851 && sym
->st_name
!= 0
4852 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4853 && addr
.offset
>= sym
->st_value
4854 && addr
.offset
- sym
->st_value
< dist
)
4857 dist
= addr
.offset
- sym
->st_value
;
4864 *symname
= (best
->st_name
>= strtab_size
4865 ? "<corrupt>" : strtab
+ best
->st_name
);
4870 *offset
= addr
.offset
;
4874 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
4876 struct ia64_unw_table_entry
* tp
;
4879 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4883 const unsigned char * dp
;
4884 const unsigned char * head
;
4885 const char * procname
;
4887 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4888 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4890 fputs ("\n<", stdout
);
4894 fputs (procname
, stdout
);
4897 printf ("+%lx", (unsigned long) offset
);
4900 fputs (">: [", stdout
);
4901 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4902 fputc ('-', stdout
);
4903 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4904 printf ("], info at +0x%lx\n",
4905 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4907 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4908 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4910 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4911 (unsigned) UNW_VER (stamp
),
4912 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4913 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4914 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4915 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4917 if (UNW_VER (stamp
) != 1)
4919 printf ("\tUnknown version.\n");
4924 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4925 dp
= unw_decode (dp
, in_body
, & in_body
);
4930 slurp_ia64_unwind_table (FILE * file
,
4931 struct ia64_unw_aux_info
* aux
,
4932 Elf_Internal_Shdr
* sec
)
4934 unsigned long size
, nrelas
, i
;
4935 Elf_Internal_Phdr
* seg
;
4936 struct ia64_unw_table_entry
* tep
;
4937 Elf_Internal_Shdr
* relsec
;
4938 Elf_Internal_Rela
* rela
;
4939 Elf_Internal_Rela
* rp
;
4940 unsigned char * table
;
4942 Elf_Internal_Sym
* sym
;
4943 const char * relname
;
4945 /* First, find the starting address of the segment that includes
4948 if (elf_header
.e_phnum
)
4950 if (! get_program_headers (file
))
4953 for (seg
= program_headers
;
4954 seg
< program_headers
+ elf_header
.e_phnum
;
4957 if (seg
->p_type
!= PT_LOAD
)
4960 if (sec
->sh_addr
>= seg
->p_vaddr
4961 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4963 aux
->seg_base
= seg
->p_vaddr
;
4969 /* Second, build the unwind table from the contents of the unwind section: */
4970 size
= sec
->sh_size
;
4971 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4975 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4977 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4979 tep
->start
.section
= SHN_UNDEF
;
4980 tep
->end
.section
= SHN_UNDEF
;
4981 tep
->info
.section
= SHN_UNDEF
;
4984 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4985 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4986 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4990 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4991 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4992 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4994 tep
->start
.offset
+= aux
->seg_base
;
4995 tep
->end
.offset
+= aux
->seg_base
;
4996 tep
->info
.offset
+= aux
->seg_base
;
5000 /* Third, apply any relocations to the unwind table: */
5001 for (relsec
= section_headers
;
5002 relsec
< section_headers
+ elf_header
.e_shnum
;
5005 if (relsec
->sh_type
!= SHT_RELA
5006 || relsec
->sh_info
>= elf_header
.e_shnum
5007 || section_headers
+ relsec
->sh_info
!= sec
)
5010 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5014 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5016 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5017 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5019 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5021 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5025 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5027 switch (rp
->r_offset
/eh_addr_size
% 3)
5030 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5031 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5034 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5035 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5038 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5039 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5049 aux
->table_len
= size
/ (3 * eh_addr_size
);
5054 ia64_process_unwind (FILE * file
)
5056 Elf_Internal_Shdr
* sec
;
5057 Elf_Internal_Shdr
* unwsec
= NULL
;
5058 Elf_Internal_Shdr
* strsec
;
5059 unsigned long i
, unwcount
= 0, unwstart
= 0;
5060 struct ia64_unw_aux_info aux
;
5062 memset (& aux
, 0, sizeof (aux
));
5064 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5066 if (sec
->sh_type
== SHT_SYMTAB
5067 && sec
->sh_link
< elf_header
.e_shnum
)
5069 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5070 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5072 strsec
= section_headers
+ sec
->sh_link
;
5073 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5074 1, strsec
->sh_size
, _("string table"));
5075 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5077 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5082 printf (_("\nThere are no unwind sections in this file.\n"));
5084 while (unwcount
-- > 0)
5089 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5090 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5091 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5098 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5100 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5102 /* We need to find which section group it is in. */
5103 struct group_list
* g
= section_headers_groups
[i
]->root
;
5105 for (; g
!= NULL
; g
= g
->next
)
5107 sec
= section_headers
+ g
->section_index
;
5109 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5114 i
= elf_header
.e_shnum
;
5116 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5118 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5119 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5120 suffix
= SECTION_NAME (unwsec
) + len
;
5121 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5123 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5124 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5129 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5130 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5131 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5132 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5134 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5135 suffix
= SECTION_NAME (unwsec
) + len
;
5136 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5138 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5139 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5143 if (i
== elf_header
.e_shnum
)
5145 printf (_("\nCould not find unwind info section for "));
5147 if (string_table
== NULL
)
5148 printf ("%d", unwsec
->sh_name
);
5150 printf (_("'%s'"), SECTION_NAME (unwsec
));
5154 aux
.info_size
= sec
->sh_size
;
5155 aux
.info_addr
= sec
->sh_addr
;
5156 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5159 printf (_("\nUnwind section "));
5161 if (string_table
== NULL
)
5162 printf ("%d", unwsec
->sh_name
);
5164 printf (_("'%s'"), SECTION_NAME (unwsec
));
5166 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5167 (unsigned long) unwsec
->sh_offset
,
5168 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5170 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5172 if (aux
.table_len
> 0)
5173 dump_ia64_unwind (& aux
);
5176 free ((char *) aux
.table
);
5178 free ((char *) aux
.info
);
5187 free ((char *) aux
.strtab
);
5192 struct hppa_unw_aux_info
5194 struct hppa_unw_table_entry
5196 struct absaddr start
;
5198 unsigned int Cannot_unwind
:1; /* 0 */
5199 unsigned int Millicode
:1; /* 1 */
5200 unsigned int Millicode_save_sr0
:1; /* 2 */
5201 unsigned int Region_description
:2; /* 3..4 */
5202 unsigned int reserved1
:1; /* 5 */
5203 unsigned int Entry_SR
:1; /* 6 */
5204 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5205 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5206 unsigned int Args_stored
:1; /* 16 */
5207 unsigned int Variable_Frame
:1; /* 17 */
5208 unsigned int Separate_Package_Body
:1; /* 18 */
5209 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5210 unsigned int Stack_Overflow_Check
:1; /* 20 */
5211 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5212 unsigned int Ada_Region
:1; /* 22 */
5213 unsigned int cxx_info
:1; /* 23 */
5214 unsigned int cxx_try_catch
:1; /* 24 */
5215 unsigned int sched_entry_seq
:1; /* 25 */
5216 unsigned int reserved2
:1; /* 26 */
5217 unsigned int Save_SP
:1; /* 27 */
5218 unsigned int Save_RP
:1; /* 28 */
5219 unsigned int Save_MRP_in_frame
:1; /* 29 */
5220 unsigned int extn_ptr_defined
:1; /* 30 */
5221 unsigned int Cleanup_defined
:1; /* 31 */
5223 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5224 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5225 unsigned int Large_frame
:1; /* 2 */
5226 unsigned int Pseudo_SP_Set
:1; /* 3 */
5227 unsigned int reserved4
:1; /* 4 */
5228 unsigned int Total_frame_size
:27; /* 5..31 */
5230 *table
; /* Unwind table. */
5231 unsigned long table_len
; /* Length of unwind table. */
5232 bfd_vma seg_base
; /* Starting address of segment. */
5233 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5234 unsigned long nsyms
; /* Number of symbols. */
5235 char * strtab
; /* The string table. */
5236 unsigned long strtab_size
; /* Size of string table. */
5240 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5242 struct hppa_unw_table_entry
* tp
;
5244 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5247 const char * procname
;
5249 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5250 aux
->strtab_size
, tp
->start
, &procname
,
5253 fputs ("\n<", stdout
);
5257 fputs (procname
, stdout
);
5260 printf ("+%lx", (unsigned long) offset
);
5263 fputs (">: [", stdout
);
5264 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5265 fputc ('-', stdout
);
5266 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5269 #define PF(_m) if (tp->_m) printf (#_m " ");
5270 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5273 PF(Millicode_save_sr0
);
5274 /* PV(Region_description); */
5280 PF(Separate_Package_Body
);
5281 PF(Frame_Extension_Millicode
);
5282 PF(Stack_Overflow_Check
);
5283 PF(Two_Instruction_SP_Increment
);
5287 PF(sched_entry_seq
);
5290 PF(Save_MRP_in_frame
);
5291 PF(extn_ptr_defined
);
5292 PF(Cleanup_defined
);
5293 PF(MPE_XL_interrupt_marker
);
5294 PF(HP_UX_interrupt_marker
);
5297 PV(Total_frame_size
);
5306 slurp_hppa_unwind_table (FILE * file
,
5307 struct hppa_unw_aux_info
* aux
,
5308 Elf_Internal_Shdr
* sec
)
5310 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5311 Elf_Internal_Phdr
* seg
;
5312 struct hppa_unw_table_entry
* tep
;
5313 Elf_Internal_Shdr
* relsec
;
5314 Elf_Internal_Rela
* rela
;
5315 Elf_Internal_Rela
* rp
;
5316 unsigned char * table
;
5318 Elf_Internal_Sym
* sym
;
5319 const char * relname
;
5321 /* First, find the starting address of the segment that includes
5324 if (elf_header
.e_phnum
)
5326 if (! get_program_headers (file
))
5329 for (seg
= program_headers
;
5330 seg
< program_headers
+ elf_header
.e_phnum
;
5333 if (seg
->p_type
!= PT_LOAD
)
5336 if (sec
->sh_addr
>= seg
->p_vaddr
5337 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5339 aux
->seg_base
= seg
->p_vaddr
;
5345 /* Second, build the unwind table from the contents of the unwind
5347 size
= sec
->sh_size
;
5348 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5353 nentries
= size
/ unw_ent_size
;
5354 size
= unw_ent_size
* nentries
;
5356 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5358 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5360 unsigned int tmp1
, tmp2
;
5362 tep
->start
.section
= SHN_UNDEF
;
5363 tep
->end
.section
= SHN_UNDEF
;
5365 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5366 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5367 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5368 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5370 tep
->start
.offset
+= aux
->seg_base
;
5371 tep
->end
.offset
+= aux
->seg_base
;
5373 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5374 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5375 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5376 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5377 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5378 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5379 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5380 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5381 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5382 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5383 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5384 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5385 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5386 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5387 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5388 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5389 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5390 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5391 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5392 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5393 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5394 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5395 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5396 tep
->Cleanup_defined
= tmp1
& 0x1;
5398 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5399 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5400 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5401 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5402 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5403 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5407 /* Third, apply any relocations to the unwind table. */
5408 for (relsec
= section_headers
;
5409 relsec
< section_headers
+ elf_header
.e_shnum
;
5412 if (relsec
->sh_type
!= SHT_RELA
5413 || relsec
->sh_info
>= elf_header
.e_shnum
5414 || section_headers
+ relsec
->sh_info
!= sec
)
5417 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5421 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5423 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5424 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5426 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5427 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5429 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5433 i
= rp
->r_offset
/ unw_ent_size
;
5435 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5438 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5439 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5442 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5443 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5453 aux
->table_len
= nentries
;
5459 hppa_process_unwind (FILE * file
)
5461 struct hppa_unw_aux_info aux
;
5462 Elf_Internal_Shdr
* unwsec
= NULL
;
5463 Elf_Internal_Shdr
* strsec
;
5464 Elf_Internal_Shdr
* sec
;
5467 memset (& aux
, 0, sizeof (aux
));
5469 if (string_table
== NULL
)
5472 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5474 if (sec
->sh_type
== SHT_SYMTAB
5475 && sec
->sh_link
< elf_header
.e_shnum
)
5477 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5478 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5480 strsec
= section_headers
+ sec
->sh_link
;
5481 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5482 1, strsec
->sh_size
, _("string table"));
5483 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5485 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5490 printf (_("\nThere are no unwind sections in this file.\n"));
5492 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5494 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5496 printf (_("\nUnwind section "));
5497 printf (_("'%s'"), SECTION_NAME (sec
));
5499 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5500 (unsigned long) sec
->sh_offset
,
5501 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5503 slurp_hppa_unwind_table (file
, &aux
, sec
);
5504 if (aux
.table_len
> 0)
5505 dump_hppa_unwind (&aux
);
5508 free ((char *) aux
.table
);
5516 free ((char *) aux
.strtab
);
5522 process_unwind (FILE * file
)
5524 struct unwind_handler
5527 int (* handler
)(FILE *);
5530 { EM_IA_64
, ia64_process_unwind
},
5531 { EM_PARISC
, hppa_process_unwind
},
5539 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5540 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5541 return handlers
[i
].handler (file
);
5543 printf (_("\nThere are no unwind sections in this file.\n"));
5548 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5550 switch (entry
->d_tag
)
5553 if (entry
->d_un
.d_val
== 0)
5557 static const char * opts
[] =
5559 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5560 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5561 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5562 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5567 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5568 if (entry
->d_un
.d_val
& (1 << cnt
))
5570 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5577 case DT_MIPS_IVERSION
:
5578 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5579 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5581 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5584 case DT_MIPS_TIME_STAMP
:
5589 time_t time
= entry
->d_un
.d_val
;
5590 tmp
= gmtime (&time
);
5591 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5592 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5593 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5594 printf ("Time Stamp: %s\n", timebuf
);
5598 case DT_MIPS_RLD_VERSION
:
5599 case DT_MIPS_LOCAL_GOTNO
:
5600 case DT_MIPS_CONFLICTNO
:
5601 case DT_MIPS_LIBLISTNO
:
5602 case DT_MIPS_SYMTABNO
:
5603 case DT_MIPS_UNREFEXTNO
:
5604 case DT_MIPS_HIPAGENO
:
5605 case DT_MIPS_DELTA_CLASS_NO
:
5606 case DT_MIPS_DELTA_INSTANCE_NO
:
5607 case DT_MIPS_DELTA_RELOC_NO
:
5608 case DT_MIPS_DELTA_SYM_NO
:
5609 case DT_MIPS_DELTA_CLASSSYM_NO
:
5610 case DT_MIPS_COMPACT_SIZE
:
5611 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5615 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5621 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5623 switch (entry
->d_tag
)
5625 case DT_HP_DLD_FLAGS
:
5634 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5635 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5636 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5637 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5638 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5639 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5640 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5641 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5642 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5643 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5644 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5645 { DT_HP_GST
, "HP_GST" },
5646 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5647 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5648 { DT_HP_NODELETE
, "HP_NODELETE" },
5649 { DT_HP_GROUP
, "HP_GROUP" },
5650 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5654 bfd_vma val
= entry
->d_un
.d_val
;
5656 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5657 if (val
& flags
[cnt
].bit
)
5661 fputs (flags
[cnt
].str
, stdout
);
5663 val
^= flags
[cnt
].bit
;
5666 if (val
!= 0 || first
)
5670 print_vma (val
, HEX
);
5676 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5683 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5685 switch (entry
->d_tag
)
5687 case DT_IA_64_PLT_RESERVE
:
5688 /* First 3 slots reserved. */
5689 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5691 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5695 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5702 get_32bit_dynamic_section (FILE * file
)
5704 Elf32_External_Dyn
* edyn
;
5705 Elf32_External_Dyn
* ext
;
5706 Elf_Internal_Dyn
* entry
;
5708 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5709 _("dynamic section"));
5713 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5714 might not have the luxury of section headers. Look for the DT_NULL
5715 terminator to determine the number of entries. */
5716 for (ext
= edyn
, dynamic_nent
= 0;
5717 (char *) ext
< (char *) edyn
+ dynamic_size
;
5721 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5725 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5726 if (dynamic_section
== NULL
)
5728 error (_("Out of memory\n"));
5733 for (ext
= edyn
, entry
= dynamic_section
;
5734 entry
< dynamic_section
+ dynamic_nent
;
5737 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5738 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5747 get_64bit_dynamic_section (FILE * file
)
5749 Elf64_External_Dyn
* edyn
;
5750 Elf64_External_Dyn
* ext
;
5751 Elf_Internal_Dyn
* entry
;
5753 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5754 _("dynamic section"));
5758 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5759 might not have the luxury of section headers. Look for the DT_NULL
5760 terminator to determine the number of entries. */
5761 for (ext
= edyn
, dynamic_nent
= 0;
5762 (char *) ext
< (char *) edyn
+ dynamic_size
;
5766 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5770 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5771 if (dynamic_section
== NULL
)
5773 error (_("Out of memory\n"));
5778 for (ext
= edyn
, entry
= dynamic_section
;
5779 entry
< dynamic_section
+ dynamic_nent
;
5782 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5783 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5792 print_dynamic_flags (bfd_vma flags
)
5800 flag
= flags
& - flags
;
5810 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5811 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5812 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5813 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5814 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5815 default: fputs ("unknown", stdout
); break;
5821 /* Parse and display the contents of the dynamic section. */
5824 process_dynamic_section (FILE * file
)
5826 Elf_Internal_Dyn
* entry
;
5828 if (dynamic_size
== 0)
5831 printf (_("\nThere is no dynamic section in this file.\n"));
5838 if (! get_32bit_dynamic_section (file
))
5841 else if (! get_64bit_dynamic_section (file
))
5844 /* Find the appropriate symbol table. */
5845 if (dynamic_symbols
== NULL
)
5847 for (entry
= dynamic_section
;
5848 entry
< dynamic_section
+ dynamic_nent
;
5851 Elf_Internal_Shdr section
;
5853 if (entry
->d_tag
!= DT_SYMTAB
)
5856 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5858 /* Since we do not know how big the symbol table is,
5859 we default to reading in the entire file (!) and
5860 processing that. This is overkill, I know, but it
5862 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5864 if (archive_file_offset
!= 0)
5865 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5868 if (fseek (file
, 0, SEEK_END
))
5869 error (_("Unable to seek to end of file!\n"));
5871 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5875 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5877 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5879 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5880 if (num_dynamic_syms
< 1)
5882 error (_("Unable to determine the number of symbols to load\n"));
5886 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5890 /* Similarly find a string table. */
5891 if (dynamic_strings
== NULL
)
5893 for (entry
= dynamic_section
;
5894 entry
< dynamic_section
+ dynamic_nent
;
5897 unsigned long offset
;
5900 if (entry
->d_tag
!= DT_STRTAB
)
5903 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5905 /* Since we do not know how big the string table is,
5906 we default to reading in the entire file (!) and
5907 processing that. This is overkill, I know, but it
5910 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5912 if (archive_file_offset
!= 0)
5913 str_tab_len
= archive_file_size
- offset
;
5916 if (fseek (file
, 0, SEEK_END
))
5917 error (_("Unable to seek to end of file\n"));
5918 str_tab_len
= ftell (file
) - offset
;
5921 if (str_tab_len
< 1)
5924 (_("Unable to determine the length of the dynamic string table\n"));
5928 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5929 _("dynamic string table"));
5930 dynamic_strings_length
= str_tab_len
;
5935 /* And find the syminfo section if available. */
5936 if (dynamic_syminfo
== NULL
)
5938 unsigned long syminsz
= 0;
5940 for (entry
= dynamic_section
;
5941 entry
< dynamic_section
+ dynamic_nent
;
5944 if (entry
->d_tag
== DT_SYMINENT
)
5946 /* Note: these braces are necessary to avoid a syntax
5947 error from the SunOS4 C compiler. */
5948 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5950 else if (entry
->d_tag
== DT_SYMINSZ
)
5951 syminsz
= entry
->d_un
.d_val
;
5952 else if (entry
->d_tag
== DT_SYMINFO
)
5953 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5957 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5959 Elf_External_Syminfo
* extsyminfo
;
5960 Elf_External_Syminfo
* extsym
;
5961 Elf_Internal_Syminfo
* syminfo
;
5963 /* There is a syminfo section. Read the data. */
5964 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5965 syminsz
, _("symbol information"));
5969 dynamic_syminfo
= malloc (syminsz
);
5970 if (dynamic_syminfo
== NULL
)
5972 error (_("Out of memory\n"));
5976 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5977 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5978 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5979 ++syminfo
, ++extsym
)
5981 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5982 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5989 if (do_dynamic
&& dynamic_addr
)
5990 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5991 dynamic_addr
, dynamic_nent
);
5993 printf (_(" Tag Type Name/Value\n"));
5995 for (entry
= dynamic_section
;
5996 entry
< dynamic_section
+ dynamic_nent
;
6004 print_vma (entry
->d_tag
, FULL_HEX
);
6005 dtype
= get_dynamic_type (entry
->d_tag
);
6006 printf (" (%s)%*s", dtype
,
6007 ((is_32bit_elf
? 27 : 19)
6008 - (int) strlen (dtype
)),
6012 switch (entry
->d_tag
)
6016 print_dynamic_flags (entry
->d_un
.d_val
);
6026 switch (entry
->d_tag
)
6029 printf (_("Auxiliary library"));
6033 printf (_("Filter library"));
6037 printf (_("Configuration file"));
6041 printf (_("Dependency audit library"));
6045 printf (_("Audit library"));
6049 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6050 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6054 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6063 printf (_("Flags:"));
6065 if (entry
->d_un
.d_val
== 0)
6066 printf (_(" None\n"));
6069 unsigned long int val
= entry
->d_un
.d_val
;
6071 if (val
& DTF_1_PARINIT
)
6073 printf (" PARINIT");
6074 val
^= DTF_1_PARINIT
;
6076 if (val
& DTF_1_CONFEXP
)
6078 printf (" CONFEXP");
6079 val
^= DTF_1_CONFEXP
;
6082 printf (" %lx", val
);
6091 printf (_("Flags:"));
6093 if (entry
->d_un
.d_val
== 0)
6094 printf (_(" None\n"));
6097 unsigned long int val
= entry
->d_un
.d_val
;
6099 if (val
& DF_P1_LAZYLOAD
)
6101 printf (" LAZYLOAD");
6102 val
^= DF_P1_LAZYLOAD
;
6104 if (val
& DF_P1_GROUPPERM
)
6106 printf (" GROUPPERM");
6107 val
^= DF_P1_GROUPPERM
;
6110 printf (" %lx", val
);
6119 printf (_("Flags:"));
6120 if (entry
->d_un
.d_val
== 0)
6121 printf (_(" None\n"));
6124 unsigned long int val
= entry
->d_un
.d_val
;
6131 if (val
& DF_1_GLOBAL
)
6136 if (val
& DF_1_GROUP
)
6141 if (val
& DF_1_NODELETE
)
6143 printf (" NODELETE");
6144 val
^= DF_1_NODELETE
;
6146 if (val
& DF_1_LOADFLTR
)
6148 printf (" LOADFLTR");
6149 val
^= DF_1_LOADFLTR
;
6151 if (val
& DF_1_INITFIRST
)
6153 printf (" INITFIRST");
6154 val
^= DF_1_INITFIRST
;
6156 if (val
& DF_1_NOOPEN
)
6161 if (val
& DF_1_ORIGIN
)
6166 if (val
& DF_1_DIRECT
)
6171 if (val
& DF_1_TRANS
)
6176 if (val
& DF_1_INTERPOSE
)
6178 printf (" INTERPOSE");
6179 val
^= DF_1_INTERPOSE
;
6181 if (val
& DF_1_NODEFLIB
)
6183 printf (" NODEFLIB");
6184 val
^= DF_1_NODEFLIB
;
6186 if (val
& DF_1_NODUMP
)
6191 if (val
& DF_1_CONLFAT
)
6193 printf (" CONLFAT");
6194 val
^= DF_1_CONLFAT
;
6197 printf (" %lx", val
);
6204 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6206 puts (get_dynamic_type (entry
->d_un
.d_val
));
6226 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6232 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6233 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6239 switch (entry
->d_tag
)
6242 printf (_("Shared library: [%s]"), name
);
6244 if (streq (name
, program_interpreter
))
6245 printf (_(" program interpreter"));
6249 printf (_("Library soname: [%s]"), name
);
6253 printf (_("Library rpath: [%s]"), name
);
6257 printf (_("Library runpath: [%s]"), name
);
6261 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6266 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6279 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6283 case DT_INIT_ARRAYSZ
:
6284 case DT_FINI_ARRAYSZ
:
6285 case DT_GNU_CONFLICTSZ
:
6286 case DT_GNU_LIBLISTSZ
:
6289 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6290 printf (" (bytes)\n");
6300 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6313 if (entry
->d_tag
== DT_USED
6314 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6316 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6320 printf (_("Not needed object: [%s]\n"), name
);
6325 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6331 /* The value of this entry is ignored. */
6336 case DT_GNU_PRELINKED
:
6340 time_t time
= entry
->d_un
.d_val
;
6342 tmp
= gmtime (&time
);
6343 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6344 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6345 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6351 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6354 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6360 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6361 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6366 switch (elf_header
.e_machine
)
6369 case EM_MIPS_RS3_LE
:
6370 dynamic_section_mips_val (entry
);
6373 dynamic_section_parisc_val (entry
);
6376 dynamic_section_ia64_val (entry
);
6379 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6391 get_ver_flags (unsigned int flags
)
6393 static char buff
[32];
6400 if (flags
& VER_FLG_BASE
)
6401 strcat (buff
, "BASE ");
6403 if (flags
& VER_FLG_WEAK
)
6405 if (flags
& VER_FLG_BASE
)
6406 strcat (buff
, "| ");
6408 strcat (buff
, "WEAK ");
6411 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6412 strcat (buff
, "| <unknown>");
6417 /* Display the contents of the version sections. */
6419 process_version_sections (FILE * file
)
6421 Elf_Internal_Shdr
* section
;
6428 for (i
= 0, section
= section_headers
;
6429 i
< elf_header
.e_shnum
;
6432 switch (section
->sh_type
)
6434 case SHT_GNU_verdef
:
6436 Elf_External_Verdef
* edefs
;
6444 (_("\nVersion definition section '%s' contains %u entries:\n"),
6445 SECTION_NAME (section
), section
->sh_info
);
6447 printf (_(" Addr: 0x"));
6448 printf_vma (section
->sh_addr
);
6449 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6450 (unsigned long) section
->sh_offset
, section
->sh_link
,
6451 section
->sh_link
< elf_header
.e_shnum
6452 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6455 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6457 _("version definition section"));
6458 endbuf
= (char *) edefs
+ section
->sh_size
;
6462 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6465 Elf_External_Verdef
* edef
;
6466 Elf_Internal_Verdef ent
;
6467 Elf_External_Verdaux
* eaux
;
6468 Elf_Internal_Verdaux aux
;
6472 vstart
= ((char *) edefs
) + idx
;
6473 if (vstart
+ sizeof (*edef
) > endbuf
)
6476 edef
= (Elf_External_Verdef
*) vstart
;
6478 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6479 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6480 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6481 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6482 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6483 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6484 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6486 printf (_(" %#06x: Rev: %d Flags: %s"),
6487 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6489 printf (_(" Index: %d Cnt: %d "),
6490 ent
.vd_ndx
, ent
.vd_cnt
);
6492 vstart
+= ent
.vd_aux
;
6494 eaux
= (Elf_External_Verdaux
*) vstart
;
6496 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6497 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6499 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6500 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6502 printf (_("Name index: %ld\n"), aux
.vda_name
);
6504 isum
= idx
+ ent
.vd_aux
;
6506 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6508 isum
+= aux
.vda_next
;
6509 vstart
+= aux
.vda_next
;
6511 eaux
= (Elf_External_Verdaux
*) vstart
;
6512 if (vstart
+ sizeof (*eaux
) > endbuf
)
6515 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6516 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6518 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6519 printf (_(" %#06x: Parent %d: %s\n"),
6520 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6522 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6523 isum
, j
, aux
.vda_name
);
6526 printf (_(" Version def aux past end of section\n"));
6530 if (cnt
< section
->sh_info
)
6531 printf (_(" Version definition past end of section\n"));
6537 case SHT_GNU_verneed
:
6539 Elf_External_Verneed
* eneed
;
6546 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6547 SECTION_NAME (section
), section
->sh_info
);
6549 printf (_(" Addr: 0x"));
6550 printf_vma (section
->sh_addr
);
6551 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6552 (unsigned long) section
->sh_offset
, section
->sh_link
,
6553 section
->sh_link
< elf_header
.e_shnum
6554 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6557 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6559 _("version need section"));
6560 endbuf
= (char *) eneed
+ section
->sh_size
;
6564 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6566 Elf_External_Verneed
* entry
;
6567 Elf_Internal_Verneed ent
;
6572 vstart
= ((char *) eneed
) + idx
;
6573 if (vstart
+ sizeof (*entry
) > endbuf
)
6576 entry
= (Elf_External_Verneed
*) vstart
;
6578 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6579 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6580 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6581 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6582 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6584 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6586 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6587 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6589 printf (_(" File: %lx"), ent
.vn_file
);
6591 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6593 vstart
+= ent
.vn_aux
;
6595 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6597 Elf_External_Vernaux
* eaux
;
6598 Elf_Internal_Vernaux aux
;
6600 if (vstart
+ sizeof (*eaux
) > endbuf
)
6602 eaux
= (Elf_External_Vernaux
*) vstart
;
6604 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6605 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6606 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6607 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6608 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6610 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6611 printf (_(" %#06x: Name: %s"),
6612 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6614 printf (_(" %#06x: Name index: %lx"),
6615 isum
, aux
.vna_name
);
6617 printf (_(" Flags: %s Version: %d\n"),
6618 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6620 isum
+= aux
.vna_next
;
6621 vstart
+= aux
.vna_next
;
6624 printf (_(" Version need aux past end of section\n"));
6628 if (cnt
< section
->sh_info
)
6629 printf (_(" Version need past end of section\n"));
6635 case SHT_GNU_versym
:
6637 Elf_Internal_Shdr
* link_section
;
6640 unsigned char * edata
;
6641 unsigned short * data
;
6643 Elf_Internal_Sym
* symbols
;
6644 Elf_Internal_Shdr
* string_sec
;
6647 if (section
->sh_link
>= elf_header
.e_shnum
)
6650 link_section
= section_headers
+ section
->sh_link
;
6651 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6653 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6658 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6660 string_sec
= section_headers
+ link_section
->sh_link
;
6662 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6663 string_sec
->sh_size
, _("version string table"));
6667 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6668 SECTION_NAME (section
), total
);
6670 printf (_(" Addr: "));
6671 printf_vma (section
->sh_addr
);
6672 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6673 (unsigned long) section
->sh_offset
, section
->sh_link
,
6674 SECTION_NAME (link_section
));
6676 off
= offset_from_vma (file
,
6677 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6678 total
* sizeof (short));
6679 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6680 _("version symbol data"));
6687 data
= cmalloc (total
, sizeof (short));
6689 for (cnt
= total
; cnt
--;)
6690 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6695 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6698 int check_def
, check_need
;
6701 printf (" %03x:", cnt
);
6703 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6704 switch (data
[cnt
+ j
])
6707 fputs (_(" 0 (*local*) "), stdout
);
6711 fputs (_(" 1 (*global*) "), stdout
);
6715 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6716 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6720 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6721 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6724 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6731 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6733 Elf_Internal_Verneed ivn
;
6734 unsigned long offset
;
6736 offset
= offset_from_vma
6737 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6738 sizeof (Elf_External_Verneed
));
6742 Elf_Internal_Vernaux ivna
;
6743 Elf_External_Verneed evn
;
6744 Elf_External_Vernaux evna
;
6745 unsigned long a_off
;
6747 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6750 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6751 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6753 a_off
= offset
+ ivn
.vn_aux
;
6757 get_data (&evna
, file
, a_off
, sizeof (evna
),
6758 1, _("version need aux (2)"));
6760 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6761 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6763 a_off
+= ivna
.vna_next
;
6765 while (ivna
.vna_other
!= data
[cnt
+ j
]
6766 && ivna
.vna_next
!= 0);
6768 if (ivna
.vna_other
== data
[cnt
+ j
])
6770 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6772 if (ivna
.vna_name
>= string_sec
->sh_size
)
6773 name
= _("*invalid*");
6775 name
= strtab
+ ivna
.vna_name
;
6776 nn
+= printf ("(%s%-*s",
6778 12 - (int) strlen (name
),
6784 offset
+= ivn
.vn_next
;
6786 while (ivn
.vn_next
);
6789 if (check_def
&& data
[cnt
+ j
] != 0x8001
6790 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6792 Elf_Internal_Verdef ivd
;
6793 Elf_External_Verdef evd
;
6794 unsigned long offset
;
6796 offset
= offset_from_vma
6797 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6802 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6805 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6806 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6808 offset
+= ivd
.vd_next
;
6810 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6811 && ivd
.vd_next
!= 0);
6813 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6815 Elf_External_Verdaux evda
;
6816 Elf_Internal_Verdaux ivda
;
6818 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6820 get_data (&evda
, file
,
6821 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6823 _("version def aux"));
6825 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6827 if (ivda
.vda_name
>= string_sec
->sh_size
)
6828 name
= _("*invalid*");
6830 name
= strtab
+ ivda
.vda_name
;
6831 nn
+= printf ("(%s%-*s",
6833 12 - (int) strlen (name
),
6839 printf ("%*c", 18 - nn
, ' ');
6857 printf (_("\nNo version information found in this file.\n"));
6863 get_symbol_binding (unsigned int binding
)
6865 static char buff
[32];
6869 case STB_LOCAL
: return "LOCAL";
6870 case STB_GLOBAL
: return "GLOBAL";
6871 case STB_WEAK
: return "WEAK";
6873 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6874 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6876 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6877 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6879 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6885 get_symbol_type (unsigned int type
)
6887 static char buff
[32];
6891 case STT_NOTYPE
: return "NOTYPE";
6892 case STT_OBJECT
: return "OBJECT";
6893 case STT_FUNC
: return "FUNC";
6894 case STT_SECTION
: return "SECTION";
6895 case STT_FILE
: return "FILE";
6896 case STT_COMMON
: return "COMMON";
6897 case STT_TLS
: return "TLS";
6898 case STT_RELC
: return "RELC";
6899 case STT_SRELC
: return "SRELC";
6901 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6903 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6904 return "THUMB_FUNC";
6906 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6909 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6910 return "PARISC_MILLI";
6912 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6914 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6916 if (elf_header
.e_machine
== EM_PARISC
)
6918 if (type
== STT_HP_OPAQUE
)
6920 if (type
== STT_HP_STUB
)
6924 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6927 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6933 get_symbol_visibility (unsigned int visibility
)
6937 case STV_DEFAULT
: return "DEFAULT";
6938 case STV_INTERNAL
: return "INTERNAL";
6939 case STV_HIDDEN
: return "HIDDEN";
6940 case STV_PROTECTED
: return "PROTECTED";
6946 get_mips_symbol_other (unsigned int other
)
6950 case STO_OPTIONAL
: return "OPTIONAL";
6951 case STO_MIPS16
: return "MIPS16";
6952 case STO_MIPS_PLT
: return "MIPS PLT";
6953 case STO_MIPS_PIC
: return "MIPS PIC";
6954 default: return NULL
;
6959 get_symbol_other (unsigned int other
)
6961 const char * result
= NULL
;
6962 static char buff
[32];
6967 switch (elf_header
.e_machine
)
6970 result
= get_mips_symbol_other (other
);
6978 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6983 get_symbol_index_type (unsigned int type
)
6985 static char buff
[32];
6989 case SHN_UNDEF
: return "UND";
6990 case SHN_ABS
: return "ABS";
6991 case SHN_COMMON
: return "COM";
6993 if (type
== SHN_IA_64_ANSI_COMMON
6994 && elf_header
.e_machine
== EM_IA_64
6995 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6997 else if (elf_header
.e_machine
== EM_X86_64
6998 && type
== SHN_X86_64_LCOMMON
)
7000 else if (type
== SHN_MIPS_SCOMMON
7001 && elf_header
.e_machine
== EM_MIPS
)
7003 else if (type
== SHN_MIPS_SUNDEFINED
7004 && elf_header
.e_machine
== EM_MIPS
)
7006 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7007 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7008 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7009 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7010 else if (type
>= SHN_LORESERVE
)
7011 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7013 sprintf (buff
, "%3d", type
);
7021 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7023 unsigned char * e_data
;
7026 e_data
= cmalloc (number
, ent_size
);
7030 error (_("Out of memory\n"));
7034 if (fread (e_data
, ent_size
, number
, file
) != number
)
7036 error (_("Unable to read in dynamic data\n"));
7040 i_data
= cmalloc (number
, sizeof (*i_data
));
7044 error (_("Out of memory\n"));
7050 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7058 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7060 Elf_Internal_Sym
* psym
;
7063 psym
= dynamic_symbols
+ si
;
7065 n
= print_vma (si
, DEC_5
);
7067 fputs (" " + n
, stdout
);
7068 printf (" %3lu: ", hn
);
7069 print_vma (psym
->st_value
, LONG_HEX
);
7071 print_vma (psym
->st_size
, DEC_5
);
7073 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7074 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7075 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7076 /* Check to see if any other bits in the st_other field are set.
7077 Note - displaying this information disrupts the layout of the
7078 table being generated, but for the moment this case is very
7080 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7081 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7082 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7083 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7084 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7086 printf (" <corrupt: %14ld>", psym
->st_name
);
7090 /* Dump the symbol table. */
7092 process_symbol_table (FILE * file
)
7094 Elf_Internal_Shdr
* section
;
7095 bfd_vma nbuckets
= 0;
7096 bfd_vma nchains
= 0;
7097 bfd_vma
* buckets
= NULL
;
7098 bfd_vma
* chains
= NULL
;
7099 bfd_vma ngnubuckets
= 0;
7100 bfd_vma
* gnubuckets
= NULL
;
7101 bfd_vma
* gnuchains
= NULL
;
7102 bfd_vma gnusymidx
= 0;
7104 if (! do_syms
&& !do_histogram
)
7107 if (dynamic_info
[DT_HASH
]
7109 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7111 unsigned char nb
[8];
7112 unsigned char nc
[8];
7113 int hash_ent_size
= 4;
7115 if ((elf_header
.e_machine
== EM_ALPHA
7116 || elf_header
.e_machine
== EM_S390
7117 || elf_header
.e_machine
== EM_S390_OLD
)
7118 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7122 (archive_file_offset
7123 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7124 sizeof nb
+ sizeof nc
)),
7127 error (_("Unable to seek to start of dynamic information\n"));
7131 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7133 error (_("Failed to read in number of buckets\n"));
7137 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7139 error (_("Failed to read in number of chains\n"));
7143 nbuckets
= byte_get (nb
, hash_ent_size
);
7144 nchains
= byte_get (nc
, hash_ent_size
);
7146 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7147 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7149 if (buckets
== NULL
|| chains
== NULL
)
7153 if (dynamic_info_DT_GNU_HASH
7155 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7157 unsigned char nb
[16];
7158 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7159 bfd_vma buckets_vma
;
7162 (archive_file_offset
7163 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7167 error (_("Unable to seek to start of dynamic information\n"));
7171 if (fread (nb
, 16, 1, file
) != 1)
7173 error (_("Failed to read in number of buckets\n"));
7177 ngnubuckets
= byte_get (nb
, 4);
7178 gnusymidx
= byte_get (nb
+ 4, 4);
7179 bitmaskwords
= byte_get (nb
+ 8, 4);
7180 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7182 buckets_vma
+= bitmaskwords
* 4;
7184 buckets_vma
+= bitmaskwords
* 8;
7187 (archive_file_offset
7188 + offset_from_vma (file
, buckets_vma
, 4)),
7191 error (_("Unable to seek to start of dynamic information\n"));
7195 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7197 if (gnubuckets
== NULL
)
7200 for (i
= 0; i
< ngnubuckets
; i
++)
7201 if (gnubuckets
[i
] != 0)
7203 if (gnubuckets
[i
] < gnusymidx
)
7206 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7207 maxchain
= gnubuckets
[i
];
7210 if (maxchain
== 0xffffffff)
7213 maxchain
-= gnusymidx
;
7216 (archive_file_offset
7217 + offset_from_vma (file
, buckets_vma
7218 + 4 * (ngnubuckets
+ maxchain
), 4)),
7221 error (_("Unable to seek to start of dynamic information\n"));
7227 if (fread (nb
, 4, 1, file
) != 1)
7229 error (_("Failed to determine last chain length\n"));
7233 if (maxchain
+ 1 == 0)
7238 while ((byte_get (nb
, 4) & 1) == 0);
7241 (archive_file_offset
7242 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7245 error (_("Unable to seek to start of dynamic information\n"));
7249 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7251 if (gnuchains
== NULL
)
7255 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7258 && dynamic_strings
!= NULL
)
7262 if (dynamic_info
[DT_HASH
])
7266 printf (_("\nSymbol table for image:\n"));
7268 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7270 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7272 for (hn
= 0; hn
< nbuckets
; hn
++)
7277 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7278 print_dynamic_symbol (si
, hn
);
7282 if (dynamic_info_DT_GNU_HASH
)
7284 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7286 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7288 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7290 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7291 if (gnubuckets
[hn
] != 0)
7293 bfd_vma si
= gnubuckets
[hn
];
7294 bfd_vma off
= si
- gnusymidx
;
7298 print_dynamic_symbol (si
, hn
);
7301 while ((gnuchains
[off
++] & 1) == 0);
7305 else if (do_syms
&& !do_using_dynamic
)
7309 for (i
= 0, section
= section_headers
;
7310 i
< elf_header
.e_shnum
;
7314 char * strtab
= NULL
;
7315 unsigned long int strtab_size
= 0;
7316 Elf_Internal_Sym
* symtab
;
7317 Elf_Internal_Sym
* psym
;
7319 if ( section
->sh_type
!= SHT_SYMTAB
7320 && section
->sh_type
!= SHT_DYNSYM
)
7323 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7324 SECTION_NAME (section
),
7325 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7327 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7329 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7331 symtab
= GET_ELF_SYMBOLS (file
, section
);
7335 if (section
->sh_link
== elf_header
.e_shstrndx
)
7337 strtab
= string_table
;
7338 strtab_size
= string_table_length
;
7340 else if (section
->sh_link
< elf_header
.e_shnum
)
7342 Elf_Internal_Shdr
* string_sec
;
7344 string_sec
= section_headers
+ section
->sh_link
;
7346 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7347 1, string_sec
->sh_size
, _("string table"));
7348 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7351 for (si
= 0, psym
= symtab
;
7352 si
< section
->sh_size
/ section
->sh_entsize
;
7355 printf ("%6d: ", si
);
7356 print_vma (psym
->st_value
, LONG_HEX
);
7358 print_vma (psym
->st_size
, DEC_5
);
7359 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7360 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7361 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7362 /* Check to see if any other bits in the st_other field are set.
7363 Note - displaying this information disrupts the layout of the
7364 table being generated, but for the moment this case is very rare. */
7365 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7366 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7367 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7368 print_symbol (25, psym
->st_name
< strtab_size
7369 ? strtab
+ psym
->st_name
: "<corrupt>");
7371 if (section
->sh_type
== SHT_DYNSYM
&&
7372 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7374 unsigned char data
[2];
7375 unsigned short vers_data
;
7376 unsigned long offset
;
7380 offset
= offset_from_vma
7381 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7382 sizeof data
+ si
* sizeof (vers_data
));
7384 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7385 sizeof (data
), 1, _("version data"));
7387 vers_data
= byte_get (data
, 2);
7389 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7390 && section_headers
[psym
->st_shndx
].sh_type
7393 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7395 if ((vers_data
& 0x8000) || vers_data
> 1)
7397 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7398 && (is_nobits
|| ! check_def
))
7400 Elf_External_Verneed evn
;
7401 Elf_Internal_Verneed ivn
;
7402 Elf_Internal_Vernaux ivna
;
7404 /* We must test both. */
7405 offset
= offset_from_vma
7406 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7411 unsigned long vna_off
;
7413 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7416 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7417 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7419 vna_off
= offset
+ ivn
.vn_aux
;
7423 Elf_External_Vernaux evna
;
7425 get_data (&evna
, file
, vna_off
,
7427 _("version need aux (3)"));
7429 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7430 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7431 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7433 vna_off
+= ivna
.vna_next
;
7435 while (ivna
.vna_other
!= vers_data
7436 && ivna
.vna_next
!= 0);
7438 if (ivna
.vna_other
== vers_data
)
7441 offset
+= ivn
.vn_next
;
7443 while (ivn
.vn_next
!= 0);
7445 if (ivna
.vna_other
== vers_data
)
7448 ivna
.vna_name
< strtab_size
7449 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7453 else if (! is_nobits
)
7454 error (_("bad dynamic symbol\n"));
7461 if (vers_data
!= 0x8001
7462 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7464 Elf_Internal_Verdef ivd
;
7465 Elf_Internal_Verdaux ivda
;
7466 Elf_External_Verdaux evda
;
7467 unsigned long offset
;
7469 offset
= offset_from_vma
7471 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7472 sizeof (Elf_External_Verdef
));
7476 Elf_External_Verdef evd
;
7478 get_data (&evd
, file
, offset
, sizeof (evd
),
7479 1, _("version def"));
7481 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7482 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7483 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7485 offset
+= ivd
.vd_next
;
7487 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7488 && ivd
.vd_next
!= 0);
7490 offset
-= ivd
.vd_next
;
7491 offset
+= ivd
.vd_aux
;
7493 get_data (&evda
, file
, offset
, sizeof (evda
),
7494 1, _("version def aux"));
7496 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7498 if (psym
->st_name
!= ivda
.vda_name
)
7499 printf ((vers_data
& 0x8000)
7501 ivda
.vda_name
< strtab_size
7502 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7512 if (strtab
!= string_table
)
7518 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7520 if (do_histogram
&& buckets
!= NULL
)
7522 unsigned long * lengths
;
7523 unsigned long * counts
;
7526 unsigned long maxlength
= 0;
7527 unsigned long nzero_counts
= 0;
7528 unsigned long nsyms
= 0;
7530 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7531 (unsigned long) nbuckets
);
7532 printf (_(" Length Number %% of total Coverage\n"));
7534 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7535 if (lengths
== NULL
)
7537 error (_("Out of memory\n"));
7540 for (hn
= 0; hn
< nbuckets
; ++hn
)
7542 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7545 if (maxlength
< ++lengths
[hn
])
7550 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7553 error (_("Out of memory\n"));
7557 for (hn
= 0; hn
< nbuckets
; ++hn
)
7558 ++counts
[lengths
[hn
]];
7563 printf (" 0 %-10lu (%5.1f%%)\n",
7564 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7565 for (i
= 1; i
<= maxlength
; ++i
)
7567 nzero_counts
+= counts
[i
] * i
;
7568 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7569 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7570 (nzero_counts
* 100.0) / nsyms
);
7578 if (buckets
!= NULL
)
7584 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7586 unsigned long * lengths
;
7587 unsigned long * counts
;
7589 unsigned long maxlength
= 0;
7590 unsigned long nzero_counts
= 0;
7591 unsigned long nsyms
= 0;
7593 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7594 if (lengths
== NULL
)
7596 error (_("Out of memory\n"));
7600 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7601 (unsigned long) ngnubuckets
);
7602 printf (_(" Length Number %% of total Coverage\n"));
7604 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7605 if (gnubuckets
[hn
] != 0)
7607 bfd_vma off
, length
= 1;
7609 for (off
= gnubuckets
[hn
] - gnusymidx
;
7610 (gnuchains
[off
] & 1) == 0; ++off
)
7612 lengths
[hn
] = length
;
7613 if (length
> maxlength
)
7618 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7621 error (_("Out of memory\n"));
7625 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7626 ++counts
[lengths
[hn
]];
7628 if (ngnubuckets
> 0)
7631 printf (" 0 %-10lu (%5.1f%%)\n",
7632 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7633 for (j
= 1; j
<= maxlength
; ++j
)
7635 nzero_counts
+= counts
[j
] * j
;
7636 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7637 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7638 (nzero_counts
* 100.0) / nsyms
);
7652 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7656 if (dynamic_syminfo
== NULL
7658 /* No syminfo, this is ok. */
7661 /* There better should be a dynamic symbol section. */
7662 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7666 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7667 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7669 printf (_(" Num: Name BoundTo Flags\n"));
7670 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7672 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7674 printf ("%4d: ", i
);
7675 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7676 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7678 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7681 switch (dynamic_syminfo
[i
].si_boundto
)
7683 case SYMINFO_BT_SELF
:
7684 fputs ("SELF ", stdout
);
7686 case SYMINFO_BT_PARENT
:
7687 fputs ("PARENT ", stdout
);
7690 if (dynamic_syminfo
[i
].si_boundto
> 0
7691 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7692 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7694 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7698 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7702 if (flags
& SYMINFO_FLG_DIRECT
)
7704 if (flags
& SYMINFO_FLG_PASSTHRU
)
7705 printf (" PASSTHRU");
7706 if (flags
& SYMINFO_FLG_COPY
)
7708 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7709 printf (" LAZYLOAD");
7717 #ifdef SUPPORT_DISASSEMBLY
7719 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
7721 printf (_("\nAssembly dump of section %s\n"),
7722 SECTION_NAME (section
));
7724 /* XXX -- to be done --- XXX */
7731 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
7733 Elf_Internal_Shdr
* relsec
;
7734 bfd_size_type num_bytes
;
7739 char * name
= SECTION_NAME (section
);
7740 bfd_boolean some_strings_shown
;
7742 num_bytes
= section
->sh_size
;
7744 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7746 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7750 addr
= section
->sh_addr
;
7752 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7757 printf (_("\nString dump of section '%s':\n"), name
);
7759 /* If the section being dumped has relocations against it the user might
7760 be expecting these relocations to have been applied. Check for this
7761 case and issue a warning message in order to avoid confusion.
7762 FIXME: Maybe we ought to have an option that dumps a section with
7764 for (relsec
= section_headers
;
7765 relsec
< section_headers
+ elf_header
.e_shnum
;
7768 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7769 || relsec
->sh_info
>= elf_header
.e_shnum
7770 || section_headers
+ relsec
->sh_info
!= section
7771 || relsec
->sh_size
== 0
7772 || relsec
->sh_link
>= elf_header
.e_shnum
)
7775 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7780 end
= start
+ num_bytes
;
7781 some_strings_shown
= FALSE
;
7785 while (!ISPRINT (* data
))
7792 printf (" [%6tx] %s\n", data
- start
, data
);
7794 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7796 data
+= strlen (data
);
7797 some_strings_shown
= TRUE
;
7801 if (! some_strings_shown
)
7802 printf (_(" No strings found in this section."));
7812 dump_section_as_bytes (Elf_Internal_Shdr
* section
, FILE * file
)
7814 Elf_Internal_Shdr
* relsec
;
7815 bfd_size_type bytes
;
7817 unsigned char * data
;
7818 unsigned char * start
;
7820 bytes
= section
->sh_size
;
7822 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7824 printf (_("\nSection '%s' has no data to dump.\n"),
7825 SECTION_NAME (section
));
7829 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7831 addr
= section
->sh_addr
;
7833 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7838 /* If the section being dumped has relocations against it the user might
7839 be expecting these relocations to have been applied. Check for this
7840 case and issue a warning message in order to avoid confusion.
7841 FIXME: Maybe we ought to have an option that dumps a section with
7843 for (relsec
= section_headers
;
7844 relsec
< section_headers
+ elf_header
.e_shnum
;
7847 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7848 || relsec
->sh_info
>= elf_header
.e_shnum
7849 || section_headers
+ relsec
->sh_info
!= section
7850 || relsec
->sh_size
== 0
7851 || relsec
->sh_link
>= elf_header
.e_shnum
)
7854 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7866 lbytes
= (bytes
> 16 ? 16 : bytes
);
7868 printf (" 0x%8.8lx ", (unsigned long) addr
);
7870 for (j
= 0; j
< 16; j
++)
7873 printf ("%2.2x", data
[j
]);
7881 for (j
= 0; j
< lbytes
; j
++)
7884 if (k
>= ' ' && k
< 0x7f)
7903 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7904 DWARF debug sections. This is a target specific test. Note - we do not
7905 go through the whole including-target-headers-multiple-times route, (as
7906 we have already done with <elf/h8.h>) because this would become very
7907 messy and even then this function would have to contain target specific
7908 information (the names of the relocs instead of their numeric values).
7909 FIXME: This is not the correct way to solve this problem. The proper way
7910 is to have target specific reloc sizing and typing functions created by
7911 the reloc-macros.h header, in the same way that it already creates the
7912 reloc naming functions. */
7915 is_32bit_abs_reloc (unsigned int reloc_type
)
7917 switch (elf_header
.e_machine
)
7921 return reloc_type
== 1; /* R_386_32. */
7923 return reloc_type
== 1; /* R_68K_32. */
7925 return reloc_type
== 1; /* R_860_32. */
7927 return reloc_type
== 1; /* XXX Is this right ? */
7929 return reloc_type
== 1; /* R_ARC_32. */
7931 return reloc_type
== 2; /* R_ARM_ABS32 */
7934 return reloc_type
== 1;
7936 return reloc_type
== 0x12; /* R_byte4_data. */
7938 return reloc_type
== 3; /* R_CRIS_32. */
7941 return reloc_type
== 3; /* R_CR16_NUM32. */
7943 return reloc_type
== 15; /* R_CRX_NUM32. */
7945 return reloc_type
== 1;
7946 case EM_CYGNUS_D10V
:
7948 return reloc_type
== 6; /* R_D10V_32. */
7949 case EM_CYGNUS_D30V
:
7951 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7953 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7954 case EM_CYGNUS_FR30
:
7956 return reloc_type
== 3; /* R_FR30_32. */
7960 return reloc_type
== 1; /* R_H8_DIR32. */
7962 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
7965 return reloc_type
== 2; /* R_IP2K_32. */
7967 return reloc_type
== 2; /* R_IQ2000_32. */
7968 case EM_LATTICEMICO32
:
7969 return reloc_type
== 3; /* R_LM32_32. */
7972 return reloc_type
== 3; /* R_M32C_32. */
7974 return reloc_type
== 34; /* R_M32R_32_RELA. */
7976 return reloc_type
== 1; /* R_MCORE_ADDR32. */
7978 return reloc_type
== 4; /* R_MEP_32. */
7980 return reloc_type
== 2; /* R_MIPS_32. */
7982 return reloc_type
== 4; /* R_MMIX_32. */
7983 case EM_CYGNUS_MN10200
:
7985 return reloc_type
== 1; /* R_MN10200_32. */
7986 case EM_CYGNUS_MN10300
:
7988 return reloc_type
== 1; /* R_MN10300_32. */
7991 return reloc_type
== 1; /* R_MSP43_32. */
7993 return reloc_type
== 2; /* R_MT_32. */
7994 case EM_ALTERA_NIOS2
:
7996 return reloc_type
== 1; /* R_NIOS_32. */
7999 return reloc_type
== 1; /* R_OR32_32. */
8001 return reloc_type
== 1; /* R_PARISC_DIR32. */
8004 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8006 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8008 return reloc_type
== 1; /* R_PPC_ADDR32. */
8010 return reloc_type
== 1; /* R_I370_ADDR31. */
8013 return reloc_type
== 4; /* R_S390_32. */
8015 return reloc_type
== 8; /* R_SCORE_ABS32. */
8017 return reloc_type
== 1; /* R_SH_DIR32. */
8018 case EM_SPARC32PLUS
:
8021 return reloc_type
== 3 /* R_SPARC_32. */
8022 || reloc_type
== 23; /* R_SPARC_UA32. */
8024 return reloc_type
== 6; /* R_SPU_ADDR32 */
8025 case EM_CYGNUS_V850
:
8027 return reloc_type
== 6; /* R_V850_ABS32. */
8029 return reloc_type
== 1; /* R_VAX_32. */
8031 return reloc_type
== 10; /* R_X86_64_32. */
8033 return reloc_type
== 1; /* R_XSTROMY16_32. */
8036 return reloc_type
== 1; /* R_XTENSA_32. */
8039 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8040 elf_header
.e_machine
);
8045 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8046 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8049 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8051 switch (elf_header
.e_machine
)
8055 return reloc_type
== 2; /* R_386_PC32. */
8057 return reloc_type
== 4; /* R_68K_PC32. */
8059 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8061 return reloc_type
== 3; /* R_ARM_REL32 */
8063 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8065 return reloc_type
== 26; /* R_PPC_REL32. */
8067 return reloc_type
== 26; /* R_PPC64_REL32. */
8070 return reloc_type
== 5; /* R_390_PC32. */
8072 return reloc_type
== 2; /* R_SH_REL32. */
8073 case EM_SPARC32PLUS
:
8076 return reloc_type
== 6; /* R_SPARC_DISP32. */
8078 return reloc_type
== 13; /* R_SPU_REL32. */
8080 return reloc_type
== 2; /* R_X86_64_PC32. */
8083 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8085 /* Do not abort or issue an error message here. Not all targets use
8086 pc-relative 32-bit relocs in their DWARF debug information and we
8087 have already tested for target coverage in is_32bit_abs_reloc. A
8088 more helpful warning message will be generated by
8089 debug_apply_relocations anyway, so just return. */
8094 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8095 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8098 is_64bit_abs_reloc (unsigned int reloc_type
)
8100 switch (elf_header
.e_machine
)
8103 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8105 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8107 return reloc_type
== 80; /* R_PARISC_DIR64. */
8109 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8110 case EM_SPARC32PLUS
:
8113 return reloc_type
== 54; /* R_SPARC_UA64. */
8115 return reloc_type
== 1; /* R_X86_64_64. */
8118 return reloc_type
== 22; /* R_S390_64 */
8120 return reloc_type
== 18; /* R_MIPS_64 */
8126 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8127 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8130 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8132 switch (elf_header
.e_machine
)
8135 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8137 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8139 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8141 return reloc_type
== 44; /* R_PPC64_REL64 */
8142 case EM_SPARC32PLUS
:
8145 return reloc_type
== 46; /* R_SPARC_DISP64 */
8147 return reloc_type
== 24; /* R_X86_64_PC64 */
8150 return reloc_type
== 23; /* R_S390_PC64 */
8156 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8157 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8160 is_16bit_abs_reloc (unsigned int reloc_type
)
8162 switch (elf_header
.e_machine
)
8166 return reloc_type
== 4; /* R_AVR_16. */
8167 case EM_CYGNUS_D10V
:
8169 return reloc_type
== 3; /* R_D10V_16. */
8173 return reloc_type
== R_H8_DIR16
;
8176 return reloc_type
== 1; /* R_IP2K_16. */
8179 return reloc_type
== 1; /* R_M32C_16 */
8182 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8183 case EM_ALTERA_NIOS2
:
8185 return reloc_type
== 9; /* R_NIOS_16. */
8191 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8192 relocation entries (possibly formerly used for SHT_GROUP sections). */
8195 is_none_reloc (unsigned int reloc_type
)
8197 switch (elf_header
.e_machine
)
8199 case EM_68K
: /* R_68K_NONE. */
8200 case EM_386
: /* R_386_NONE. */
8201 case EM_SPARC32PLUS
:
8203 case EM_SPARC
: /* R_SPARC_NONE. */
8204 case EM_MIPS
: /* R_MIPS_NONE. */
8205 case EM_PARISC
: /* R_PARISC_NONE. */
8206 case EM_ALPHA
: /* R_ALPHA_NONE. */
8207 case EM_PPC
: /* R_PPC_NONE. */
8208 case EM_PPC64
: /* R_PPC64_NONE. */
8209 case EM_ARM
: /* R_ARM_NONE. */
8210 case EM_IA_64
: /* R_IA64_NONE. */
8211 case EM_SH
: /* R_SH_NONE. */
8213 case EM_S390
: /* R_390_NONE. */
8214 case EM_CRIS
: /* R_CRIS_NONE. */
8215 case EM_X86_64
: /* R_X86_64_NONE. */
8216 case EM_MN10300
: /* R_MN10300_NONE. */
8217 case EM_M32R
: /* R_M32R_NONE. */
8218 return reloc_type
== 0;
8223 /* Uncompresses a section that was compressed using zlib, in place.
8224 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8227 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8230 /* These are just to quiet gcc. */
8235 dwarf_size_type compressed_size
= *size
;
8236 unsigned char * compressed_buffer
= *buffer
;
8237 dwarf_size_type uncompressed_size
;
8238 unsigned char * uncompressed_buffer
;
8241 dwarf_size_type header_size
= 12;
8243 /* Read the zlib header. In this case, it should be "ZLIB" followed
8244 by the uncompressed section size, 8 bytes in big-endian order. */
8245 if (compressed_size
< header_size
8246 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8249 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8250 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8251 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8252 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8253 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8254 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8255 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8256 uncompressed_size
+= compressed_buffer
[11];
8258 /* It is possible the section consists of several compressed
8259 buffers concatenated together, so we uncompress in a loop. */
8263 strm
.avail_in
= compressed_size
- header_size
;
8264 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8265 strm
.avail_out
= uncompressed_size
;
8266 uncompressed_buffer
= xmalloc (uncompressed_size
);
8268 rc
= inflateInit (& strm
);
8269 while (strm
.avail_in
> 0)
8273 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8274 + (uncompressed_size
- strm
.avail_out
));
8275 rc
= inflate (&strm
, Z_FINISH
);
8276 if (rc
!= Z_STREAM_END
)
8278 rc
= inflateReset (& strm
);
8280 rc
= inflateEnd (& strm
);
8282 || strm
.avail_out
!= 0)
8285 free (compressed_buffer
);
8286 *buffer
= uncompressed_buffer
;
8287 *size
= uncompressed_size
;
8291 free (uncompressed_buffer
);
8293 #endif /* HAVE_ZLIB_H */
8296 /* Apply relocations to a debug section. */
8299 debug_apply_relocations (void * file
,
8300 Elf_Internal_Shdr
* section
,
8301 unsigned char * start
)
8303 Elf_Internal_Shdr
* relsec
;
8304 unsigned char * end
= start
+ section
->sh_size
;
8306 if (elf_header
.e_type
!= ET_REL
)
8309 /* Find the reloc section associated with the debug section. */
8310 for (relsec
= section_headers
;
8311 relsec
< section_headers
+ elf_header
.e_shnum
;
8314 bfd_boolean is_rela
;
8315 unsigned long num_relocs
;
8316 Elf_Internal_Rela
* relocs
;
8317 Elf_Internal_Rela
* rp
;
8318 Elf_Internal_Shdr
* symsec
;
8319 Elf_Internal_Sym
* symtab
;
8320 Elf_Internal_Sym
* sym
;
8322 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8323 || relsec
->sh_info
>= elf_header
.e_shnum
8324 || section_headers
+ relsec
->sh_info
!= section
8325 || relsec
->sh_size
== 0
8326 || relsec
->sh_link
>= elf_header
.e_shnum
)
8329 is_rela
= relsec
->sh_type
== SHT_RELA
;
8333 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8334 & relocs
, & num_relocs
))
8339 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8340 & relocs
, & num_relocs
))
8344 /* SH uses RELA but uses in place value instead of the addend field. */
8345 if (elf_header
.e_machine
== EM_SH
)
8348 symsec
= section_headers
+ relsec
->sh_link
;
8349 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8351 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8354 unsigned int reloc_type
;
8355 unsigned int reloc_size
;
8356 unsigned char * loc
;
8358 reloc_type
= get_reloc_type (rp
->r_info
);
8360 if (is_none_reloc (reloc_type
))
8363 if (is_32bit_abs_reloc (reloc_type
)
8364 || is_32bit_pcrel_reloc (reloc_type
))
8366 else if (is_64bit_abs_reloc (reloc_type
)
8367 || is_64bit_pcrel_reloc (reloc_type
))
8369 else if (is_16bit_abs_reloc (reloc_type
))
8373 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8374 reloc_type
, SECTION_NAME (section
));
8378 loc
= start
+ rp
->r_offset
;
8379 if ((loc
+ reloc_size
) > end
)
8381 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8382 (unsigned long) rp
->r_offset
,
8383 SECTION_NAME (section
));
8387 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8389 /* If the reloc has a symbol associated with it,
8390 make sure that it is of an appropriate type.
8392 Relocations against symbols without type can happen.
8393 Gcc -feliminate-dwarf2-dups may generate symbols
8394 without type for debug info.
8396 Icc generates relocations against function symbols
8397 instead of local labels.
8399 Relocations against object symbols can happen, eg when
8400 referencing a global array. For an example of this see
8401 the _clz.o binary in libgcc.a. */
8403 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8405 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8406 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8407 (long int)(rp
- relocs
),
8408 SECTION_NAME (relsec
));
8412 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8414 if (is_32bit_pcrel_reloc (reloc_type
)
8415 || is_64bit_pcrel_reloc (reloc_type
))
8417 /* On HPPA, all pc-relative relocations are biased by 8. */
8418 if (elf_header
.e_machine
== EM_PARISC
)
8420 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8424 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8434 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8435 Elf_Internal_Shdr
* sec
, void * file
)
8437 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8439 int section_is_compressed
;
8441 /* If it is already loaded, do nothing. */
8442 if (section
->start
!= NULL
)
8445 section_is_compressed
= section
->name
== section
->compressed_name
;
8447 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8448 section
->address
= sec
->sh_addr
;
8449 section
->size
= sec
->sh_size
;
8450 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8452 if (section
->start
== NULL
)
8455 if (section_is_compressed
)
8456 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8459 if (debug_displays
[debug
].relocate
)
8460 debug_apply_relocations (file
, sec
, section
->start
);
8466 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8468 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8469 Elf_Internal_Shdr
* sec
;
8471 /* Locate the debug section. */
8472 sec
= find_section (section
->uncompressed_name
);
8474 section
->name
= section
->uncompressed_name
;
8477 sec
= find_section (section
->compressed_name
);
8479 section
->name
= section
->compressed_name
;
8484 return load_specific_debug_section (debug
, sec
, file
);
8488 free_debug_section (enum dwarf_section_display_enum debug
)
8490 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8492 if (section
->start
== NULL
)
8495 free ((char *) section
->start
);
8496 section
->start
= NULL
;
8497 section
->address
= 0;
8502 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8504 char * name
= SECTION_NAME (section
);
8505 bfd_size_type length
;
8507 enum dwarf_section_display_enum i
;
8509 length
= section
->sh_size
;
8512 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8516 if (const_strneq (name
, ".gnu.linkonce.wi."))
8517 name
= ".debug_info";
8519 /* See if we know how to display the contents of this section. */
8520 for (i
= 0; i
< max
; i
++)
8521 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8522 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8524 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8525 int secondary
= (section
!= find_section (name
));
8528 free_debug_section (i
);
8530 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8531 sec
->name
= sec
->uncompressed_name
;
8533 sec
->name
= sec
->compressed_name
;
8534 if (load_specific_debug_section (i
, section
, file
))
8536 result
&= debug_displays
[i
].display (sec
, file
);
8538 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8539 free_debug_section (i
);
8547 printf (_("Unrecognized debug section: %s\n"), name
);
8554 /* Set DUMP_SECTS for all sections where dumps were requested
8555 based on section name. */
8558 initialise_dumps_byname (void)
8560 struct dump_list_entry
* cur
;
8562 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8567 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8568 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8570 request_dump_bynumber (i
, cur
->type
);
8575 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8581 process_section_contents (FILE * file
)
8583 Elf_Internal_Shdr
* section
;
8589 initialise_dumps_byname ();
8591 for (i
= 0, section
= section_headers
;
8592 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8595 #ifdef SUPPORT_DISASSEMBLY
8596 if (dump_sects
[i
] & DISASS_DUMP
)
8597 disassemble_section (section
, file
);
8599 if (dump_sects
[i
] & HEX_DUMP
)
8600 dump_section_as_bytes (section
, file
);
8602 if (dump_sects
[i
] & DEBUG_DUMP
)
8603 display_debug_section (section
, file
);
8605 if (dump_sects
[i
] & STRING_DUMP
)
8606 dump_section_as_strings (section
, file
);
8609 /* Check to see if the user requested a
8610 dump of a section that does not exist. */
8611 while (i
++ < num_dump_sects
)
8613 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8617 process_mips_fpe_exception (int mask
)
8622 if (mask
& OEX_FPU_INEX
)
8623 fputs ("INEX", stdout
), first
= 0;
8624 if (mask
& OEX_FPU_UFLO
)
8625 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8626 if (mask
& OEX_FPU_OFLO
)
8627 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8628 if (mask
& OEX_FPU_DIV0
)
8629 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8630 if (mask
& OEX_FPU_INVAL
)
8631 printf ("%sINVAL", first
? "" : "|");
8634 fputs ("0", stdout
);
8637 /* ARM EABI attributes section. */
8642 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8644 const char ** table
;
8645 } arm_attr_public_tag
;
8647 static const char * arm_attr_tag_CPU_arch
[] =
8648 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8649 "v6K", "v7", "v6-M", "v6S-M"};
8650 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8651 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8652 {"No", "Thumb-1", "Thumb-2"};
8653 static const char * arm_attr_tag_VFP_arch
[] =
8654 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8655 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8656 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8657 static const char * arm_attr_tag_PCS_config
[] =
8658 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8659 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8660 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8661 {"V6", "SB", "TLS", "Unused"};
8662 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8663 {"Absolute", "PC-relative", "SB-relative", "None"};
8664 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8665 {"Absolute", "PC-relative", "None"};
8666 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8667 {"None", "direct", "GOT-indirect"};
8668 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8669 {"None", "??? 1", "2", "??? 3", "4"};
8670 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8671 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8672 {"Unused", "Needed", "Sign only"};
8673 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8674 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8675 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8676 {"Unused", "Finite", "RTABI", "IEEE 754"};
8677 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8678 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8679 {"No", "Yes, except leaf SP", "Yes"};
8680 static const char * arm_attr_tag_ABI_enum_size
[] =
8681 {"Unused", "small", "int", "forced to int"};
8682 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8683 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8684 static const char * arm_attr_tag_ABI_VFP_args
[] =
8685 {"AAPCS", "VFP registers", "custom"};
8686 static const char * arm_attr_tag_ABI_WMMX_args
[] =
8687 {"AAPCS", "WMMX registers", "custom"};
8688 static const char * arm_attr_tag_ABI_optimization_goals
[] =
8689 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8690 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8691 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
8692 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8693 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8694 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8695 static const char * arm_attr_tag_VFP_HP_extension
[] =
8696 {"Not Allowed", "Allowed"};
8697 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
8698 {"None", "IEEE 754", "Alternative Format"};
8699 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8700 static const char * arm_attr_tag_Virtualization_use
[] =
8701 {"Not Allowed", "Allowed"};
8702 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8704 #define LOOKUP(id, name) \
8705 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8706 static arm_attr_public_tag arm_attr_public_tags
[] =
8708 {4, "CPU_raw_name", 1, NULL
},
8709 {5, "CPU_name", 1, NULL
},
8710 LOOKUP(6, CPU_arch
),
8711 {7, "CPU_arch_profile", 0, NULL
},
8712 LOOKUP(8, ARM_ISA_use
),
8713 LOOKUP(9, THUMB_ISA_use
),
8714 LOOKUP(10, VFP_arch
),
8715 LOOKUP(11, WMMX_arch
),
8716 LOOKUP(12, Advanced_SIMD_arch
),
8717 LOOKUP(13, PCS_config
),
8718 LOOKUP(14, ABI_PCS_R9_use
),
8719 LOOKUP(15, ABI_PCS_RW_data
),
8720 LOOKUP(16, ABI_PCS_RO_data
),
8721 LOOKUP(17, ABI_PCS_GOT_use
),
8722 LOOKUP(18, ABI_PCS_wchar_t
),
8723 LOOKUP(19, ABI_FP_rounding
),
8724 LOOKUP(20, ABI_FP_denormal
),
8725 LOOKUP(21, ABI_FP_exceptions
),
8726 LOOKUP(22, ABI_FP_user_exceptions
),
8727 LOOKUP(23, ABI_FP_number_model
),
8728 LOOKUP(24, ABI_align8_needed
),
8729 LOOKUP(25, ABI_align8_preserved
),
8730 LOOKUP(26, ABI_enum_size
),
8731 LOOKUP(27, ABI_HardFP_use
),
8732 LOOKUP(28, ABI_VFP_args
),
8733 LOOKUP(29, ABI_WMMX_args
),
8734 LOOKUP(30, ABI_optimization_goals
),
8735 LOOKUP(31, ABI_FP_optimization_goals
),
8736 {32, "compatibility", 0, NULL
},
8737 LOOKUP(34, CPU_unaligned_access
),
8738 LOOKUP(36, VFP_HP_extension
),
8739 LOOKUP(38, ABI_FP_16bit_format
),
8740 {64, "nodefaults", 0, NULL
},
8741 {65, "also_compatible_with", 0, NULL
},
8742 LOOKUP(66, T2EE_use
),
8743 {67, "conformance", 1, NULL
},
8744 LOOKUP(68, Virtualization_use
),
8745 LOOKUP(70, MPextension_use
)
8749 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8753 read_uleb128 (unsigned char * p
, unsigned int * plen
)
8767 val
|= ((unsigned int)c
& 0x7f) << shift
;
8776 static unsigned char *
8777 display_arm_attribute (unsigned char * p
)
8782 arm_attr_public_tag
* attr
;
8786 tag
= read_uleb128 (p
, &len
);
8789 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
8791 if (arm_attr_public_tags
[i
].tag
== tag
)
8793 attr
= &arm_attr_public_tags
[i
];
8800 printf (" Tag_%s: ", attr
->name
);
8806 case 7: /* Tag_CPU_arch_profile. */
8807 val
= read_uleb128 (p
, &len
);
8811 case 0: printf ("None\n"); break;
8812 case 'A': printf ("Application\n"); break;
8813 case 'R': printf ("Realtime\n"); break;
8814 case 'M': printf ("Microcontroller\n"); break;
8815 default: printf ("??? (%d)\n", val
); break;
8819 case 32: /* Tag_compatibility. */
8820 val
= read_uleb128 (p
, &len
);
8822 printf ("flag = %d, vendor = %s\n", val
, p
);
8823 p
+= strlen ((char *) p
) + 1;
8826 case 64: /* Tag_nodefaults. */
8831 case 65: /* Tag_also_compatible_with. */
8832 val
= read_uleb128 (p
, &len
);
8834 if (val
== 6 /* Tag_CPU_arch. */)
8836 val
= read_uleb128 (p
, &len
);
8838 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
8839 printf ("??? (%d)\n", val
);
8841 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
8845 while (*(p
++) != '\0' /* NUL terminator. */);
8859 assert (attr
->type
& 0x80);
8860 val
= read_uleb128 (p
, &len
);
8862 type
= attr
->type
& 0x7f;
8864 printf ("??? (%d)\n", val
);
8866 printf ("%s\n", attr
->table
[val
]);
8873 type
= 1; /* String. */
8875 type
= 2; /* uleb128. */
8876 printf (" Tag_unknown_%d: ", tag
);
8881 printf ("\"%s\"\n", p
);
8882 p
+= strlen ((char *) p
) + 1;
8886 val
= read_uleb128 (p
, &len
);
8888 printf ("%d (0x%x)\n", val
, val
);
8894 static unsigned char *
8895 display_gnu_attribute (unsigned char * p
,
8896 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8903 tag
= read_uleb128 (p
, &len
);
8906 /* Tag_compatibility is the only generic GNU attribute defined at
8910 val
= read_uleb128 (p
, &len
);
8912 printf ("flag = %d, vendor = %s\n", val
, p
);
8913 p
+= strlen ((char *) p
) + 1;
8917 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8918 return display_proc_gnu_attribute (p
, tag
);
8921 type
= 1; /* String. */
8923 type
= 2; /* uleb128. */
8924 printf (" Tag_unknown_%d: ", tag
);
8928 printf ("\"%s\"\n", p
);
8929 p
+= strlen ((char *) p
) + 1;
8933 val
= read_uleb128 (p
, &len
);
8935 printf ("%d (0x%x)\n", val
, val
);
8941 static unsigned char *
8942 display_power_gnu_attribute (unsigned char * p
, int tag
)
8948 if (tag
== Tag_GNU_Power_ABI_FP
)
8950 val
= read_uleb128 (p
, &len
);
8952 printf (" Tag_GNU_Power_ABI_FP: ");
8957 printf ("Hard or soft float\n");
8960 printf ("Hard float\n");
8963 printf ("Soft float\n");
8966 printf ("Single-precision hard float\n");
8969 printf ("??? (%d)\n", val
);
8975 if (tag
== Tag_GNU_Power_ABI_Vector
)
8977 val
= read_uleb128 (p
, &len
);
8979 printf (" Tag_GNU_Power_ABI_Vector: ");
8986 printf ("Generic\n");
8989 printf ("AltiVec\n");
8995 printf ("??? (%d)\n", val
);
9001 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9003 val
= read_uleb128 (p
, &len
);
9005 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9015 printf ("Memory\n");
9018 printf ("??? (%d)\n", val
);
9025 type
= 1; /* String. */
9027 type
= 2; /* uleb128. */
9028 printf (" Tag_unknown_%d: ", tag
);
9032 printf ("\"%s\"\n", p
);
9033 p
+= strlen ((char *) p
) + 1;
9037 val
= read_uleb128 (p
, &len
);
9039 printf ("%d (0x%x)\n", val
, val
);
9045 static unsigned char *
9046 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9052 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9054 val
= read_uleb128 (p
, &len
);
9056 printf (" Tag_GNU_MIPS_ABI_FP: ");
9061 printf ("Hard or soft float\n");
9064 printf ("Hard float (-mdouble-float)\n");
9067 printf ("Hard float (-msingle-float)\n");
9070 printf ("Soft float\n");
9073 printf ("64-bit float (-mips32r2 -mfp64)\n");
9076 printf ("??? (%d)\n", val
);
9083 type
= 1; /* String. */
9085 type
= 2; /* uleb128. */
9086 printf (" Tag_unknown_%d: ", tag
);
9090 printf ("\"%s\"\n", p
);
9091 p
+= strlen ((char *) p
) + 1;
9095 val
= read_uleb128 (p
, &len
);
9097 printf ("%d (0x%x)\n", val
, val
);
9104 process_attributes (FILE * file
,
9105 const char * public_name
,
9106 unsigned int proc_type
,
9107 unsigned char * (* display_pub_attribute
) (unsigned char *),
9108 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9110 Elf_Internal_Shdr
* sect
;
9111 unsigned char * contents
;
9113 unsigned char * end
;
9114 bfd_vma section_len
;
9118 /* Find the section header so that we get the size. */
9119 for (i
= 0, sect
= section_headers
;
9120 i
< elf_header
.e_shnum
;
9123 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9126 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9128 if (contents
== NULL
)
9134 len
= sect
->sh_size
- 1;
9140 bfd_boolean public_section
;
9141 bfd_boolean gnu_section
;
9143 section_len
= byte_get (p
, 4);
9146 if (section_len
> len
)
9148 printf (_("ERROR: Bad section length (%d > %d)\n"),
9149 (int) section_len
, (int) len
);
9154 printf ("Attribute Section: %s\n", p
);
9156 if (public_name
&& streq ((char *) p
, public_name
))
9157 public_section
= TRUE
;
9159 public_section
= FALSE
;
9161 if (streq ((char *) p
, "gnu"))
9164 gnu_section
= FALSE
;
9166 namelen
= strlen ((char *) p
) + 1;
9168 section_len
-= namelen
+ 4;
9170 while (section_len
> 0)
9176 size
= byte_get (p
, 4);
9177 if (size
> section_len
)
9179 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9180 (int) size
, (int) section_len
);
9184 section_len
-= size
;
9191 printf ("File Attributes\n");
9194 printf ("Section Attributes:");
9197 printf ("Symbol Attributes:");
9203 val
= read_uleb128 (p
, &i
);
9207 printf (" %d", val
);
9212 printf ("Unknown tag: %d\n", tag
);
9213 public_section
= FALSE
;
9220 p
= display_pub_attribute (p
);
9222 else if (gnu_section
)
9225 p
= display_gnu_attribute (p
,
9226 display_proc_gnu_attribute
);
9230 /* ??? Do something sensible, like dump hex. */
9231 printf (" Unknown section contexts\n");
9238 printf (_("Unknown format '%c'\n"), *p
);
9246 process_arm_specific (FILE * file
)
9248 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9249 display_arm_attribute
, NULL
);
9253 process_power_specific (FILE * file
)
9255 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9256 display_power_gnu_attribute
);
9259 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9260 Print the Address, Access and Initial fields of an entry at VMA ADDR
9261 and return the VMA of the next entry. */
9264 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9267 print_vma (addr
, LONG_HEX
);
9269 if (addr
< pltgot
+ 0xfff0)
9270 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9272 printf ("%10s", "");
9275 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9280 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9281 print_vma (entry
, LONG_HEX
);
9283 return addr
+ (is_32bit_elf
? 4 : 8);
9286 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9287 PLTGOT. Print the Address and Initial fields of an entry at VMA
9288 ADDR and return the VMA of the next entry. */
9291 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9294 print_vma (addr
, LONG_HEX
);
9297 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9302 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9303 print_vma (entry
, LONG_HEX
);
9305 return addr
+ (is_32bit_elf
? 4 : 8);
9309 process_mips_specific (FILE * file
)
9311 Elf_Internal_Dyn
* entry
;
9312 size_t liblist_offset
= 0;
9313 size_t liblistno
= 0;
9314 size_t conflictsno
= 0;
9315 size_t options_offset
= 0;
9316 size_t conflicts_offset
= 0;
9317 size_t pltrelsz
= 0;
9320 bfd_vma mips_pltgot
= 0;
9322 bfd_vma local_gotno
= 0;
9324 bfd_vma symtabno
= 0;
9326 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9327 display_mips_gnu_attribute
);
9329 /* We have a lot of special sections. Thanks SGI! */
9330 if (dynamic_section
== NULL
)
9331 /* No information available. */
9334 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9335 switch (entry
->d_tag
)
9337 case DT_MIPS_LIBLIST
:
9339 = offset_from_vma (file
, entry
->d_un
.d_val
,
9340 liblistno
* sizeof (Elf32_External_Lib
));
9342 case DT_MIPS_LIBLISTNO
:
9343 liblistno
= entry
->d_un
.d_val
;
9345 case DT_MIPS_OPTIONS
:
9346 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9348 case DT_MIPS_CONFLICT
:
9350 = offset_from_vma (file
, entry
->d_un
.d_val
,
9351 conflictsno
* sizeof (Elf32_External_Conflict
));
9353 case DT_MIPS_CONFLICTNO
:
9354 conflictsno
= entry
->d_un
.d_val
;
9357 pltgot
= entry
->d_un
.d_ptr
;
9359 case DT_MIPS_LOCAL_GOTNO
:
9360 local_gotno
= entry
->d_un
.d_val
;
9362 case DT_MIPS_GOTSYM
:
9363 gotsym
= entry
->d_un
.d_val
;
9365 case DT_MIPS_SYMTABNO
:
9366 symtabno
= entry
->d_un
.d_val
;
9368 case DT_MIPS_PLTGOT
:
9369 mips_pltgot
= entry
->d_un
.d_ptr
;
9372 pltrel
= entry
->d_un
.d_val
;
9375 pltrelsz
= entry
->d_un
.d_val
;
9378 jmprel
= entry
->d_un
.d_ptr
;
9384 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9386 Elf32_External_Lib
* elib
;
9389 elib
= get_data (NULL
, file
, liblist_offset
,
9390 liblistno
, sizeof (Elf32_External_Lib
),
9394 printf ("\nSection '.liblist' contains %lu entries:\n",
9395 (unsigned long) liblistno
);
9396 fputs (" Library Time Stamp Checksum Version Flags\n",
9399 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9406 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9407 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9408 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9409 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9410 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9412 tmp
= gmtime (&time
);
9413 snprintf (timebuf
, sizeof (timebuf
),
9414 "%04u-%02u-%02uT%02u:%02u:%02u",
9415 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9416 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9418 printf ("%3lu: ", (unsigned long) cnt
);
9419 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9420 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9422 printf ("<corrupt: %9ld>", liblist
.l_name
);
9423 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9426 if (liblist
.l_flags
== 0)
9437 { " EXACT_MATCH", LL_EXACT_MATCH
},
9438 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9439 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9440 { " EXPORTS", LL_EXPORTS
},
9441 { " DELAY_LOAD", LL_DELAY_LOAD
},
9442 { " DELTA", LL_DELTA
}
9444 int flags
= liblist
.l_flags
;
9447 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9448 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9450 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9451 flags
^= l_flags_vals
[fcnt
].bit
;
9454 printf (" %#x", (unsigned int) flags
);
9464 if (options_offset
!= 0)
9466 Elf_External_Options
* eopt
;
9467 Elf_Internal_Shdr
* sect
= section_headers
;
9468 Elf_Internal_Options
* iopt
;
9469 Elf_Internal_Options
* option
;
9473 /* Find the section header so that we get the size. */
9474 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9477 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9481 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9484 error (_("Out of memory\n"));
9491 while (offset
< sect
->sh_size
)
9493 Elf_External_Options
* eoption
;
9495 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9497 option
->kind
= BYTE_GET (eoption
->kind
);
9498 option
->size
= BYTE_GET (eoption
->size
);
9499 option
->section
= BYTE_GET (eoption
->section
);
9500 option
->info
= BYTE_GET (eoption
->info
);
9502 offset
+= option
->size
;
9508 printf (_("\nSection '%s' contains %d entries:\n"),
9509 SECTION_NAME (sect
), cnt
);
9517 switch (option
->kind
)
9520 /* This shouldn't happen. */
9521 printf (" NULL %d %lx", option
->section
, option
->info
);
9524 printf (" REGINFO ");
9525 if (elf_header
.e_machine
== EM_MIPS
)
9528 Elf32_External_RegInfo
* ereg
;
9529 Elf32_RegInfo reginfo
;
9531 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9532 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9533 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9534 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9535 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9536 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9537 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9539 printf ("GPR %08lx GP 0x%lx\n",
9541 (unsigned long) reginfo
.ri_gp_value
);
9542 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9543 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9544 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9549 Elf64_External_RegInfo
* ereg
;
9550 Elf64_Internal_RegInfo reginfo
;
9552 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9553 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9554 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9555 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9556 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9557 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9558 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9560 printf ("GPR %08lx GP 0x",
9561 reginfo
.ri_gprmask
);
9562 printf_vma (reginfo
.ri_gp_value
);
9565 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9566 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9567 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9571 case ODK_EXCEPTIONS
:
9572 fputs (" EXCEPTIONS fpe_min(", stdout
);
9573 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9574 fputs (") fpe_max(", stdout
);
9575 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9576 fputs (")", stdout
);
9578 if (option
->info
& OEX_PAGE0
)
9579 fputs (" PAGE0", stdout
);
9580 if (option
->info
& OEX_SMM
)
9581 fputs (" SMM", stdout
);
9582 if (option
->info
& OEX_FPDBUG
)
9583 fputs (" FPDBUG", stdout
);
9584 if (option
->info
& OEX_DISMISS
)
9585 fputs (" DISMISS", stdout
);
9588 fputs (" PAD ", stdout
);
9589 if (option
->info
& OPAD_PREFIX
)
9590 fputs (" PREFIX", stdout
);
9591 if (option
->info
& OPAD_POSTFIX
)
9592 fputs (" POSTFIX", stdout
);
9593 if (option
->info
& OPAD_SYMBOL
)
9594 fputs (" SYMBOL", stdout
);
9597 fputs (" HWPATCH ", stdout
);
9598 if (option
->info
& OHW_R4KEOP
)
9599 fputs (" R4KEOP", stdout
);
9600 if (option
->info
& OHW_R8KPFETCH
)
9601 fputs (" R8KPFETCH", stdout
);
9602 if (option
->info
& OHW_R5KEOP
)
9603 fputs (" R5KEOP", stdout
);
9604 if (option
->info
& OHW_R5KCVTL
)
9605 fputs (" R5KCVTL", stdout
);
9608 fputs (" FILL ", stdout
);
9609 /* XXX Print content of info word? */
9612 fputs (" TAGS ", stdout
);
9613 /* XXX Print content of info word? */
9616 fputs (" HWAND ", stdout
);
9617 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9618 fputs (" R4KEOP_CHECKED", stdout
);
9619 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9620 fputs (" R4KEOP_CLEAN", stdout
);
9623 fputs (" HWOR ", stdout
);
9624 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9625 fputs (" R4KEOP_CHECKED", stdout
);
9626 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9627 fputs (" R4KEOP_CLEAN", stdout
);
9630 printf (" GP_GROUP %#06lx self-contained %#06lx",
9631 option
->info
& OGP_GROUP
,
9632 (option
->info
& OGP_SELF
) >> 16);
9635 printf (" IDENT %#06lx self-contained %#06lx",
9636 option
->info
& OGP_GROUP
,
9637 (option
->info
& OGP_SELF
) >> 16);
9640 /* This shouldn't happen. */
9641 printf (" %3d ??? %d %lx",
9642 option
->kind
, option
->section
, option
->info
);
9646 len
= sizeof (* eopt
);
9647 while (len
< option
->size
)
9648 if (((char *) option
)[len
] >= ' '
9649 && ((char *) option
)[len
] < 0x7f)
9650 printf ("%c", ((char *) option
)[len
++]);
9652 printf ("\\%03o", ((char *) option
)[len
++]);
9654 fputs ("\n", stdout
);
9662 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9664 Elf32_Conflict
* iconf
;
9667 if (dynamic_symbols
== NULL
)
9669 error (_("conflict list found without a dynamic symbol table\n"));
9673 iconf
= cmalloc (conflictsno
, sizeof (* iconf
));
9676 error (_("Out of memory\n"));
9682 Elf32_External_Conflict
* econf32
;
9684 econf32
= get_data (NULL
, file
, conflicts_offset
,
9685 conflictsno
, sizeof (* econf32
), _("conflict"));
9689 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9690 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9696 Elf64_External_Conflict
* econf64
;
9698 econf64
= get_data (NULL
, file
, conflicts_offset
,
9699 conflictsno
, sizeof (* econf64
), _("conflict"));
9703 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9704 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9709 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9710 (unsigned long) conflictsno
);
9711 puts (_(" Num: Index Value Name"));
9713 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9715 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9717 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9718 print_vma (psym
->st_value
, FULL_HEX
);
9720 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9721 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9723 printf ("<corrupt: %14ld>", psym
->st_name
);
9730 if (pltgot
!= 0 && local_gotno
!= 0)
9732 bfd_vma entry
, local_end
, global_end
;
9734 unsigned char * data
;
9738 addr_size
= (is_32bit_elf
? 4 : 8);
9739 local_end
= pltgot
+ local_gotno
* addr_size
;
9740 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9742 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9743 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9744 printf (_("\nPrimary GOT:\n"));
9745 printf (_(" Canonical gp value: "));
9746 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9749 printf (_(" Reserved entries:\n"));
9750 printf (_(" %*s %10s %*s Purpose\n"),
9751 addr_size
* 2, "Address", "Access",
9752 addr_size
* 2, "Initial");
9753 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9754 printf (" Lazy resolver\n");
9756 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9757 >> (addr_size
* 8 - 1)) != 0)
9759 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9760 printf (" Module pointer (GNU extension)\n");
9764 if (entry
< local_end
)
9766 printf (_(" Local entries:\n"));
9767 printf (_(" %*s %10s %*s\n"),
9768 addr_size
* 2, "Address", "Access",
9769 addr_size
* 2, "Initial");
9770 while (entry
< local_end
)
9772 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9778 if (gotsym
< symtabno
)
9782 printf (_(" Global entries:\n"));
9783 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9784 addr_size
* 2, "Address", "Access",
9785 addr_size
* 2, "Initial",
9786 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9787 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9788 for (i
= gotsym
; i
< symtabno
; i
++)
9790 Elf_Internal_Sym
* psym
;
9792 psym
= dynamic_symbols
+ i
;
9793 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9795 print_vma (psym
->st_value
, LONG_HEX
);
9796 printf (" %-7s %3s ",
9797 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9798 get_symbol_index_type (psym
->st_shndx
));
9799 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9800 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9802 printf ("<corrupt: %14ld>", psym
->st_name
);
9812 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9815 size_t offset
, rel_offset
;
9816 unsigned long count
, i
;
9817 unsigned char * data
;
9818 int addr_size
, sym_width
;
9819 Elf_Internal_Rela
* rels
;
9821 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9822 if (pltrel
== DT_RELA
)
9824 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9829 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9833 entry
= mips_pltgot
;
9834 addr_size
= (is_32bit_elf
? 4 : 8);
9835 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9837 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9838 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9839 printf (_("\nPLT GOT:\n\n"));
9840 printf (_(" Reserved entries:\n"));
9841 printf (_(" %*s %*s Purpose\n"),
9842 addr_size
* 2, "Address", addr_size
* 2, "Initial");
9843 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9844 printf (" PLT lazy resolver\n");
9845 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9846 printf (" Module pointer\n");
9849 printf (_(" Entries:\n"));
9850 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9851 addr_size
* 2, "Address",
9852 addr_size
* 2, "Initial",
9853 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9854 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
9855 for (i
= 0; i
< count
; i
++)
9857 Elf_Internal_Sym
* psym
;
9859 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
9860 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9862 print_vma (psym
->st_value
, LONG_HEX
);
9863 printf (" %-7s %3s ",
9864 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9865 get_symbol_index_type (psym
->st_shndx
));
9866 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9867 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9869 printf ("<corrupt: %14ld>", psym
->st_name
);
9883 process_gnu_liblist (FILE * file
)
9885 Elf_Internal_Shdr
* section
;
9886 Elf_Internal_Shdr
* string_sec
;
9887 Elf32_External_Lib
* elib
;
9896 for (i
= 0, section
= section_headers
;
9897 i
< elf_header
.e_shnum
;
9900 switch (section
->sh_type
)
9902 case SHT_GNU_LIBLIST
:
9903 if (section
->sh_link
>= elf_header
.e_shnum
)
9906 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9911 string_sec
= section_headers
+ section
->sh_link
;
9913 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9914 string_sec
->sh_size
, _("liblist string table"));
9915 strtab_size
= string_sec
->sh_size
;
9918 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9924 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9925 SECTION_NAME (section
),
9926 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9928 puts (" Library Time Stamp Checksum Version Flags");
9930 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9938 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9939 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9940 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9941 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9942 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9944 tmp
= gmtime (&time
);
9945 snprintf (timebuf
, sizeof (timebuf
),
9946 "%04u-%02u-%02uT%02u:%02u:%02u",
9947 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9948 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9950 printf ("%3lu: ", (unsigned long) cnt
);
9952 printf ("%-20s", liblist
.l_name
< strtab_size
9953 ? strtab
+ liblist
.l_name
: "<corrupt>");
9955 printf ("%-20.20s", liblist
.l_name
< strtab_size
9956 ? strtab
+ liblist
.l_name
: "<corrupt>");
9957 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9958 liblist
.l_version
, liblist
.l_flags
);
9969 get_note_type (unsigned e_type
)
9971 static char buff
[64];
9973 if (elf_header
.e_type
== ET_CORE
)
9977 return _("NT_AUXV (auxiliary vector)");
9979 return _("NT_PRSTATUS (prstatus structure)");
9981 return _("NT_FPREGSET (floating point registers)");
9983 return _("NT_PRPSINFO (prpsinfo structure)");
9985 return _("NT_TASKSTRUCT (task structure)");
9987 return _("NT_PRXFPREG (user_xfpregs structure)");
9989 return _("NT_PPC_VMX (ppc Altivec registers)");
9991 return _("NT_PPC_VSX (ppc VSX registers)");
9993 return _("NT_PSTATUS (pstatus structure)");
9995 return _("NT_FPREGS (floating point registers)");
9997 return _("NT_PSINFO (psinfo structure)");
9999 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10001 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10002 case NT_WIN32PSTATUS
:
10003 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10011 return _("NT_VERSION (version)");
10013 return _("NT_ARCH (architecture)");
10018 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10022 static const char *
10023 get_gnu_elf_note_type (unsigned e_type
)
10025 static char buff
[64];
10029 case NT_GNU_ABI_TAG
:
10030 return _("NT_GNU_ABI_TAG (ABI version tag)");
10032 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10033 case NT_GNU_BUILD_ID
:
10034 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10035 case NT_GNU_GOLD_VERSION
:
10036 return _("NT_GNU_GOLD_VERSION (gold version)");
10041 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10045 static const char *
10046 get_netbsd_elfcore_note_type (unsigned e_type
)
10048 static char buff
[64];
10050 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10052 /* NetBSD core "procinfo" structure. */
10053 return _("NetBSD procinfo structure");
10056 /* As of Jan 2002 there are no other machine-independent notes
10057 defined for NetBSD core files. If the note type is less
10058 than the start of the machine-dependent note types, we don't
10061 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10063 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10067 switch (elf_header
.e_machine
)
10069 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10070 and PT_GETFPREGS == mach+2. */
10075 case EM_SPARC32PLUS
:
10079 case NT_NETBSDCORE_FIRSTMACH
+0:
10080 return _("PT_GETREGS (reg structure)");
10081 case NT_NETBSDCORE_FIRSTMACH
+2:
10082 return _("PT_GETFPREGS (fpreg structure)");
10088 /* On all other arch's, PT_GETREGS == mach+1 and
10089 PT_GETFPREGS == mach+3. */
10093 case NT_NETBSDCORE_FIRSTMACH
+1:
10094 return _("PT_GETREGS (reg structure)");
10095 case NT_NETBSDCORE_FIRSTMACH
+3:
10096 return _("PT_GETFPREGS (fpreg structure)");
10102 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10103 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10107 /* Note that by the ELF standard, the name field is already null byte
10108 terminated, and namesz includes the terminating null byte.
10109 I.E. the value of namesz for the name "FSF" is 4.
10111 If the value of namesz is zero, there is no name present. */
10113 process_note (Elf_Internal_Note
* pnote
)
10115 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10118 if (pnote
->namesz
== 0)
10119 /* If there is no note name, then use the default set of
10120 note type strings. */
10121 nt
= get_note_type (pnote
->type
);
10123 else if (const_strneq (pnote
->namedata
, "GNU"))
10124 /* GNU-specific object file notes. */
10125 nt
= get_gnu_elf_note_type (pnote
->type
);
10127 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10128 /* NetBSD-specific core file notes. */
10129 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10131 else if (strneq (pnote
->namedata
, "SPU/", 4))
10133 /* SPU-specific core file notes. */
10134 nt
= pnote
->namedata
+ 4;
10139 /* Don't recognize this note name; just use the default set of
10140 note type strings. */
10141 nt
= get_note_type (pnote
->type
);
10143 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10149 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10151 Elf_External_Note
* pnotes
;
10152 Elf_External_Note
* external
;
10158 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10164 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10165 (unsigned long) offset
, (unsigned long) length
);
10166 printf (_(" Owner\t\tData size\tDescription\n"));
10168 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10170 Elf_External_Note
* next
;
10171 Elf_Internal_Note inote
;
10172 char * temp
= NULL
;
10174 inote
.type
= BYTE_GET (external
->type
);
10175 inote
.namesz
= BYTE_GET (external
->namesz
);
10176 inote
.namedata
= external
->name
;
10177 inote
.descsz
= BYTE_GET (external
->descsz
);
10178 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10179 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10181 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10183 if (((char *) next
) > (((char *) pnotes
) + length
))
10185 warn (_("corrupt note found at offset %lx into core notes\n"),
10186 (unsigned long) ((char *) external
- (char *) pnotes
));
10187 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10188 inote
.type
, inote
.namesz
, inote
.descsz
);
10194 /* Verify that name is null terminated. It appears that at least
10195 one version of Linux (RedHat 6.0) generates corefiles that don't
10196 comply with the ELF spec by failing to include the null byte in
10198 if (inote
.namedata
[inote
.namesz
] != '\0')
10200 temp
= malloc (inote
.namesz
+ 1);
10204 error (_("Out of memory\n"));
10209 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10210 temp
[inote
.namesz
] = 0;
10212 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10213 inote
.namedata
= temp
;
10216 res
&= process_note (& inote
);
10231 process_corefile_note_segments (FILE * file
)
10233 Elf_Internal_Phdr
* segment
;
10237 if (! get_program_headers (file
))
10240 for (i
= 0, segment
= program_headers
;
10241 i
< elf_header
.e_phnum
;
10244 if (segment
->p_type
== PT_NOTE
)
10245 res
&= process_corefile_note_segment (file
,
10246 (bfd_vma
) segment
->p_offset
,
10247 (bfd_vma
) segment
->p_filesz
);
10254 process_note_sections (FILE * file
)
10256 Elf_Internal_Shdr
* section
;
10260 for (i
= 0, section
= section_headers
;
10261 i
< elf_header
.e_shnum
;
10263 if (section
->sh_type
== SHT_NOTE
)
10264 res
&= process_corefile_note_segment (file
,
10265 (bfd_vma
) section
->sh_offset
,
10266 (bfd_vma
) section
->sh_size
);
10272 process_notes (FILE * file
)
10274 /* If we have not been asked to display the notes then do nothing. */
10278 if (elf_header
.e_type
!= ET_CORE
)
10279 return process_note_sections (file
);
10281 /* No program headers means no NOTE segment. */
10282 if (elf_header
.e_phnum
> 0)
10283 return process_corefile_note_segments (file
);
10285 printf (_("No note segments present in the core file.\n"));
10290 process_arch_specific (FILE * file
)
10295 switch (elf_header
.e_machine
)
10298 return process_arm_specific (file
);
10300 case EM_MIPS_RS3_LE
:
10301 return process_mips_specific (file
);
10304 return process_power_specific (file
);
10313 get_file_header (FILE * file
)
10315 /* Read in the identity array. */
10316 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10319 /* Determine how to read the rest of the header. */
10320 switch (elf_header
.e_ident
[EI_DATA
])
10322 default: /* fall through */
10323 case ELFDATANONE
: /* fall through */
10325 byte_get
= byte_get_little_endian
;
10326 byte_put
= byte_put_little_endian
;
10329 byte_get
= byte_get_big_endian
;
10330 byte_put
= byte_put_big_endian
;
10334 /* For now we only support 32 bit and 64 bit ELF files. */
10335 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10337 /* Read in the rest of the header. */
10340 Elf32_External_Ehdr ehdr32
;
10342 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10345 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10346 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10347 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10348 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10349 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10350 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10351 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10352 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10353 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10354 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10355 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10356 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10357 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10361 Elf64_External_Ehdr ehdr64
;
10363 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10364 we will not be able to cope with the 64bit data found in
10365 64 ELF files. Detect this now and abort before we start
10366 overwriting things. */
10367 if (sizeof (bfd_vma
) < 8)
10369 error (_("This instance of readelf has been built without support for a\n\
10370 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10374 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10377 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10378 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10379 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10380 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10381 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10382 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10383 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10384 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10385 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10386 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10387 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10388 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10389 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10392 if (elf_header
.e_shoff
)
10394 /* There may be some extensions in the first section header. Don't
10395 bomb if we can't read it. */
10397 get_32bit_section_headers (file
, 1);
10399 get_64bit_section_headers (file
, 1);
10405 /* Process one ELF object file according to the command line options.
10406 This file may actually be stored in an archive. The file is
10407 positioned at the start of the ELF object. */
10410 process_object (char * file_name
, FILE * file
)
10414 if (! get_file_header (file
))
10416 error (_("%s: Failed to read file header\n"), file_name
);
10420 /* Initialise per file variables. */
10421 for (i
= ARRAY_SIZE (version_info
); i
--;)
10422 version_info
[i
] = 0;
10424 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10425 dynamic_info
[i
] = 0;
10427 /* Process the file. */
10429 printf (_("\nFile: %s\n"), file_name
);
10431 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10432 Note we do this even if cmdline_dump_sects is empty because we
10433 must make sure that the dump_sets array is zeroed out before each
10434 object file is processed. */
10435 if (num_dump_sects
> num_cmdline_dump_sects
)
10436 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10438 if (num_cmdline_dump_sects
> 0)
10440 if (num_dump_sects
== 0)
10441 /* A sneaky way of allocating the dump_sects array. */
10442 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10444 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10445 memcpy (dump_sects
, cmdline_dump_sects
,
10446 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10449 if (! process_file_header ())
10452 if (! process_section_headers (file
))
10454 /* Without loaded section headers we cannot process lots of
10456 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10458 if (! do_using_dynamic
)
10459 do_syms
= do_reloc
= 0;
10462 if (! process_section_groups (file
))
10464 /* Without loaded section groups we cannot process unwind. */
10468 if (process_program_headers (file
))
10469 process_dynamic_section (file
);
10471 process_relocs (file
);
10473 process_unwind (file
);
10475 process_symbol_table (file
);
10477 process_syminfo (file
);
10479 process_version_sections (file
);
10481 process_section_contents (file
);
10483 process_notes (file
);
10485 process_gnu_liblist (file
);
10487 process_arch_specific (file
);
10489 if (program_headers
)
10491 free (program_headers
);
10492 program_headers
= NULL
;
10495 if (section_headers
)
10497 free (section_headers
);
10498 section_headers
= NULL
;
10503 free (string_table
);
10504 string_table
= NULL
;
10505 string_table_length
= 0;
10508 if (dynamic_strings
)
10510 free (dynamic_strings
);
10511 dynamic_strings
= NULL
;
10512 dynamic_strings_length
= 0;
10515 if (dynamic_symbols
)
10517 free (dynamic_symbols
);
10518 dynamic_symbols
= NULL
;
10519 num_dynamic_syms
= 0;
10522 if (dynamic_syminfo
)
10524 free (dynamic_syminfo
);
10525 dynamic_syminfo
= NULL
;
10528 if (section_headers_groups
)
10530 free (section_headers_groups
);
10531 section_headers_groups
= NULL
;
10534 if (section_groups
)
10536 struct group_list
* g
;
10537 struct group_list
* next
;
10539 for (i
= 0; i
< group_count
; i
++)
10541 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10548 free (section_groups
);
10549 section_groups
= NULL
;
10552 free_debug_memory ();
10557 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10558 to the path name of the thin archive itself if necessary. Always returns
10559 a pointer to malloc'ed memory. */
10562 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10564 char * member_file_name
;
10565 const char * base_name
= lbasename (file_name
);
10567 /* This is a proxy entry for a thin archive member.
10568 If the extended name table contains an absolute path
10569 name, or if the archive is in the current directory,
10570 use the path name as given. Otherwise, we need to
10571 find the member relative to the directory where the
10572 archive is located. */
10573 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10575 member_file_name
= malloc (name_len
+ 1);
10576 if (member_file_name
== NULL
)
10578 error (_("Out of memory\n"));
10581 memcpy (member_file_name
, name
, name_len
);
10582 member_file_name
[name_len
] = '\0';
10586 /* Concatenate the path components of the archive file name
10587 to the relative path name from the extended name table. */
10588 size_t prefix_len
= base_name
- file_name
;
10589 member_file_name
= malloc (prefix_len
+ name_len
+ 1);
10590 if (member_file_name
== NULL
)
10592 error (_("Out of memory\n"));
10595 memcpy (member_file_name
, file_name
, prefix_len
);
10596 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10597 member_file_name
[prefix_len
+ name_len
] = '\0';
10599 return member_file_name
;
10602 /* Structure to hold information about an archive file. */
10604 struct archive_info
10606 char * file_name
; /* Archive file name. */
10607 FILE * file
; /* Open file descriptor. */
10608 unsigned long index_num
; /* Number of symbols in table. */
10609 unsigned long * index_array
; /* The array of member offsets. */
10610 char * sym_table
; /* The symbol table. */
10611 unsigned long sym_size
; /* Size of the symbol table. */
10612 char * longnames
; /* The long file names table. */
10613 unsigned long longnames_size
; /* Size of the long file names table. */
10614 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10615 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10616 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10617 struct ar_hdr arhdr
; /* Current archive header. */
10620 /* Read the symbol table and long-name table from an archive. */
10623 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10624 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10627 unsigned long size
;
10629 arch
->file_name
= strdup (file_name
);
10631 arch
->index_num
= 0;
10632 arch
->index_array
= NULL
;
10633 arch
->sym_table
= NULL
;
10634 arch
->sym_size
= 0;
10635 arch
->longnames
= NULL
;
10636 arch
->longnames_size
= 0;
10637 arch
->nested_member_origin
= 0;
10638 arch
->is_thin_archive
= is_thin_archive
;
10639 arch
->next_arhdr_offset
= SARMAG
;
10641 /* Read the first archive member header. */
10642 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10644 error (_("%s: failed to seek to first archive header\n"), file_name
);
10647 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10648 if (got
!= sizeof arch
->arhdr
)
10653 error (_("%s: failed to read archive header\n"), file_name
);
10657 /* See if this is the archive symbol table. */
10658 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10659 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10661 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10662 size
= size
+ (size
& 1);
10664 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10669 /* A buffer used to hold numbers read in from an archive index.
10670 These are always 4 bytes long and stored in big-endian format. */
10671 #define SIZEOF_AR_INDEX_NUMBERS 4
10672 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10673 unsigned char * index_buffer
;
10675 /* Check the size of the archive index. */
10676 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10678 error (_("%s: the archive index is empty\n"), file_name
);
10682 /* Read the numer of entries in the archive index. */
10683 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10684 if (got
!= sizeof (integer_buffer
))
10686 error (_("%s: failed to read archive index\n"), file_name
);
10689 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10690 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10692 /* Read in the archive index. */
10693 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10695 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10696 file_name
, arch
->index_num
);
10699 index_buffer
= malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10700 if (index_buffer
== NULL
)
10702 error (_("Out of memory whilst trying to read archive symbol index\n"));
10705 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
10706 if (got
!= arch
->index_num
)
10708 free (index_buffer
);
10709 error (_("%s: failed to read archive index\n"), file_name
);
10712 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10714 /* Convert the index numbers into the host's numeric format. */
10715 arch
->index_array
= malloc (arch
->index_num
* sizeof (* arch
->index_array
));
10716 if (arch
->index_array
== NULL
)
10718 free (index_buffer
);
10719 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10723 for (i
= 0; i
< arch
->index_num
; i
++)
10724 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10725 SIZEOF_AR_INDEX_NUMBERS
);
10726 free (index_buffer
);
10728 /* The remaining space in the header is taken up by the symbol table. */
10731 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10734 arch
->sym_table
= malloc (size
);
10735 arch
->sym_size
= size
;
10736 if (arch
->sym_table
== NULL
)
10738 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10741 got
= fread (arch
->sym_table
, 1, size
, file
);
10744 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10750 if (fseek (file
, size
, SEEK_CUR
) != 0)
10752 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10757 /* Read the next archive header. */
10758 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10759 if (got
!= sizeof arch
->arhdr
)
10763 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10767 else if (read_symbols
)
10768 printf (_("%s has no archive index\n"), file_name
);
10770 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
10772 /* This is the archive string table holding long member names. */
10773 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10774 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
10776 arch
->longnames
= malloc (arch
->longnames_size
);
10777 if (arch
->longnames
== NULL
)
10779 error (_("Out of memory reading long symbol names in archive\n"));
10783 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
10785 free (arch
->longnames
);
10786 arch
->longnames
= NULL
;
10787 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10791 if ((arch
->longnames_size
& 1) != 0)
10798 /* Release the memory used for the archive information. */
10801 release_archive (struct archive_info
* arch
)
10803 if (arch
->file_name
!= NULL
)
10804 free (arch
->file_name
);
10805 if (arch
->index_array
!= NULL
)
10806 free (arch
->index_array
);
10807 if (arch
->sym_table
!= NULL
)
10808 free (arch
->sym_table
);
10809 if (arch
->longnames
!= NULL
)
10810 free (arch
->longnames
);
10813 /* Open and setup a nested archive, if not already open. */
10816 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
10818 FILE * member_file
;
10820 /* Have we already setup this archive? */
10821 if (nested_arch
->file_name
!= NULL
10822 && streq (nested_arch
->file_name
, member_file_name
))
10825 /* Close previous file and discard cached information. */
10826 if (nested_arch
->file
!= NULL
)
10827 fclose (nested_arch
->file
);
10828 release_archive (nested_arch
);
10830 member_file
= fopen (member_file_name
, "rb");
10831 if (member_file
== NULL
)
10833 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
10837 get_archive_member_name_at (struct archive_info
* arch
,
10838 unsigned long offset
,
10839 struct archive_info
* nested_arch
);
10841 /* Get the name of an archive member from the current archive header.
10842 For simple names, this will modify the ar_name field of the current
10843 archive header. For long names, it will return a pointer to the
10844 longnames table. For nested archives, it will open the nested archive
10845 and get the name recursively. NESTED_ARCH is a single-entry cache so
10846 we don't keep rereading the same information from a nested archive. */
10849 get_archive_member_name (struct archive_info
* arch
,
10850 struct archive_info
* nested_arch
)
10852 unsigned long j
, k
;
10854 if (arch
->arhdr
.ar_name
[0] == '/')
10856 /* We have a long name. */
10858 char * member_file_name
;
10859 char * member_name
;
10861 arch
->nested_member_origin
= 0;
10862 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
10863 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
10864 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
10866 while ((j
< arch
->longnames_size
)
10867 && (arch
->longnames
[j
] != '\n')
10868 && (arch
->longnames
[j
] != '\0'))
10870 if (arch
->longnames
[j
-1] == '/')
10872 arch
->longnames
[j
] = '\0';
10874 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
10875 return arch
->longnames
+ k
;
10877 /* This is a proxy for a member of a nested archive.
10878 Find the name of the member in that archive. */
10879 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
10880 if (member_file_name
!= NULL
10881 && setup_nested_archive (nested_arch
, member_file_name
) == 0
10882 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
10884 free (member_file_name
);
10885 return member_name
;
10887 free (member_file_name
);
10889 /* Last resort: just return the name of the nested archive. */
10890 return arch
->longnames
+ k
;
10893 /* We have a normal (short) name. */
10895 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
10897 arch
->arhdr
.ar_name
[j
] = '\0';
10898 return arch
->arhdr
.ar_name
;
10901 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
10904 get_archive_member_name_at (struct archive_info
* arch
,
10905 unsigned long offset
,
10906 struct archive_info
* nested_arch
)
10910 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
10912 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
10915 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
10916 if (got
!= sizeof arch
->arhdr
)
10918 error (_("%s: failed to read archive header\n"), arch
->file_name
);
10921 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
10923 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
10927 return get_archive_member_name (arch
, nested_arch
);
10930 /* Construct a string showing the name of the archive member, qualified
10931 with the name of the containing archive file. For thin archives, we
10932 use square brackets to denote the indirection. For nested archives,
10933 we show the qualified name of the external member inside the square
10934 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
10937 make_qualified_name (struct archive_info
* arch
,
10938 struct archive_info
* nested_arch
,
10939 char * member_name
)
10944 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
10945 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
10946 len
+= strlen (nested_arch
->file_name
) + 2;
10948 name
= malloc (len
);
10951 error (_("Out of memory\n"));
10955 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
10956 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
10957 else if (arch
->is_thin_archive
)
10958 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
10960 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
10965 /* Process an ELF archive.
10966 On entry the file is positioned just after the ARMAG string. */
10969 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
10971 struct archive_info arch
;
10972 struct archive_info nested_arch
;
10974 size_t file_name_size
;
10979 /* The ARCH structure is used to hold information about this archive. */
10980 arch
.file_name
= NULL
;
10982 arch
.index_array
= NULL
;
10983 arch
.sym_table
= NULL
;
10984 arch
.longnames
= NULL
;
10986 /* The NESTED_ARCH structure is used as a single-item cache of information
10987 about a nested archive (when members of a thin archive reside within
10988 another regular archive file). */
10989 nested_arch
.file_name
= NULL
;
10990 nested_arch
.file
= NULL
;
10991 nested_arch
.index_array
= NULL
;
10992 nested_arch
.sym_table
= NULL
;
10993 nested_arch
.longnames
= NULL
;
10995 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11001 if (do_archive_index
)
11003 if (arch
.sym_table
== NULL
)
11004 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11008 unsigned long current_pos
;
11010 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11011 file_name
, arch
.index_num
, arch
.sym_size
);
11012 current_pos
= ftell (file
);
11014 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11016 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11018 char * member_name
;
11020 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11022 if (member_name
!= NULL
)
11024 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11026 if (qualified_name
!= NULL
)
11028 printf (_("Binary %s contains:\n"), qualified_name
);
11029 free (qualified_name
);
11034 if (l
>= arch
.sym_size
)
11036 error (_("%s: end of the symbol table reached before the end of the index\n"),
11040 printf ("\t%s\n", arch
.sym_table
+ l
);
11041 l
+= strlen (arch
.sym_table
+ l
) + 1;
11046 if (l
< arch
.sym_size
)
11047 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11050 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11052 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11058 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11059 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11060 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11061 && !do_section_groups
)
11063 ret
= 0; /* Archive index only. */
11068 file_name_size
= strlen (file_name
);
11075 char * qualified_name
;
11077 /* Read the next archive header. */
11078 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11080 error (_("%s: failed to seek to next archive header\n"), file_name
);
11083 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11084 if (got
!= sizeof arch
.arhdr
)
11088 error (_("%s: failed to read archive header\n"), file_name
);
11092 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11094 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11099 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11101 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11102 if (archive_file_size
& 01)
11103 ++archive_file_size
;
11105 name
= get_archive_member_name (&arch
, &nested_arch
);
11108 error (_("%s: bad archive file name\n"), file_name
);
11112 namelen
= strlen (name
);
11114 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11115 if (qualified_name
== NULL
)
11117 error (_("%s: bad archive file name\n"), file_name
);
11122 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11124 /* This is a proxy for an external member of a thin archive. */
11125 FILE * member_file
;
11126 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11127 if (member_file_name
== NULL
)
11133 member_file
= fopen (member_file_name
, "rb");
11134 if (member_file
== NULL
)
11136 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11137 free (member_file_name
);
11142 archive_file_offset
= arch
.nested_member_origin
;
11144 ret
|= process_object (qualified_name
, member_file
);
11146 fclose (member_file
);
11147 free (member_file_name
);
11149 else if (is_thin_archive
)
11151 /* This is a proxy for a member of a nested archive. */
11152 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11154 /* The nested archive file will have been opened and setup by
11155 get_archive_member_name. */
11156 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11158 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11163 ret
|= process_object (qualified_name
, nested_arch
.file
);
11167 archive_file_offset
= arch
.next_arhdr_offset
;
11168 arch
.next_arhdr_offset
+= archive_file_size
;
11170 ret
|= process_object (qualified_name
, file
);
11173 free (qualified_name
);
11177 if (nested_arch
.file
!= NULL
)
11178 fclose (nested_arch
.file
);
11179 release_archive (&nested_arch
);
11180 release_archive (&arch
);
11186 process_file (char * file_name
)
11189 struct stat statbuf
;
11190 char armag
[SARMAG
];
11193 if (stat (file_name
, &statbuf
) < 0)
11195 if (errno
== ENOENT
)
11196 error (_("'%s': No such file\n"), file_name
);
11198 error (_("Could not locate '%s'. System error message: %s\n"),
11199 file_name
, strerror (errno
));
11203 if (! S_ISREG (statbuf
.st_mode
))
11205 error (_("'%s' is not an ordinary file\n"), file_name
);
11209 file
= fopen (file_name
, "rb");
11212 error (_("Input file '%s' is not readable.\n"), file_name
);
11216 if (fread (armag
, SARMAG
, 1, file
) != 1)
11218 error (_("%s: Failed to read file's magic number\n"), file_name
);
11223 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11224 ret
= process_archive (file_name
, file
, FALSE
);
11225 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11226 ret
= process_archive (file_name
, file
, TRUE
);
11229 if (do_archive_index
)
11230 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11234 archive_file_size
= archive_file_offset
= 0;
11235 ret
= process_object (file_name
, file
);
11243 #ifdef SUPPORT_DISASSEMBLY
11244 /* Needed by the i386 disassembler. For extra credit, someone could
11245 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11249 print_address (unsigned int addr
, FILE * outfile
)
11251 fprintf (outfile
,"0x%8.8x", addr
);
11254 /* Needed by the i386 disassembler. */
11256 db_task_printsym (unsigned int addr
)
11258 print_address (addr
, stderr
);
11263 main (int argc
, char ** argv
)
11267 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11268 setlocale (LC_MESSAGES
, "");
11270 #if defined (HAVE_SETLOCALE)
11271 setlocale (LC_CTYPE
, "");
11273 bindtextdomain (PACKAGE
, LOCALEDIR
);
11274 textdomain (PACKAGE
);
11276 expandargv (&argc
, &argv
);
11278 parse_args (argc
, argv
);
11280 if (num_dump_sects
> 0)
11282 /* Make a copy of the dump_sects array. */
11283 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
11284 if (cmdline_dump_sects
== NULL
)
11285 error (_("Out of memory allocating dump request table.\n"));
11288 memcpy (cmdline_dump_sects
, dump_sects
,
11289 num_dump_sects
* sizeof (* dump_sects
));
11290 num_cmdline_dump_sects
= num_dump_sects
;
11294 if (optind
< (argc
- 1))
11298 while (optind
< argc
)
11299 err
|= process_file (argv
[optind
++]);
11301 if (dump_sects
!= NULL
)
11303 if (cmdline_dump_sects
!= NULL
)
11304 free (cmdline_dump_sects
);