1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/fr30.h"
107 #include "elf/hppa.h"
108 #include "elf/i386.h"
109 #include "elf/i370.h"
110 #include "elf/i860.h"
111 #include "elf/i960.h"
112 #include "elf/ia64.h"
113 #include "elf/ip2k.h"
114 #include "elf/lm32.h"
115 #include "elf/iq2000.h"
116 #include "elf/m32c.h"
117 #include "elf/m32r.h"
118 #include "elf/m68k.h"
119 #include "elf/m68hc11.h"
120 #include "elf/mcore.h"
122 #include "elf/mips.h"
123 #include "elf/mmix.h"
124 #include "elf/mn10200.h"
125 #include "elf/mn10300.h"
127 #include "elf/msp430.h"
128 #include "elf/or32.h"
131 #include "elf/ppc64.h"
132 #include "elf/s390.h"
133 #include "elf/score.h"
135 #include "elf/sparc.h"
137 #include "elf/v850.h"
139 #include "elf/x86-64.h"
140 #include "elf/xstormy16.h"
141 #include "elf/xtensa.h"
146 #include "libiberty.h"
147 #include "safe-ctype.h"
148 #include "filenames.h"
150 char * program_name
= "readelf";
152 static long archive_file_offset
;
153 static unsigned long archive_file_size
;
154 static unsigned long dynamic_addr
;
155 static bfd_size_type dynamic_size
;
156 static unsigned int dynamic_nent
;
157 static char * dynamic_strings
;
158 static unsigned long dynamic_strings_length
;
159 static char * string_table
;
160 static unsigned long string_table_length
;
161 static unsigned long num_dynamic_syms
;
162 static Elf_Internal_Sym
* dynamic_symbols
;
163 static Elf_Internal_Syminfo
* dynamic_syminfo
;
164 static unsigned long dynamic_syminfo_offset
;
165 static unsigned int dynamic_syminfo_nent
;
166 static char program_interpreter
[PATH_MAX
];
167 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
168 static bfd_vma dynamic_info_DT_GNU_HASH
;
169 static bfd_vma version_info
[16];
170 static Elf_Internal_Ehdr elf_header
;
171 static Elf_Internal_Shdr
* section_headers
;
172 static Elf_Internal_Phdr
* program_headers
;
173 static Elf_Internal_Dyn
* dynamic_section
;
174 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
175 static int show_name
;
176 static int do_dynamic
;
179 static int do_sections
;
180 static int do_section_groups
;
181 static int do_section_details
;
182 static int do_segments
;
183 static int do_unwind
;
184 static int do_using_dynamic
;
185 static int do_header
;
187 static int do_version
;
188 static int do_histogram
;
189 static int do_debugging
;
192 static int do_archive_index
;
193 static int is_32bit_elf
;
197 struct group_list
* next
;
198 unsigned int section_index
;
203 struct group_list
* root
;
204 unsigned int group_index
;
207 static size_t group_count
;
208 static struct group
* section_groups
;
209 static struct group
** section_headers_groups
;
212 /* Flag bits indicating particular types of dump. */
213 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
214 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
215 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
216 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
218 typedef unsigned char dump_type
;
220 /* A linked list of the section names for which dumps were requested. */
221 struct dump_list_entry
225 struct dump_list_entry
* next
;
227 static struct dump_list_entry
* dump_sects_byname
;
229 /* A dynamic array of flags indicating for which sections a dump
230 has been requested via command line switches. */
231 static dump_type
* cmdline_dump_sects
= NULL
;
232 static unsigned int num_cmdline_dump_sects
= 0;
234 /* A dynamic array of flags indicating for which sections a dump of
235 some kind has been requested. It is reset on a per-object file
236 basis and then initialised from the cmdline_dump_sects array,
237 the results of interpreting the -w switch, and the
238 dump_sects_byname list. */
239 static dump_type
* dump_sects
= NULL
;
240 static unsigned int num_dump_sects
= 0;
243 /* How to print a vma value. */
244 typedef enum print_mode
256 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
260 #define SECTION_NAME(X) \
261 ((X) == NULL ? "<none>" \
262 : string_table == NULL ? "<no-name>" \
263 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
264 : string_table + (X)->sh_name))
266 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
268 #define BYTE_GET(field) byte_get (field, sizeof (field))
270 #define GET_ELF_SYMBOLS(file, section) \
271 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
272 : get_64bit_elf_symbols (file, section))
274 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
275 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
276 already been called and verified that the string exists. */
277 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
279 /* This is just a bit of syntatic sugar. */
280 #define streq(a,b) (strcmp ((a), (b)) == 0)
281 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
282 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
285 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
290 if (size
== 0 || nmemb
== 0)
293 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
295 error (_("Unable to seek to 0x%lx for %s\n"),
296 (unsigned long) archive_file_offset
+ offset
, reason
);
303 /* Check for overflow. */
304 if (nmemb
< (~(size_t) 0 - 1) / size
)
305 /* + 1 so that we can '\0' terminate invalid string table sections. */
306 mvar
= malloc (size
* nmemb
+ 1);
310 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
311 (unsigned long)(size
* nmemb
), reason
);
315 ((char *) mvar
)[size
* nmemb
] = '\0';
318 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
320 error (_("Unable to read in 0x%lx bytes of %s\n"),
321 (unsigned long)(size
* nmemb
), reason
);
331 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
336 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
337 field
[6] = ((value
>> 24) >> 24) & 0xff;
338 field
[5] = ((value
>> 24) >> 16) & 0xff;
339 field
[4] = ((value
>> 24) >> 8) & 0xff;
342 field
[3] = (value
>> 24) & 0xff;
343 field
[2] = (value
>> 16) & 0xff;
346 field
[1] = (value
>> 8) & 0xff;
349 field
[0] = value
& 0xff;
353 error (_("Unhandled data length: %d\n"), size
);
358 /* Print a VMA value. */
361 print_vma (bfd_vma vma
, print_mode mode
)
374 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
381 return printf ("%5" BFD_VMA_FMT
"d", vma
);
389 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
392 return printf ("%" BFD_VMA_FMT
"d", vma
);
395 return printf ("%" BFD_VMA_FMT
"u", vma
);
400 /* Display a symbol on stdout. Handles the display of non-printing characters.
402 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
403 truncating as necessary. If WIDTH is negative then format the string to be
404 exactly - WIDTH characters, truncating or padding as necessary.
406 Returns the number of emitted characters. */
409 print_symbol (int width
, const char * symbol
)
412 bfd_boolean extra_padding
= FALSE
;
413 unsigned int num_printed
= 0;
417 /* Set the width to a very large value. This simplifies the code below. */
422 /* Keep the width positive. This also helps. */
424 extra_padding
= TRUE
;
433 /* Look for non-printing symbols inside the symbol's name.
434 This test is triggered in particular by the names generated
435 by the assembler for local labels. */
436 while (ISPRINT (* c
))
446 printf ("%.*s", len
, symbol
);
452 if (* c
== 0 || width
== 0)
455 /* Now display the non-printing character, if
456 there is room left in which to dipslay it. */
462 printf ("^%c", *c
+ 0x40);
472 printf ("<0x%.2x>", *c
);
481 if (extra_padding
&& width
> 0)
483 /* Fill in the remaining spaces. */
484 printf ("%-*s", width
, " ");
492 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
497 field
[7] = value
& 0xff;
498 field
[6] = (value
>> 8) & 0xff;
499 field
[5] = (value
>> 16) & 0xff;
500 field
[4] = (value
>> 24) & 0xff;
505 field
[3] = value
& 0xff;
506 field
[2] = (value
>> 8) & 0xff;
510 field
[1] = value
& 0xff;
514 field
[0] = value
& 0xff;
518 error (_("Unhandled data length: %d\n"), size
);
523 /* Return a pointer to section NAME, or NULL if no such section exists. */
525 static Elf_Internal_Shdr
*
526 find_section (const char * name
)
530 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
531 if (streq (SECTION_NAME (section_headers
+ i
), name
))
532 return section_headers
+ i
;
537 /* Guess the relocation size commonly used by the specific machines. */
540 guess_is_rela (unsigned int e_machine
)
544 /* Targets that use REL relocations. */
560 /* Targets that use RELA relocations. */
564 case EM_ALTERA_NIOS2
:
584 case EM_LATTICEMICO32
:
592 case EM_CYGNUS_MN10200
:
594 case EM_CYGNUS_MN10300
:
635 warn (_("Don't know about relocations on this machine architecture\n"));
641 slurp_rela_relocs (FILE * file
,
642 unsigned long rel_offset
,
643 unsigned long rel_size
,
644 Elf_Internal_Rela
** relasp
,
645 unsigned long * nrelasp
)
647 Elf_Internal_Rela
* relas
;
648 unsigned long nrelas
;
653 Elf32_External_Rela
* erelas
;
655 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
659 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
661 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
666 error (_("out of memory parsing relocs\n"));
670 for (i
= 0; i
< nrelas
; i
++)
672 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
673 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
674 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
681 Elf64_External_Rela
* erelas
;
683 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
687 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
689 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
694 error (_("out of memory parsing relocs\n"));
698 for (i
= 0; i
< nrelas
; i
++)
700 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
701 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
702 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
704 /* The #ifdef BFD64 below is to prevent a compile time
705 warning. We know that if we do not have a 64 bit data
706 type that we will never execute this code anyway. */
708 if (elf_header
.e_machine
== EM_MIPS
709 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
711 /* In little-endian objects, r_info isn't really a
712 64-bit little-endian value: it has a 32-bit
713 little-endian symbol index followed by four
714 individual byte fields. Reorder INFO
716 bfd_vma info
= relas
[i
].r_info
;
717 info
= (((info
& 0xffffffff) << 32)
718 | ((info
>> 56) & 0xff)
719 | ((info
>> 40) & 0xff00)
720 | ((info
>> 24) & 0xff0000)
721 | ((info
>> 8) & 0xff000000));
722 relas
[i
].r_info
= info
;
735 slurp_rel_relocs (FILE * file
,
736 unsigned long rel_offset
,
737 unsigned long rel_size
,
738 Elf_Internal_Rela
** relsp
,
739 unsigned long * nrelsp
)
741 Elf_Internal_Rela
* rels
;
747 Elf32_External_Rel
* erels
;
749 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
753 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
755 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
760 error (_("out of memory parsing relocs\n"));
764 for (i
= 0; i
< nrels
; i
++)
766 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
767 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
768 rels
[i
].r_addend
= 0;
775 Elf64_External_Rel
* erels
;
777 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
781 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
783 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
788 error (_("out of memory parsing relocs\n"));
792 for (i
= 0; i
< nrels
; i
++)
794 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
795 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
796 rels
[i
].r_addend
= 0;
798 /* The #ifdef BFD64 below is to prevent a compile time
799 warning. We know that if we do not have a 64 bit data
800 type that we will never execute this code anyway. */
802 if (elf_header
.e_machine
== EM_MIPS
803 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
805 /* In little-endian objects, r_info isn't really a
806 64-bit little-endian value: it has a 32-bit
807 little-endian symbol index followed by four
808 individual byte fields. Reorder INFO
810 bfd_vma info
= rels
[i
].r_info
;
811 info
= (((info
& 0xffffffff) << 32)
812 | ((info
>> 56) & 0xff)
813 | ((info
>> 40) & 0xff00)
814 | ((info
>> 24) & 0xff0000)
815 | ((info
>> 8) & 0xff000000));
816 rels
[i
].r_info
= info
;
828 /* Returns the reloc type extracted from the reloc info field. */
831 get_reloc_type (bfd_vma reloc_info
)
834 return ELF32_R_TYPE (reloc_info
);
836 switch (elf_header
.e_machine
)
839 /* Note: We assume that reloc_info has already been adjusted for us. */
840 return ELF64_MIPS_R_TYPE (reloc_info
);
843 return ELF64_R_TYPE_ID (reloc_info
);
846 return ELF64_R_TYPE (reloc_info
);
850 /* Return the symbol index extracted from the reloc info field. */
853 get_reloc_symindex (bfd_vma reloc_info
)
855 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
858 /* Display the contents of the relocation data found at the specified
862 dump_relocations (FILE * file
,
863 unsigned long rel_offset
,
864 unsigned long rel_size
,
865 Elf_Internal_Sym
* symtab
,
868 unsigned long strtablen
,
872 Elf_Internal_Rela
* rels
;
874 if (is_rela
== UNKNOWN
)
875 is_rela
= guess_is_rela (elf_header
.e_machine
);
879 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
884 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
893 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
895 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
900 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
902 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
910 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
912 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
917 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
919 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
923 for (i
= 0; i
< rel_size
; i
++)
928 bfd_vma symtab_index
;
931 offset
= rels
[i
].r_offset
;
932 info
= rels
[i
].r_info
;
934 type
= get_reloc_type (info
);
935 symtab_index
= get_reloc_symindex (info
);
939 printf ("%8.8lx %8.8lx ",
940 (unsigned long) offset
& 0xffffffff,
941 (unsigned long) info
& 0xffffffff);
945 #if BFD_HOST_64BIT_LONG
947 ? "%16.16lx %16.16lx "
948 : "%12.12lx %12.12lx ",
950 #elif BFD_HOST_64BIT_LONG_LONG
953 ? "%16.16llx %16.16llx "
954 : "%12.12llx %12.12llx ",
958 ? "%16.16I64x %16.16I64x "
959 : "%12.12I64x %12.12I64x ",
964 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
965 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
966 _bfd_int64_high (offset
),
967 _bfd_int64_low (offset
),
968 _bfd_int64_high (info
),
969 _bfd_int64_low (info
));
973 switch (elf_header
.e_machine
)
981 rtype
= elf_m32r_reloc_type (type
);
986 rtype
= elf_i386_reloc_type (type
);
991 rtype
= elf_m68hc11_reloc_type (type
);
995 rtype
= elf_m68k_reloc_type (type
);
999 rtype
= elf_i960_reloc_type (type
);
1004 rtype
= elf_avr_reloc_type (type
);
1007 case EM_OLD_SPARCV9
:
1008 case EM_SPARC32PLUS
:
1011 rtype
= elf_sparc_reloc_type (type
);
1015 rtype
= elf_spu_reloc_type (type
);
1019 case EM_CYGNUS_V850
:
1020 rtype
= v850_reloc_type (type
);
1024 case EM_CYGNUS_D10V
:
1025 rtype
= elf_d10v_reloc_type (type
);
1029 case EM_CYGNUS_D30V
:
1030 rtype
= elf_d30v_reloc_type (type
);
1034 rtype
= elf_dlx_reloc_type (type
);
1038 rtype
= elf_sh_reloc_type (type
);
1042 case EM_CYGNUS_MN10300
:
1043 rtype
= elf_mn10300_reloc_type (type
);
1047 case EM_CYGNUS_MN10200
:
1048 rtype
= elf_mn10200_reloc_type (type
);
1052 case EM_CYGNUS_FR30
:
1053 rtype
= elf_fr30_reloc_type (type
);
1057 rtype
= elf_frv_reloc_type (type
);
1061 rtype
= elf_mcore_reloc_type (type
);
1065 rtype
= elf_mmix_reloc_type (type
);
1070 rtype
= elf_msp430_reloc_type (type
);
1074 rtype
= elf_ppc_reloc_type (type
);
1078 rtype
= elf_ppc64_reloc_type (type
);
1082 case EM_MIPS_RS3_LE
:
1083 rtype
= elf_mips_reloc_type (type
);
1087 rtype
= elf_alpha_reloc_type (type
);
1091 rtype
= elf_arm_reloc_type (type
);
1095 rtype
= elf_arc_reloc_type (type
);
1099 rtype
= elf_hppa_reloc_type (type
);
1105 rtype
= elf_h8_reloc_type (type
);
1110 rtype
= elf_or32_reloc_type (type
);
1115 rtype
= elf_pj_reloc_type (type
);
1118 rtype
= elf_ia64_reloc_type (type
);
1122 rtype
= elf_cris_reloc_type (type
);
1126 rtype
= elf_i860_reloc_type (type
);
1130 rtype
= elf_x86_64_reloc_type (type
);
1134 rtype
= i370_reloc_type (type
);
1139 rtype
= elf_s390_reloc_type (type
);
1143 rtype
= elf_score_reloc_type (type
);
1147 rtype
= elf_xstormy16_reloc_type (type
);
1151 rtype
= elf_crx_reloc_type (type
);
1155 rtype
= elf_vax_reloc_type (type
);
1160 rtype
= elf_ip2k_reloc_type (type
);
1164 rtype
= elf_iq2000_reloc_type (type
);
1169 rtype
= elf_xtensa_reloc_type (type
);
1172 case EM_LATTICEMICO32
:
1173 rtype
= elf_lm32_reloc_type (type
);
1178 rtype
= elf_m32c_reloc_type (type
);
1182 rtype
= elf_mt_reloc_type (type
);
1186 rtype
= elf_bfin_reloc_type (type
);
1190 rtype
= elf_mep_reloc_type (type
);
1195 rtype
= elf_cr16_reloc_type (type
);
1200 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1202 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1204 if (elf_header
.e_machine
== EM_ALPHA
1206 && streq (rtype
, "R_ALPHA_LITUSE")
1209 switch (rels
[i
].r_addend
)
1211 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1212 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1213 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1214 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1215 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1216 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1217 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1218 default: rtype
= NULL
;
1221 printf (" (%s)", rtype
);
1225 printf (_("<unknown addend: %lx>"),
1226 (unsigned long) rels
[i
].r_addend
);
1229 else if (symtab_index
)
1231 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1232 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1235 Elf_Internal_Sym
* psym
;
1237 psym
= symtab
+ symtab_index
;
1241 print_vma (psym
->st_value
, LONG_HEX
);
1243 printf (is_32bit_elf
? " " : " ");
1245 if (psym
->st_name
== 0)
1247 const char * sec_name
= "<null>";
1250 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1252 if (psym
->st_shndx
< elf_header
.e_shnum
)
1254 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1255 else if (psym
->st_shndx
== SHN_ABS
)
1257 else if (psym
->st_shndx
== SHN_COMMON
)
1258 sec_name
= "COMMON";
1259 else if (elf_header
.e_machine
== EM_MIPS
1260 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1261 sec_name
= "SCOMMON";
1262 else if (elf_header
.e_machine
== EM_MIPS
1263 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1264 sec_name
= "SUNDEF";
1265 else if (elf_header
.e_machine
== EM_X86_64
1266 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1267 sec_name
= "LARGE_COMMON";
1268 else if (elf_header
.e_machine
== EM_IA_64
1269 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1270 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1271 sec_name
= "ANSI_COM";
1272 else if (elf_header
.e_machine
== EM_IA_64
1273 && (elf_header
.e_ident
[EI_OSABI
]
1274 == ELFOSABI_OPENVMS
)
1275 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1276 sec_name
= "VMS_SYMVEC";
1279 sprintf (name_buf
, "<section 0x%x>",
1280 (unsigned int) psym
->st_shndx
);
1281 sec_name
= name_buf
;
1284 print_symbol (22, sec_name
);
1286 else if (strtab
== NULL
)
1287 printf (_("<string table index: %3ld>"), psym
->st_name
);
1288 else if (psym
->st_name
>= strtablen
)
1289 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1291 print_symbol (22, strtab
+ psym
->st_name
);
1295 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1298 printf (" - %lx", - offset
);
1300 printf (" + %lx", offset
);
1306 printf ("%*c", is_32bit_elf
?
1307 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1308 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1311 if (elf_header
.e_machine
== EM_SPARCV9
1313 && streq (rtype
, "R_SPARC_OLO10"))
1314 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1319 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1321 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1322 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1323 const char * rtype2
= elf_mips_reloc_type (type2
);
1324 const char * rtype3
= elf_mips_reloc_type (type3
);
1326 printf (" Type2: ");
1329 printf (_("unrecognized: %-7lx"),
1330 (unsigned long) type2
& 0xffffffff);
1332 printf ("%-17.17s", rtype2
);
1334 printf ("\n Type3: ");
1337 printf (_("unrecognized: %-7lx"),
1338 (unsigned long) type3
& 0xffffffff);
1340 printf ("%-17.17s", rtype3
);
1351 get_mips_dynamic_type (unsigned long type
)
1355 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1356 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1357 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1358 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1359 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1360 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1361 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1362 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1363 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1364 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1365 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1366 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1367 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1368 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1369 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1370 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1371 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1372 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1373 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1374 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1375 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1376 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1377 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1378 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1379 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1380 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1381 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1382 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1383 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1384 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1385 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1386 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1387 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1388 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1389 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1390 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1391 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1392 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1393 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1394 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1395 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1396 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1397 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1398 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1399 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1406 get_sparc64_dynamic_type (unsigned long type
)
1410 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1417 get_ppc_dynamic_type (unsigned long type
)
1421 case DT_PPC_GOT
: return "PPC_GOT";
1428 get_ppc64_dynamic_type (unsigned long type
)
1432 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1433 case DT_PPC64_OPD
: return "PPC64_OPD";
1434 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1441 get_parisc_dynamic_type (unsigned long type
)
1445 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1446 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1447 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1448 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1449 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1450 case DT_HP_PREINIT
: return "HP_PREINIT";
1451 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1452 case DT_HP_NEEDED
: return "HP_NEEDED";
1453 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1454 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1455 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1456 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1457 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1458 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1459 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1460 case DT_HP_FILTERED
: return "HP_FILTERED";
1461 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1462 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1463 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1464 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1465 case DT_PLT
: return "PLT";
1466 case DT_PLT_SIZE
: return "PLT_SIZE";
1467 case DT_DLT
: return "DLT";
1468 case DT_DLT_SIZE
: return "DLT_SIZE";
1475 get_ia64_dynamic_type (unsigned long type
)
1479 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1480 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1481 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1482 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1483 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1484 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1485 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1486 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1487 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1488 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1489 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1490 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1491 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1492 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1493 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1494 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1495 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1496 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1497 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1498 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1499 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1500 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1501 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1502 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1503 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1504 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1505 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1506 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1507 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1508 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1509 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1516 get_alpha_dynamic_type (unsigned long type
)
1520 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1527 get_score_dynamic_type (unsigned long type
)
1531 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1532 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1533 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1534 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1535 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1536 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1544 get_dynamic_type (unsigned long type
)
1546 static char buff
[64];
1550 case DT_NULL
: return "NULL";
1551 case DT_NEEDED
: return "NEEDED";
1552 case DT_PLTRELSZ
: return "PLTRELSZ";
1553 case DT_PLTGOT
: return "PLTGOT";
1554 case DT_HASH
: return "HASH";
1555 case DT_STRTAB
: return "STRTAB";
1556 case DT_SYMTAB
: return "SYMTAB";
1557 case DT_RELA
: return "RELA";
1558 case DT_RELASZ
: return "RELASZ";
1559 case DT_RELAENT
: return "RELAENT";
1560 case DT_STRSZ
: return "STRSZ";
1561 case DT_SYMENT
: return "SYMENT";
1562 case DT_INIT
: return "INIT";
1563 case DT_FINI
: return "FINI";
1564 case DT_SONAME
: return "SONAME";
1565 case DT_RPATH
: return "RPATH";
1566 case DT_SYMBOLIC
: return "SYMBOLIC";
1567 case DT_REL
: return "REL";
1568 case DT_RELSZ
: return "RELSZ";
1569 case DT_RELENT
: return "RELENT";
1570 case DT_PLTREL
: return "PLTREL";
1571 case DT_DEBUG
: return "DEBUG";
1572 case DT_TEXTREL
: return "TEXTREL";
1573 case DT_JMPREL
: return "JMPREL";
1574 case DT_BIND_NOW
: return "BIND_NOW";
1575 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1576 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1577 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1578 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1579 case DT_RUNPATH
: return "RUNPATH";
1580 case DT_FLAGS
: return "FLAGS";
1582 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1583 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1585 case DT_CHECKSUM
: return "CHECKSUM";
1586 case DT_PLTPADSZ
: return "PLTPADSZ";
1587 case DT_MOVEENT
: return "MOVEENT";
1588 case DT_MOVESZ
: return "MOVESZ";
1589 case DT_FEATURE
: return "FEATURE";
1590 case DT_POSFLAG_1
: return "POSFLAG_1";
1591 case DT_SYMINSZ
: return "SYMINSZ";
1592 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1594 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1595 case DT_CONFIG
: return "CONFIG";
1596 case DT_DEPAUDIT
: return "DEPAUDIT";
1597 case DT_AUDIT
: return "AUDIT";
1598 case DT_PLTPAD
: return "PLTPAD";
1599 case DT_MOVETAB
: return "MOVETAB";
1600 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1602 case DT_VERSYM
: return "VERSYM";
1604 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1605 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1606 case DT_RELACOUNT
: return "RELACOUNT";
1607 case DT_RELCOUNT
: return "RELCOUNT";
1608 case DT_FLAGS_1
: return "FLAGS_1";
1609 case DT_VERDEF
: return "VERDEF";
1610 case DT_VERDEFNUM
: return "VERDEFNUM";
1611 case DT_VERNEED
: return "VERNEED";
1612 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1614 case DT_AUXILIARY
: return "AUXILIARY";
1615 case DT_USED
: return "USED";
1616 case DT_FILTER
: return "FILTER";
1618 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1619 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1620 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1621 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1622 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1623 case DT_GNU_HASH
: return "GNU_HASH";
1626 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1628 const char * result
;
1630 switch (elf_header
.e_machine
)
1633 case EM_MIPS_RS3_LE
:
1634 result
= get_mips_dynamic_type (type
);
1637 result
= get_sparc64_dynamic_type (type
);
1640 result
= get_ppc_dynamic_type (type
);
1643 result
= get_ppc64_dynamic_type (type
);
1646 result
= get_ia64_dynamic_type (type
);
1649 result
= get_alpha_dynamic_type (type
);
1652 result
= get_score_dynamic_type (type
);
1662 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1664 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1665 || (elf_header
.e_machine
== EM_PARISC
1666 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1668 const char * result
;
1670 switch (elf_header
.e_machine
)
1673 result
= get_parisc_dynamic_type (type
);
1676 result
= get_ia64_dynamic_type (type
);
1686 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1690 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1697 get_file_type (unsigned e_type
)
1699 static char buff
[32];
1703 case ET_NONE
: return _("NONE (None)");
1704 case ET_REL
: return _("REL (Relocatable file)");
1705 case ET_EXEC
: return _("EXEC (Executable file)");
1706 case ET_DYN
: return _("DYN (Shared object file)");
1707 case ET_CORE
: return _("CORE (Core file)");
1710 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1711 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1712 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1713 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1715 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1721 get_machine_name (unsigned e_machine
)
1723 static char buff
[64]; /* XXX */
1727 case EM_NONE
: return _("None");
1728 case EM_M32
: return "WE32100";
1729 case EM_SPARC
: return "Sparc";
1730 case EM_SPU
: return "SPU";
1731 case EM_386
: return "Intel 80386";
1732 case EM_68K
: return "MC68000";
1733 case EM_88K
: return "MC88000";
1734 case EM_486
: return "Intel 80486";
1735 case EM_860
: return "Intel 80860";
1736 case EM_MIPS
: return "MIPS R3000";
1737 case EM_S370
: return "IBM System/370";
1738 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1739 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1740 case EM_PARISC
: return "HPPA";
1741 case EM_PPC_OLD
: return "Power PC (old)";
1742 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1743 case EM_960
: return "Intel 90860";
1744 case EM_PPC
: return "PowerPC";
1745 case EM_PPC64
: return "PowerPC64";
1746 case EM_V800
: return "NEC V800";
1747 case EM_FR20
: return "Fujitsu FR20";
1748 case EM_RH32
: return "TRW RH32";
1749 case EM_MCORE
: return "MCORE";
1750 case EM_ARM
: return "ARM";
1751 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1752 case EM_SH
: return "Renesas / SuperH SH";
1753 case EM_SPARCV9
: return "Sparc v9";
1754 case EM_TRICORE
: return "Siemens Tricore";
1755 case EM_ARC
: return "ARC";
1756 case EM_H8_300
: return "Renesas H8/300";
1757 case EM_H8_300H
: return "Renesas H8/300H";
1758 case EM_H8S
: return "Renesas H8S";
1759 case EM_H8_500
: return "Renesas H8/500";
1760 case EM_IA_64
: return "Intel IA-64";
1761 case EM_MIPS_X
: return "Stanford MIPS-X";
1762 case EM_COLDFIRE
: return "Motorola Coldfire";
1763 case EM_68HC12
: return "Motorola M68HC12";
1764 case EM_ALPHA
: return "Alpha";
1765 case EM_CYGNUS_D10V
:
1766 case EM_D10V
: return "d10v";
1767 case EM_CYGNUS_D30V
:
1768 case EM_D30V
: return "d30v";
1769 case EM_CYGNUS_M32R
:
1770 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1771 case EM_CYGNUS_V850
:
1772 case EM_V850
: return "NEC v850";
1773 case EM_CYGNUS_MN10300
:
1774 case EM_MN10300
: return "mn10300";
1775 case EM_CYGNUS_MN10200
:
1776 case EM_MN10200
: return "mn10200";
1777 case EM_CYGNUS_FR30
:
1778 case EM_FR30
: return "Fujitsu FR30";
1779 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1781 case EM_PJ
: return "picoJava";
1782 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1783 case EM_PCP
: return "Siemens PCP";
1784 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1785 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1786 case EM_STARCORE
: return "Motorola Star*Core processor";
1787 case EM_ME16
: return "Toyota ME16 processor";
1788 case EM_ST100
: return "STMicroelectronics ST100 processor";
1789 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1790 case EM_FX66
: return "Siemens FX66 microcontroller";
1791 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1792 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1793 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1794 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1795 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1796 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1797 case EM_SVX
: return "Silicon Graphics SVx";
1798 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1799 case EM_VAX
: return "Digital VAX";
1801 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1802 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1803 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1804 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1805 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1806 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1807 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1808 case EM_PRISM
: return "Vitesse Prism";
1809 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1811 case EM_S390
: return "IBM S/390";
1812 case EM_SCORE
: return "SUNPLUS S+Core";
1813 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1815 case EM_OR32
: return "OpenRISC";
1816 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1817 case EM_DLX
: return "OpenDLX";
1819 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1820 case EM_IQ2000
: return "Vitesse IQ2000";
1822 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1823 case EM_LATTICEMICO32
: return "Lattice Mico32";
1825 case EM_M32C
: return "Renesas M32c";
1826 case EM_MT
: return "Morpho Techologies MT processor";
1827 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1828 case EM_NIOS32
: return "Altera Nios";
1829 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1830 case EM_XC16X
: return "Infineon Technologies xc16x";
1831 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1833 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1835 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1841 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1846 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1847 e_flags
&= ~ EF_ARM_EABIMASK
;
1849 /* Handle "generic" ARM flags. */
1850 if (e_flags
& EF_ARM_RELEXEC
)
1852 strcat (buf
, ", relocatable executable");
1853 e_flags
&= ~ EF_ARM_RELEXEC
;
1856 if (e_flags
& EF_ARM_HASENTRY
)
1858 strcat (buf
, ", has entry point");
1859 e_flags
&= ~ EF_ARM_HASENTRY
;
1862 /* Now handle EABI specific flags. */
1866 strcat (buf
, ", <unrecognized EABI>");
1871 case EF_ARM_EABI_VER1
:
1872 strcat (buf
, ", Version1 EABI");
1877 /* Process flags one bit at a time. */
1878 flag
= e_flags
& - e_flags
;
1883 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1884 strcat (buf
, ", sorted symbol tables");
1894 case EF_ARM_EABI_VER2
:
1895 strcat (buf
, ", Version2 EABI");
1900 /* Process flags one bit at a time. */
1901 flag
= e_flags
& - e_flags
;
1906 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1907 strcat (buf
, ", sorted symbol tables");
1910 case EF_ARM_DYNSYMSUSESEGIDX
:
1911 strcat (buf
, ", dynamic symbols use segment index");
1914 case EF_ARM_MAPSYMSFIRST
:
1915 strcat (buf
, ", mapping symbols precede others");
1925 case EF_ARM_EABI_VER3
:
1926 strcat (buf
, ", Version3 EABI");
1929 case EF_ARM_EABI_VER4
:
1930 strcat (buf
, ", Version4 EABI");
1933 case EF_ARM_EABI_VER5
:
1934 strcat (buf
, ", Version5 EABI");
1940 /* Process flags one bit at a time. */
1941 flag
= e_flags
& - e_flags
;
1947 strcat (buf
, ", BE8");
1951 strcat (buf
, ", LE8");
1961 case EF_ARM_EABI_UNKNOWN
:
1962 strcat (buf
, ", GNU EABI");
1967 /* Process flags one bit at a time. */
1968 flag
= e_flags
& - e_flags
;
1973 case EF_ARM_INTERWORK
:
1974 strcat (buf
, ", interworking enabled");
1977 case EF_ARM_APCS_26
:
1978 strcat (buf
, ", uses APCS/26");
1981 case EF_ARM_APCS_FLOAT
:
1982 strcat (buf
, ", uses APCS/float");
1986 strcat (buf
, ", position independent");
1990 strcat (buf
, ", 8 bit structure alignment");
1993 case EF_ARM_NEW_ABI
:
1994 strcat (buf
, ", uses new ABI");
1997 case EF_ARM_OLD_ABI
:
1998 strcat (buf
, ", uses old ABI");
2001 case EF_ARM_SOFT_FLOAT
:
2002 strcat (buf
, ", software FP");
2005 case EF_ARM_VFP_FLOAT
:
2006 strcat (buf
, ", VFP");
2009 case EF_ARM_MAVERICK_FLOAT
:
2010 strcat (buf
, ", Maverick FP");
2021 strcat (buf
,", <unknown>");
2025 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2027 static char buf
[1024];
2039 decode_ARM_machine_flags (e_flags
, buf
);
2043 switch (e_flags
& EF_FRV_CPU_MASK
)
2045 case EF_FRV_CPU_GENERIC
:
2049 strcat (buf
, ", fr???");
2052 case EF_FRV_CPU_FR300
:
2053 strcat (buf
, ", fr300");
2056 case EF_FRV_CPU_FR400
:
2057 strcat (buf
, ", fr400");
2059 case EF_FRV_CPU_FR405
:
2060 strcat (buf
, ", fr405");
2063 case EF_FRV_CPU_FR450
:
2064 strcat (buf
, ", fr450");
2067 case EF_FRV_CPU_FR500
:
2068 strcat (buf
, ", fr500");
2070 case EF_FRV_CPU_FR550
:
2071 strcat (buf
, ", fr550");
2074 case EF_FRV_CPU_SIMPLE
:
2075 strcat (buf
, ", simple");
2077 case EF_FRV_CPU_TOMCAT
:
2078 strcat (buf
, ", tomcat");
2084 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2085 strcat (buf
, ", m68000");
2086 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2087 strcat (buf
, ", cpu32");
2088 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2089 strcat (buf
, ", fido_a");
2092 char const * isa
= _("unknown");
2093 char const * mac
= _("unknown mac");
2094 char const * additional
= NULL
;
2096 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2098 case EF_M68K_CF_ISA_A_NODIV
:
2100 additional
= ", nodiv";
2102 case EF_M68K_CF_ISA_A
:
2105 case EF_M68K_CF_ISA_A_PLUS
:
2108 case EF_M68K_CF_ISA_B_NOUSP
:
2110 additional
= ", nousp";
2112 case EF_M68K_CF_ISA_B
:
2116 strcat (buf
, ", cf, isa ");
2119 strcat (buf
, additional
);
2120 if (e_flags
& EF_M68K_CF_FLOAT
)
2121 strcat (buf
, ", float");
2122 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2127 case EF_M68K_CF_MAC
:
2130 case EF_M68K_CF_EMAC
:
2143 if (e_flags
& EF_PPC_EMB
)
2144 strcat (buf
, ", emb");
2146 if (e_flags
& EF_PPC_RELOCATABLE
)
2147 strcat (buf
, ", relocatable");
2149 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2150 strcat (buf
, ", relocatable-lib");
2154 case EM_CYGNUS_V850
:
2155 switch (e_flags
& EF_V850_ARCH
)
2158 strcat (buf
, ", v850e1");
2161 strcat (buf
, ", v850e");
2164 strcat (buf
, ", v850");
2167 strcat (buf
, ", unknown v850 architecture variant");
2173 case EM_CYGNUS_M32R
:
2174 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2175 strcat (buf
, ", m32r");
2179 case EM_MIPS_RS3_LE
:
2180 if (e_flags
& EF_MIPS_NOREORDER
)
2181 strcat (buf
, ", noreorder");
2183 if (e_flags
& EF_MIPS_PIC
)
2184 strcat (buf
, ", pic");
2186 if (e_flags
& EF_MIPS_CPIC
)
2187 strcat (buf
, ", cpic");
2189 if (e_flags
& EF_MIPS_UCODE
)
2190 strcat (buf
, ", ugen_reserved");
2192 if (e_flags
& EF_MIPS_ABI2
)
2193 strcat (buf
, ", abi2");
2195 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2196 strcat (buf
, ", odk first");
2198 if (e_flags
& EF_MIPS_32BITMODE
)
2199 strcat (buf
, ", 32bitmode");
2201 switch ((e_flags
& EF_MIPS_MACH
))
2203 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2204 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2205 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2206 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2207 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2208 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2209 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2210 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2211 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2212 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2213 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2214 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2215 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2216 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2218 /* We simply ignore the field in this case to avoid confusion:
2219 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2222 default: strcat (buf
, ", unknown CPU"); break;
2225 switch ((e_flags
& EF_MIPS_ABI
))
2227 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2228 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2229 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2230 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2232 /* We simply ignore the field in this case to avoid confusion:
2233 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2234 This means it is likely to be an o32 file, but not for
2237 default: strcat (buf
, ", unknown ABI"); break;
2240 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2241 strcat (buf
, ", mdmx");
2243 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2244 strcat (buf
, ", mips16");
2246 switch ((e_flags
& EF_MIPS_ARCH
))
2248 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2249 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2250 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2251 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2252 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2253 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2254 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2255 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2256 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2257 default: strcat (buf
, ", unknown ISA"); break;
2263 switch ((e_flags
& EF_SH_MACH_MASK
))
2265 case EF_SH1
: strcat (buf
, ", sh1"); break;
2266 case EF_SH2
: strcat (buf
, ", sh2"); break;
2267 case EF_SH3
: strcat (buf
, ", sh3"); break;
2268 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2269 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2270 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2271 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2272 case EF_SH4
: strcat (buf
, ", sh4"); break;
2273 case EF_SH5
: strcat (buf
, ", sh5"); break;
2274 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2275 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2276 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2277 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2278 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2279 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2280 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2281 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2282 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2283 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2284 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2285 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2286 default: strcat (buf
, ", unknown ISA"); break;
2292 if (e_flags
& EF_SPARC_32PLUS
)
2293 strcat (buf
, ", v8+");
2295 if (e_flags
& EF_SPARC_SUN_US1
)
2296 strcat (buf
, ", ultrasparcI");
2298 if (e_flags
& EF_SPARC_SUN_US3
)
2299 strcat (buf
, ", ultrasparcIII");
2301 if (e_flags
& EF_SPARC_HAL_R1
)
2302 strcat (buf
, ", halr1");
2304 if (e_flags
& EF_SPARC_LEDATA
)
2305 strcat (buf
, ", ledata");
2307 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2308 strcat (buf
, ", tso");
2310 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2311 strcat (buf
, ", pso");
2313 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2314 strcat (buf
, ", rmo");
2318 switch (e_flags
& EF_PARISC_ARCH
)
2320 case EFA_PARISC_1_0
:
2321 strcpy (buf
, ", PA-RISC 1.0");
2323 case EFA_PARISC_1_1
:
2324 strcpy (buf
, ", PA-RISC 1.1");
2326 case EFA_PARISC_2_0
:
2327 strcpy (buf
, ", PA-RISC 2.0");
2332 if (e_flags
& EF_PARISC_TRAPNIL
)
2333 strcat (buf
, ", trapnil");
2334 if (e_flags
& EF_PARISC_EXT
)
2335 strcat (buf
, ", ext");
2336 if (e_flags
& EF_PARISC_LSB
)
2337 strcat (buf
, ", lsb");
2338 if (e_flags
& EF_PARISC_WIDE
)
2339 strcat (buf
, ", wide");
2340 if (e_flags
& EF_PARISC_NO_KABP
)
2341 strcat (buf
, ", no kabp");
2342 if (e_flags
& EF_PARISC_LAZYSWAP
)
2343 strcat (buf
, ", lazyswap");
2348 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2349 strcat (buf
, ", new calling convention");
2351 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2352 strcat (buf
, ", gnu calling convention");
2356 if ((e_flags
& EF_IA_64_ABI64
))
2357 strcat (buf
, ", 64-bit");
2359 strcat (buf
, ", 32-bit");
2360 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2361 strcat (buf
, ", reduced fp model");
2362 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2363 strcat (buf
, ", no function descriptors, constant gp");
2364 else if ((e_flags
& EF_IA_64_CONS_GP
))
2365 strcat (buf
, ", constant gp");
2366 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2367 strcat (buf
, ", absolute");
2371 if ((e_flags
& EF_VAX_NONPIC
))
2372 strcat (buf
, ", non-PIC");
2373 if ((e_flags
& EF_VAX_DFLOAT
))
2374 strcat (buf
, ", D-Float");
2375 if ((e_flags
& EF_VAX_GFLOAT
))
2376 strcat (buf
, ", G-Float");
2385 get_osabi_name (unsigned int osabi
)
2387 static char buff
[32];
2391 case ELFOSABI_NONE
: return "UNIX - System V";
2392 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2393 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2394 case ELFOSABI_LINUX
: return "UNIX - Linux";
2395 case ELFOSABI_HURD
: return "GNU/Hurd";
2396 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2397 case ELFOSABI_AIX
: return "UNIX - AIX";
2398 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2399 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2400 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2401 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2402 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2403 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2404 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2405 case ELFOSABI_AROS
: return "AROS";
2406 case ELFOSABI_STANDALONE
: return _("Standalone App");
2407 case ELFOSABI_ARM
: return "ARM";
2409 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2415 get_arm_segment_type (unsigned long type
)
2429 get_mips_segment_type (unsigned long type
)
2433 case PT_MIPS_REGINFO
:
2435 case PT_MIPS_RTPROC
:
2437 case PT_MIPS_OPTIONS
:
2447 get_parisc_segment_type (unsigned long type
)
2451 case PT_HP_TLS
: return "HP_TLS";
2452 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2453 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2454 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2455 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2456 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2457 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2458 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2459 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2460 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2461 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2462 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2463 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2464 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2465 case PT_HP_STACK
: return "HP_STACK";
2466 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2467 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2468 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2469 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2478 get_ia64_segment_type (unsigned long type
)
2482 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2483 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2484 case PT_HP_TLS
: return "HP_TLS";
2485 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2486 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2487 case PT_IA_64_HP_STACK
: return "HP_STACK";
2496 get_segment_type (unsigned long p_type
)
2498 static char buff
[32];
2502 case PT_NULL
: return "NULL";
2503 case PT_LOAD
: return "LOAD";
2504 case PT_DYNAMIC
: return "DYNAMIC";
2505 case PT_INTERP
: return "INTERP";
2506 case PT_NOTE
: return "NOTE";
2507 case PT_SHLIB
: return "SHLIB";
2508 case PT_PHDR
: return "PHDR";
2509 case PT_TLS
: return "TLS";
2511 case PT_GNU_EH_FRAME
:
2512 return "GNU_EH_FRAME";
2513 case PT_GNU_STACK
: return "GNU_STACK";
2514 case PT_GNU_RELRO
: return "GNU_RELRO";
2517 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2519 const char * result
;
2521 switch (elf_header
.e_machine
)
2524 result
= get_arm_segment_type (p_type
);
2527 case EM_MIPS_RS3_LE
:
2528 result
= get_mips_segment_type (p_type
);
2531 result
= get_parisc_segment_type (p_type
);
2534 result
= get_ia64_segment_type (p_type
);
2544 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2546 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2548 const char * result
;
2550 switch (elf_header
.e_machine
)
2553 result
= get_parisc_segment_type (p_type
);
2556 result
= get_ia64_segment_type (p_type
);
2566 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2569 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2576 get_mips_section_type_name (unsigned int sh_type
)
2580 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2581 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2582 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2583 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2584 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2585 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2586 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2587 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2588 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2589 case SHT_MIPS_RELD
: return "MIPS_RELD";
2590 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2591 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2592 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2593 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2594 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2595 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2596 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2597 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2598 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2599 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2600 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2601 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2602 case SHT_MIPS_LINE
: return "MIPS_LINE";
2603 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2604 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2605 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2606 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2607 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2608 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2609 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2610 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2611 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2612 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2613 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2614 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2615 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2616 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2617 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2618 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2626 get_parisc_section_type_name (unsigned int sh_type
)
2630 case SHT_PARISC_EXT
: return "PARISC_EXT";
2631 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2632 case SHT_PARISC_DOC
: return "PARISC_DOC";
2633 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2634 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2635 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2636 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2644 get_ia64_section_type_name (unsigned int sh_type
)
2646 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2647 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2648 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2652 case SHT_IA_64_EXT
: return "IA_64_EXT";
2653 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2654 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2655 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2656 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2657 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2658 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2659 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2660 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2661 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2669 get_x86_64_section_type_name (unsigned int sh_type
)
2673 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2681 get_arm_section_type_name (unsigned int sh_type
)
2687 case SHT_ARM_PREEMPTMAP
:
2688 return "ARM_PREEMPTMAP";
2689 case SHT_ARM_ATTRIBUTES
:
2690 return "ARM_ATTRIBUTES";
2698 get_section_type_name (unsigned int sh_type
)
2700 static char buff
[32];
2704 case SHT_NULL
: return "NULL";
2705 case SHT_PROGBITS
: return "PROGBITS";
2706 case SHT_SYMTAB
: return "SYMTAB";
2707 case SHT_STRTAB
: return "STRTAB";
2708 case SHT_RELA
: return "RELA";
2709 case SHT_HASH
: return "HASH";
2710 case SHT_DYNAMIC
: return "DYNAMIC";
2711 case SHT_NOTE
: return "NOTE";
2712 case SHT_NOBITS
: return "NOBITS";
2713 case SHT_REL
: return "REL";
2714 case SHT_SHLIB
: return "SHLIB";
2715 case SHT_DYNSYM
: return "DYNSYM";
2716 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2717 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2718 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2719 case SHT_GNU_HASH
: return "GNU_HASH";
2720 case SHT_GROUP
: return "GROUP";
2721 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2722 case SHT_GNU_verdef
: return "VERDEF";
2723 case SHT_GNU_verneed
: return "VERNEED";
2724 case SHT_GNU_versym
: return "VERSYM";
2725 case 0x6ffffff0: return "VERSYM";
2726 case 0x6ffffffc: return "VERDEF";
2727 case 0x7ffffffd: return "AUXILIARY";
2728 case 0x7fffffff: return "FILTER";
2729 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2732 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2734 const char * result
;
2736 switch (elf_header
.e_machine
)
2739 case EM_MIPS_RS3_LE
:
2740 result
= get_mips_section_type_name (sh_type
);
2743 result
= get_parisc_section_type_name (sh_type
);
2746 result
= get_ia64_section_type_name (sh_type
);
2749 result
= get_x86_64_section_type_name (sh_type
);
2752 result
= get_arm_section_type_name (sh_type
);
2762 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2764 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2766 const char * result
;
2768 switch (elf_header
.e_machine
)
2771 result
= get_ia64_section_type_name (sh_type
);
2781 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2783 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2784 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2786 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2792 #define OPTION_DEBUG_DUMP 512
2794 static struct option options
[] =
2796 {"all", no_argument
, 0, 'a'},
2797 {"file-header", no_argument
, 0, 'h'},
2798 {"program-headers", no_argument
, 0, 'l'},
2799 {"headers", no_argument
, 0, 'e'},
2800 {"histogram", no_argument
, 0, 'I'},
2801 {"segments", no_argument
, 0, 'l'},
2802 {"sections", no_argument
, 0, 'S'},
2803 {"section-headers", no_argument
, 0, 'S'},
2804 {"section-groups", no_argument
, 0, 'g'},
2805 {"section-details", no_argument
, 0, 't'},
2806 {"full-section-name",no_argument
, 0, 'N'},
2807 {"symbols", no_argument
, 0, 's'},
2808 {"syms", no_argument
, 0, 's'},
2809 {"relocs", no_argument
, 0, 'r'},
2810 {"notes", no_argument
, 0, 'n'},
2811 {"dynamic", no_argument
, 0, 'd'},
2812 {"arch-specific", no_argument
, 0, 'A'},
2813 {"version-info", no_argument
, 0, 'V'},
2814 {"use-dynamic", no_argument
, 0, 'D'},
2815 {"unwind", no_argument
, 0, 'u'},
2816 {"archive-index", no_argument
, 0, 'c'},
2817 {"hex-dump", required_argument
, 0, 'x'},
2818 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2819 {"string-dump", required_argument
, 0, 'p'},
2820 #ifdef SUPPORT_DISASSEMBLY
2821 {"instruction-dump", required_argument
, 0, 'i'},
2824 {"version", no_argument
, 0, 'v'},
2825 {"wide", no_argument
, 0, 'W'},
2826 {"help", no_argument
, 0, 'H'},
2827 {0, no_argument
, 0, 0}
2831 usage (FILE * stream
)
2833 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2834 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2835 fprintf (stream
, _(" Options are:\n\
2836 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2837 -h --file-header Display the ELF file header\n\
2838 -l --program-headers Display the program headers\n\
2839 --segments An alias for --program-headers\n\
2840 -S --section-headers Display the sections' header\n\
2841 --sections An alias for --section-headers\n\
2842 -g --section-groups Display the section groups\n\
2843 -t --section-details Display the section details\n\
2844 -e --headers Equivalent to: -h -l -S\n\
2845 -s --syms Display the symbol table\n\
2846 --symbols An alias for --syms\n\
2847 -n --notes Display the core notes (if present)\n\
2848 -r --relocs Display the relocations (if present)\n\
2849 -u --unwind Display the unwind info (if present)\n\
2850 -d --dynamic Display the dynamic section (if present)\n\
2851 -V --version-info Display the version sections (if present)\n\
2852 -A --arch-specific Display architecture specific information (if any).\n\
2853 -c --archive-index Display the symbol/file index in an archive\n\
2854 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2855 -x --hex-dump=<number|name>\n\
2856 Dump the contents of section <number|name> as bytes\n\
2857 -p --string-dump=<number|name>\n\
2858 Dump the contents of section <number|name> as strings\n\
2859 -w[lLiaprmfFsoR] or\n\
2860 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2861 Display the contents of DWARF2 debug sections\n"));
2862 #ifdef SUPPORT_DISASSEMBLY
2863 fprintf (stream
, _("\
2864 -i --instruction-dump=<number|name>\n\
2865 Disassemble the contents of section <number|name>\n"));
2867 fprintf (stream
, _("\
2868 -I --histogram Display histogram of bucket list lengths\n\
2869 -W --wide Allow output width to exceed 80 characters\n\
2870 @<file> Read options from <file>\n\
2871 -H --help Display this information\n\
2872 -v --version Display the version number of readelf\n"));
2874 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2875 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2877 exit (stream
== stdout
? 0 : 1);
2880 /* Record the fact that the user wants the contents of section number
2881 SECTION to be displayed using the method(s) encoded as flags bits
2882 in TYPE. Note, TYPE can be zero if we are creating the array for
2886 request_dump_bynumber (unsigned int section
, dump_type type
)
2888 if (section
>= num_dump_sects
)
2890 dump_type
* new_dump_sects
;
2892 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2894 if (new_dump_sects
== NULL
)
2895 error (_("Out of memory allocating dump request table.\n"));
2898 /* Copy current flag settings. */
2899 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2903 dump_sects
= new_dump_sects
;
2904 num_dump_sects
= section
+ 1;
2909 dump_sects
[section
] |= type
;
2914 /* Request a dump by section name. */
2917 request_dump_byname (const char * section
, dump_type type
)
2919 struct dump_list_entry
* new_request
;
2921 new_request
= malloc (sizeof (struct dump_list_entry
));
2923 error (_("Out of memory allocating dump request table.\n"));
2925 new_request
->name
= strdup (section
);
2926 if (!new_request
->name
)
2927 error (_("Out of memory allocating dump request table.\n"));
2929 new_request
->type
= type
;
2931 new_request
->next
= dump_sects_byname
;
2932 dump_sects_byname
= new_request
;
2936 parse_args (int argc
, char ** argv
)
2943 while ((c
= getopt_long
2944 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
2965 do_section_groups
++;
2973 do_section_groups
++;
2978 do_section_details
++;
3023 section
= strtoul (optarg
, & cp
, 0);
3024 if (! *cp
&& section
>= 0)
3025 request_dump_bynumber (section
, HEX_DUMP
);
3027 request_dump_byname (optarg
, HEX_DUMP
);
3031 section
= strtoul (optarg
, & cp
, 0);
3032 if (! *cp
&& section
>= 0)
3033 request_dump_bynumber (section
, STRING_DUMP
);
3035 request_dump_byname (optarg
, STRING_DUMP
);
3042 dwarf_select_sections_all ();
3047 dwarf_select_sections_by_letters (optarg
);
3050 case OPTION_DEBUG_DUMP
:
3057 dwarf_select_sections_by_names (optarg
);
3060 #ifdef SUPPORT_DISASSEMBLY
3063 section
= strtoul (optarg
, & cp
, 0);
3064 if (! *cp
&& section
>= 0)
3065 request_dump_bynumber (section
, DISASS_DUMP
);
3067 request_dump_byname (optarg
, DISASS_DUMP
);
3070 print_version (program_name
);
3079 /* xgettext:c-format */
3080 error (_("Invalid option '-%c'\n"), c
);
3087 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3088 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3089 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3090 && !do_section_groups
&& !do_archive_index
)
3094 warn (_("Nothing to do.\n"));
3100 get_elf_class (unsigned int elf_class
)
3102 static char buff
[32];
3106 case ELFCLASSNONE
: return _("none");
3107 case ELFCLASS32
: return "ELF32";
3108 case ELFCLASS64
: return "ELF64";
3110 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3116 get_data_encoding (unsigned int encoding
)
3118 static char buff
[32];
3122 case ELFDATANONE
: return _("none");
3123 case ELFDATA2LSB
: return _("2's complement, little endian");
3124 case ELFDATA2MSB
: return _("2's complement, big endian");
3126 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3131 /* Decode the data held in 'elf_header'. */
3134 process_file_header (void)
3136 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3137 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3138 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3139 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3142 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3146 init_dwarf_regnames (elf_header
.e_machine
);
3152 printf (_("ELF Header:\n"));
3153 printf (_(" Magic: "));
3154 for (i
= 0; i
< EI_NIDENT
; i
++)
3155 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3157 printf (_(" Class: %s\n"),
3158 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3159 printf (_(" Data: %s\n"),
3160 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3161 printf (_(" Version: %d %s\n"),
3162 elf_header
.e_ident
[EI_VERSION
],
3163 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3165 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3168 printf (_(" OS/ABI: %s\n"),
3169 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3170 printf (_(" ABI Version: %d\n"),
3171 elf_header
.e_ident
[EI_ABIVERSION
]);
3172 printf (_(" Type: %s\n"),
3173 get_file_type (elf_header
.e_type
));
3174 printf (_(" Machine: %s\n"),
3175 get_machine_name (elf_header
.e_machine
));
3176 printf (_(" Version: 0x%lx\n"),
3177 (unsigned long) elf_header
.e_version
);
3179 printf (_(" Entry point address: "));
3180 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3181 printf (_("\n Start of program headers: "));
3182 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3183 printf (_(" (bytes into file)\n Start of section headers: "));
3184 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3185 printf (_(" (bytes into file)\n"));
3187 printf (_(" Flags: 0x%lx%s\n"),
3188 (unsigned long) elf_header
.e_flags
,
3189 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3190 printf (_(" Size of this header: %ld (bytes)\n"),
3191 (long) elf_header
.e_ehsize
);
3192 printf (_(" Size of program headers: %ld (bytes)\n"),
3193 (long) elf_header
.e_phentsize
);
3194 printf (_(" Number of program headers: %ld\n"),
3195 (long) elf_header
.e_phnum
);
3196 printf (_(" Size of section headers: %ld (bytes)\n"),
3197 (long) elf_header
.e_shentsize
);
3198 printf (_(" Number of section headers: %ld"),
3199 (long) elf_header
.e_shnum
);
3200 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3201 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3202 putc ('\n', stdout
);
3203 printf (_(" Section header string table index: %ld"),
3204 (long) elf_header
.e_shstrndx
);
3205 if (section_headers
!= NULL
3206 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3207 printf (" (%u)", section_headers
[0].sh_link
);
3208 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3209 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3210 printf (" <corrupt: out of range>");
3211 putc ('\n', stdout
);
3214 if (section_headers
!= NULL
)
3216 if (elf_header
.e_shnum
== SHN_UNDEF
)
3217 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3218 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3219 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3220 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3221 elf_header
.e_shstrndx
= SHN_UNDEF
;
3222 free (section_headers
);
3223 section_headers
= NULL
;
3231 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3233 Elf32_External_Phdr
* phdrs
;
3234 Elf32_External_Phdr
* external
;
3235 Elf_Internal_Phdr
* internal
;
3238 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3239 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3240 _("program headers"));
3244 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3245 i
< elf_header
.e_phnum
;
3246 i
++, internal
++, external
++)
3248 internal
->p_type
= BYTE_GET (external
->p_type
);
3249 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3250 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3251 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3252 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3253 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3254 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3255 internal
->p_align
= BYTE_GET (external
->p_align
);
3264 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3266 Elf64_External_Phdr
* phdrs
;
3267 Elf64_External_Phdr
* external
;
3268 Elf_Internal_Phdr
* internal
;
3271 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3272 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3273 _("program headers"));
3277 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3278 i
< elf_header
.e_phnum
;
3279 i
++, internal
++, external
++)
3281 internal
->p_type
= BYTE_GET (external
->p_type
);
3282 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3283 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3284 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3285 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3286 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3287 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3288 internal
->p_align
= BYTE_GET (external
->p_align
);
3296 /* Returns 1 if the program headers were read into `program_headers'. */
3299 get_program_headers (FILE * file
)
3301 Elf_Internal_Phdr
* phdrs
;
3303 /* Check cache of prior read. */
3304 if (program_headers
!= NULL
)
3307 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3311 error (_("Out of memory\n"));
3316 ? get_32bit_program_headers (file
, phdrs
)
3317 : get_64bit_program_headers (file
, phdrs
))
3319 program_headers
= phdrs
;
3327 /* Returns 1 if the program headers were loaded. */
3330 process_program_headers (FILE * file
)
3332 Elf_Internal_Phdr
* segment
;
3335 if (elf_header
.e_phnum
== 0)
3338 printf (_("\nThere are no program headers in this file.\n"));
3342 if (do_segments
&& !do_header
)
3344 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3345 printf (_("Entry point "));
3346 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3347 printf (_("\nThere are %d program headers, starting at offset "),
3348 elf_header
.e_phnum
);
3349 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3353 if (! get_program_headers (file
))
3358 if (elf_header
.e_phnum
> 1)
3359 printf (_("\nProgram Headers:\n"));
3361 printf (_("\nProgram Headers:\n"));
3365 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3368 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3372 (_(" Type Offset VirtAddr PhysAddr\n"));
3374 (_(" FileSiz MemSiz Flags Align\n"));
3381 for (i
= 0, segment
= program_headers
;
3382 i
< elf_header
.e_phnum
;
3387 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3391 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3392 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3393 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3394 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3395 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3397 (segment
->p_flags
& PF_R
? 'R' : ' '),
3398 (segment
->p_flags
& PF_W
? 'W' : ' '),
3399 (segment
->p_flags
& PF_X
? 'E' : ' '));
3400 printf ("%#lx", (unsigned long) segment
->p_align
);
3404 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3405 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3408 print_vma (segment
->p_offset
, FULL_HEX
);
3412 print_vma (segment
->p_vaddr
, FULL_HEX
);
3414 print_vma (segment
->p_paddr
, FULL_HEX
);
3417 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3418 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3421 print_vma (segment
->p_filesz
, FULL_HEX
);
3425 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3426 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3429 print_vma (segment
->p_offset
, FULL_HEX
);
3433 (segment
->p_flags
& PF_R
? 'R' : ' '),
3434 (segment
->p_flags
& PF_W
? 'W' : ' '),
3435 (segment
->p_flags
& PF_X
? 'E' : ' '));
3437 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3438 printf ("%#lx", (unsigned long) segment
->p_align
);
3441 print_vma (segment
->p_align
, PREFIX_HEX
);
3446 print_vma (segment
->p_offset
, FULL_HEX
);
3448 print_vma (segment
->p_vaddr
, FULL_HEX
);
3450 print_vma (segment
->p_paddr
, FULL_HEX
);
3452 print_vma (segment
->p_filesz
, FULL_HEX
);
3454 print_vma (segment
->p_memsz
, FULL_HEX
);
3456 (segment
->p_flags
& PF_R
? 'R' : ' '),
3457 (segment
->p_flags
& PF_W
? 'W' : ' '),
3458 (segment
->p_flags
& PF_X
? 'E' : ' '));
3459 print_vma (segment
->p_align
, HEX
);
3463 switch (segment
->p_type
)
3467 error (_("more than one dynamic segment\n"));
3469 /* By default, assume that the .dynamic section is the first
3470 section in the DYNAMIC segment. */
3471 dynamic_addr
= segment
->p_offset
;
3472 dynamic_size
= segment
->p_filesz
;
3474 /* Try to locate the .dynamic section. If there is
3475 a section header table, we can easily locate it. */
3476 if (section_headers
!= NULL
)
3478 Elf_Internal_Shdr
* sec
;
3480 sec
= find_section (".dynamic");
3481 if (sec
== NULL
|| sec
->sh_size
== 0)
3483 error (_("no .dynamic section in the dynamic segment\n"));
3487 if (sec
->sh_type
== SHT_NOBITS
)
3493 dynamic_addr
= sec
->sh_offset
;
3494 dynamic_size
= sec
->sh_size
;
3496 if (dynamic_addr
< segment
->p_offset
3497 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3498 warn (_("the .dynamic section is not contained"
3499 " within the dynamic segment\n"));
3500 else if (dynamic_addr
> segment
->p_offset
)
3501 warn (_("the .dynamic section is not the first section"
3502 " in the dynamic segment.\n"));
3507 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3509 error (_("Unable to find program interpreter name\n"));
3513 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3515 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3516 error (_("Internal error: failed to create format string to display program interpreter\n"));
3518 program_interpreter
[0] = 0;
3519 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3520 error (_("Unable to read program interpreter name\n"));
3523 printf (_("\n [Requesting program interpreter: %s]"),
3524 program_interpreter
);
3530 putc ('\n', stdout
);
3533 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3535 printf (_("\n Section to Segment mapping:\n"));
3536 printf (_(" Segment Sections...\n"));
3538 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3541 Elf_Internal_Shdr
* section
;
3543 segment
= program_headers
+ i
;
3544 section
= section_headers
+ 1;
3546 printf (" %2.2d ", i
);
3548 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3550 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3551 printf ("%s ", SECTION_NAME (section
));
3562 /* Find the file offset corresponding to VMA by using the program headers. */
3565 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3567 Elf_Internal_Phdr
* seg
;
3569 if (! get_program_headers (file
))
3571 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3575 for (seg
= program_headers
;
3576 seg
< program_headers
+ elf_header
.e_phnum
;
3579 if (seg
->p_type
!= PT_LOAD
)
3582 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3583 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3584 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3587 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3588 (unsigned long) vma
);
3594 get_32bit_section_headers (FILE * file
, unsigned int num
)
3596 Elf32_External_Shdr
* shdrs
;
3597 Elf_Internal_Shdr
* internal
;
3600 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3601 elf_header
.e_shentsize
, num
, _("section headers"));
3605 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3607 if (section_headers
== NULL
)
3609 error (_("Out of memory\n"));
3613 for (i
= 0, internal
= section_headers
;
3617 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3618 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3619 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3620 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3621 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3622 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3623 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3624 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3625 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3626 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3635 get_64bit_section_headers (FILE * file
, unsigned int num
)
3637 Elf64_External_Shdr
* shdrs
;
3638 Elf_Internal_Shdr
* internal
;
3641 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3642 elf_header
.e_shentsize
, num
, _("section headers"));
3646 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3648 if (section_headers
== NULL
)
3650 error (_("Out of memory\n"));
3654 for (i
= 0, internal
= section_headers
;
3658 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3659 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3660 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3661 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3662 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3663 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3664 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3665 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3666 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3667 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3675 static Elf_Internal_Sym
*
3676 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3678 unsigned long number
;
3679 Elf32_External_Sym
* esyms
;
3680 Elf_External_Sym_Shndx
* shndx
;
3681 Elf_Internal_Sym
* isyms
;
3682 Elf_Internal_Sym
* psym
;
3685 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3691 if (symtab_shndx_hdr
!= NULL
3692 && (symtab_shndx_hdr
->sh_link
3693 == (unsigned long) (section
- section_headers
)))
3695 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3696 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3704 number
= section
->sh_size
/ section
->sh_entsize
;
3705 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3709 error (_("Out of memory\n"));
3716 for (j
= 0, psym
= isyms
;
3720 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3721 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3722 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3723 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3724 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3726 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3727 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3728 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3729 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3730 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3740 static Elf_Internal_Sym
*
3741 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3743 unsigned long number
;
3744 Elf64_External_Sym
* esyms
;
3745 Elf_External_Sym_Shndx
* shndx
;
3746 Elf_Internal_Sym
* isyms
;
3747 Elf_Internal_Sym
* psym
;
3750 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3756 if (symtab_shndx_hdr
!= NULL
3757 && (symtab_shndx_hdr
->sh_link
3758 == (unsigned long) (section
- section_headers
)))
3760 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3761 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3769 number
= section
->sh_size
/ section
->sh_entsize
;
3770 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3774 error (_("Out of memory\n"));
3781 for (j
= 0, psym
= isyms
;
3785 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3786 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3787 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3788 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3789 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3791 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3792 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3793 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3794 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3795 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3806 get_elf_section_flags (bfd_vma sh_flags
)
3808 static char buff
[1024];
3810 int field_size
= is_32bit_elf
? 8 : 16;
3811 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3812 bfd_vma os_flags
= 0;
3813 bfd_vma proc_flags
= 0;
3814 bfd_vma unknown_flags
= 0;
3828 { "LINK ORDER", 10 },
3829 { "OS NONCONF", 10 },
3832 /* IA-64 specific. */
3835 /* IA-64 OpenVMS specific. */
3836 { "VMS_GLOBAL", 10 },
3837 { "VMS_OVERLAID", 12 },
3838 { "VMS_SHARED", 10 },
3839 { "VMS_VECTOR", 10 },
3840 { "VMS_ALLOC_64BIT", 15 },
3841 { "VMS_PROTECTED", 13}
3844 if (do_section_details
)
3846 sprintf (buff
, "[%*.*lx]: ",
3847 field_size
, field_size
, (unsigned long) sh_flags
);
3848 p
+= field_size
+ 4;
3855 flag
= sh_flags
& - sh_flags
;
3858 if (do_section_details
)
3862 case SHF_WRITE
: index
= 0; break;
3863 case SHF_ALLOC
: index
= 1; break;
3864 case SHF_EXECINSTR
: index
= 2; break;
3865 case SHF_MERGE
: index
= 3; break;
3866 case SHF_STRINGS
: index
= 4; break;
3867 case SHF_INFO_LINK
: index
= 5; break;
3868 case SHF_LINK_ORDER
: index
= 6; break;
3869 case SHF_OS_NONCONFORMING
: index
= 7; break;
3870 case SHF_GROUP
: index
= 8; break;
3871 case SHF_TLS
: index
= 9; break;
3875 if (elf_header
.e_machine
== EM_IA_64
)
3877 if (flag
== SHF_IA_64_SHORT
)
3879 else if (flag
== SHF_IA_64_NORECOV
)
3882 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3885 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3886 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3887 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3888 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3889 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3890 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3900 if (p
!= buff
+ field_size
+ 4)
3902 if (size
< (10 + 2))
3909 size
-= flags
[index
].len
;
3910 p
= stpcpy (p
, flags
[index
].str
);
3912 else if (flag
& SHF_MASKOS
)
3914 else if (flag
& SHF_MASKPROC
)
3917 unknown_flags
|= flag
;
3923 case SHF_WRITE
: *p
= 'W'; break;
3924 case SHF_ALLOC
: *p
= 'A'; break;
3925 case SHF_EXECINSTR
: *p
= 'X'; break;
3926 case SHF_MERGE
: *p
= 'M'; break;
3927 case SHF_STRINGS
: *p
= 'S'; break;
3928 case SHF_INFO_LINK
: *p
= 'I'; break;
3929 case SHF_LINK_ORDER
: *p
= 'L'; break;
3930 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3931 case SHF_GROUP
: *p
= 'G'; break;
3932 case SHF_TLS
: *p
= 'T'; break;
3935 if (elf_header
.e_machine
== EM_X86_64
3936 && flag
== SHF_X86_64_LARGE
)
3938 else if (flag
& SHF_MASKOS
)
3941 sh_flags
&= ~ SHF_MASKOS
;
3943 else if (flag
& SHF_MASKPROC
)
3946 sh_flags
&= ~ SHF_MASKPROC
;
3956 if (do_section_details
)
3960 size
-= 5 + field_size
;
3961 if (p
!= buff
+ field_size
+ 4)
3969 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3970 (unsigned long) os_flags
);
3971 p
+= 5 + field_size
;
3975 size
-= 7 + field_size
;
3976 if (p
!= buff
+ field_size
+ 4)
3984 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3985 (unsigned long) proc_flags
);
3986 p
+= 7 + field_size
;
3990 size
-= 10 + field_size
;
3991 if (p
!= buff
+ field_size
+ 4)
3999 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4000 (unsigned long) unknown_flags
);
4001 p
+= 10 + field_size
;
4010 process_section_headers (FILE * file
)
4012 Elf_Internal_Shdr
* section
;
4015 section_headers
= NULL
;
4017 if (elf_header
.e_shnum
== 0)
4020 printf (_("\nThere are no sections in this file.\n"));
4025 if (do_sections
&& !do_header
)
4026 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4027 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4031 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4034 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4037 /* Read in the string table, so that we have names to display. */
4038 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4039 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4041 section
= section_headers
+ elf_header
.e_shstrndx
;
4043 if (section
->sh_size
!= 0)
4045 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4046 1, section
->sh_size
, _("string table"));
4048 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4052 /* Scan the sections for the dynamic symbol table
4053 and dynamic string table and debug sections. */
4054 dynamic_symbols
= NULL
;
4055 dynamic_strings
= NULL
;
4056 dynamic_syminfo
= NULL
;
4057 symtab_shndx_hdr
= NULL
;
4059 eh_addr_size
= is_32bit_elf
? 4 : 8;
4060 switch (elf_header
.e_machine
)
4063 case EM_MIPS_RS3_LE
:
4064 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4065 FDE addresses. However, the ABI also has a semi-official ILP32
4066 variant for which the normal FDE address size rules apply.
4068 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4069 section, where XX is the size of longs in bits. Unfortunately,
4070 earlier compilers provided no way of distinguishing ILP32 objects
4071 from LP64 objects, so if there's any doubt, we should assume that
4072 the official LP64 form is being used. */
4073 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4074 && find_section (".gcc_compiled_long32") == NULL
)
4080 switch (elf_header
.e_flags
& EF_H8_MACH
)
4082 case E_H8_MACH_H8300
:
4083 case E_H8_MACH_H8300HN
:
4084 case E_H8_MACH_H8300SN
:
4085 case E_H8_MACH_H8300SXN
:
4088 case E_H8_MACH_H8300H
:
4089 case E_H8_MACH_H8300S
:
4090 case E_H8_MACH_H8300SX
:
4098 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4100 case EF_M32C_CPU_M16C
:
4107 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4110 size_t expected_entsize \
4111 = is_32bit_elf ? size32 : size64; \
4112 if (section->sh_entsize != expected_entsize) \
4113 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4114 i, (unsigned long int) section->sh_entsize, \
4115 (unsigned long int) expected_entsize); \
4116 section->sh_entsize = expected_entsize; \
4119 #define CHECK_ENTSIZE(section, i, type) \
4120 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4121 sizeof (Elf64_External_##type))
4123 for (i
= 0, section
= section_headers
;
4124 i
< elf_header
.e_shnum
;
4127 char * name
= SECTION_NAME (section
);
4129 if (section
->sh_type
== SHT_DYNSYM
)
4131 if (dynamic_symbols
!= NULL
)
4133 error (_("File contains multiple dynamic symbol tables\n"));
4137 CHECK_ENTSIZE (section
, i
, Sym
);
4138 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4139 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4141 else if (section
->sh_type
== SHT_STRTAB
4142 && streq (name
, ".dynstr"))
4144 if (dynamic_strings
!= NULL
)
4146 error (_("File contains multiple dynamic string tables\n"));
4150 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4151 1, section
->sh_size
, _("dynamic strings"));
4152 dynamic_strings_length
= section
->sh_size
;
4154 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4156 if (symtab_shndx_hdr
!= NULL
)
4158 error (_("File contains multiple symtab shndx tables\n"));
4161 symtab_shndx_hdr
= section
;
4163 else if (section
->sh_type
== SHT_SYMTAB
)
4164 CHECK_ENTSIZE (section
, i
, Sym
);
4165 else if (section
->sh_type
== SHT_GROUP
)
4166 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4167 else if (section
->sh_type
== SHT_REL
)
4168 CHECK_ENTSIZE (section
, i
, Rel
);
4169 else if (section
->sh_type
== SHT_RELA
)
4170 CHECK_ENTSIZE (section
, i
, Rela
);
4171 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4172 || do_debug_lines
|| do_debug_pubnames
4173 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4174 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4175 && (const_strneq (name
, ".debug_")
4176 || const_strneq (name
, ".zdebug_")))
4179 name
+= sizeof (".zdebug_") - 1;
4181 name
+= sizeof (".debug_") - 1;
4184 || (do_debug_info
&& streq (name
, "info"))
4185 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4186 || (do_debug_lines
&& streq (name
, "line"))
4187 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4188 || (do_debug_aranges
&& streq (name
, "aranges"))
4189 || (do_debug_ranges
&& streq (name
, "ranges"))
4190 || (do_debug_frames
&& streq (name
, "frame"))
4191 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4192 || (do_debug_str
&& streq (name
, "str"))
4193 || (do_debug_loc
&& streq (name
, "loc"))
4195 request_dump_bynumber (i
, DEBUG_DUMP
);
4197 /* Linkonce section to be combined with .debug_info at link time. */
4198 else if ((do_debugging
|| do_debug_info
)
4199 && const_strneq (name
, ".gnu.linkonce.wi."))
4200 request_dump_bynumber (i
, DEBUG_DUMP
);
4201 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4202 request_dump_bynumber (i
, DEBUG_DUMP
);
4208 if (elf_header
.e_shnum
> 1)
4209 printf (_("\nSection Headers:\n"));
4211 printf (_("\nSection Header:\n"));
4215 if (do_section_details
)
4217 printf (_(" [Nr] Name\n"));
4218 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4222 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4226 if (do_section_details
)
4228 printf (_(" [Nr] Name\n"));
4229 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4233 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4237 if (do_section_details
)
4239 printf (_(" [Nr] Name\n"));
4240 printf (_(" Type Address Offset Link\n"));
4241 printf (_(" Size EntSize Info Align\n"));
4245 printf (_(" [Nr] Name Type Address Offset\n"));
4246 printf (_(" Size EntSize Flags Link Info Align\n"));
4250 if (do_section_details
)
4251 printf (_(" Flags\n"));
4253 for (i
= 0, section
= section_headers
;
4254 i
< elf_header
.e_shnum
;
4257 if (do_section_details
)
4259 printf (" [%2u] %s\n",
4261 SECTION_NAME (section
));
4262 if (is_32bit_elf
|| do_wide
)
4263 printf (" %-15.15s ",
4264 get_section_type_name (section
->sh_type
));
4267 printf ((do_wide
? " [%2u] %-17s %-15s "
4268 : " [%2u] %-17.17s %-15.15s "),
4270 SECTION_NAME (section
),
4271 get_section_type_name (section
->sh_type
));
4275 print_vma (section
->sh_addr
, LONG_HEX
);
4277 printf ( " %6.6lx %6.6lx %2.2lx",
4278 (unsigned long) section
->sh_offset
,
4279 (unsigned long) section
->sh_size
,
4280 (unsigned long) section
->sh_entsize
);
4282 if (do_section_details
)
4283 fputs (" ", stdout
);
4285 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4287 printf ("%2u %3u %2lu\n",
4290 (unsigned long) section
->sh_addralign
);
4294 print_vma (section
->sh_addr
, LONG_HEX
);
4296 if ((long) section
->sh_offset
== section
->sh_offset
)
4297 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4301 print_vma (section
->sh_offset
, LONG_HEX
);
4304 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4305 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4309 print_vma (section
->sh_size
, LONG_HEX
);
4312 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4313 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4317 print_vma (section
->sh_entsize
, LONG_HEX
);
4320 if (do_section_details
)
4321 fputs (" ", stdout
);
4323 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4325 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4327 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4328 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4331 print_vma (section
->sh_addralign
, DEC
);
4335 else if (do_section_details
)
4337 printf (" %-15.15s ",
4338 get_section_type_name (section
->sh_type
));
4339 print_vma (section
->sh_addr
, LONG_HEX
);
4340 if ((long) section
->sh_offset
== section
->sh_offset
)
4341 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4345 print_vma (section
->sh_offset
, LONG_HEX
);
4347 printf (" %u\n ", section
->sh_link
);
4348 print_vma (section
->sh_size
, LONG_HEX
);
4350 print_vma (section
->sh_entsize
, LONG_HEX
);
4352 printf (" %-16u %lu\n",
4354 (unsigned long) section
->sh_addralign
);
4359 print_vma (section
->sh_addr
, LONG_HEX
);
4360 if ((long) section
->sh_offset
== section
->sh_offset
)
4361 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4365 print_vma (section
->sh_offset
, LONG_HEX
);
4368 print_vma (section
->sh_size
, LONG_HEX
);
4370 print_vma (section
->sh_entsize
, LONG_HEX
);
4372 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4374 printf (" %2u %3u %lu\n",
4377 (unsigned long) section
->sh_addralign
);
4380 if (do_section_details
)
4381 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4384 if (!do_section_details
)
4385 printf (_("Key to Flags:\n\
4386 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4387 I (info), L (link order), G (group), x (unknown)\n\
4388 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4394 get_group_flags (unsigned int flags
)
4396 static char buff
[32];
4403 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4410 process_section_groups (FILE * file
)
4412 Elf_Internal_Shdr
* section
;
4414 struct group
* group
;
4415 Elf_Internal_Shdr
* symtab_sec
;
4416 Elf_Internal_Shdr
* strtab_sec
;
4417 Elf_Internal_Sym
* symtab
;
4421 /* Don't process section groups unless needed. */
4422 if (!do_unwind
&& !do_section_groups
)
4425 if (elf_header
.e_shnum
== 0)
4427 if (do_section_groups
)
4428 printf (_("\nThere are no sections in this file.\n"));
4433 if (section_headers
== NULL
)
4435 error (_("Section headers are not available!\n"));
4439 section_headers_groups
= calloc (elf_header
.e_shnum
,
4440 sizeof (struct group
*));
4442 if (section_headers_groups
== NULL
)
4444 error (_("Out of memory\n"));
4448 /* Scan the sections for the group section. */
4450 for (i
= 0, section
= section_headers
;
4451 i
< elf_header
.e_shnum
;
4453 if (section
->sh_type
== SHT_GROUP
)
4456 if (group_count
== 0)
4458 if (do_section_groups
)
4459 printf (_("\nThere are no section groups in this file.\n"));
4464 section_groups
= calloc (group_count
, sizeof (struct group
));
4466 if (section_groups
== NULL
)
4468 error (_("Out of memory\n"));
4477 for (i
= 0, section
= section_headers
, group
= section_groups
;
4478 i
< elf_header
.e_shnum
;
4481 if (section
->sh_type
== SHT_GROUP
)
4483 char * name
= SECTION_NAME (section
);
4485 unsigned char * start
;
4486 unsigned char * indices
;
4487 unsigned int entry
, j
, size
;
4488 Elf_Internal_Shdr
* sec
;
4489 Elf_Internal_Sym
* sym
;
4491 /* Get the symbol table. */
4492 if (section
->sh_link
>= elf_header
.e_shnum
4493 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4496 error (_("Bad sh_link in group section `%s'\n"), name
);
4500 if (symtab_sec
!= sec
)
4505 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4508 sym
= symtab
+ section
->sh_info
;
4510 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4512 if (sym
->st_shndx
== 0
4513 || sym
->st_shndx
>= elf_header
.e_shnum
)
4515 error (_("Bad sh_info in group section `%s'\n"), name
);
4519 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4528 /* Get the string table. */
4529 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4538 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4543 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4544 1, strtab_sec
->sh_size
,
4546 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4548 group_name
= sym
->st_name
< strtab_size
4549 ? strtab
+ sym
->st_name
: "<corrupt>";
4552 start
= get_data (NULL
, file
, section
->sh_offset
,
4553 1, section
->sh_size
, _("section data"));
4556 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4557 entry
= byte_get (indices
, 4);
4560 if (do_section_groups
)
4562 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4563 get_group_flags (entry
), i
, name
, group_name
, size
);
4565 printf (_(" [Index] Name\n"));
4568 group
->group_index
= i
;
4570 for (j
= 0; j
< size
; j
++)
4572 struct group_list
* g
;
4574 entry
= byte_get (indices
, 4);
4577 if (entry
>= elf_header
.e_shnum
)
4579 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4580 entry
, i
, elf_header
.e_shnum
- 1);
4584 if (section_headers_groups
[entry
] != NULL
)
4588 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4590 section_headers_groups
[entry
]->group_index
);
4595 /* Intel C/C++ compiler may put section 0 in a
4596 section group. We just warn it the first time
4597 and ignore it afterwards. */
4598 static int warned
= 0;
4601 error (_("section 0 in group section [%5u]\n"),
4602 section_headers_groups
[entry
]->group_index
);
4608 section_headers_groups
[entry
] = group
;
4610 if (do_section_groups
)
4612 sec
= section_headers
+ entry
;
4613 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4616 g
= xmalloc (sizeof (struct group_list
));
4617 g
->section_index
= entry
;
4618 g
->next
= group
->root
;
4642 } dynamic_relocations
[] =
4644 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4645 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4646 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4649 /* Process the reloc section. */
4652 process_relocs (FILE * file
)
4654 unsigned long rel_size
;
4655 unsigned long rel_offset
;
4661 if (do_using_dynamic
)
4665 int has_dynamic_reloc
;
4668 has_dynamic_reloc
= 0;
4670 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4672 is_rela
= dynamic_relocations
[i
].rela
;
4673 name
= dynamic_relocations
[i
].name
;
4674 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4675 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4677 has_dynamic_reloc
|= rel_size
;
4679 if (is_rela
== UNKNOWN
)
4681 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4682 switch (dynamic_info
[DT_PLTREL
])
4696 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4697 name
, rel_offset
, rel_size
);
4699 dump_relocations (file
,
4700 offset_from_vma (file
, rel_offset
, rel_size
),
4702 dynamic_symbols
, num_dynamic_syms
,
4703 dynamic_strings
, dynamic_strings_length
, is_rela
);
4707 if (! has_dynamic_reloc
)
4708 printf (_("\nThere are no dynamic relocations in this file.\n"));
4712 Elf_Internal_Shdr
* section
;
4716 for (i
= 0, section
= section_headers
;
4717 i
< elf_header
.e_shnum
;
4720 if ( section
->sh_type
!= SHT_RELA
4721 && section
->sh_type
!= SHT_REL
)
4724 rel_offset
= section
->sh_offset
;
4725 rel_size
= section
->sh_size
;
4729 Elf_Internal_Shdr
* strsec
;
4732 printf (_("\nRelocation section "));
4734 if (string_table
== NULL
)
4735 printf ("%d", section
->sh_name
);
4737 printf (_("'%s'"), SECTION_NAME (section
));
4739 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4740 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4742 is_rela
= section
->sh_type
== SHT_RELA
;
4744 if (section
->sh_link
!= 0
4745 && section
->sh_link
< elf_header
.e_shnum
)
4747 Elf_Internal_Shdr
* symsec
;
4748 Elf_Internal_Sym
* symtab
;
4749 unsigned long nsyms
;
4750 unsigned long strtablen
= 0;
4751 char * strtab
= NULL
;
4753 symsec
= section_headers
+ section
->sh_link
;
4754 if (symsec
->sh_type
!= SHT_SYMTAB
4755 && symsec
->sh_type
!= SHT_DYNSYM
)
4758 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4759 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4764 if (symsec
->sh_link
!= 0
4765 && symsec
->sh_link
< elf_header
.e_shnum
)
4767 strsec
= section_headers
+ symsec
->sh_link
;
4769 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4772 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4775 dump_relocations (file
, rel_offset
, rel_size
,
4776 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4782 dump_relocations (file
, rel_offset
, rel_size
,
4783 NULL
, 0, NULL
, 0, is_rela
);
4790 printf (_("\nThere are no relocations in this file.\n"));
4796 /* Process the unwind section. */
4798 #include "unwind-ia64.h"
4800 /* An absolute address consists of a section and an offset. If the
4801 section is NULL, the offset itself is the address, otherwise, the
4802 address equals to LOAD_ADDRESS(section) + offset. */
4806 unsigned short section
;
4810 #define ABSADDR(a) \
4812 ? section_headers [(a).section].sh_addr + (a).offset \
4815 struct ia64_unw_aux_info
4817 struct ia64_unw_table_entry
4819 struct absaddr start
;
4821 struct absaddr info
;
4823 *table
; /* Unwind table. */
4824 unsigned long table_len
; /* Length of unwind table. */
4825 unsigned char * info
; /* Unwind info. */
4826 unsigned long info_size
; /* Size of unwind info. */
4827 bfd_vma info_addr
; /* starting address of unwind info. */
4828 bfd_vma seg_base
; /* Starting address of segment. */
4829 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4830 unsigned long nsyms
; /* Number of symbols. */
4831 char * strtab
; /* The string table. */
4832 unsigned long strtab_size
; /* Size of string table. */
4836 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4837 unsigned long nsyms
,
4838 const char * strtab
,
4839 unsigned long strtab_size
,
4840 struct absaddr addr
,
4841 const char ** symname
,
4844 bfd_vma dist
= 0x100000;
4845 Elf_Internal_Sym
* sym
;
4846 Elf_Internal_Sym
* best
= NULL
;
4849 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4851 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4852 && sym
->st_name
!= 0
4853 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4854 && addr
.offset
>= sym
->st_value
4855 && addr
.offset
- sym
->st_value
< dist
)
4858 dist
= addr
.offset
- sym
->st_value
;
4865 *symname
= (best
->st_name
>= strtab_size
4866 ? "<corrupt>" : strtab
+ best
->st_name
);
4871 *offset
= addr
.offset
;
4875 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
4877 struct ia64_unw_table_entry
* tp
;
4880 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4884 const unsigned char * dp
;
4885 const unsigned char * head
;
4886 const char * procname
;
4888 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4889 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4891 fputs ("\n<", stdout
);
4895 fputs (procname
, stdout
);
4898 printf ("+%lx", (unsigned long) offset
);
4901 fputs (">: [", stdout
);
4902 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4903 fputc ('-', stdout
);
4904 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4905 printf ("], info at +0x%lx\n",
4906 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4908 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4909 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4911 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4912 (unsigned) UNW_VER (stamp
),
4913 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4914 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4915 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4916 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4918 if (UNW_VER (stamp
) != 1)
4920 printf ("\tUnknown version.\n");
4925 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4926 dp
= unw_decode (dp
, in_body
, & in_body
);
4931 slurp_ia64_unwind_table (FILE * file
,
4932 struct ia64_unw_aux_info
* aux
,
4933 Elf_Internal_Shdr
* sec
)
4935 unsigned long size
, nrelas
, i
;
4936 Elf_Internal_Phdr
* seg
;
4937 struct ia64_unw_table_entry
* tep
;
4938 Elf_Internal_Shdr
* relsec
;
4939 Elf_Internal_Rela
* rela
;
4940 Elf_Internal_Rela
* rp
;
4941 unsigned char * table
;
4943 Elf_Internal_Sym
* sym
;
4944 const char * relname
;
4946 /* First, find the starting address of the segment that includes
4949 if (elf_header
.e_phnum
)
4951 if (! get_program_headers (file
))
4954 for (seg
= program_headers
;
4955 seg
< program_headers
+ elf_header
.e_phnum
;
4958 if (seg
->p_type
!= PT_LOAD
)
4961 if (sec
->sh_addr
>= seg
->p_vaddr
4962 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4964 aux
->seg_base
= seg
->p_vaddr
;
4970 /* Second, build the unwind table from the contents of the unwind section: */
4971 size
= sec
->sh_size
;
4972 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4976 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4978 for (tp
= table
; tp
< table
+ size
; ++tep
)
4980 tep
->start
.section
= SHN_UNDEF
;
4981 tep
->end
.section
= SHN_UNDEF
;
4982 tep
->info
.section
= SHN_UNDEF
;
4983 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
4984 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
4985 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
4986 tep
->start
.offset
+= aux
->seg_base
;
4987 tep
->end
.offset
+= aux
->seg_base
;
4988 tep
->info
.offset
+= aux
->seg_base
;
4992 /* Third, apply any relocations to the unwind table: */
4993 for (relsec
= section_headers
;
4994 relsec
< section_headers
+ elf_header
.e_shnum
;
4997 if (relsec
->sh_type
!= SHT_RELA
4998 || relsec
->sh_info
>= elf_header
.e_shnum
4999 || section_headers
+ relsec
->sh_info
!= sec
)
5002 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5006 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5008 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5009 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5011 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5013 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5017 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5019 switch (rp
->r_offset
/eh_addr_size
% 3)
5022 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5023 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5026 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5027 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5030 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5031 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5041 aux
->table_len
= size
/ (3 * eh_addr_size
);
5046 ia64_process_unwind (FILE * file
)
5048 Elf_Internal_Shdr
* sec
;
5049 Elf_Internal_Shdr
* unwsec
= NULL
;
5050 Elf_Internal_Shdr
* strsec
;
5051 unsigned long i
, unwcount
= 0, unwstart
= 0;
5052 struct ia64_unw_aux_info aux
;
5054 memset (& aux
, 0, sizeof (aux
));
5056 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5058 if (sec
->sh_type
== SHT_SYMTAB
5059 && sec
->sh_link
< elf_header
.e_shnum
)
5061 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5062 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5064 strsec
= section_headers
+ sec
->sh_link
;
5065 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5066 1, strsec
->sh_size
, _("string table"));
5067 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5069 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5074 printf (_("\nThere are no unwind sections in this file.\n"));
5076 while (unwcount
-- > 0)
5081 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5082 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5083 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5090 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5092 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5094 /* We need to find which section group it is in. */
5095 struct group_list
* g
= section_headers_groups
[i
]->root
;
5097 for (; g
!= NULL
; g
= g
->next
)
5099 sec
= section_headers
+ g
->section_index
;
5101 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5106 i
= elf_header
.e_shnum
;
5108 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5110 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5111 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5112 suffix
= SECTION_NAME (unwsec
) + len
;
5113 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5115 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5116 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5121 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5122 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5123 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5124 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5126 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5127 suffix
= SECTION_NAME (unwsec
) + len
;
5128 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5130 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5131 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5135 if (i
== elf_header
.e_shnum
)
5137 printf (_("\nCould not find unwind info section for "));
5139 if (string_table
== NULL
)
5140 printf ("%d", unwsec
->sh_name
);
5142 printf (_("'%s'"), SECTION_NAME (unwsec
));
5146 aux
.info_size
= sec
->sh_size
;
5147 aux
.info_addr
= sec
->sh_addr
;
5148 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5151 printf (_("\nUnwind section "));
5153 if (string_table
== NULL
)
5154 printf ("%d", unwsec
->sh_name
);
5156 printf (_("'%s'"), SECTION_NAME (unwsec
));
5158 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5159 (unsigned long) unwsec
->sh_offset
,
5160 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5162 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5164 if (aux
.table_len
> 0)
5165 dump_ia64_unwind (& aux
);
5168 free ((char *) aux
.table
);
5170 free ((char *) aux
.info
);
5179 free ((char *) aux
.strtab
);
5184 struct hppa_unw_aux_info
5186 struct hppa_unw_table_entry
5188 struct absaddr start
;
5190 unsigned int Cannot_unwind
:1; /* 0 */
5191 unsigned int Millicode
:1; /* 1 */
5192 unsigned int Millicode_save_sr0
:1; /* 2 */
5193 unsigned int Region_description
:2; /* 3..4 */
5194 unsigned int reserved1
:1; /* 5 */
5195 unsigned int Entry_SR
:1; /* 6 */
5196 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5197 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5198 unsigned int Args_stored
:1; /* 16 */
5199 unsigned int Variable_Frame
:1; /* 17 */
5200 unsigned int Separate_Package_Body
:1; /* 18 */
5201 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5202 unsigned int Stack_Overflow_Check
:1; /* 20 */
5203 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5204 unsigned int Ada_Region
:1; /* 22 */
5205 unsigned int cxx_info
:1; /* 23 */
5206 unsigned int cxx_try_catch
:1; /* 24 */
5207 unsigned int sched_entry_seq
:1; /* 25 */
5208 unsigned int reserved2
:1; /* 26 */
5209 unsigned int Save_SP
:1; /* 27 */
5210 unsigned int Save_RP
:1; /* 28 */
5211 unsigned int Save_MRP_in_frame
:1; /* 29 */
5212 unsigned int extn_ptr_defined
:1; /* 30 */
5213 unsigned int Cleanup_defined
:1; /* 31 */
5215 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5216 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5217 unsigned int Large_frame
:1; /* 2 */
5218 unsigned int Pseudo_SP_Set
:1; /* 3 */
5219 unsigned int reserved4
:1; /* 4 */
5220 unsigned int Total_frame_size
:27; /* 5..31 */
5222 *table
; /* Unwind table. */
5223 unsigned long table_len
; /* Length of unwind table. */
5224 bfd_vma seg_base
; /* Starting address of segment. */
5225 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5226 unsigned long nsyms
; /* Number of symbols. */
5227 char * strtab
; /* The string table. */
5228 unsigned long strtab_size
; /* Size of string table. */
5232 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5234 struct hppa_unw_table_entry
* tp
;
5236 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5239 const char * procname
;
5241 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5242 aux
->strtab_size
, tp
->start
, &procname
,
5245 fputs ("\n<", stdout
);
5249 fputs (procname
, stdout
);
5252 printf ("+%lx", (unsigned long) offset
);
5255 fputs (">: [", stdout
);
5256 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5257 fputc ('-', stdout
);
5258 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5261 #define PF(_m) if (tp->_m) printf (#_m " ");
5262 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5265 PF(Millicode_save_sr0
);
5266 /* PV(Region_description); */
5272 PF(Separate_Package_Body
);
5273 PF(Frame_Extension_Millicode
);
5274 PF(Stack_Overflow_Check
);
5275 PF(Two_Instruction_SP_Increment
);
5279 PF(sched_entry_seq
);
5282 PF(Save_MRP_in_frame
);
5283 PF(extn_ptr_defined
);
5284 PF(Cleanup_defined
);
5285 PF(MPE_XL_interrupt_marker
);
5286 PF(HP_UX_interrupt_marker
);
5289 PV(Total_frame_size
);
5298 slurp_hppa_unwind_table (FILE * file
,
5299 struct hppa_unw_aux_info
* aux
,
5300 Elf_Internal_Shdr
* sec
)
5302 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5303 Elf_Internal_Phdr
* seg
;
5304 struct hppa_unw_table_entry
* tep
;
5305 Elf_Internal_Shdr
* relsec
;
5306 Elf_Internal_Rela
* rela
;
5307 Elf_Internal_Rela
* rp
;
5308 unsigned char * table
;
5310 Elf_Internal_Sym
* sym
;
5311 const char * relname
;
5313 /* First, find the starting address of the segment that includes
5316 if (elf_header
.e_phnum
)
5318 if (! get_program_headers (file
))
5321 for (seg
= program_headers
;
5322 seg
< program_headers
+ elf_header
.e_phnum
;
5325 if (seg
->p_type
!= PT_LOAD
)
5328 if (sec
->sh_addr
>= seg
->p_vaddr
5329 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5331 aux
->seg_base
= seg
->p_vaddr
;
5337 /* Second, build the unwind table from the contents of the unwind
5339 size
= sec
->sh_size
;
5340 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5345 nentries
= size
/ unw_ent_size
;
5346 size
= unw_ent_size
* nentries
;
5348 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5350 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5352 unsigned int tmp1
, tmp2
;
5354 tep
->start
.section
= SHN_UNDEF
;
5355 tep
->end
.section
= SHN_UNDEF
;
5357 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5358 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5359 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5360 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5362 tep
->start
.offset
+= aux
->seg_base
;
5363 tep
->end
.offset
+= aux
->seg_base
;
5365 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5366 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5367 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5368 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5369 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5370 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5371 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5372 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5373 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5374 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5375 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5376 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5377 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5378 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5379 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5380 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5381 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5382 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5383 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5384 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5385 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5386 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5387 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5388 tep
->Cleanup_defined
= tmp1
& 0x1;
5390 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5391 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5392 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5393 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5394 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5395 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5399 /* Third, apply any relocations to the unwind table. */
5400 for (relsec
= section_headers
;
5401 relsec
< section_headers
+ elf_header
.e_shnum
;
5404 if (relsec
->sh_type
!= SHT_RELA
5405 || relsec
->sh_info
>= elf_header
.e_shnum
5406 || section_headers
+ relsec
->sh_info
!= sec
)
5409 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5413 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5415 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5416 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5418 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5419 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5421 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5425 i
= rp
->r_offset
/ unw_ent_size
;
5427 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5430 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5431 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5434 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5435 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5445 aux
->table_len
= nentries
;
5451 hppa_process_unwind (FILE * file
)
5453 struct hppa_unw_aux_info aux
;
5454 Elf_Internal_Shdr
* unwsec
= NULL
;
5455 Elf_Internal_Shdr
* strsec
;
5456 Elf_Internal_Shdr
* sec
;
5459 memset (& aux
, 0, sizeof (aux
));
5461 if (string_table
== NULL
)
5464 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5466 if (sec
->sh_type
== SHT_SYMTAB
5467 && sec
->sh_link
< elf_header
.e_shnum
)
5469 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5470 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5472 strsec
= section_headers
+ sec
->sh_link
;
5473 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5474 1, strsec
->sh_size
, _("string table"));
5475 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5477 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5482 printf (_("\nThere are no unwind sections in this file.\n"));
5484 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5486 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5488 printf (_("\nUnwind section "));
5489 printf (_("'%s'"), SECTION_NAME (sec
));
5491 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5492 (unsigned long) sec
->sh_offset
,
5493 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5495 slurp_hppa_unwind_table (file
, &aux
, sec
);
5496 if (aux
.table_len
> 0)
5497 dump_hppa_unwind (&aux
);
5500 free ((char *) aux
.table
);
5508 free ((char *) aux
.strtab
);
5514 process_unwind (FILE * file
)
5516 struct unwind_handler
5519 int (* handler
)(FILE *);
5522 { EM_IA_64
, ia64_process_unwind
},
5523 { EM_PARISC
, hppa_process_unwind
},
5531 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5532 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5533 return handlers
[i
].handler (file
);
5535 printf (_("\nThere are no unwind sections in this file.\n"));
5540 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5542 switch (entry
->d_tag
)
5545 if (entry
->d_un
.d_val
== 0)
5549 static const char * opts
[] =
5551 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5552 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5553 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5554 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5559 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5560 if (entry
->d_un
.d_val
& (1 << cnt
))
5562 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5569 case DT_MIPS_IVERSION
:
5570 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5571 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5573 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5576 case DT_MIPS_TIME_STAMP
:
5581 time_t time
= entry
->d_un
.d_val
;
5582 tmp
= gmtime (&time
);
5583 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5584 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5585 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5586 printf ("Time Stamp: %s\n", timebuf
);
5590 case DT_MIPS_RLD_VERSION
:
5591 case DT_MIPS_LOCAL_GOTNO
:
5592 case DT_MIPS_CONFLICTNO
:
5593 case DT_MIPS_LIBLISTNO
:
5594 case DT_MIPS_SYMTABNO
:
5595 case DT_MIPS_UNREFEXTNO
:
5596 case DT_MIPS_HIPAGENO
:
5597 case DT_MIPS_DELTA_CLASS_NO
:
5598 case DT_MIPS_DELTA_INSTANCE_NO
:
5599 case DT_MIPS_DELTA_RELOC_NO
:
5600 case DT_MIPS_DELTA_SYM_NO
:
5601 case DT_MIPS_DELTA_CLASSSYM_NO
:
5602 case DT_MIPS_COMPACT_SIZE
:
5603 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5607 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5613 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5615 switch (entry
->d_tag
)
5617 case DT_HP_DLD_FLAGS
:
5626 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5627 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5628 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5629 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5630 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5631 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5632 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5633 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5634 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5635 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5636 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5637 { DT_HP_GST
, "HP_GST" },
5638 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5639 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5640 { DT_HP_NODELETE
, "HP_NODELETE" },
5641 { DT_HP_GROUP
, "HP_GROUP" },
5642 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5646 bfd_vma val
= entry
->d_un
.d_val
;
5648 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5649 if (val
& flags
[cnt
].bit
)
5653 fputs (flags
[cnt
].str
, stdout
);
5655 val
^= flags
[cnt
].bit
;
5658 if (val
!= 0 || first
)
5662 print_vma (val
, HEX
);
5668 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5675 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5677 switch (entry
->d_tag
)
5679 case DT_IA_64_PLT_RESERVE
:
5680 /* First 3 slots reserved. */
5681 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5683 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5687 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5694 get_32bit_dynamic_section (FILE * file
)
5696 Elf32_External_Dyn
* edyn
;
5697 Elf32_External_Dyn
* ext
;
5698 Elf_Internal_Dyn
* entry
;
5700 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5701 _("dynamic section"));
5705 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5706 might not have the luxury of section headers. Look for the DT_NULL
5707 terminator to determine the number of entries. */
5708 for (ext
= edyn
, dynamic_nent
= 0;
5709 (char *) ext
< (char *) edyn
+ dynamic_size
;
5713 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5717 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5718 if (dynamic_section
== NULL
)
5720 error (_("Out of memory\n"));
5725 for (ext
= edyn
, entry
= dynamic_section
;
5726 entry
< dynamic_section
+ dynamic_nent
;
5729 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5730 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5739 get_64bit_dynamic_section (FILE * file
)
5741 Elf64_External_Dyn
* edyn
;
5742 Elf64_External_Dyn
* ext
;
5743 Elf_Internal_Dyn
* entry
;
5745 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5746 _("dynamic section"));
5750 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5751 might not have the luxury of section headers. Look for the DT_NULL
5752 terminator to determine the number of entries. */
5753 for (ext
= edyn
, dynamic_nent
= 0;
5754 (char *) ext
< (char *) edyn
+ dynamic_size
;
5758 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5762 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5763 if (dynamic_section
== NULL
)
5765 error (_("Out of memory\n"));
5770 for (ext
= edyn
, entry
= dynamic_section
;
5771 entry
< dynamic_section
+ dynamic_nent
;
5774 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5775 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5784 print_dynamic_flags (bfd_vma flags
)
5792 flag
= flags
& - flags
;
5802 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5803 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5804 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5805 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5806 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5807 default: fputs ("unknown", stdout
); break;
5813 /* Parse and display the contents of the dynamic section. */
5816 process_dynamic_section (FILE * file
)
5818 Elf_Internal_Dyn
* entry
;
5820 if (dynamic_size
== 0)
5823 printf (_("\nThere is no dynamic section in this file.\n"));
5830 if (! get_32bit_dynamic_section (file
))
5833 else if (! get_64bit_dynamic_section (file
))
5836 /* Find the appropriate symbol table. */
5837 if (dynamic_symbols
== NULL
)
5839 for (entry
= dynamic_section
;
5840 entry
< dynamic_section
+ dynamic_nent
;
5843 Elf_Internal_Shdr section
;
5845 if (entry
->d_tag
!= DT_SYMTAB
)
5848 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5850 /* Since we do not know how big the symbol table is,
5851 we default to reading in the entire file (!) and
5852 processing that. This is overkill, I know, but it
5854 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5856 if (archive_file_offset
!= 0)
5857 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5860 if (fseek (file
, 0, SEEK_END
))
5861 error (_("Unable to seek to end of file!\n"));
5863 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5867 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5869 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5871 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5872 if (num_dynamic_syms
< 1)
5874 error (_("Unable to determine the number of symbols to load\n"));
5878 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5882 /* Similarly find a string table. */
5883 if (dynamic_strings
== NULL
)
5885 for (entry
= dynamic_section
;
5886 entry
< dynamic_section
+ dynamic_nent
;
5889 unsigned long offset
;
5892 if (entry
->d_tag
!= DT_STRTAB
)
5895 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5897 /* Since we do not know how big the string table is,
5898 we default to reading in the entire file (!) and
5899 processing that. This is overkill, I know, but it
5902 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5904 if (archive_file_offset
!= 0)
5905 str_tab_len
= archive_file_size
- offset
;
5908 if (fseek (file
, 0, SEEK_END
))
5909 error (_("Unable to seek to end of file\n"));
5910 str_tab_len
= ftell (file
) - offset
;
5913 if (str_tab_len
< 1)
5916 (_("Unable to determine the length of the dynamic string table\n"));
5920 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5921 _("dynamic string table"));
5922 dynamic_strings_length
= str_tab_len
;
5927 /* And find the syminfo section if available. */
5928 if (dynamic_syminfo
== NULL
)
5930 unsigned long syminsz
= 0;
5932 for (entry
= dynamic_section
;
5933 entry
< dynamic_section
+ dynamic_nent
;
5936 if (entry
->d_tag
== DT_SYMINENT
)
5938 /* Note: these braces are necessary to avoid a syntax
5939 error from the SunOS4 C compiler. */
5940 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5942 else if (entry
->d_tag
== DT_SYMINSZ
)
5943 syminsz
= entry
->d_un
.d_val
;
5944 else if (entry
->d_tag
== DT_SYMINFO
)
5945 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5949 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5951 Elf_External_Syminfo
* extsyminfo
;
5952 Elf_External_Syminfo
* extsym
;
5953 Elf_Internal_Syminfo
* syminfo
;
5955 /* There is a syminfo section. Read the data. */
5956 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5957 syminsz
, _("symbol information"));
5961 dynamic_syminfo
= malloc (syminsz
);
5962 if (dynamic_syminfo
== NULL
)
5964 error (_("Out of memory\n"));
5968 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5969 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5970 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5971 ++syminfo
, ++extsym
)
5973 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5974 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5981 if (do_dynamic
&& dynamic_addr
)
5982 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5983 dynamic_addr
, dynamic_nent
);
5985 printf (_(" Tag Type Name/Value\n"));
5987 for (entry
= dynamic_section
;
5988 entry
< dynamic_section
+ dynamic_nent
;
5996 print_vma (entry
->d_tag
, FULL_HEX
);
5997 dtype
= get_dynamic_type (entry
->d_tag
);
5998 printf (" (%s)%*s", dtype
,
5999 ((is_32bit_elf
? 27 : 19)
6000 - (int) strlen (dtype
)),
6004 switch (entry
->d_tag
)
6008 print_dynamic_flags (entry
->d_un
.d_val
);
6018 switch (entry
->d_tag
)
6021 printf (_("Auxiliary library"));
6025 printf (_("Filter library"));
6029 printf (_("Configuration file"));
6033 printf (_("Dependency audit library"));
6037 printf (_("Audit library"));
6041 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6042 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6046 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6055 printf (_("Flags:"));
6057 if (entry
->d_un
.d_val
== 0)
6058 printf (_(" None\n"));
6061 unsigned long int val
= entry
->d_un
.d_val
;
6063 if (val
& DTF_1_PARINIT
)
6065 printf (" PARINIT");
6066 val
^= DTF_1_PARINIT
;
6068 if (val
& DTF_1_CONFEXP
)
6070 printf (" CONFEXP");
6071 val
^= DTF_1_CONFEXP
;
6074 printf (" %lx", val
);
6083 printf (_("Flags:"));
6085 if (entry
->d_un
.d_val
== 0)
6086 printf (_(" None\n"));
6089 unsigned long int val
= entry
->d_un
.d_val
;
6091 if (val
& DF_P1_LAZYLOAD
)
6093 printf (" LAZYLOAD");
6094 val
^= DF_P1_LAZYLOAD
;
6096 if (val
& DF_P1_GROUPPERM
)
6098 printf (" GROUPPERM");
6099 val
^= DF_P1_GROUPPERM
;
6102 printf (" %lx", val
);
6111 printf (_("Flags:"));
6112 if (entry
->d_un
.d_val
== 0)
6113 printf (_(" None\n"));
6116 unsigned long int val
= entry
->d_un
.d_val
;
6123 if (val
& DF_1_GLOBAL
)
6128 if (val
& DF_1_GROUP
)
6133 if (val
& DF_1_NODELETE
)
6135 printf (" NODELETE");
6136 val
^= DF_1_NODELETE
;
6138 if (val
& DF_1_LOADFLTR
)
6140 printf (" LOADFLTR");
6141 val
^= DF_1_LOADFLTR
;
6143 if (val
& DF_1_INITFIRST
)
6145 printf (" INITFIRST");
6146 val
^= DF_1_INITFIRST
;
6148 if (val
& DF_1_NOOPEN
)
6153 if (val
& DF_1_ORIGIN
)
6158 if (val
& DF_1_DIRECT
)
6163 if (val
& DF_1_TRANS
)
6168 if (val
& DF_1_INTERPOSE
)
6170 printf (" INTERPOSE");
6171 val
^= DF_1_INTERPOSE
;
6173 if (val
& DF_1_NODEFLIB
)
6175 printf (" NODEFLIB");
6176 val
^= DF_1_NODEFLIB
;
6178 if (val
& DF_1_NODUMP
)
6183 if (val
& DF_1_CONLFAT
)
6185 printf (" CONLFAT");
6186 val
^= DF_1_CONLFAT
;
6189 printf (" %lx", val
);
6196 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6198 puts (get_dynamic_type (entry
->d_un
.d_val
));
6218 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6224 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6225 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6231 switch (entry
->d_tag
)
6234 printf (_("Shared library: [%s]"), name
);
6236 if (streq (name
, program_interpreter
))
6237 printf (_(" program interpreter"));
6241 printf (_("Library soname: [%s]"), name
);
6245 printf (_("Library rpath: [%s]"), name
);
6249 printf (_("Library runpath: [%s]"), name
);
6253 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6258 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6271 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6275 case DT_INIT_ARRAYSZ
:
6276 case DT_FINI_ARRAYSZ
:
6277 case DT_GNU_CONFLICTSZ
:
6278 case DT_GNU_LIBLISTSZ
:
6281 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6282 printf (" (bytes)\n");
6292 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6305 if (entry
->d_tag
== DT_USED
6306 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6308 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6312 printf (_("Not needed object: [%s]\n"), name
);
6317 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6323 /* The value of this entry is ignored. */
6328 case DT_GNU_PRELINKED
:
6332 time_t time
= entry
->d_un
.d_val
;
6334 tmp
= gmtime (&time
);
6335 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6336 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6337 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6343 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6346 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6352 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6353 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6358 switch (elf_header
.e_machine
)
6361 case EM_MIPS_RS3_LE
:
6362 dynamic_section_mips_val (entry
);
6365 dynamic_section_parisc_val (entry
);
6368 dynamic_section_ia64_val (entry
);
6371 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6383 get_ver_flags (unsigned int flags
)
6385 static char buff
[32];
6392 if (flags
& VER_FLG_BASE
)
6393 strcat (buff
, "BASE ");
6395 if (flags
& VER_FLG_WEAK
)
6397 if (flags
& VER_FLG_BASE
)
6398 strcat (buff
, "| ");
6400 strcat (buff
, "WEAK ");
6403 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6404 strcat (buff
, "| <unknown>");
6409 /* Display the contents of the version sections. */
6411 process_version_sections (FILE * file
)
6413 Elf_Internal_Shdr
* section
;
6420 for (i
= 0, section
= section_headers
;
6421 i
< elf_header
.e_shnum
;
6424 switch (section
->sh_type
)
6426 case SHT_GNU_verdef
:
6428 Elf_External_Verdef
* edefs
;
6436 (_("\nVersion definition section '%s' contains %u entries:\n"),
6437 SECTION_NAME (section
), section
->sh_info
);
6439 printf (_(" Addr: 0x"));
6440 printf_vma (section
->sh_addr
);
6441 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6442 (unsigned long) section
->sh_offset
, section
->sh_link
,
6443 section
->sh_link
< elf_header
.e_shnum
6444 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6447 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6449 _("version definition section"));
6450 endbuf
= (char *) edefs
+ section
->sh_size
;
6454 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6457 Elf_External_Verdef
* edef
;
6458 Elf_Internal_Verdef ent
;
6459 Elf_External_Verdaux
* eaux
;
6460 Elf_Internal_Verdaux aux
;
6464 vstart
= ((char *) edefs
) + idx
;
6465 if (vstart
+ sizeof (*edef
) > endbuf
)
6468 edef
= (Elf_External_Verdef
*) vstart
;
6470 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6471 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6472 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6473 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6474 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6475 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6476 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6478 printf (_(" %#06x: Rev: %d Flags: %s"),
6479 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6481 printf (_(" Index: %d Cnt: %d "),
6482 ent
.vd_ndx
, ent
.vd_cnt
);
6484 vstart
+= ent
.vd_aux
;
6486 eaux
= (Elf_External_Verdaux
*) vstart
;
6488 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6489 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6491 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6492 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6494 printf (_("Name index: %ld\n"), aux
.vda_name
);
6496 isum
= idx
+ ent
.vd_aux
;
6498 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6500 isum
+= aux
.vda_next
;
6501 vstart
+= aux
.vda_next
;
6503 eaux
= (Elf_External_Verdaux
*) vstart
;
6504 if (vstart
+ sizeof (*eaux
) > endbuf
)
6507 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6508 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6510 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6511 printf (_(" %#06x: Parent %d: %s\n"),
6512 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6514 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6515 isum
, j
, aux
.vda_name
);
6518 printf (_(" Version def aux past end of section\n"));
6522 if (cnt
< section
->sh_info
)
6523 printf (_(" Version definition past end of section\n"));
6529 case SHT_GNU_verneed
:
6531 Elf_External_Verneed
* eneed
;
6538 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6539 SECTION_NAME (section
), section
->sh_info
);
6541 printf (_(" Addr: 0x"));
6542 printf_vma (section
->sh_addr
);
6543 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6544 (unsigned long) section
->sh_offset
, section
->sh_link
,
6545 section
->sh_link
< elf_header
.e_shnum
6546 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6549 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6551 _("version need section"));
6552 endbuf
= (char *) eneed
+ section
->sh_size
;
6556 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6558 Elf_External_Verneed
* entry
;
6559 Elf_Internal_Verneed ent
;
6564 vstart
= ((char *) eneed
) + idx
;
6565 if (vstart
+ sizeof (*entry
) > endbuf
)
6568 entry
= (Elf_External_Verneed
*) vstart
;
6570 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6571 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6572 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6573 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6574 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6576 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6578 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6579 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6581 printf (_(" File: %lx"), ent
.vn_file
);
6583 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6585 vstart
+= ent
.vn_aux
;
6587 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6589 Elf_External_Vernaux
* eaux
;
6590 Elf_Internal_Vernaux aux
;
6592 if (vstart
+ sizeof (*eaux
) > endbuf
)
6594 eaux
= (Elf_External_Vernaux
*) vstart
;
6596 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6597 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6598 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6599 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6600 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6602 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6603 printf (_(" %#06x: Name: %s"),
6604 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6606 printf (_(" %#06x: Name index: %lx"),
6607 isum
, aux
.vna_name
);
6609 printf (_(" Flags: %s Version: %d\n"),
6610 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6612 isum
+= aux
.vna_next
;
6613 vstart
+= aux
.vna_next
;
6616 printf (_(" Version need aux past end of section\n"));
6620 if (cnt
< section
->sh_info
)
6621 printf (_(" Version need past end of section\n"));
6627 case SHT_GNU_versym
:
6629 Elf_Internal_Shdr
* link_section
;
6632 unsigned char * edata
;
6633 unsigned short * data
;
6635 Elf_Internal_Sym
* symbols
;
6636 Elf_Internal_Shdr
* string_sec
;
6639 if (section
->sh_link
>= elf_header
.e_shnum
)
6642 link_section
= section_headers
+ section
->sh_link
;
6643 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6645 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6650 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6652 string_sec
= section_headers
+ link_section
->sh_link
;
6654 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6655 string_sec
->sh_size
, _("version string table"));
6659 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6660 SECTION_NAME (section
), total
);
6662 printf (_(" Addr: "));
6663 printf_vma (section
->sh_addr
);
6664 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6665 (unsigned long) section
->sh_offset
, section
->sh_link
,
6666 SECTION_NAME (link_section
));
6668 off
= offset_from_vma (file
,
6669 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6670 total
* sizeof (short));
6671 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6672 _("version symbol data"));
6679 data
= cmalloc (total
, sizeof (short));
6681 for (cnt
= total
; cnt
--;)
6682 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6687 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6690 int check_def
, check_need
;
6693 printf (" %03x:", cnt
);
6695 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6696 switch (data
[cnt
+ j
])
6699 fputs (_(" 0 (*local*) "), stdout
);
6703 fputs (_(" 1 (*global*) "), stdout
);
6707 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6708 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6712 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6713 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6716 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6723 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6725 Elf_Internal_Verneed ivn
;
6726 unsigned long offset
;
6728 offset
= offset_from_vma
6729 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6730 sizeof (Elf_External_Verneed
));
6734 Elf_Internal_Vernaux ivna
;
6735 Elf_External_Verneed evn
;
6736 Elf_External_Vernaux evna
;
6737 unsigned long a_off
;
6739 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6742 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6743 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6745 a_off
= offset
+ ivn
.vn_aux
;
6749 get_data (&evna
, file
, a_off
, sizeof (evna
),
6750 1, _("version need aux (2)"));
6752 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6753 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6755 a_off
+= ivna
.vna_next
;
6757 while (ivna
.vna_other
!= data
[cnt
+ j
]
6758 && ivna
.vna_next
!= 0);
6760 if (ivna
.vna_other
== data
[cnt
+ j
])
6762 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6764 if (ivna
.vna_name
>= string_sec
->sh_size
)
6765 name
= _("*invalid*");
6767 name
= strtab
+ ivna
.vna_name
;
6768 nn
+= printf ("(%s%-*s",
6770 12 - (int) strlen (name
),
6776 offset
+= ivn
.vn_next
;
6778 while (ivn
.vn_next
);
6781 if (check_def
&& data
[cnt
+ j
] != 0x8001
6782 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6784 Elf_Internal_Verdef ivd
;
6785 Elf_External_Verdef evd
;
6786 unsigned long offset
;
6788 offset
= offset_from_vma
6789 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6794 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6797 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6798 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6800 offset
+= ivd
.vd_next
;
6802 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6803 && ivd
.vd_next
!= 0);
6805 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6807 Elf_External_Verdaux evda
;
6808 Elf_Internal_Verdaux ivda
;
6810 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6812 get_data (&evda
, file
,
6813 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6815 _("version def aux"));
6817 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6819 if (ivda
.vda_name
>= string_sec
->sh_size
)
6820 name
= _("*invalid*");
6822 name
= strtab
+ ivda
.vda_name
;
6823 nn
+= printf ("(%s%-*s",
6825 12 - (int) strlen (name
),
6831 printf ("%*c", 18 - nn
, ' ');
6849 printf (_("\nNo version information found in this file.\n"));
6855 get_symbol_binding (unsigned int binding
)
6857 static char buff
[32];
6861 case STB_LOCAL
: return "LOCAL";
6862 case STB_GLOBAL
: return "GLOBAL";
6863 case STB_WEAK
: return "WEAK";
6865 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6866 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6868 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6869 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6871 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6877 get_symbol_type (unsigned int type
)
6879 static char buff
[32];
6883 case STT_NOTYPE
: return "NOTYPE";
6884 case STT_OBJECT
: return "OBJECT";
6885 case STT_FUNC
: return "FUNC";
6886 case STT_SECTION
: return "SECTION";
6887 case STT_FILE
: return "FILE";
6888 case STT_COMMON
: return "COMMON";
6889 case STT_TLS
: return "TLS";
6890 case STT_RELC
: return "RELC";
6891 case STT_SRELC
: return "SRELC";
6893 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6895 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6896 return "THUMB_FUNC";
6898 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6901 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6902 return "PARISC_MILLI";
6904 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6906 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6908 if (elf_header
.e_machine
== EM_PARISC
)
6910 if (type
== STT_HP_OPAQUE
)
6912 if (type
== STT_HP_STUB
)
6916 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6919 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6925 get_symbol_visibility (unsigned int visibility
)
6929 case STV_DEFAULT
: return "DEFAULT";
6930 case STV_INTERNAL
: return "INTERNAL";
6931 case STV_HIDDEN
: return "HIDDEN";
6932 case STV_PROTECTED
: return "PROTECTED";
6938 get_mips_symbol_other (unsigned int other
)
6942 case STO_OPTIONAL
: return "OPTIONAL";
6943 case STO_MIPS16
: return "MIPS16";
6944 case STO_MIPS_PLT
: return "MIPS PLT";
6945 case STO_MIPS_PIC
: return "MIPS PIC";
6946 default: return NULL
;
6951 get_symbol_other (unsigned int other
)
6953 const char * result
= NULL
;
6954 static char buff
[32];
6959 switch (elf_header
.e_machine
)
6962 result
= get_mips_symbol_other (other
);
6970 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6975 get_symbol_index_type (unsigned int type
)
6977 static char buff
[32];
6981 case SHN_UNDEF
: return "UND";
6982 case SHN_ABS
: return "ABS";
6983 case SHN_COMMON
: return "COM";
6985 if (type
== SHN_IA_64_ANSI_COMMON
6986 && elf_header
.e_machine
== EM_IA_64
6987 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6989 else if (elf_header
.e_machine
== EM_X86_64
6990 && type
== SHN_X86_64_LCOMMON
)
6992 else if (type
== SHN_MIPS_SCOMMON
6993 && elf_header
.e_machine
== EM_MIPS
)
6995 else if (type
== SHN_MIPS_SUNDEFINED
6996 && elf_header
.e_machine
== EM_MIPS
)
6998 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6999 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7000 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7001 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7002 else if (type
>= SHN_LORESERVE
)
7003 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7005 sprintf (buff
, "%3d", type
);
7013 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7015 unsigned char * e_data
;
7018 e_data
= cmalloc (number
, ent_size
);
7022 error (_("Out of memory\n"));
7026 if (fread (e_data
, ent_size
, number
, file
) != number
)
7028 error (_("Unable to read in dynamic data\n"));
7032 i_data
= cmalloc (number
, sizeof (*i_data
));
7036 error (_("Out of memory\n"));
7042 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7050 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7052 Elf_Internal_Sym
* psym
;
7055 psym
= dynamic_symbols
+ si
;
7057 n
= print_vma (si
, DEC_5
);
7059 fputs (" " + n
, stdout
);
7060 printf (" %3lu: ", hn
);
7061 print_vma (psym
->st_value
, LONG_HEX
);
7063 print_vma (psym
->st_size
, DEC_5
);
7065 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7066 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7067 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7068 /* Check to see if any other bits in the st_other field are set.
7069 Note - displaying this information disrupts the layout of the
7070 table being generated, but for the moment this case is very
7072 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7073 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7074 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7075 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7076 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7078 printf (" <corrupt: %14ld>", psym
->st_name
);
7082 /* Dump the symbol table. */
7084 process_symbol_table (FILE * file
)
7086 Elf_Internal_Shdr
* section
;
7087 bfd_vma nbuckets
= 0;
7088 bfd_vma nchains
= 0;
7089 bfd_vma
* buckets
= NULL
;
7090 bfd_vma
* chains
= NULL
;
7091 bfd_vma ngnubuckets
= 0;
7092 bfd_vma
* gnubuckets
= NULL
;
7093 bfd_vma
* gnuchains
= NULL
;
7094 bfd_vma gnusymidx
= 0;
7096 if (! do_syms
&& !do_histogram
)
7099 if (dynamic_info
[DT_HASH
]
7101 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7103 unsigned char nb
[8];
7104 unsigned char nc
[8];
7105 int hash_ent_size
= 4;
7107 if ((elf_header
.e_machine
== EM_ALPHA
7108 || elf_header
.e_machine
== EM_S390
7109 || elf_header
.e_machine
== EM_S390_OLD
)
7110 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7114 (archive_file_offset
7115 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7116 sizeof nb
+ sizeof nc
)),
7119 error (_("Unable to seek to start of dynamic information\n"));
7123 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7125 error (_("Failed to read in number of buckets\n"));
7129 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7131 error (_("Failed to read in number of chains\n"));
7135 nbuckets
= byte_get (nb
, hash_ent_size
);
7136 nchains
= byte_get (nc
, hash_ent_size
);
7138 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7139 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7141 if (buckets
== NULL
|| chains
== NULL
)
7145 if (dynamic_info_DT_GNU_HASH
7147 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7149 unsigned char nb
[16];
7150 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7151 bfd_vma buckets_vma
;
7154 (archive_file_offset
7155 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7159 error (_("Unable to seek to start of dynamic information\n"));
7163 if (fread (nb
, 16, 1, file
) != 1)
7165 error (_("Failed to read in number of buckets\n"));
7169 ngnubuckets
= byte_get (nb
, 4);
7170 gnusymidx
= byte_get (nb
+ 4, 4);
7171 bitmaskwords
= byte_get (nb
+ 8, 4);
7172 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7174 buckets_vma
+= bitmaskwords
* 4;
7176 buckets_vma
+= bitmaskwords
* 8;
7179 (archive_file_offset
7180 + offset_from_vma (file
, buckets_vma
, 4)),
7183 error (_("Unable to seek to start of dynamic information\n"));
7187 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7189 if (gnubuckets
== NULL
)
7192 for (i
= 0; i
< ngnubuckets
; i
++)
7193 if (gnubuckets
[i
] != 0)
7195 if (gnubuckets
[i
] < gnusymidx
)
7198 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7199 maxchain
= gnubuckets
[i
];
7202 if (maxchain
== 0xffffffff)
7205 maxchain
-= gnusymidx
;
7208 (archive_file_offset
7209 + offset_from_vma (file
, buckets_vma
7210 + 4 * (ngnubuckets
+ maxchain
), 4)),
7213 error (_("Unable to seek to start of dynamic information\n"));
7219 if (fread (nb
, 4, 1, file
) != 1)
7221 error (_("Failed to determine last chain length\n"));
7225 if (maxchain
+ 1 == 0)
7230 while ((byte_get (nb
, 4) & 1) == 0);
7233 (archive_file_offset
7234 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7237 error (_("Unable to seek to start of dynamic information\n"));
7241 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7243 if (gnuchains
== NULL
)
7247 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7250 && dynamic_strings
!= NULL
)
7254 if (dynamic_info
[DT_HASH
])
7258 printf (_("\nSymbol table for image:\n"));
7260 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7262 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7264 for (hn
= 0; hn
< nbuckets
; hn
++)
7269 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7270 print_dynamic_symbol (si
, hn
);
7274 if (dynamic_info_DT_GNU_HASH
)
7276 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7278 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7280 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7282 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7283 if (gnubuckets
[hn
] != 0)
7285 bfd_vma si
= gnubuckets
[hn
];
7286 bfd_vma off
= si
- gnusymidx
;
7290 print_dynamic_symbol (si
, hn
);
7293 while ((gnuchains
[off
++] & 1) == 0);
7297 else if (do_syms
&& !do_using_dynamic
)
7301 for (i
= 0, section
= section_headers
;
7302 i
< elf_header
.e_shnum
;
7306 char * strtab
= NULL
;
7307 unsigned long int strtab_size
= 0;
7308 Elf_Internal_Sym
* symtab
;
7309 Elf_Internal_Sym
* psym
;
7311 if ( section
->sh_type
!= SHT_SYMTAB
7312 && section
->sh_type
!= SHT_DYNSYM
)
7315 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7316 SECTION_NAME (section
),
7317 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7319 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7321 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7323 symtab
= GET_ELF_SYMBOLS (file
, section
);
7327 if (section
->sh_link
== elf_header
.e_shstrndx
)
7329 strtab
= string_table
;
7330 strtab_size
= string_table_length
;
7332 else if (section
->sh_link
< elf_header
.e_shnum
)
7334 Elf_Internal_Shdr
* string_sec
;
7336 string_sec
= section_headers
+ section
->sh_link
;
7338 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7339 1, string_sec
->sh_size
, _("string table"));
7340 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7343 for (si
= 0, psym
= symtab
;
7344 si
< section
->sh_size
/ section
->sh_entsize
;
7347 printf ("%6d: ", si
);
7348 print_vma (psym
->st_value
, LONG_HEX
);
7350 print_vma (psym
->st_size
, DEC_5
);
7351 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7352 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7353 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7354 /* Check to see if any other bits in the st_other field are set.
7355 Note - displaying this information disrupts the layout of the
7356 table being generated, but for the moment this case is very rare. */
7357 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7358 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7359 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7360 print_symbol (25, psym
->st_name
< strtab_size
7361 ? strtab
+ psym
->st_name
: "<corrupt>");
7363 if (section
->sh_type
== SHT_DYNSYM
&&
7364 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7366 unsigned char data
[2];
7367 unsigned short vers_data
;
7368 unsigned long offset
;
7372 offset
= offset_from_vma
7373 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7374 sizeof data
+ si
* sizeof (vers_data
));
7376 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7377 sizeof (data
), 1, _("version data"));
7379 vers_data
= byte_get (data
, 2);
7381 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7382 && section_headers
[psym
->st_shndx
].sh_type
7385 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7387 if ((vers_data
& 0x8000) || vers_data
> 1)
7389 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7390 && (is_nobits
|| ! check_def
))
7392 Elf_External_Verneed evn
;
7393 Elf_Internal_Verneed ivn
;
7394 Elf_Internal_Vernaux ivna
;
7396 /* We must test both. */
7397 offset
= offset_from_vma
7398 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7403 unsigned long vna_off
;
7405 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7408 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7409 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7411 vna_off
= offset
+ ivn
.vn_aux
;
7415 Elf_External_Vernaux evna
;
7417 get_data (&evna
, file
, vna_off
,
7419 _("version need aux (3)"));
7421 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7422 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7423 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7425 vna_off
+= ivna
.vna_next
;
7427 while (ivna
.vna_other
!= vers_data
7428 && ivna
.vna_next
!= 0);
7430 if (ivna
.vna_other
== vers_data
)
7433 offset
+= ivn
.vn_next
;
7435 while (ivn
.vn_next
!= 0);
7437 if (ivna
.vna_other
== vers_data
)
7440 ivna
.vna_name
< strtab_size
7441 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7445 else if (! is_nobits
)
7446 error (_("bad dynamic symbol\n"));
7453 if (vers_data
!= 0x8001
7454 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7456 Elf_Internal_Verdef ivd
;
7457 Elf_Internal_Verdaux ivda
;
7458 Elf_External_Verdaux evda
;
7459 unsigned long offset
;
7461 offset
= offset_from_vma
7463 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7464 sizeof (Elf_External_Verdef
));
7468 Elf_External_Verdef evd
;
7470 get_data (&evd
, file
, offset
, sizeof (evd
),
7471 1, _("version def"));
7473 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7474 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7475 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7477 offset
+= ivd
.vd_next
;
7479 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7480 && ivd
.vd_next
!= 0);
7482 offset
-= ivd
.vd_next
;
7483 offset
+= ivd
.vd_aux
;
7485 get_data (&evda
, file
, offset
, sizeof (evda
),
7486 1, _("version def aux"));
7488 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7490 if (psym
->st_name
!= ivda
.vda_name
)
7491 printf ((vers_data
& 0x8000)
7493 ivda
.vda_name
< strtab_size
7494 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7504 if (strtab
!= string_table
)
7510 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7512 if (do_histogram
&& buckets
!= NULL
)
7514 unsigned long * lengths
;
7515 unsigned long * counts
;
7518 unsigned long maxlength
= 0;
7519 unsigned long nzero_counts
= 0;
7520 unsigned long nsyms
= 0;
7522 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7523 (unsigned long) nbuckets
);
7524 printf (_(" Length Number %% of total Coverage\n"));
7526 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7527 if (lengths
== NULL
)
7529 error (_("Out of memory\n"));
7532 for (hn
= 0; hn
< nbuckets
; ++hn
)
7534 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7537 if (maxlength
< ++lengths
[hn
])
7542 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7545 error (_("Out of memory\n"));
7549 for (hn
= 0; hn
< nbuckets
; ++hn
)
7550 ++counts
[lengths
[hn
]];
7555 printf (" 0 %-10lu (%5.1f%%)\n",
7556 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7557 for (i
= 1; i
<= maxlength
; ++i
)
7559 nzero_counts
+= counts
[i
] * i
;
7560 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7561 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7562 (nzero_counts
* 100.0) / nsyms
);
7570 if (buckets
!= NULL
)
7576 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7578 unsigned long * lengths
;
7579 unsigned long * counts
;
7581 unsigned long maxlength
= 0;
7582 unsigned long nzero_counts
= 0;
7583 unsigned long nsyms
= 0;
7585 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7586 if (lengths
== NULL
)
7588 error (_("Out of memory\n"));
7592 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7593 (unsigned long) ngnubuckets
);
7594 printf (_(" Length Number %% of total Coverage\n"));
7596 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7597 if (gnubuckets
[hn
] != 0)
7599 bfd_vma off
, length
= 1;
7601 for (off
= gnubuckets
[hn
] - gnusymidx
;
7602 (gnuchains
[off
] & 1) == 0; ++off
)
7604 lengths
[hn
] = length
;
7605 if (length
> maxlength
)
7610 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7613 error (_("Out of memory\n"));
7617 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7618 ++counts
[lengths
[hn
]];
7620 if (ngnubuckets
> 0)
7623 printf (" 0 %-10lu (%5.1f%%)\n",
7624 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7625 for (j
= 1; j
<= maxlength
; ++j
)
7627 nzero_counts
+= counts
[j
] * j
;
7628 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7629 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7630 (nzero_counts
* 100.0) / nsyms
);
7644 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7648 if (dynamic_syminfo
== NULL
7650 /* No syminfo, this is ok. */
7653 /* There better should be a dynamic symbol section. */
7654 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7658 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7659 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7661 printf (_(" Num: Name BoundTo Flags\n"));
7662 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7664 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7666 printf ("%4d: ", i
);
7667 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7668 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7670 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7673 switch (dynamic_syminfo
[i
].si_boundto
)
7675 case SYMINFO_BT_SELF
:
7676 fputs ("SELF ", stdout
);
7678 case SYMINFO_BT_PARENT
:
7679 fputs ("PARENT ", stdout
);
7682 if (dynamic_syminfo
[i
].si_boundto
> 0
7683 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7684 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7686 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7690 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7694 if (flags
& SYMINFO_FLG_DIRECT
)
7696 if (flags
& SYMINFO_FLG_PASSTHRU
)
7697 printf (" PASSTHRU");
7698 if (flags
& SYMINFO_FLG_COPY
)
7700 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7701 printf (" LAZYLOAD");
7709 #ifdef SUPPORT_DISASSEMBLY
7711 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
7713 printf (_("\nAssembly dump of section %s\n"),
7714 SECTION_NAME (section
));
7716 /* XXX -- to be done --- XXX */
7723 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
7725 Elf_Internal_Shdr
* relsec
;
7726 bfd_size_type num_bytes
;
7731 char * name
= SECTION_NAME (section
);
7732 bfd_boolean some_strings_shown
;
7734 num_bytes
= section
->sh_size
;
7736 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7738 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7742 addr
= section
->sh_addr
;
7744 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7749 printf (_("\nString dump of section '%s':\n"), name
);
7751 /* If the section being dumped has relocations against it the user might
7752 be expecting these relocations to have been applied. Check for this
7753 case and issue a warning message in order to avoid confusion.
7754 FIXME: Maybe we ought to have an option that dumps a section with
7756 for (relsec
= section_headers
;
7757 relsec
< section_headers
+ elf_header
.e_shnum
;
7760 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7761 || relsec
->sh_info
>= elf_header
.e_shnum
7762 || section_headers
+ relsec
->sh_info
!= section
7763 || relsec
->sh_size
== 0
7764 || relsec
->sh_link
>= elf_header
.e_shnum
)
7767 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7772 end
= start
+ num_bytes
;
7773 some_strings_shown
= FALSE
;
7777 while (!ISPRINT (* data
))
7784 printf (" [%6tx] %s\n", data
- start
, data
);
7786 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7788 data
+= strlen (data
);
7789 some_strings_shown
= TRUE
;
7793 if (! some_strings_shown
)
7794 printf (_(" No strings found in this section."));
7804 dump_section_as_bytes (Elf_Internal_Shdr
* section
, FILE * file
)
7806 Elf_Internal_Shdr
* relsec
;
7807 bfd_size_type bytes
;
7809 unsigned char * data
;
7810 unsigned char * start
;
7812 bytes
= section
->sh_size
;
7814 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7816 printf (_("\nSection '%s' has no data to dump.\n"),
7817 SECTION_NAME (section
));
7821 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7823 addr
= section
->sh_addr
;
7825 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7830 /* If the section being dumped has relocations against it the user might
7831 be expecting these relocations to have been applied. Check for this
7832 case and issue a warning message in order to avoid confusion.
7833 FIXME: Maybe we ought to have an option that dumps a section with
7835 for (relsec
= section_headers
;
7836 relsec
< section_headers
+ elf_header
.e_shnum
;
7839 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7840 || relsec
->sh_info
>= elf_header
.e_shnum
7841 || section_headers
+ relsec
->sh_info
!= section
7842 || relsec
->sh_size
== 0
7843 || relsec
->sh_link
>= elf_header
.e_shnum
)
7846 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7858 lbytes
= (bytes
> 16 ? 16 : bytes
);
7860 printf (" 0x%8.8lx ", (unsigned long) addr
);
7862 for (j
= 0; j
< 16; j
++)
7865 printf ("%2.2x", data
[j
]);
7873 for (j
= 0; j
< lbytes
; j
++)
7876 if (k
>= ' ' && k
< 0x7f)
7895 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7896 DWARF debug sections. This is a target specific test. Note - we do not
7897 go through the whole including-target-headers-multiple-times route, (as
7898 we have already done with <elf/h8.h>) because this would become very
7899 messy and even then this function would have to contain target specific
7900 information (the names of the relocs instead of their numeric values).
7901 FIXME: This is not the correct way to solve this problem. The proper way
7902 is to have target specific reloc sizing and typing functions created by
7903 the reloc-macros.h header, in the same way that it already creates the
7904 reloc naming functions. */
7907 is_32bit_abs_reloc (unsigned int reloc_type
)
7909 switch (elf_header
.e_machine
)
7913 return reloc_type
== 1; /* R_386_32. */
7915 return reloc_type
== 1; /* R_68K_32. */
7917 return reloc_type
== 1; /* R_860_32. */
7919 return reloc_type
== 1; /* XXX Is this right ? */
7921 return reloc_type
== 1; /* R_ARC_32. */
7923 return reloc_type
== 2; /* R_ARM_ABS32 */
7926 return reloc_type
== 1;
7928 return reloc_type
== 0x12; /* R_byte4_data. */
7930 return reloc_type
== 3; /* R_CRIS_32. */
7933 return reloc_type
== 3; /* R_CR16_NUM32. */
7935 return reloc_type
== 15; /* R_CRX_NUM32. */
7937 return reloc_type
== 1;
7938 case EM_CYGNUS_D10V
:
7940 return reloc_type
== 6; /* R_D10V_32. */
7941 case EM_CYGNUS_D30V
:
7943 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7945 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7946 case EM_CYGNUS_FR30
:
7948 return reloc_type
== 3; /* R_FR30_32. */
7952 return reloc_type
== 1; /* R_H8_DIR32. */
7954 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
7957 return reloc_type
== 2; /* R_IP2K_32. */
7959 return reloc_type
== 2; /* R_IQ2000_32. */
7960 case EM_LATTICEMICO32
:
7961 return reloc_type
== 3; /* R_LM32_32. */
7964 return reloc_type
== 3; /* R_M32C_32. */
7966 return reloc_type
== 34; /* R_M32R_32_RELA. */
7968 return reloc_type
== 1; /* R_MCORE_ADDR32. */
7970 return reloc_type
== 4; /* R_MEP_32. */
7972 return reloc_type
== 2; /* R_MIPS_32. */
7974 return reloc_type
== 4; /* R_MMIX_32. */
7975 case EM_CYGNUS_MN10200
:
7977 return reloc_type
== 1; /* R_MN10200_32. */
7978 case EM_CYGNUS_MN10300
:
7980 return reloc_type
== 1; /* R_MN10300_32. */
7983 return reloc_type
== 1; /* R_MSP43_32. */
7985 return reloc_type
== 2; /* R_MT_32. */
7986 case EM_ALTERA_NIOS2
:
7988 return reloc_type
== 1; /* R_NIOS_32. */
7991 return reloc_type
== 1; /* R_OR32_32. */
7993 return reloc_type
== 1; /* R_PARISC_DIR32. */
7996 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
7998 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8000 return reloc_type
== 1; /* R_PPC_ADDR32. */
8002 return reloc_type
== 1; /* R_I370_ADDR31. */
8005 return reloc_type
== 4; /* R_S390_32. */
8007 return reloc_type
== 8; /* R_SCORE_ABS32. */
8009 return reloc_type
== 1; /* R_SH_DIR32. */
8010 case EM_SPARC32PLUS
:
8013 return reloc_type
== 3 /* R_SPARC_32. */
8014 || reloc_type
== 23; /* R_SPARC_UA32. */
8016 return reloc_type
== 6; /* R_SPU_ADDR32 */
8017 case EM_CYGNUS_V850
:
8019 return reloc_type
== 6; /* R_V850_ABS32. */
8021 return reloc_type
== 1; /* R_VAX_32. */
8023 return reloc_type
== 10; /* R_X86_64_32. */
8025 return reloc_type
== 1; /* R_XSTROMY16_32. */
8028 return reloc_type
== 1; /* R_XTENSA_32. */
8031 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8032 elf_header
.e_machine
);
8037 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8038 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8041 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8043 switch (elf_header
.e_machine
)
8047 return reloc_type
== 2; /* R_386_PC32. */
8049 return reloc_type
== 4; /* R_68K_PC32. */
8051 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8053 return reloc_type
== 3; /* R_ARM_REL32 */
8055 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8057 return reloc_type
== 26; /* R_PPC_REL32. */
8059 return reloc_type
== 26; /* R_PPC64_REL32. */
8062 return reloc_type
== 5; /* R_390_PC32. */
8064 return reloc_type
== 2; /* R_SH_REL32. */
8065 case EM_SPARC32PLUS
:
8068 return reloc_type
== 6; /* R_SPARC_DISP32. */
8070 return reloc_type
== 13; /* R_SPU_REL32. */
8072 return reloc_type
== 2; /* R_X86_64_PC32. */
8075 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8077 /* Do not abort or issue an error message here. Not all targets use
8078 pc-relative 32-bit relocs in their DWARF debug information and we
8079 have already tested for target coverage in is_32bit_abs_reloc. A
8080 more helpful warning message will be generated by
8081 debug_apply_relocations anyway, so just return. */
8086 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8087 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8090 is_64bit_abs_reloc (unsigned int reloc_type
)
8092 switch (elf_header
.e_machine
)
8095 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8097 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8099 return reloc_type
== 80; /* R_PARISC_DIR64. */
8101 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8102 case EM_SPARC32PLUS
:
8105 return reloc_type
== 54; /* R_SPARC_UA64. */
8107 return reloc_type
== 1; /* R_X86_64_64. */
8110 return reloc_type
== 22; /* R_S390_64 */
8112 return reloc_type
== 18; /* R_MIPS_64 */
8118 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8119 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8122 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8124 switch (elf_header
.e_machine
)
8127 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8129 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8131 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8133 return reloc_type
== 44; /* R_PPC64_REL64 */
8134 case EM_SPARC32PLUS
:
8137 return reloc_type
== 46; /* R_SPARC_DISP64 */
8139 return reloc_type
== 24; /* R_X86_64_PC64 */
8142 return reloc_type
== 23; /* R_S390_PC64 */
8148 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8149 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8152 is_16bit_abs_reloc (unsigned int reloc_type
)
8154 switch (elf_header
.e_machine
)
8158 return reloc_type
== 4; /* R_AVR_16. */
8159 case EM_CYGNUS_D10V
:
8161 return reloc_type
== 3; /* R_D10V_16. */
8165 return reloc_type
== R_H8_DIR16
;
8168 return reloc_type
== 1; /* R_IP2K_16. */
8171 return reloc_type
== 1; /* R_M32C_16 */
8174 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8175 case EM_ALTERA_NIOS2
:
8177 return reloc_type
== 9; /* R_NIOS_16. */
8183 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8184 relocation entries (possibly formerly used for SHT_GROUP sections). */
8187 is_none_reloc (unsigned int reloc_type
)
8189 switch (elf_header
.e_machine
)
8191 case EM_68K
: /* R_68K_NONE. */
8192 case EM_386
: /* R_386_NONE. */
8193 case EM_SPARC32PLUS
:
8195 case EM_SPARC
: /* R_SPARC_NONE. */
8196 case EM_MIPS
: /* R_MIPS_NONE. */
8197 case EM_PARISC
: /* R_PARISC_NONE. */
8198 case EM_ALPHA
: /* R_ALPHA_NONE. */
8199 case EM_PPC
: /* R_PPC_NONE. */
8200 case EM_PPC64
: /* R_PPC64_NONE. */
8201 case EM_ARM
: /* R_ARM_NONE. */
8202 case EM_IA_64
: /* R_IA64_NONE. */
8203 case EM_SH
: /* R_SH_NONE. */
8205 case EM_S390
: /* R_390_NONE. */
8206 case EM_CRIS
: /* R_CRIS_NONE. */
8207 case EM_X86_64
: /* R_X86_64_NONE. */
8208 case EM_MN10300
: /* R_MN10300_NONE. */
8209 case EM_M32R
: /* R_M32R_NONE. */
8210 return reloc_type
== 0;
8215 /* Uncompresses a section that was compressed using zlib, in place.
8216 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8219 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8222 /* These are just to quiet gcc. */
8227 dwarf_size_type compressed_size
= *size
;
8228 unsigned char * compressed_buffer
= *buffer
;
8229 dwarf_size_type uncompressed_size
;
8230 unsigned char * uncompressed_buffer
;
8233 dwarf_size_type header_size
= 12;
8235 /* Read the zlib header. In this case, it should be "ZLIB" followed
8236 by the uncompressed section size, 8 bytes in big-endian order. */
8237 if (compressed_size
< header_size
8238 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8241 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8242 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8243 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8244 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8245 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8246 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8247 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8248 uncompressed_size
+= compressed_buffer
[11];
8250 /* It is possible the section consists of several compressed
8251 buffers concatenated together, so we uncompress in a loop. */
8255 strm
.avail_in
= compressed_size
- header_size
;
8256 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8257 strm
.avail_out
= uncompressed_size
;
8258 uncompressed_buffer
= xmalloc (uncompressed_size
);
8260 rc
= inflateInit (& strm
);
8261 while (strm
.avail_in
> 0)
8265 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8266 + (uncompressed_size
- strm
.avail_out
));
8267 rc
= inflate (&strm
, Z_FINISH
);
8268 if (rc
!= Z_STREAM_END
)
8270 rc
= inflateReset (& strm
);
8272 rc
= inflateEnd (& strm
);
8274 || strm
.avail_out
!= 0)
8277 free (compressed_buffer
);
8278 *buffer
= uncompressed_buffer
;
8279 *size
= uncompressed_size
;
8283 free (uncompressed_buffer
);
8285 #endif /* HAVE_ZLIB_H */
8288 /* Apply relocations to a debug section. */
8291 debug_apply_relocations (void * file
,
8292 Elf_Internal_Shdr
* section
,
8293 unsigned char * start
)
8295 Elf_Internal_Shdr
* relsec
;
8296 unsigned char * end
= start
+ section
->sh_size
;
8298 if (elf_header
.e_type
!= ET_REL
)
8301 /* Find the reloc section associated with the debug section. */
8302 for (relsec
= section_headers
;
8303 relsec
< section_headers
+ elf_header
.e_shnum
;
8306 bfd_boolean is_rela
;
8307 unsigned long num_relocs
;
8308 Elf_Internal_Rela
* relocs
;
8309 Elf_Internal_Rela
* rp
;
8310 Elf_Internal_Shdr
* symsec
;
8311 Elf_Internal_Sym
* symtab
;
8312 Elf_Internal_Sym
* sym
;
8314 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8315 || relsec
->sh_info
>= elf_header
.e_shnum
8316 || section_headers
+ relsec
->sh_info
!= section
8317 || relsec
->sh_size
== 0
8318 || relsec
->sh_link
>= elf_header
.e_shnum
)
8321 is_rela
= relsec
->sh_type
== SHT_RELA
;
8325 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8326 & relocs
, & num_relocs
))
8331 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8332 & relocs
, & num_relocs
))
8336 /* SH uses RELA but uses in place value instead of the addend field. */
8337 if (elf_header
.e_machine
== EM_SH
)
8340 symsec
= section_headers
+ relsec
->sh_link
;
8341 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8343 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8346 unsigned int reloc_type
;
8347 unsigned int reloc_size
;
8348 unsigned char * loc
;
8350 reloc_type
= get_reloc_type (rp
->r_info
);
8352 if (is_none_reloc (reloc_type
))
8355 if (is_32bit_abs_reloc (reloc_type
)
8356 || is_32bit_pcrel_reloc (reloc_type
))
8358 else if (is_64bit_abs_reloc (reloc_type
)
8359 || is_64bit_pcrel_reloc (reloc_type
))
8361 else if (is_16bit_abs_reloc (reloc_type
))
8365 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8366 reloc_type
, SECTION_NAME (section
));
8370 loc
= start
+ rp
->r_offset
;
8371 if ((loc
+ reloc_size
) > end
)
8373 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8374 (unsigned long) rp
->r_offset
,
8375 SECTION_NAME (section
));
8379 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8381 /* If the reloc has a symbol associated with it,
8382 make sure that it is of an appropriate type.
8384 Relocations against symbols without type can happen.
8385 Gcc -feliminate-dwarf2-dups may generate symbols
8386 without type for debug info.
8388 Icc generates relocations against function symbols
8389 instead of local labels.
8391 Relocations against object symbols can happen, eg when
8392 referencing a global array. For an example of this see
8393 the _clz.o binary in libgcc.a. */
8395 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8397 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8398 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8399 (long int)(rp
- relocs
),
8400 SECTION_NAME (relsec
));
8404 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8406 if (is_32bit_pcrel_reloc (reloc_type
)
8407 || is_64bit_pcrel_reloc (reloc_type
))
8409 /* On HPPA, all pc-relative relocations are biased by 8. */
8410 if (elf_header
.e_machine
== EM_PARISC
)
8412 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8416 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8426 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8427 Elf_Internal_Shdr
* sec
, void * file
)
8429 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8431 int section_is_compressed
;
8433 /* If it is already loaded, do nothing. */
8434 if (section
->start
!= NULL
)
8437 section_is_compressed
= section
->name
== section
->compressed_name
;
8439 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8440 section
->address
= sec
->sh_addr
;
8441 section
->size
= sec
->sh_size
;
8442 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8444 if (section
->start
== NULL
)
8447 if (section_is_compressed
)
8448 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8451 if (debug_displays
[debug
].relocate
)
8452 debug_apply_relocations (file
, sec
, section
->start
);
8458 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8460 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8461 Elf_Internal_Shdr
* sec
;
8463 /* Locate the debug section. */
8464 sec
= find_section (section
->uncompressed_name
);
8466 section
->name
= section
->uncompressed_name
;
8469 sec
= find_section (section
->compressed_name
);
8471 section
->name
= section
->compressed_name
;
8476 return load_specific_debug_section (debug
, sec
, file
);
8480 free_debug_section (enum dwarf_section_display_enum debug
)
8482 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8484 if (section
->start
== NULL
)
8487 free ((char *) section
->start
);
8488 section
->start
= NULL
;
8489 section
->address
= 0;
8494 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8496 char * name
= SECTION_NAME (section
);
8497 bfd_size_type length
;
8499 enum dwarf_section_display_enum i
;
8501 length
= section
->sh_size
;
8504 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8508 if (const_strneq (name
, ".gnu.linkonce.wi."))
8509 name
= ".debug_info";
8511 /* See if we know how to display the contents of this section. */
8512 for (i
= 0; i
< max
; i
++)
8513 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8514 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8516 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8517 int secondary
= (section
!= find_section (name
));
8520 free_debug_section (i
);
8522 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8523 sec
->name
= sec
->uncompressed_name
;
8525 sec
->name
= sec
->compressed_name
;
8526 if (load_specific_debug_section (i
, section
, file
))
8528 result
&= debug_displays
[i
].display (sec
, file
);
8530 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8531 free_debug_section (i
);
8539 printf (_("Unrecognized debug section: %s\n"), name
);
8546 /* Set DUMP_SECTS for all sections where dumps were requested
8547 based on section name. */
8550 initialise_dumps_byname (void)
8552 struct dump_list_entry
* cur
;
8554 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8559 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8560 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8562 request_dump_bynumber (i
, cur
->type
);
8567 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8573 process_section_contents (FILE * file
)
8575 Elf_Internal_Shdr
* section
;
8581 initialise_dumps_byname ();
8583 for (i
= 0, section
= section_headers
;
8584 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8587 #ifdef SUPPORT_DISASSEMBLY
8588 if (dump_sects
[i
] & DISASS_DUMP
)
8589 disassemble_section (section
, file
);
8591 if (dump_sects
[i
] & HEX_DUMP
)
8592 dump_section_as_bytes (section
, file
);
8594 if (dump_sects
[i
] & DEBUG_DUMP
)
8595 display_debug_section (section
, file
);
8597 if (dump_sects
[i
] & STRING_DUMP
)
8598 dump_section_as_strings (section
, file
);
8601 /* Check to see if the user requested a
8602 dump of a section that does not exist. */
8603 while (i
++ < num_dump_sects
)
8605 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8609 process_mips_fpe_exception (int mask
)
8614 if (mask
& OEX_FPU_INEX
)
8615 fputs ("INEX", stdout
), first
= 0;
8616 if (mask
& OEX_FPU_UFLO
)
8617 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8618 if (mask
& OEX_FPU_OFLO
)
8619 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8620 if (mask
& OEX_FPU_DIV0
)
8621 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8622 if (mask
& OEX_FPU_INVAL
)
8623 printf ("%sINVAL", first
? "" : "|");
8626 fputs ("0", stdout
);
8629 /* ARM EABI attributes section. */
8634 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8636 const char ** table
;
8637 } arm_attr_public_tag
;
8639 static const char * arm_attr_tag_CPU_arch
[] =
8640 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8641 "v6K", "v7", "v6-M", "v6S-M"};
8642 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8643 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8644 {"No", "Thumb-1", "Thumb-2"};
8645 static const char * arm_attr_tag_VFP_arch
[] =
8646 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8647 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8648 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8649 static const char * arm_attr_tag_PCS_config
[] =
8650 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8651 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8652 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8653 {"V6", "SB", "TLS", "Unused"};
8654 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8655 {"Absolute", "PC-relative", "SB-relative", "None"};
8656 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8657 {"Absolute", "PC-relative", "None"};
8658 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8659 {"None", "direct", "GOT-indirect"};
8660 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8661 {"None", "??? 1", "2", "??? 3", "4"};
8662 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8663 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8664 {"Unused", "Needed", "Sign only"};
8665 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8666 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8667 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8668 {"Unused", "Finite", "RTABI", "IEEE 754"};
8669 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8670 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8671 {"No", "Yes, except leaf SP", "Yes"};
8672 static const char * arm_attr_tag_ABI_enum_size
[] =
8673 {"Unused", "small", "int", "forced to int"};
8674 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8675 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8676 static const char * arm_attr_tag_ABI_VFP_args
[] =
8677 {"AAPCS", "VFP registers", "custom"};
8678 static const char * arm_attr_tag_ABI_WMMX_args
[] =
8679 {"AAPCS", "WMMX registers", "custom"};
8680 static const char * arm_attr_tag_ABI_optimization_goals
[] =
8681 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8682 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8683 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
8684 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8685 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8686 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8687 static const char * arm_attr_tag_VFP_HP_extension
[] =
8688 {"Not Allowed", "Allowed"};
8689 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
8690 {"None", "IEEE 754", "Alternative Format"};
8691 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8692 static const char * arm_attr_tag_Virtualization_use
[] =
8693 {"Not Allowed", "Allowed"};
8694 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8696 #define LOOKUP(id, name) \
8697 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8698 static arm_attr_public_tag arm_attr_public_tags
[] =
8700 {4, "CPU_raw_name", 1, NULL
},
8701 {5, "CPU_name", 1, NULL
},
8702 LOOKUP(6, CPU_arch
),
8703 {7, "CPU_arch_profile", 0, NULL
},
8704 LOOKUP(8, ARM_ISA_use
),
8705 LOOKUP(9, THUMB_ISA_use
),
8706 LOOKUP(10, VFP_arch
),
8707 LOOKUP(11, WMMX_arch
),
8708 LOOKUP(12, Advanced_SIMD_arch
),
8709 LOOKUP(13, PCS_config
),
8710 LOOKUP(14, ABI_PCS_R9_use
),
8711 LOOKUP(15, ABI_PCS_RW_data
),
8712 LOOKUP(16, ABI_PCS_RO_data
),
8713 LOOKUP(17, ABI_PCS_GOT_use
),
8714 LOOKUP(18, ABI_PCS_wchar_t
),
8715 LOOKUP(19, ABI_FP_rounding
),
8716 LOOKUP(20, ABI_FP_denormal
),
8717 LOOKUP(21, ABI_FP_exceptions
),
8718 LOOKUP(22, ABI_FP_user_exceptions
),
8719 LOOKUP(23, ABI_FP_number_model
),
8720 LOOKUP(24, ABI_align8_needed
),
8721 LOOKUP(25, ABI_align8_preserved
),
8722 LOOKUP(26, ABI_enum_size
),
8723 LOOKUP(27, ABI_HardFP_use
),
8724 LOOKUP(28, ABI_VFP_args
),
8725 LOOKUP(29, ABI_WMMX_args
),
8726 LOOKUP(30, ABI_optimization_goals
),
8727 LOOKUP(31, ABI_FP_optimization_goals
),
8728 {32, "compatibility", 0, NULL
},
8729 LOOKUP(34, CPU_unaligned_access
),
8730 LOOKUP(36, VFP_HP_extension
),
8731 LOOKUP(38, ABI_FP_16bit_format
),
8732 {64, "nodefaults", 0, NULL
},
8733 {65, "also_compatible_with", 0, NULL
},
8734 LOOKUP(66, T2EE_use
),
8735 {67, "conformance", 1, NULL
},
8736 LOOKUP(68, Virtualization_use
),
8737 LOOKUP(70, MPextension_use
)
8741 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8745 read_uleb128 (unsigned char * p
, unsigned int * plen
)
8759 val
|= ((unsigned int)c
& 0x7f) << shift
;
8768 static unsigned char *
8769 display_arm_attribute (unsigned char * p
)
8774 arm_attr_public_tag
* attr
;
8778 tag
= read_uleb128 (p
, &len
);
8781 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
8783 if (arm_attr_public_tags
[i
].tag
== tag
)
8785 attr
= &arm_attr_public_tags
[i
];
8792 printf (" Tag_%s: ", attr
->name
);
8798 case 7: /* Tag_CPU_arch_profile. */
8799 val
= read_uleb128 (p
, &len
);
8803 case 0: printf ("None\n"); break;
8804 case 'A': printf ("Application\n"); break;
8805 case 'R': printf ("Realtime\n"); break;
8806 case 'M': printf ("Microcontroller\n"); break;
8807 default: printf ("??? (%d)\n", val
); break;
8811 case 32: /* Tag_compatibility. */
8812 val
= read_uleb128 (p
, &len
);
8814 printf ("flag = %d, vendor = %s\n", val
, p
);
8815 p
+= strlen ((char *) p
) + 1;
8818 case 64: /* Tag_nodefaults. */
8823 case 65: /* Tag_also_compatible_with. */
8824 val
= read_uleb128 (p
, &len
);
8826 if (val
== 6 /* Tag_CPU_arch. */)
8828 val
= read_uleb128 (p
, &len
);
8830 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
8831 printf ("??? (%d)\n", val
);
8833 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
8837 while (*(p
++) != '\0' /* NUL terminator. */);
8851 assert (attr
->type
& 0x80);
8852 val
= read_uleb128 (p
, &len
);
8854 type
= attr
->type
& 0x7f;
8856 printf ("??? (%d)\n", val
);
8858 printf ("%s\n", attr
->table
[val
]);
8865 type
= 1; /* String. */
8867 type
= 2; /* uleb128. */
8868 printf (" Tag_unknown_%d: ", tag
);
8873 printf ("\"%s\"\n", p
);
8874 p
+= strlen ((char *) p
) + 1;
8878 val
= read_uleb128 (p
, &len
);
8880 printf ("%d (0x%x)\n", val
, val
);
8886 static unsigned char *
8887 display_gnu_attribute (unsigned char * p
,
8888 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8895 tag
= read_uleb128 (p
, &len
);
8898 /* Tag_compatibility is the only generic GNU attribute defined at
8902 val
= read_uleb128 (p
, &len
);
8904 printf ("flag = %d, vendor = %s\n", val
, p
);
8905 p
+= strlen ((char *) p
) + 1;
8909 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8910 return display_proc_gnu_attribute (p
, tag
);
8913 type
= 1; /* String. */
8915 type
= 2; /* uleb128. */
8916 printf (" Tag_unknown_%d: ", tag
);
8920 printf ("\"%s\"\n", p
);
8921 p
+= strlen ((char *) p
) + 1;
8925 val
= read_uleb128 (p
, &len
);
8927 printf ("%d (0x%x)\n", val
, val
);
8933 static unsigned char *
8934 display_power_gnu_attribute (unsigned char * p
, int tag
)
8940 if (tag
== Tag_GNU_Power_ABI_FP
)
8942 val
= read_uleb128 (p
, &len
);
8944 printf (" Tag_GNU_Power_ABI_FP: ");
8949 printf ("Hard or soft float\n");
8952 printf ("Hard float\n");
8955 printf ("Soft float\n");
8958 printf ("Single-precision hard float\n");
8961 printf ("??? (%d)\n", val
);
8967 if (tag
== Tag_GNU_Power_ABI_Vector
)
8969 val
= read_uleb128 (p
, &len
);
8971 printf (" Tag_GNU_Power_ABI_Vector: ");
8978 printf ("Generic\n");
8981 printf ("AltiVec\n");
8987 printf ("??? (%d)\n", val
);
8993 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
8995 val
= read_uleb128 (p
, &len
);
8997 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9007 printf ("Memory\n");
9010 printf ("??? (%d)\n", val
);
9017 type
= 1; /* String. */
9019 type
= 2; /* uleb128. */
9020 printf (" Tag_unknown_%d: ", tag
);
9024 printf ("\"%s\"\n", p
);
9025 p
+= strlen ((char *) p
) + 1;
9029 val
= read_uleb128 (p
, &len
);
9031 printf ("%d (0x%x)\n", val
, val
);
9037 static unsigned char *
9038 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9044 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9046 val
= read_uleb128 (p
, &len
);
9048 printf (" Tag_GNU_MIPS_ABI_FP: ");
9053 printf ("Hard or soft float\n");
9056 printf ("Hard float (-mdouble-float)\n");
9059 printf ("Hard float (-msingle-float)\n");
9062 printf ("Soft float\n");
9065 printf ("64-bit float (-mips32r2 -mfp64)\n");
9068 printf ("??? (%d)\n", val
);
9075 type
= 1; /* String. */
9077 type
= 2; /* uleb128. */
9078 printf (" Tag_unknown_%d: ", tag
);
9082 printf ("\"%s\"\n", p
);
9083 p
+= strlen ((char *) p
) + 1;
9087 val
= read_uleb128 (p
, &len
);
9089 printf ("%d (0x%x)\n", val
, val
);
9096 process_attributes (FILE * file
,
9097 const char * public_name
,
9098 unsigned int proc_type
,
9099 unsigned char * (* display_pub_attribute
) (unsigned char *),
9100 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9102 Elf_Internal_Shdr
* sect
;
9103 unsigned char * contents
;
9105 unsigned char * end
;
9106 bfd_vma section_len
;
9110 /* Find the section header so that we get the size. */
9111 for (i
= 0, sect
= section_headers
;
9112 i
< elf_header
.e_shnum
;
9115 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9118 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9120 if (contents
== NULL
)
9126 len
= sect
->sh_size
- 1;
9132 bfd_boolean public_section
;
9133 bfd_boolean gnu_section
;
9135 section_len
= byte_get (p
, 4);
9138 if (section_len
> len
)
9140 printf (_("ERROR: Bad section length (%d > %d)\n"),
9141 (int) section_len
, (int) len
);
9146 printf ("Attribute Section: %s\n", p
);
9148 if (public_name
&& streq ((char *) p
, public_name
))
9149 public_section
= TRUE
;
9151 public_section
= FALSE
;
9153 if (streq ((char *) p
, "gnu"))
9156 gnu_section
= FALSE
;
9158 namelen
= strlen ((char *) p
) + 1;
9160 section_len
-= namelen
+ 4;
9162 while (section_len
> 0)
9168 size
= byte_get (p
, 4);
9169 if (size
> section_len
)
9171 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9172 (int) size
, (int) section_len
);
9176 section_len
-= size
;
9183 printf ("File Attributes\n");
9186 printf ("Section Attributes:");
9189 printf ("Symbol Attributes:");
9195 val
= read_uleb128 (p
, &i
);
9199 printf (" %d", val
);
9204 printf ("Unknown tag: %d\n", tag
);
9205 public_section
= FALSE
;
9212 p
= display_pub_attribute (p
);
9214 else if (gnu_section
)
9217 p
= display_gnu_attribute (p
,
9218 display_proc_gnu_attribute
);
9222 /* ??? Do something sensible, like dump hex. */
9223 printf (" Unknown section contexts\n");
9230 printf (_("Unknown format '%c'\n"), *p
);
9238 process_arm_specific (FILE * file
)
9240 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9241 display_arm_attribute
, NULL
);
9245 process_power_specific (FILE * file
)
9247 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9248 display_power_gnu_attribute
);
9251 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9252 Print the Address, Access and Initial fields of an entry at VMA ADDR
9253 and return the VMA of the next entry. */
9256 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9259 print_vma (addr
, LONG_HEX
);
9261 if (addr
< pltgot
+ 0xfff0)
9262 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9264 printf ("%10s", "");
9267 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9272 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9273 print_vma (entry
, LONG_HEX
);
9275 return addr
+ (is_32bit_elf
? 4 : 8);
9278 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9279 PLTGOT. Print the Address and Initial fields of an entry at VMA
9280 ADDR and return the VMA of the next entry. */
9283 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9286 print_vma (addr
, LONG_HEX
);
9289 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9294 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9295 print_vma (entry
, LONG_HEX
);
9297 return addr
+ (is_32bit_elf
? 4 : 8);
9301 process_mips_specific (FILE * file
)
9303 Elf_Internal_Dyn
* entry
;
9304 size_t liblist_offset
= 0;
9305 size_t liblistno
= 0;
9306 size_t conflictsno
= 0;
9307 size_t options_offset
= 0;
9308 size_t conflicts_offset
= 0;
9309 size_t pltrelsz
= 0;
9312 bfd_vma mips_pltgot
= 0;
9314 bfd_vma local_gotno
= 0;
9316 bfd_vma symtabno
= 0;
9318 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9319 display_mips_gnu_attribute
);
9321 /* We have a lot of special sections. Thanks SGI! */
9322 if (dynamic_section
== NULL
)
9323 /* No information available. */
9326 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9327 switch (entry
->d_tag
)
9329 case DT_MIPS_LIBLIST
:
9331 = offset_from_vma (file
, entry
->d_un
.d_val
,
9332 liblistno
* sizeof (Elf32_External_Lib
));
9334 case DT_MIPS_LIBLISTNO
:
9335 liblistno
= entry
->d_un
.d_val
;
9337 case DT_MIPS_OPTIONS
:
9338 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9340 case DT_MIPS_CONFLICT
:
9342 = offset_from_vma (file
, entry
->d_un
.d_val
,
9343 conflictsno
* sizeof (Elf32_External_Conflict
));
9345 case DT_MIPS_CONFLICTNO
:
9346 conflictsno
= entry
->d_un
.d_val
;
9349 pltgot
= entry
->d_un
.d_ptr
;
9351 case DT_MIPS_LOCAL_GOTNO
:
9352 local_gotno
= entry
->d_un
.d_val
;
9354 case DT_MIPS_GOTSYM
:
9355 gotsym
= entry
->d_un
.d_val
;
9357 case DT_MIPS_SYMTABNO
:
9358 symtabno
= entry
->d_un
.d_val
;
9360 case DT_MIPS_PLTGOT
:
9361 mips_pltgot
= entry
->d_un
.d_ptr
;
9364 pltrel
= entry
->d_un
.d_val
;
9367 pltrelsz
= entry
->d_un
.d_val
;
9370 jmprel
= entry
->d_un
.d_ptr
;
9376 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9378 Elf32_External_Lib
* elib
;
9381 elib
= get_data (NULL
, file
, liblist_offset
,
9382 liblistno
, sizeof (Elf32_External_Lib
),
9386 printf ("\nSection '.liblist' contains %lu entries:\n",
9387 (unsigned long) liblistno
);
9388 fputs (" Library Time Stamp Checksum Version Flags\n",
9391 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9398 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9399 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9400 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9401 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9402 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9404 tmp
= gmtime (&time
);
9405 snprintf (timebuf
, sizeof (timebuf
),
9406 "%04u-%02u-%02uT%02u:%02u:%02u",
9407 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9408 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9410 printf ("%3lu: ", (unsigned long) cnt
);
9411 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9412 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9414 printf ("<corrupt: %9ld>", liblist
.l_name
);
9415 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9418 if (liblist
.l_flags
== 0)
9429 { " EXACT_MATCH", LL_EXACT_MATCH
},
9430 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9431 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9432 { " EXPORTS", LL_EXPORTS
},
9433 { " DELAY_LOAD", LL_DELAY_LOAD
},
9434 { " DELTA", LL_DELTA
}
9436 int flags
= liblist
.l_flags
;
9439 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9440 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9442 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9443 flags
^= l_flags_vals
[fcnt
].bit
;
9446 printf (" %#x", (unsigned int) flags
);
9456 if (options_offset
!= 0)
9458 Elf_External_Options
* eopt
;
9459 Elf_Internal_Shdr
* sect
= section_headers
;
9460 Elf_Internal_Options
* iopt
;
9461 Elf_Internal_Options
* option
;
9465 /* Find the section header so that we get the size. */
9466 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9469 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9473 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9476 error (_("Out of memory\n"));
9483 while (offset
< sect
->sh_size
)
9485 Elf_External_Options
* eoption
;
9487 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9489 option
->kind
= BYTE_GET (eoption
->kind
);
9490 option
->size
= BYTE_GET (eoption
->size
);
9491 option
->section
= BYTE_GET (eoption
->section
);
9492 option
->info
= BYTE_GET (eoption
->info
);
9494 offset
+= option
->size
;
9500 printf (_("\nSection '%s' contains %d entries:\n"),
9501 SECTION_NAME (sect
), cnt
);
9509 switch (option
->kind
)
9512 /* This shouldn't happen. */
9513 printf (" NULL %d %lx", option
->section
, option
->info
);
9516 printf (" REGINFO ");
9517 if (elf_header
.e_machine
== EM_MIPS
)
9520 Elf32_External_RegInfo
* ereg
;
9521 Elf32_RegInfo reginfo
;
9523 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9524 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9525 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9526 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9527 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9528 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9529 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9531 printf ("GPR %08lx GP 0x%lx\n",
9533 (unsigned long) reginfo
.ri_gp_value
);
9534 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9535 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9536 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9541 Elf64_External_RegInfo
* ereg
;
9542 Elf64_Internal_RegInfo reginfo
;
9544 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9545 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9546 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9547 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9548 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9549 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9550 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9552 printf ("GPR %08lx GP 0x",
9553 reginfo
.ri_gprmask
);
9554 printf_vma (reginfo
.ri_gp_value
);
9557 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9558 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9559 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9563 case ODK_EXCEPTIONS
:
9564 fputs (" EXCEPTIONS fpe_min(", stdout
);
9565 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9566 fputs (") fpe_max(", stdout
);
9567 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9568 fputs (")", stdout
);
9570 if (option
->info
& OEX_PAGE0
)
9571 fputs (" PAGE0", stdout
);
9572 if (option
->info
& OEX_SMM
)
9573 fputs (" SMM", stdout
);
9574 if (option
->info
& OEX_FPDBUG
)
9575 fputs (" FPDBUG", stdout
);
9576 if (option
->info
& OEX_DISMISS
)
9577 fputs (" DISMISS", stdout
);
9580 fputs (" PAD ", stdout
);
9581 if (option
->info
& OPAD_PREFIX
)
9582 fputs (" PREFIX", stdout
);
9583 if (option
->info
& OPAD_POSTFIX
)
9584 fputs (" POSTFIX", stdout
);
9585 if (option
->info
& OPAD_SYMBOL
)
9586 fputs (" SYMBOL", stdout
);
9589 fputs (" HWPATCH ", stdout
);
9590 if (option
->info
& OHW_R4KEOP
)
9591 fputs (" R4KEOP", stdout
);
9592 if (option
->info
& OHW_R8KPFETCH
)
9593 fputs (" R8KPFETCH", stdout
);
9594 if (option
->info
& OHW_R5KEOP
)
9595 fputs (" R5KEOP", stdout
);
9596 if (option
->info
& OHW_R5KCVTL
)
9597 fputs (" R5KCVTL", stdout
);
9600 fputs (" FILL ", stdout
);
9601 /* XXX Print content of info word? */
9604 fputs (" TAGS ", stdout
);
9605 /* XXX Print content of info word? */
9608 fputs (" HWAND ", stdout
);
9609 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9610 fputs (" R4KEOP_CHECKED", stdout
);
9611 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9612 fputs (" R4KEOP_CLEAN", stdout
);
9615 fputs (" HWOR ", stdout
);
9616 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9617 fputs (" R4KEOP_CHECKED", stdout
);
9618 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9619 fputs (" R4KEOP_CLEAN", stdout
);
9622 printf (" GP_GROUP %#06lx self-contained %#06lx",
9623 option
->info
& OGP_GROUP
,
9624 (option
->info
& OGP_SELF
) >> 16);
9627 printf (" IDENT %#06lx self-contained %#06lx",
9628 option
->info
& OGP_GROUP
,
9629 (option
->info
& OGP_SELF
) >> 16);
9632 /* This shouldn't happen. */
9633 printf (" %3d ??? %d %lx",
9634 option
->kind
, option
->section
, option
->info
);
9638 len
= sizeof (* eopt
);
9639 while (len
< option
->size
)
9640 if (((char *) option
)[len
] >= ' '
9641 && ((char *) option
)[len
] < 0x7f)
9642 printf ("%c", ((char *) option
)[len
++]);
9644 printf ("\\%03o", ((char *) option
)[len
++]);
9646 fputs ("\n", stdout
);
9654 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9656 Elf32_Conflict
* iconf
;
9659 if (dynamic_symbols
== NULL
)
9661 error (_("conflict list found without a dynamic symbol table\n"));
9665 iconf
= cmalloc (conflictsno
, sizeof (* iconf
));
9668 error (_("Out of memory\n"));
9674 Elf32_External_Conflict
* econf32
;
9676 econf32
= get_data (NULL
, file
, conflicts_offset
,
9677 conflictsno
, sizeof (* econf32
), _("conflict"));
9681 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9682 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9688 Elf64_External_Conflict
* econf64
;
9690 econf64
= get_data (NULL
, file
, conflicts_offset
,
9691 conflictsno
, sizeof (* econf64
), _("conflict"));
9695 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9696 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9701 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9702 (unsigned long) conflictsno
);
9703 puts (_(" Num: Index Value Name"));
9705 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9707 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9709 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9710 print_vma (psym
->st_value
, FULL_HEX
);
9712 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9713 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9715 printf ("<corrupt: %14ld>", psym
->st_name
);
9722 if (pltgot
!= 0 && local_gotno
!= 0)
9724 bfd_vma entry
, local_end
, global_end
;
9726 unsigned char * data
;
9730 addr_size
= (is_32bit_elf
? 4 : 8);
9731 local_end
= pltgot
+ local_gotno
* addr_size
;
9732 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9734 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9735 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9736 printf (_("\nPrimary GOT:\n"));
9737 printf (_(" Canonical gp value: "));
9738 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9741 printf (_(" Reserved entries:\n"));
9742 printf (_(" %*s %10s %*s Purpose\n"),
9743 addr_size
* 2, "Address", "Access",
9744 addr_size
* 2, "Initial");
9745 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9746 printf (" Lazy resolver\n");
9748 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9749 >> (addr_size
* 8 - 1)) != 0)
9751 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9752 printf (" Module pointer (GNU extension)\n");
9756 if (entry
< local_end
)
9758 printf (_(" Local entries:\n"));
9759 printf (_(" %*s %10s %*s\n"),
9760 addr_size
* 2, "Address", "Access",
9761 addr_size
* 2, "Initial");
9762 while (entry
< local_end
)
9764 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9770 if (gotsym
< symtabno
)
9774 printf (_(" Global entries:\n"));
9775 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9776 addr_size
* 2, "Address", "Access",
9777 addr_size
* 2, "Initial",
9778 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9779 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9780 for (i
= gotsym
; i
< symtabno
; i
++)
9782 Elf_Internal_Sym
* psym
;
9784 psym
= dynamic_symbols
+ i
;
9785 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9787 print_vma (psym
->st_value
, LONG_HEX
);
9788 printf (" %-7s %3s ",
9789 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9790 get_symbol_index_type (psym
->st_shndx
));
9791 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9792 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9794 printf ("<corrupt: %14ld>", psym
->st_name
);
9804 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9807 size_t offset
, rel_offset
;
9808 unsigned long count
, i
;
9809 unsigned char * data
;
9810 int addr_size
, sym_width
;
9811 Elf_Internal_Rela
* rels
;
9813 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9814 if (pltrel
== DT_RELA
)
9816 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9821 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9825 entry
= mips_pltgot
;
9826 addr_size
= (is_32bit_elf
? 4 : 8);
9827 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9829 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9830 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9831 printf (_("\nPLT GOT:\n\n"));
9832 printf (_(" Reserved entries:\n"));
9833 printf (_(" %*s %*s Purpose\n"),
9834 addr_size
* 2, "Address", addr_size
* 2, "Initial");
9835 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9836 printf (" PLT lazy resolver\n");
9837 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9838 printf (" Module pointer\n");
9841 printf (_(" Entries:\n"));
9842 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9843 addr_size
* 2, "Address",
9844 addr_size
* 2, "Initial",
9845 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9846 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
9847 for (i
= 0; i
< count
; i
++)
9849 Elf_Internal_Sym
* psym
;
9851 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
9852 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9854 print_vma (psym
->st_value
, LONG_HEX
);
9855 printf (" %-7s %3s ",
9856 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9857 get_symbol_index_type (psym
->st_shndx
));
9858 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9859 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9861 printf ("<corrupt: %14ld>", psym
->st_name
);
9875 process_gnu_liblist (FILE * file
)
9877 Elf_Internal_Shdr
* section
;
9878 Elf_Internal_Shdr
* string_sec
;
9879 Elf32_External_Lib
* elib
;
9888 for (i
= 0, section
= section_headers
;
9889 i
< elf_header
.e_shnum
;
9892 switch (section
->sh_type
)
9894 case SHT_GNU_LIBLIST
:
9895 if (section
->sh_link
>= elf_header
.e_shnum
)
9898 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9903 string_sec
= section_headers
+ section
->sh_link
;
9905 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9906 string_sec
->sh_size
, _("liblist string table"));
9907 strtab_size
= string_sec
->sh_size
;
9910 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9916 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9917 SECTION_NAME (section
),
9918 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9920 puts (" Library Time Stamp Checksum Version Flags");
9922 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9930 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9931 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9932 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9933 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9934 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9936 tmp
= gmtime (&time
);
9937 snprintf (timebuf
, sizeof (timebuf
),
9938 "%04u-%02u-%02uT%02u:%02u:%02u",
9939 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9940 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9942 printf ("%3lu: ", (unsigned long) cnt
);
9944 printf ("%-20s", liblist
.l_name
< strtab_size
9945 ? strtab
+ liblist
.l_name
: "<corrupt>");
9947 printf ("%-20.20s", liblist
.l_name
< strtab_size
9948 ? strtab
+ liblist
.l_name
: "<corrupt>");
9949 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9950 liblist
.l_version
, liblist
.l_flags
);
9961 get_note_type (unsigned e_type
)
9963 static char buff
[64];
9965 if (elf_header
.e_type
== ET_CORE
)
9969 return _("NT_AUXV (auxiliary vector)");
9971 return _("NT_PRSTATUS (prstatus structure)");
9973 return _("NT_FPREGSET (floating point registers)");
9975 return _("NT_PRPSINFO (prpsinfo structure)");
9977 return _("NT_TASKSTRUCT (task structure)");
9979 return _("NT_PRXFPREG (user_xfpregs structure)");
9981 return _("NT_PPC_VMX (ppc Altivec registers)");
9983 return _("NT_PPC_VSX (ppc VSX registers)");
9985 return _("NT_PSTATUS (pstatus structure)");
9987 return _("NT_FPREGS (floating point registers)");
9989 return _("NT_PSINFO (psinfo structure)");
9991 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9993 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9994 case NT_WIN32PSTATUS
:
9995 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10003 return _("NT_VERSION (version)");
10005 return _("NT_ARCH (architecture)");
10010 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10014 static const char *
10015 get_gnu_elf_note_type (unsigned e_type
)
10017 static char buff
[64];
10021 case NT_GNU_ABI_TAG
:
10022 return _("NT_GNU_ABI_TAG (ABI version tag)");
10024 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10025 case NT_GNU_BUILD_ID
:
10026 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10027 case NT_GNU_GOLD_VERSION
:
10028 return _("NT_GNU_GOLD_VERSION (gold version)");
10033 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10037 static const char *
10038 get_netbsd_elfcore_note_type (unsigned e_type
)
10040 static char buff
[64];
10042 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10044 /* NetBSD core "procinfo" structure. */
10045 return _("NetBSD procinfo structure");
10048 /* As of Jan 2002 there are no other machine-independent notes
10049 defined for NetBSD core files. If the note type is less
10050 than the start of the machine-dependent note types, we don't
10053 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10055 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10059 switch (elf_header
.e_machine
)
10061 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10062 and PT_GETFPREGS == mach+2. */
10067 case EM_SPARC32PLUS
:
10071 case NT_NETBSDCORE_FIRSTMACH
+0:
10072 return _("PT_GETREGS (reg structure)");
10073 case NT_NETBSDCORE_FIRSTMACH
+2:
10074 return _("PT_GETFPREGS (fpreg structure)");
10080 /* On all other arch's, PT_GETREGS == mach+1 and
10081 PT_GETFPREGS == mach+3. */
10085 case NT_NETBSDCORE_FIRSTMACH
+1:
10086 return _("PT_GETREGS (reg structure)");
10087 case NT_NETBSDCORE_FIRSTMACH
+3:
10088 return _("PT_GETFPREGS (fpreg structure)");
10094 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10095 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10099 /* Note that by the ELF standard, the name field is already null byte
10100 terminated, and namesz includes the terminating null byte.
10101 I.E. the value of namesz for the name "FSF" is 4.
10103 If the value of namesz is zero, there is no name present. */
10105 process_note (Elf_Internal_Note
* pnote
)
10107 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10110 if (pnote
->namesz
== 0)
10111 /* If there is no note name, then use the default set of
10112 note type strings. */
10113 nt
= get_note_type (pnote
->type
);
10115 else if (const_strneq (pnote
->namedata
, "GNU"))
10116 /* GNU-specific object file notes. */
10117 nt
= get_gnu_elf_note_type (pnote
->type
);
10119 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10120 /* NetBSD-specific core file notes. */
10121 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10123 else if (strneq (pnote
->namedata
, "SPU/", 4))
10125 /* SPU-specific core file notes. */
10126 nt
= pnote
->namedata
+ 4;
10131 /* Don't recognize this note name; just use the default set of
10132 note type strings. */
10133 nt
= get_note_type (pnote
->type
);
10135 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10141 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10143 Elf_External_Note
* pnotes
;
10144 Elf_External_Note
* external
;
10150 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10156 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10157 (unsigned long) offset
, (unsigned long) length
);
10158 printf (_(" Owner\t\tData size\tDescription\n"));
10160 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10162 Elf_External_Note
* next
;
10163 Elf_Internal_Note inote
;
10164 char * temp
= NULL
;
10166 inote
.type
= BYTE_GET (external
->type
);
10167 inote
.namesz
= BYTE_GET (external
->namesz
);
10168 inote
.namedata
= external
->name
;
10169 inote
.descsz
= BYTE_GET (external
->descsz
);
10170 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10171 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10173 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10175 if (((char *) next
) > (((char *) pnotes
) + length
))
10177 warn (_("corrupt note found at offset %lx into core notes\n"),
10178 (unsigned long) ((char *) external
- (char *) pnotes
));
10179 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10180 inote
.type
, inote
.namesz
, inote
.descsz
);
10186 /* Verify that name is null terminated. It appears that at least
10187 one version of Linux (RedHat 6.0) generates corefiles that don't
10188 comply with the ELF spec by failing to include the null byte in
10190 if (inote
.namedata
[inote
.namesz
] != '\0')
10192 temp
= malloc (inote
.namesz
+ 1);
10196 error (_("Out of memory\n"));
10201 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10202 temp
[inote
.namesz
] = 0;
10204 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10205 inote
.namedata
= temp
;
10208 res
&= process_note (& inote
);
10223 process_corefile_note_segments (FILE * file
)
10225 Elf_Internal_Phdr
* segment
;
10229 if (! get_program_headers (file
))
10232 for (i
= 0, segment
= program_headers
;
10233 i
< elf_header
.e_phnum
;
10236 if (segment
->p_type
== PT_NOTE
)
10237 res
&= process_corefile_note_segment (file
,
10238 (bfd_vma
) segment
->p_offset
,
10239 (bfd_vma
) segment
->p_filesz
);
10246 process_note_sections (FILE * file
)
10248 Elf_Internal_Shdr
* section
;
10252 for (i
= 0, section
= section_headers
;
10253 i
< elf_header
.e_shnum
;
10255 if (section
->sh_type
== SHT_NOTE
)
10256 res
&= process_corefile_note_segment (file
,
10257 (bfd_vma
) section
->sh_offset
,
10258 (bfd_vma
) section
->sh_size
);
10264 process_notes (FILE * file
)
10266 /* If we have not been asked to display the notes then do nothing. */
10270 if (elf_header
.e_type
!= ET_CORE
)
10271 return process_note_sections (file
);
10273 /* No program headers means no NOTE segment. */
10274 if (elf_header
.e_phnum
> 0)
10275 return process_corefile_note_segments (file
);
10277 printf (_("No note segments present in the core file.\n"));
10282 process_arch_specific (FILE * file
)
10287 switch (elf_header
.e_machine
)
10290 return process_arm_specific (file
);
10292 case EM_MIPS_RS3_LE
:
10293 return process_mips_specific (file
);
10296 return process_power_specific (file
);
10305 get_file_header (FILE * file
)
10307 /* Read in the identity array. */
10308 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10311 /* Determine how to read the rest of the header. */
10312 switch (elf_header
.e_ident
[EI_DATA
])
10314 default: /* fall through */
10315 case ELFDATANONE
: /* fall through */
10317 byte_get
= byte_get_little_endian
;
10318 byte_put
= byte_put_little_endian
;
10321 byte_get
= byte_get_big_endian
;
10322 byte_put
= byte_put_big_endian
;
10326 /* For now we only support 32 bit and 64 bit ELF files. */
10327 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10329 /* Read in the rest of the header. */
10332 Elf32_External_Ehdr ehdr32
;
10334 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10337 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10338 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10339 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10340 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10341 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10342 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10343 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10344 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10345 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10346 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10347 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10348 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10349 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10353 Elf64_External_Ehdr ehdr64
;
10355 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10356 we will not be able to cope with the 64bit data found in
10357 64 ELF files. Detect this now and abort before we start
10358 overwriting things. */
10359 if (sizeof (bfd_vma
) < 8)
10361 error (_("This instance of readelf has been built without support for a\n\
10362 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10366 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10369 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10370 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10371 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10372 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10373 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10374 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10375 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10376 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10377 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10378 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10379 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10380 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10381 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10384 if (elf_header
.e_shoff
)
10386 /* There may be some extensions in the first section header. Don't
10387 bomb if we can't read it. */
10389 get_32bit_section_headers (file
, 1);
10391 get_64bit_section_headers (file
, 1);
10397 /* Process one ELF object file according to the command line options.
10398 This file may actually be stored in an archive. The file is
10399 positioned at the start of the ELF object. */
10402 process_object (char * file_name
, FILE * file
)
10406 if (! get_file_header (file
))
10408 error (_("%s: Failed to read file header\n"), file_name
);
10412 /* Initialise per file variables. */
10413 for (i
= ARRAY_SIZE (version_info
); i
--;)
10414 version_info
[i
] = 0;
10416 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10417 dynamic_info
[i
] = 0;
10419 /* Process the file. */
10421 printf (_("\nFile: %s\n"), file_name
);
10423 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10424 Note we do this even if cmdline_dump_sects is empty because we
10425 must make sure that the dump_sets array is zeroed out before each
10426 object file is processed. */
10427 if (num_dump_sects
> num_cmdline_dump_sects
)
10428 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10430 if (num_cmdline_dump_sects
> 0)
10432 if (num_dump_sects
== 0)
10433 /* A sneaky way of allocating the dump_sects array. */
10434 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10436 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10437 memcpy (dump_sects
, cmdline_dump_sects
,
10438 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10441 if (! process_file_header ())
10444 if (! process_section_headers (file
))
10446 /* Without loaded section headers we cannot process lots of
10448 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10450 if (! do_using_dynamic
)
10451 do_syms
= do_reloc
= 0;
10454 if (! process_section_groups (file
))
10456 /* Without loaded section groups we cannot process unwind. */
10460 if (process_program_headers (file
))
10461 process_dynamic_section (file
);
10463 process_relocs (file
);
10465 process_unwind (file
);
10467 process_symbol_table (file
);
10469 process_syminfo (file
);
10471 process_version_sections (file
);
10473 process_section_contents (file
);
10475 process_notes (file
);
10477 process_gnu_liblist (file
);
10479 process_arch_specific (file
);
10481 if (program_headers
)
10483 free (program_headers
);
10484 program_headers
= NULL
;
10487 if (section_headers
)
10489 free (section_headers
);
10490 section_headers
= NULL
;
10495 free (string_table
);
10496 string_table
= NULL
;
10497 string_table_length
= 0;
10500 if (dynamic_strings
)
10502 free (dynamic_strings
);
10503 dynamic_strings
= NULL
;
10504 dynamic_strings_length
= 0;
10507 if (dynamic_symbols
)
10509 free (dynamic_symbols
);
10510 dynamic_symbols
= NULL
;
10511 num_dynamic_syms
= 0;
10514 if (dynamic_syminfo
)
10516 free (dynamic_syminfo
);
10517 dynamic_syminfo
= NULL
;
10520 if (section_headers_groups
)
10522 free (section_headers_groups
);
10523 section_headers_groups
= NULL
;
10526 if (section_groups
)
10528 struct group_list
* g
;
10529 struct group_list
* next
;
10531 for (i
= 0; i
< group_count
; i
++)
10533 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10540 free (section_groups
);
10541 section_groups
= NULL
;
10544 free_debug_memory ();
10549 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10550 to the path name of the thin archive itself if necessary. Always returns
10551 a pointer to malloc'ed memory. */
10554 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10556 char * member_file_name
;
10557 const char * base_name
= lbasename (file_name
);
10559 /* This is a proxy entry for a thin archive member.
10560 If the extended name table contains an absolute path
10561 name, or if the archive is in the current directory,
10562 use the path name as given. Otherwise, we need to
10563 find the member relative to the directory where the
10564 archive is located. */
10565 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10567 member_file_name
= malloc (name_len
+ 1);
10568 if (member_file_name
== NULL
)
10570 error (_("Out of memory\n"));
10573 memcpy (member_file_name
, name
, name_len
);
10574 member_file_name
[name_len
] = '\0';
10578 /* Concatenate the path components of the archive file name
10579 to the relative path name from the extended name table. */
10580 size_t prefix_len
= base_name
- file_name
;
10581 member_file_name
= malloc (prefix_len
+ name_len
+ 1);
10582 if (member_file_name
== NULL
)
10584 error (_("Out of memory\n"));
10587 memcpy (member_file_name
, file_name
, prefix_len
);
10588 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10589 member_file_name
[prefix_len
+ name_len
] = '\0';
10591 return member_file_name
;
10594 /* Structure to hold information about an archive file. */
10596 struct archive_info
10598 char * file_name
; /* Archive file name. */
10599 FILE * file
; /* Open file descriptor. */
10600 unsigned long index_num
; /* Number of symbols in table. */
10601 unsigned long * index_array
; /* The array of member offsets. */
10602 char * sym_table
; /* The symbol table. */
10603 unsigned long sym_size
; /* Size of the symbol table. */
10604 char * longnames
; /* The long file names table. */
10605 unsigned long longnames_size
; /* Size of the long file names table. */
10606 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10607 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10608 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10609 struct ar_hdr arhdr
; /* Current archive header. */
10612 /* Read the symbol table and long-name table from an archive. */
10615 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10616 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10619 unsigned long size
;
10621 arch
->file_name
= strdup (file_name
);
10623 arch
->index_num
= 0;
10624 arch
->index_array
= NULL
;
10625 arch
->sym_table
= NULL
;
10626 arch
->sym_size
= 0;
10627 arch
->longnames
= NULL
;
10628 arch
->longnames_size
= 0;
10629 arch
->nested_member_origin
= 0;
10630 arch
->is_thin_archive
= is_thin_archive
;
10631 arch
->next_arhdr_offset
= SARMAG
;
10633 /* Read the first archive member header. */
10634 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10636 error (_("%s: failed to seek to first archive header\n"), file_name
);
10639 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10640 if (got
!= sizeof arch
->arhdr
)
10645 error (_("%s: failed to read archive header\n"), file_name
);
10649 /* See if this is the archive symbol table. */
10650 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10651 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10653 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10654 size
= size
+ (size
& 1);
10656 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10661 /* A buffer used to hold numbers read in from an archive index.
10662 These are always 4 bytes long and stored in big-endian format. */
10663 #define SIZEOF_AR_INDEX_NUMBERS 4
10664 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10665 unsigned char * index_buffer
;
10667 /* Check the size of the archive index. */
10668 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10670 error (_("%s: the archive index is empty\n"), file_name
);
10674 /* Read the numer of entries in the archive index. */
10675 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10676 if (got
!= sizeof (integer_buffer
))
10678 error (_("%s: failed to read archive index\n"), file_name
);
10681 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10682 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10684 /* Read in the archive index. */
10685 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10687 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10688 file_name
, arch
->index_num
);
10691 index_buffer
= malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10692 if (index_buffer
== NULL
)
10694 error (_("Out of memory whilst trying to read archive symbol index\n"));
10697 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
10698 if (got
!= arch
->index_num
)
10700 free (index_buffer
);
10701 error (_("%s: failed to read archive index\n"), file_name
);
10704 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10706 /* Convert the index numbers into the host's numeric format. */
10707 arch
->index_array
= malloc (arch
->index_num
* sizeof (* arch
->index_array
));
10708 if (arch
->index_array
== NULL
)
10710 free (index_buffer
);
10711 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10715 for (i
= 0; i
< arch
->index_num
; i
++)
10716 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10717 SIZEOF_AR_INDEX_NUMBERS
);
10718 free (index_buffer
);
10720 /* The remaining space in the header is taken up by the symbol table. */
10723 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10726 arch
->sym_table
= malloc (size
);
10727 arch
->sym_size
= size
;
10728 if (arch
->sym_table
== NULL
)
10730 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10733 got
= fread (arch
->sym_table
, 1, size
, file
);
10736 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10742 if (fseek (file
, size
, SEEK_CUR
) != 0)
10744 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10749 /* Read the next archive header. */
10750 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10751 if (got
!= sizeof arch
->arhdr
)
10755 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10759 else if (read_symbols
)
10760 printf (_("%s has no archive index\n"), file_name
);
10762 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
10764 /* This is the archive string table holding long member names. */
10765 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10766 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
10768 arch
->longnames
= malloc (arch
->longnames_size
);
10769 if (arch
->longnames
== NULL
)
10771 error (_("Out of memory reading long symbol names in archive\n"));
10775 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
10777 free (arch
->longnames
);
10778 arch
->longnames
= NULL
;
10779 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10783 if ((arch
->longnames_size
& 1) != 0)
10790 /* Release the memory used for the archive information. */
10793 release_archive (struct archive_info
* arch
)
10795 if (arch
->file_name
!= NULL
)
10796 free (arch
->file_name
);
10797 if (arch
->index_array
!= NULL
)
10798 free (arch
->index_array
);
10799 if (arch
->sym_table
!= NULL
)
10800 free (arch
->sym_table
);
10801 if (arch
->longnames
!= NULL
)
10802 free (arch
->longnames
);
10805 /* Open and setup a nested archive, if not already open. */
10808 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
10810 FILE * member_file
;
10812 /* Have we already setup this archive? */
10813 if (nested_arch
->file_name
!= NULL
10814 && streq (nested_arch
->file_name
, member_file_name
))
10817 /* Close previous file and discard cached information. */
10818 if (nested_arch
->file
!= NULL
)
10819 fclose (nested_arch
->file
);
10820 release_archive (nested_arch
);
10822 member_file
= fopen (member_file_name
, "rb");
10823 if (member_file
== NULL
)
10825 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
10829 get_archive_member_name_at (struct archive_info
* arch
,
10830 unsigned long offset
,
10831 struct archive_info
* nested_arch
);
10833 /* Get the name of an archive member from the current archive header.
10834 For simple names, this will modify the ar_name field of the current
10835 archive header. For long names, it will return a pointer to the
10836 longnames table. For nested archives, it will open the nested archive
10837 and get the name recursively. NESTED_ARCH is a single-entry cache so
10838 we don't keep rereading the same information from a nested archive. */
10841 get_archive_member_name (struct archive_info
* arch
,
10842 struct archive_info
* nested_arch
)
10844 unsigned long j
, k
;
10846 if (arch
->arhdr
.ar_name
[0] == '/')
10848 /* We have a long name. */
10850 char * member_file_name
;
10851 char * member_name
;
10853 arch
->nested_member_origin
= 0;
10854 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
10855 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
10856 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
10858 while ((j
< arch
->longnames_size
)
10859 && (arch
->longnames
[j
] != '\n')
10860 && (arch
->longnames
[j
] != '\0'))
10862 if (arch
->longnames
[j
-1] == '/')
10864 arch
->longnames
[j
] = '\0';
10866 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
10867 return arch
->longnames
+ k
;
10869 /* This is a proxy for a member of a nested archive.
10870 Find the name of the member in that archive. */
10871 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
10872 if (member_file_name
!= NULL
10873 && setup_nested_archive (nested_arch
, member_file_name
) == 0
10874 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
10876 free (member_file_name
);
10877 return member_name
;
10879 free (member_file_name
);
10881 /* Last resort: just return the name of the nested archive. */
10882 return arch
->longnames
+ k
;
10885 /* We have a normal (short) name. */
10887 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
10889 arch
->arhdr
.ar_name
[j
] = '\0';
10890 return arch
->arhdr
.ar_name
;
10893 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
10896 get_archive_member_name_at (struct archive_info
* arch
,
10897 unsigned long offset
,
10898 struct archive_info
* nested_arch
)
10902 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
10904 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
10907 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
10908 if (got
!= sizeof arch
->arhdr
)
10910 error (_("%s: failed to read archive header\n"), arch
->file_name
);
10913 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
10915 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
10919 return get_archive_member_name (arch
, nested_arch
);
10922 /* Construct a string showing the name of the archive member, qualified
10923 with the name of the containing archive file. For thin archives, we
10924 use square brackets to denote the indirection. For nested archives,
10925 we show the qualified name of the external member inside the square
10926 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
10929 make_qualified_name (struct archive_info
* arch
,
10930 struct archive_info
* nested_arch
,
10931 char * member_name
)
10936 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
10937 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
10938 len
+= strlen (nested_arch
->file_name
) + 2;
10940 name
= malloc (len
);
10943 error (_("Out of memory\n"));
10947 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
10948 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
10949 else if (arch
->is_thin_archive
)
10950 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
10952 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
10957 /* Process an ELF archive.
10958 On entry the file is positioned just after the ARMAG string. */
10961 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
10963 struct archive_info arch
;
10964 struct archive_info nested_arch
;
10966 size_t file_name_size
;
10971 /* The ARCH structure is used to hold information about this archive. */
10972 arch
.file_name
= NULL
;
10974 arch
.index_array
= NULL
;
10975 arch
.sym_table
= NULL
;
10976 arch
.longnames
= NULL
;
10978 /* The NESTED_ARCH structure is used as a single-item cache of information
10979 about a nested archive (when members of a thin archive reside within
10980 another regular archive file). */
10981 nested_arch
.file_name
= NULL
;
10982 nested_arch
.file
= NULL
;
10983 nested_arch
.index_array
= NULL
;
10984 nested_arch
.sym_table
= NULL
;
10985 nested_arch
.longnames
= NULL
;
10987 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
10993 if (do_archive_index
)
10995 if (arch
.sym_table
== NULL
)
10996 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11000 unsigned long current_pos
;
11002 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11003 file_name
, arch
.index_num
, arch
.sym_size
);
11004 current_pos
= ftell (file
);
11006 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11008 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11010 char * member_name
;
11012 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11014 if (member_name
!= NULL
)
11016 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11018 if (qualified_name
!= NULL
)
11020 printf (_("Binary %s contains:\n"), qualified_name
);
11021 free (qualified_name
);
11026 if (l
>= arch
.sym_size
)
11028 error (_("%s: end of the symbol table reached before the end of the index\n"),
11032 printf ("\t%s\n", arch
.sym_table
+ l
);
11033 l
+= strlen (arch
.sym_table
+ l
) + 1;
11038 if (l
< arch
.sym_size
)
11039 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11042 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11044 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11050 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11051 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11052 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11053 && !do_section_groups
)
11055 ret
= 0; /* Archive index only. */
11060 file_name_size
= strlen (file_name
);
11067 char * qualified_name
;
11069 /* Read the next archive header. */
11070 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11072 error (_("%s: failed to seek to next archive header\n"), file_name
);
11075 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11076 if (got
!= sizeof arch
.arhdr
)
11080 error (_("%s: failed to read archive header\n"), file_name
);
11084 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11086 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11091 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11093 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11094 if (archive_file_size
& 01)
11095 ++archive_file_size
;
11097 name
= get_archive_member_name (&arch
, &nested_arch
);
11100 error (_("%s: bad archive file name\n"), file_name
);
11104 namelen
= strlen (name
);
11106 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11107 if (qualified_name
== NULL
)
11109 error (_("%s: bad archive file name\n"), file_name
);
11114 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11116 /* This is a proxy for an external member of a thin archive. */
11117 FILE * member_file
;
11118 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11119 if (member_file_name
== NULL
)
11125 member_file
= fopen (member_file_name
, "rb");
11126 if (member_file
== NULL
)
11128 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11129 free (member_file_name
);
11134 archive_file_offset
= arch
.nested_member_origin
;
11136 ret
|= process_object (qualified_name
, member_file
);
11138 fclose (member_file
);
11139 free (member_file_name
);
11141 else if (is_thin_archive
)
11143 /* This is a proxy for a member of a nested archive. */
11144 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11146 /* The nested archive file will have been opened and setup by
11147 get_archive_member_name. */
11148 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11150 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11155 ret
|= process_object (qualified_name
, nested_arch
.file
);
11159 archive_file_offset
= arch
.next_arhdr_offset
;
11160 arch
.next_arhdr_offset
+= archive_file_size
;
11162 ret
|= process_object (qualified_name
, file
);
11165 free (qualified_name
);
11169 if (nested_arch
.file
!= NULL
)
11170 fclose (nested_arch
.file
);
11171 release_archive (&nested_arch
);
11172 release_archive (&arch
);
11178 process_file (char * file_name
)
11181 struct stat statbuf
;
11182 char armag
[SARMAG
];
11185 if (stat (file_name
, &statbuf
) < 0)
11187 if (errno
== ENOENT
)
11188 error (_("'%s': No such file\n"), file_name
);
11190 error (_("Could not locate '%s'. System error message: %s\n"),
11191 file_name
, strerror (errno
));
11195 if (! S_ISREG (statbuf
.st_mode
))
11197 error (_("'%s' is not an ordinary file\n"), file_name
);
11201 file
= fopen (file_name
, "rb");
11204 error (_("Input file '%s' is not readable.\n"), file_name
);
11208 if (fread (armag
, SARMAG
, 1, file
) != 1)
11210 error (_("%s: Failed to read file's magic number\n"), file_name
);
11215 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11216 ret
= process_archive (file_name
, file
, FALSE
);
11217 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11218 ret
= process_archive (file_name
, file
, TRUE
);
11221 if (do_archive_index
)
11222 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11226 archive_file_size
= archive_file_offset
= 0;
11227 ret
= process_object (file_name
, file
);
11235 #ifdef SUPPORT_DISASSEMBLY
11236 /* Needed by the i386 disassembler. For extra credit, someone could
11237 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11241 print_address (unsigned int addr
, FILE * outfile
)
11243 fprintf (outfile
,"0x%8.8x", addr
);
11246 /* Needed by the i386 disassembler. */
11248 db_task_printsym (unsigned int addr
)
11250 print_address (addr
, stderr
);
11255 main (int argc
, char ** argv
)
11259 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11260 setlocale (LC_MESSAGES
, "");
11262 #if defined (HAVE_SETLOCALE)
11263 setlocale (LC_CTYPE
, "");
11265 bindtextdomain (PACKAGE
, LOCALEDIR
);
11266 textdomain (PACKAGE
);
11268 expandargv (&argc
, &argv
);
11270 parse_args (argc
, argv
);
11272 if (num_dump_sects
> 0)
11274 /* Make a copy of the dump_sects array. */
11275 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
11276 if (cmdline_dump_sects
== NULL
)
11277 error (_("Out of memory allocating dump request table.\n"));
11280 memcpy (cmdline_dump_sects
, dump_sects
,
11281 num_dump_sects
* sizeof (* dump_sects
));
11282 num_cmdline_dump_sects
= num_dump_sects
;
11286 if (optind
< (argc
- 1))
11290 while (optind
< argc
)
11291 err
|= process_file (argv
[optind
++]);
11293 if (dump_sects
!= NULL
)
11295 if (cmdline_dump_sects
!= NULL
)
11296 free (cmdline_dump_sects
);