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/microblaze.h"
123 #include "elf/mips.h"
124 #include "elf/mmix.h"
125 #include "elf/mn10200.h"
126 #include "elf/mn10300.h"
128 #include "elf/msp430.h"
129 #include "elf/or32.h"
132 #include "elf/ppc64.h"
134 #include "elf/s390.h"
135 #include "elf/score.h"
137 #include "elf/sparc.h"
139 #include "elf/v850.h"
141 #include "elf/x86-64.h"
142 #include "elf/xstormy16.h"
143 #include "elf/xtensa.h"
148 #include "libiberty.h"
149 #include "safe-ctype.h"
150 #include "filenames.h"
152 char * program_name
= "readelf";
153 static long archive_file_offset
;
154 static unsigned long archive_file_size
;
155 static unsigned long dynamic_addr
;
156 static bfd_size_type dynamic_size
;
157 static unsigned int dynamic_nent
;
158 static char * dynamic_strings
;
159 static unsigned long dynamic_strings_length
;
160 static char * string_table
;
161 static unsigned long string_table_length
;
162 static unsigned long num_dynamic_syms
;
163 static Elf_Internal_Sym
* dynamic_symbols
;
164 static Elf_Internal_Syminfo
* dynamic_syminfo
;
165 static unsigned long dynamic_syminfo_offset
;
166 static unsigned int dynamic_syminfo_nent
;
167 static char program_interpreter
[PATH_MAX
];
168 static bfd_vma dynamic_info
[DT_ENCODING
];
169 static bfd_vma dynamic_info_DT_GNU_HASH
;
170 static bfd_vma version_info
[16];
171 static Elf_Internal_Ehdr elf_header
;
172 static Elf_Internal_Shdr
* section_headers
;
173 static Elf_Internal_Phdr
* program_headers
;
174 static Elf_Internal_Dyn
* dynamic_section
;
175 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
176 static int show_name
;
177 static int do_dynamic
;
180 static int do_sections
;
181 static int do_section_groups
;
182 static int do_section_details
;
183 static int do_segments
;
184 static int do_unwind
;
185 static int do_using_dynamic
;
186 static int do_header
;
188 static int do_version
;
189 static int do_histogram
;
190 static int do_debugging
;
193 static int do_archive_index
;
194 static int is_32bit_elf
;
198 struct group_list
* next
;
199 unsigned int section_index
;
204 struct group_list
* root
;
205 unsigned int group_index
;
208 static size_t group_count
;
209 static struct group
* section_groups
;
210 static struct group
** section_headers_groups
;
213 /* Flag bits indicating particular types of dump. */
214 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
215 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
216 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
217 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
218 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
220 typedef unsigned char dump_type
;
222 /* A linked list of the section names for which dumps were requested. */
223 struct dump_list_entry
227 struct dump_list_entry
* next
;
229 static struct dump_list_entry
* dump_sects_byname
;
231 /* A dynamic array of flags indicating for which sections a dump
232 has been requested via command line switches. */
233 static dump_type
* cmdline_dump_sects
= NULL
;
234 static unsigned int num_cmdline_dump_sects
= 0;
236 /* A dynamic array of flags indicating for which sections a dump of
237 some kind has been requested. It is reset on a per-object file
238 basis and then initialised from the cmdline_dump_sects array,
239 the results of interpreting the -w switch, and the
240 dump_sects_byname list. */
241 static dump_type
* dump_sects
= NULL
;
242 static unsigned int num_dump_sects
= 0;
245 /* How to print a vma value. */
246 typedef enum print_mode
258 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
262 #define SECTION_NAME(X) \
263 ((X) == NULL ? "<none>" \
264 : string_table == NULL ? "<no-name>" \
265 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
266 : string_table + (X)->sh_name))
268 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
270 #define BYTE_GET(field) byte_get (field, sizeof (field))
272 #define GET_ELF_SYMBOLS(file, section) \
273 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
274 : get_64bit_elf_symbols (file, section))
276 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
277 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
278 already been called and verified that the string exists. */
279 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
281 /* This is just a bit of syntatic sugar. */
282 #define streq(a,b) (strcmp ((a), (b)) == 0)
283 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
284 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
287 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
292 if (size
== 0 || nmemb
== 0)
295 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
297 error (_("Unable to seek to 0x%lx for %s\n"),
298 (unsigned long) archive_file_offset
+ offset
, reason
);
305 /* Check for overflow. */
306 if (nmemb
< (~(size_t) 0 - 1) / size
)
307 /* + 1 so that we can '\0' terminate invalid string table sections. */
308 mvar
= malloc (size
* nmemb
+ 1);
312 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
313 (unsigned long)(size
* nmemb
), reason
);
317 ((char *) mvar
)[size
* nmemb
] = '\0';
320 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
322 error (_("Unable to read in 0x%lx bytes of %s\n"),
323 (unsigned long)(size
* nmemb
), reason
);
333 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
338 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
339 field
[6] = ((value
>> 24) >> 24) & 0xff;
340 field
[5] = ((value
>> 24) >> 16) & 0xff;
341 field
[4] = ((value
>> 24) >> 8) & 0xff;
344 field
[3] = (value
>> 24) & 0xff;
347 field
[2] = (value
>> 16) & 0xff;
350 field
[1] = (value
>> 8) & 0xff;
353 field
[0] = value
& 0xff;
357 error (_("Unhandled data length: %d\n"), size
);
362 /* Print a VMA value. */
365 print_vma (bfd_vma vma
, print_mode mode
)
378 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
385 return printf ("%5" BFD_VMA_FMT
"d", vma
);
393 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
396 return printf ("%" BFD_VMA_FMT
"d", vma
);
399 return printf ("%" BFD_VMA_FMT
"u", vma
);
404 /* Display a symbol on stdout. Handles the display of non-printing characters.
406 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
407 truncating as necessary. If WIDTH is negative then format the string to be
408 exactly - WIDTH characters, truncating or padding as necessary.
410 Returns the number of emitted characters. */
413 print_symbol (int width
, const char * symbol
)
416 bfd_boolean extra_padding
= FALSE
;
417 unsigned int num_printed
= 0;
421 /* Set the width to a very large value. This simplifies the code below. */
426 /* Keep the width positive. This also helps. */
428 extra_padding
= TRUE
;
437 /* Look for non-printing symbols inside the symbol's name.
438 This test is triggered in particular by the names generated
439 by the assembler for local labels. */
440 while (ISPRINT (* c
))
450 printf ("%.*s", len
, symbol
);
456 if (* c
== 0 || width
== 0)
459 /* Now display the non-printing character, if
460 there is room left in which to dipslay it. */
466 printf ("^%c", *c
+ 0x40);
476 printf ("<0x%.2x>", *c
);
485 if (extra_padding
&& width
> 0)
487 /* Fill in the remaining spaces. */
488 printf ("%-*s", width
, " ");
496 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
501 field
[7] = value
& 0xff;
502 field
[6] = (value
>> 8) & 0xff;
503 field
[5] = (value
>> 16) & 0xff;
504 field
[4] = (value
>> 24) & 0xff;
509 field
[3] = value
& 0xff;
513 field
[2] = value
& 0xff;
517 field
[1] = value
& 0xff;
521 field
[0] = value
& 0xff;
525 error (_("Unhandled data length: %d\n"), size
);
530 /* Return a pointer to section NAME, or NULL if no such section exists. */
532 static Elf_Internal_Shdr
*
533 find_section (const char * name
)
537 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
538 if (streq (SECTION_NAME (section_headers
+ i
), name
))
539 return section_headers
+ i
;
544 /* Guess the relocation size commonly used by the specific machines. */
547 guess_is_rela (unsigned int e_machine
)
551 /* Targets that use REL relocations. */
567 /* Targets that use RELA relocations. */
571 case EM_ALTERA_NIOS2
:
591 case EM_LATTICEMICO32
:
599 case EM_CYGNUS_MN10200
:
601 case EM_CYGNUS_MN10300
:
625 case EM_MICROBLAZE_OLD
:
646 warn (_("Don't know about relocations on this machine architecture\n"));
652 slurp_rela_relocs (FILE * file
,
653 unsigned long rel_offset
,
654 unsigned long rel_size
,
655 Elf_Internal_Rela
** relasp
,
656 unsigned long * nrelasp
)
658 Elf_Internal_Rela
* relas
;
659 unsigned long nrelas
;
664 Elf32_External_Rela
* erelas
;
666 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
667 rel_size
, _("relocs"));
671 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
673 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
674 sizeof (Elf_Internal_Rela
));
679 error (_("out of memory parsing relocs\n"));
683 for (i
= 0; i
< nrelas
; i
++)
685 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
686 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
687 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
694 Elf64_External_Rela
* erelas
;
696 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
697 rel_size
, _("relocs"));
701 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
703 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
704 sizeof (Elf_Internal_Rela
));
709 error (_("out of memory parsing relocs\n"));
713 for (i
= 0; i
< nrelas
; i
++)
715 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
716 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
717 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
719 /* The #ifdef BFD64 below is to prevent a compile time
720 warning. We know that if we do not have a 64 bit data
721 type that we will never execute this code anyway. */
723 if (elf_header
.e_machine
== EM_MIPS
724 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
726 /* In little-endian objects, r_info isn't really a
727 64-bit little-endian value: it has a 32-bit
728 little-endian symbol index followed by four
729 individual byte fields. Reorder INFO
731 bfd_vma info
= relas
[i
].r_info
;
732 info
= (((info
& 0xffffffff) << 32)
733 | ((info
>> 56) & 0xff)
734 | ((info
>> 40) & 0xff00)
735 | ((info
>> 24) & 0xff0000)
736 | ((info
>> 8) & 0xff000000));
737 relas
[i
].r_info
= info
;
750 slurp_rel_relocs (FILE * file
,
751 unsigned long rel_offset
,
752 unsigned long rel_size
,
753 Elf_Internal_Rela
** relsp
,
754 unsigned long * nrelsp
)
756 Elf_Internal_Rela
* rels
;
762 Elf32_External_Rel
* erels
;
764 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
765 rel_size
, _("relocs"));
769 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
771 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
776 error (_("out of memory parsing relocs\n"));
780 for (i
= 0; i
< nrels
; i
++)
782 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
783 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
784 rels
[i
].r_addend
= 0;
791 Elf64_External_Rel
* erels
;
793 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
794 rel_size
, _("relocs"));
798 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
800 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
805 error (_("out of memory parsing relocs\n"));
809 for (i
= 0; i
< nrels
; i
++)
811 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
812 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
813 rels
[i
].r_addend
= 0;
815 /* The #ifdef BFD64 below is to prevent a compile time
816 warning. We know that if we do not have a 64 bit data
817 type that we will never execute this code anyway. */
819 if (elf_header
.e_machine
== EM_MIPS
820 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
822 /* In little-endian objects, r_info isn't really a
823 64-bit little-endian value: it has a 32-bit
824 little-endian symbol index followed by four
825 individual byte fields. Reorder INFO
827 bfd_vma info
= rels
[i
].r_info
;
828 info
= (((info
& 0xffffffff) << 32)
829 | ((info
>> 56) & 0xff)
830 | ((info
>> 40) & 0xff00)
831 | ((info
>> 24) & 0xff0000)
832 | ((info
>> 8) & 0xff000000));
833 rels
[i
].r_info
= info
;
845 /* Returns the reloc type extracted from the reloc info field. */
848 get_reloc_type (bfd_vma reloc_info
)
851 return ELF32_R_TYPE (reloc_info
);
853 switch (elf_header
.e_machine
)
856 /* Note: We assume that reloc_info has already been adjusted for us. */
857 return ELF64_MIPS_R_TYPE (reloc_info
);
860 return ELF64_R_TYPE_ID (reloc_info
);
863 return ELF64_R_TYPE (reloc_info
);
867 /* Return the symbol index extracted from the reloc info field. */
870 get_reloc_symindex (bfd_vma reloc_info
)
872 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
875 /* Display the contents of the relocation data found at the specified
879 dump_relocations (FILE * file
,
880 unsigned long rel_offset
,
881 unsigned long rel_size
,
882 Elf_Internal_Sym
* symtab
,
885 unsigned long strtablen
,
889 Elf_Internal_Rela
* rels
;
891 if (is_rela
== UNKNOWN
)
892 is_rela
= guess_is_rela (elf_header
.e_machine
);
896 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
901 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
910 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
912 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
917 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
919 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
927 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
929 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
934 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
936 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
940 for (i
= 0; i
< rel_size
; i
++)
945 bfd_vma symtab_index
;
948 offset
= rels
[i
].r_offset
;
949 info
= rels
[i
].r_info
;
951 type
= get_reloc_type (info
);
952 symtab_index
= get_reloc_symindex (info
);
956 printf ("%8.8lx %8.8lx ",
957 (unsigned long) offset
& 0xffffffff,
958 (unsigned long) info
& 0xffffffff);
962 #if BFD_HOST_64BIT_LONG
964 ? "%16.16lx %16.16lx "
965 : "%12.12lx %12.12lx ",
967 #elif BFD_HOST_64BIT_LONG_LONG
970 ? "%16.16llx %16.16llx "
971 : "%12.12llx %12.12llx ",
975 ? "%16.16I64x %16.16I64x "
976 : "%12.12I64x %12.12I64x ",
981 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
982 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
983 _bfd_int64_high (offset
),
984 _bfd_int64_low (offset
),
985 _bfd_int64_high (info
),
986 _bfd_int64_low (info
));
990 switch (elf_header
.e_machine
)
998 rtype
= elf_m32r_reloc_type (type
);
1003 rtype
= elf_i386_reloc_type (type
);
1008 rtype
= elf_m68hc11_reloc_type (type
);
1012 rtype
= elf_m68k_reloc_type (type
);
1016 rtype
= elf_i960_reloc_type (type
);
1021 rtype
= elf_avr_reloc_type (type
);
1024 case EM_OLD_SPARCV9
:
1025 case EM_SPARC32PLUS
:
1028 rtype
= elf_sparc_reloc_type (type
);
1032 rtype
= elf_spu_reloc_type (type
);
1036 case EM_CYGNUS_V850
:
1037 rtype
= v850_reloc_type (type
);
1041 case EM_CYGNUS_D10V
:
1042 rtype
= elf_d10v_reloc_type (type
);
1046 case EM_CYGNUS_D30V
:
1047 rtype
= elf_d30v_reloc_type (type
);
1051 rtype
= elf_dlx_reloc_type (type
);
1055 rtype
= elf_sh_reloc_type (type
);
1059 case EM_CYGNUS_MN10300
:
1060 rtype
= elf_mn10300_reloc_type (type
);
1064 case EM_CYGNUS_MN10200
:
1065 rtype
= elf_mn10200_reloc_type (type
);
1069 case EM_CYGNUS_FR30
:
1070 rtype
= elf_fr30_reloc_type (type
);
1074 rtype
= elf_frv_reloc_type (type
);
1078 rtype
= elf_mcore_reloc_type (type
);
1082 rtype
= elf_mmix_reloc_type (type
);
1087 rtype
= elf_msp430_reloc_type (type
);
1091 rtype
= elf_ppc_reloc_type (type
);
1095 rtype
= elf_ppc64_reloc_type (type
);
1099 case EM_MIPS_RS3_LE
:
1100 rtype
= elf_mips_reloc_type (type
);
1104 rtype
= elf_alpha_reloc_type (type
);
1108 rtype
= elf_arm_reloc_type (type
);
1112 rtype
= elf_arc_reloc_type (type
);
1116 rtype
= elf_hppa_reloc_type (type
);
1122 rtype
= elf_h8_reloc_type (type
);
1127 rtype
= elf_or32_reloc_type (type
);
1132 rtype
= elf_pj_reloc_type (type
);
1135 rtype
= elf_ia64_reloc_type (type
);
1139 rtype
= elf_cris_reloc_type (type
);
1143 rtype
= elf_i860_reloc_type (type
);
1148 rtype
= elf_x86_64_reloc_type (type
);
1152 rtype
= i370_reloc_type (type
);
1157 rtype
= elf_s390_reloc_type (type
);
1161 rtype
= elf_score_reloc_type (type
);
1165 rtype
= elf_xstormy16_reloc_type (type
);
1169 rtype
= elf_crx_reloc_type (type
);
1173 rtype
= elf_vax_reloc_type (type
);
1178 rtype
= elf_ip2k_reloc_type (type
);
1182 rtype
= elf_iq2000_reloc_type (type
);
1187 rtype
= elf_xtensa_reloc_type (type
);
1190 case EM_LATTICEMICO32
:
1191 rtype
= elf_lm32_reloc_type (type
);
1196 rtype
= elf_m32c_reloc_type (type
);
1200 rtype
= elf_mt_reloc_type (type
);
1204 rtype
= elf_bfin_reloc_type (type
);
1208 rtype
= elf_mep_reloc_type (type
);
1213 rtype
= elf_cr16_reloc_type (type
);
1217 case EM_MICROBLAZE_OLD
:
1218 rtype
= elf_microblaze_reloc_type (type
);
1222 rtype
= elf_rx_reloc_type (type
);
1227 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1229 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1231 if (elf_header
.e_machine
== EM_ALPHA
1233 && streq (rtype
, "R_ALPHA_LITUSE")
1236 switch (rels
[i
].r_addend
)
1238 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1239 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1240 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1241 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1242 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1243 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1244 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1245 default: rtype
= NULL
;
1248 printf (" (%s)", rtype
);
1252 printf (_("<unknown addend: %lx>"),
1253 (unsigned long) rels
[i
].r_addend
);
1256 else if (symtab_index
)
1258 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1259 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1262 Elf_Internal_Sym
* psym
;
1264 psym
= symtab
+ symtab_index
;
1268 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1272 unsigned int width
= is_32bit_elf
? 8 : 14;
1274 /* Relocations against GNU_IFUNC symbols do not use the value
1275 of the symbol as the address to relocate against. Instead
1276 they invoke the function named by the symbol and use its
1277 result as the address for relocation.
1279 To indicate this to the user, do not display the value of
1280 the symbol in the "Symbols's Value" field. Instead show
1281 its name followed by () as a hint that the symbol is
1285 || psym
->st_name
== 0
1286 || psym
->st_name
>= strtablen
)
1289 name
= strtab
+ psym
->st_name
;
1291 len
= print_symbol (width
, name
);
1292 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1296 print_vma (psym
->st_value
, LONG_HEX
);
1298 printf (is_32bit_elf
? " " : " ");
1301 if (psym
->st_name
== 0)
1303 const char * sec_name
= "<null>";
1306 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1308 if (psym
->st_shndx
< elf_header
.e_shnum
)
1310 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1311 else if (psym
->st_shndx
== SHN_ABS
)
1313 else if (psym
->st_shndx
== SHN_COMMON
)
1314 sec_name
= "COMMON";
1315 else if (elf_header
.e_machine
== EM_MIPS
1316 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1317 sec_name
= "SCOMMON";
1318 else if (elf_header
.e_machine
== EM_MIPS
1319 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1320 sec_name
= "SUNDEF";
1321 else if ((elf_header
.e_machine
== EM_X86_64
1322 || elf_header
.e_machine
== EM_L1OM
)
1323 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1324 sec_name
= "LARGE_COMMON";
1325 else if (elf_header
.e_machine
== EM_IA_64
1326 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1327 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1328 sec_name
= "ANSI_COM";
1329 else if (elf_header
.e_machine
== EM_IA_64
1330 && (elf_header
.e_ident
[EI_OSABI
]
1331 == ELFOSABI_OPENVMS
)
1332 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1333 sec_name
= "VMS_SYMVEC";
1336 sprintf (name_buf
, "<section 0x%x>",
1337 (unsigned int) psym
->st_shndx
);
1338 sec_name
= name_buf
;
1341 print_symbol (22, sec_name
);
1343 else if (strtab
== NULL
)
1344 printf (_("<string table index: %3ld>"), psym
->st_name
);
1345 else if (psym
->st_name
>= strtablen
)
1346 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1348 print_symbol (22, strtab
+ psym
->st_name
);
1352 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1355 printf (" - %lx", - offset
);
1357 printf (" + %lx", offset
);
1363 printf ("%*c", is_32bit_elf
?
1364 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1365 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1368 if (elf_header
.e_machine
== EM_SPARCV9
1370 && streq (rtype
, "R_SPARC_OLO10"))
1371 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1376 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1378 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1379 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1380 const char * rtype2
= elf_mips_reloc_type (type2
);
1381 const char * rtype3
= elf_mips_reloc_type (type3
);
1383 printf (" Type2: ");
1386 printf (_("unrecognized: %-7lx"),
1387 (unsigned long) type2
& 0xffffffff);
1389 printf ("%-17.17s", rtype2
);
1391 printf ("\n Type3: ");
1394 printf (_("unrecognized: %-7lx"),
1395 (unsigned long) type3
& 0xffffffff);
1397 printf ("%-17.17s", rtype3
);
1408 get_mips_dynamic_type (unsigned long type
)
1412 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1413 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1414 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1415 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1416 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1417 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1418 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1419 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1420 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1421 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1422 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1423 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1424 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1425 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1426 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1427 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1428 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1429 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1430 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1431 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1432 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1433 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1434 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1435 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1436 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1437 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1438 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1439 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1440 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1441 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1442 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1443 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1444 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1445 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1446 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1447 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1448 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1449 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1450 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1451 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1452 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1453 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1454 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1455 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1456 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1463 get_sparc64_dynamic_type (unsigned long type
)
1467 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1474 get_ppc_dynamic_type (unsigned long type
)
1478 case DT_PPC_GOT
: return "PPC_GOT";
1479 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1486 get_ppc64_dynamic_type (unsigned long type
)
1490 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1491 case DT_PPC64_OPD
: return "PPC64_OPD";
1492 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1493 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1500 get_parisc_dynamic_type (unsigned long type
)
1504 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1505 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1506 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1507 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1508 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1509 case DT_HP_PREINIT
: return "HP_PREINIT";
1510 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1511 case DT_HP_NEEDED
: return "HP_NEEDED";
1512 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1513 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1514 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1515 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1516 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1517 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1518 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1519 case DT_HP_FILTERED
: return "HP_FILTERED";
1520 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1521 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1522 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1523 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1524 case DT_PLT
: return "PLT";
1525 case DT_PLT_SIZE
: return "PLT_SIZE";
1526 case DT_DLT
: return "DLT";
1527 case DT_DLT_SIZE
: return "DLT_SIZE";
1534 get_ia64_dynamic_type (unsigned long type
)
1538 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1539 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1540 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1541 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1542 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1543 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1544 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1545 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1546 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1547 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1548 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1549 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1550 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1551 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1552 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1553 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1554 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1555 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1556 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1557 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1558 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1559 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1560 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1561 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1562 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1563 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1564 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1565 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1566 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1567 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1568 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1575 get_alpha_dynamic_type (unsigned long type
)
1579 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1586 get_score_dynamic_type (unsigned long type
)
1590 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1591 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1592 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1593 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1594 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1595 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1603 get_dynamic_type (unsigned long type
)
1605 static char buff
[64];
1609 case DT_NULL
: return "NULL";
1610 case DT_NEEDED
: return "NEEDED";
1611 case DT_PLTRELSZ
: return "PLTRELSZ";
1612 case DT_PLTGOT
: return "PLTGOT";
1613 case DT_HASH
: return "HASH";
1614 case DT_STRTAB
: return "STRTAB";
1615 case DT_SYMTAB
: return "SYMTAB";
1616 case DT_RELA
: return "RELA";
1617 case DT_RELASZ
: return "RELASZ";
1618 case DT_RELAENT
: return "RELAENT";
1619 case DT_STRSZ
: return "STRSZ";
1620 case DT_SYMENT
: return "SYMENT";
1621 case DT_INIT
: return "INIT";
1622 case DT_FINI
: return "FINI";
1623 case DT_SONAME
: return "SONAME";
1624 case DT_RPATH
: return "RPATH";
1625 case DT_SYMBOLIC
: return "SYMBOLIC";
1626 case DT_REL
: return "REL";
1627 case DT_RELSZ
: return "RELSZ";
1628 case DT_RELENT
: return "RELENT";
1629 case DT_PLTREL
: return "PLTREL";
1630 case DT_DEBUG
: return "DEBUG";
1631 case DT_TEXTREL
: return "TEXTREL";
1632 case DT_JMPREL
: return "JMPREL";
1633 case DT_BIND_NOW
: return "BIND_NOW";
1634 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1635 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1636 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1637 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1638 case DT_RUNPATH
: return "RUNPATH";
1639 case DT_FLAGS
: return "FLAGS";
1641 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1642 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1644 case DT_CHECKSUM
: return "CHECKSUM";
1645 case DT_PLTPADSZ
: return "PLTPADSZ";
1646 case DT_MOVEENT
: return "MOVEENT";
1647 case DT_MOVESZ
: return "MOVESZ";
1648 case DT_FEATURE
: return "FEATURE";
1649 case DT_POSFLAG_1
: return "POSFLAG_1";
1650 case DT_SYMINSZ
: return "SYMINSZ";
1651 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1653 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1654 case DT_CONFIG
: return "CONFIG";
1655 case DT_DEPAUDIT
: return "DEPAUDIT";
1656 case DT_AUDIT
: return "AUDIT";
1657 case DT_PLTPAD
: return "PLTPAD";
1658 case DT_MOVETAB
: return "MOVETAB";
1659 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1661 case DT_VERSYM
: return "VERSYM";
1663 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1664 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1665 case DT_RELACOUNT
: return "RELACOUNT";
1666 case DT_RELCOUNT
: return "RELCOUNT";
1667 case DT_FLAGS_1
: return "FLAGS_1";
1668 case DT_VERDEF
: return "VERDEF";
1669 case DT_VERDEFNUM
: return "VERDEFNUM";
1670 case DT_VERNEED
: return "VERNEED";
1671 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1673 case DT_AUXILIARY
: return "AUXILIARY";
1674 case DT_USED
: return "USED";
1675 case DT_FILTER
: return "FILTER";
1677 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1678 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1679 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1680 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1681 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1682 case DT_GNU_HASH
: return "GNU_HASH";
1685 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1687 const char * result
;
1689 switch (elf_header
.e_machine
)
1692 case EM_MIPS_RS3_LE
:
1693 result
= get_mips_dynamic_type (type
);
1696 result
= get_sparc64_dynamic_type (type
);
1699 result
= get_ppc_dynamic_type (type
);
1702 result
= get_ppc64_dynamic_type (type
);
1705 result
= get_ia64_dynamic_type (type
);
1708 result
= get_alpha_dynamic_type (type
);
1711 result
= get_score_dynamic_type (type
);
1721 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1723 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1724 || (elf_header
.e_machine
== EM_PARISC
1725 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1727 const char * result
;
1729 switch (elf_header
.e_machine
)
1732 result
= get_parisc_dynamic_type (type
);
1735 result
= get_ia64_dynamic_type (type
);
1745 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1749 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1756 get_file_type (unsigned e_type
)
1758 static char buff
[32];
1762 case ET_NONE
: return _("NONE (None)");
1763 case ET_REL
: return _("REL (Relocatable file)");
1764 case ET_EXEC
: return _("EXEC (Executable file)");
1765 case ET_DYN
: return _("DYN (Shared object file)");
1766 case ET_CORE
: return _("CORE (Core file)");
1769 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1770 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1771 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1772 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1774 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1780 get_machine_name (unsigned e_machine
)
1782 static char buff
[64]; /* XXX */
1786 case EM_NONE
: return _("None");
1787 case EM_M32
: return "WE32100";
1788 case EM_SPARC
: return "Sparc";
1789 case EM_SPU
: return "SPU";
1790 case EM_386
: return "Intel 80386";
1791 case EM_68K
: return "MC68000";
1792 case EM_88K
: return "MC88000";
1793 case EM_486
: return "Intel 80486";
1794 case EM_860
: return "Intel 80860";
1795 case EM_MIPS
: return "MIPS R3000";
1796 case EM_S370
: return "IBM System/370";
1797 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1798 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1799 case EM_PARISC
: return "HPPA";
1800 case EM_PPC_OLD
: return "Power PC (old)";
1801 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1802 case EM_960
: return "Intel 90860";
1803 case EM_PPC
: return "PowerPC";
1804 case EM_PPC64
: return "PowerPC64";
1805 case EM_V800
: return "NEC V800";
1806 case EM_FR20
: return "Fujitsu FR20";
1807 case EM_RH32
: return "TRW RH32";
1808 case EM_MCORE
: return "MCORE";
1809 case EM_ARM
: return "ARM";
1810 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1811 case EM_SH
: return "Renesas / SuperH SH";
1812 case EM_SPARCV9
: return "Sparc v9";
1813 case EM_TRICORE
: return "Siemens Tricore";
1814 case EM_ARC
: return "ARC";
1815 case EM_H8_300
: return "Renesas H8/300";
1816 case EM_H8_300H
: return "Renesas H8/300H";
1817 case EM_H8S
: return "Renesas H8S";
1818 case EM_H8_500
: return "Renesas H8/500";
1819 case EM_IA_64
: return "Intel IA-64";
1820 case EM_MIPS_X
: return "Stanford MIPS-X";
1821 case EM_COLDFIRE
: return "Motorola Coldfire";
1822 case EM_68HC12
: return "Motorola M68HC12";
1823 case EM_ALPHA
: return "Alpha";
1824 case EM_CYGNUS_D10V
:
1825 case EM_D10V
: return "d10v";
1826 case EM_CYGNUS_D30V
:
1827 case EM_D30V
: return "d30v";
1828 case EM_CYGNUS_M32R
:
1829 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1830 case EM_CYGNUS_V850
:
1831 case EM_V850
: return "NEC v850";
1832 case EM_CYGNUS_MN10300
:
1833 case EM_MN10300
: return "mn10300";
1834 case EM_CYGNUS_MN10200
:
1835 case EM_MN10200
: return "mn10200";
1836 case EM_CYGNUS_FR30
:
1837 case EM_FR30
: return "Fujitsu FR30";
1838 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1840 case EM_PJ
: return "picoJava";
1841 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1842 case EM_PCP
: return "Siemens PCP";
1843 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1844 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1845 case EM_STARCORE
: return "Motorola Star*Core processor";
1846 case EM_ME16
: return "Toyota ME16 processor";
1847 case EM_ST100
: return "STMicroelectronics ST100 processor";
1848 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1849 case EM_FX66
: return "Siemens FX66 microcontroller";
1850 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1851 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1852 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1853 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1854 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1855 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1856 case EM_SVX
: return "Silicon Graphics SVx";
1857 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1858 case EM_VAX
: return "Digital VAX";
1860 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1861 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1862 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1863 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1864 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1865 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1866 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1867 case EM_PRISM
: return "Vitesse Prism";
1868 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1869 case EM_L1OM
: return "Intel L1OM";
1871 case EM_S390
: return "IBM S/390";
1872 case EM_SCORE
: return "SUNPLUS S+Core";
1873 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1875 case EM_OR32
: return "OpenRISC";
1876 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1877 case EM_DLX
: return "OpenDLX";
1879 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1880 case EM_IQ2000
: return "Vitesse IQ2000";
1882 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1883 case EM_LATTICEMICO32
: return "Lattice Mico32";
1885 case EM_M32C
: return "Renesas M32c";
1886 case EM_MT
: return "Morpho Techologies MT processor";
1887 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1888 case EM_NIOS32
: return "Altera Nios";
1889 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1890 case EM_XC16X
: return "Infineon Technologies xc16x";
1891 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1893 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1894 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1895 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1896 case EM_RX
: return "Renesas RX";
1898 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1904 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1909 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1910 e_flags
&= ~ EF_ARM_EABIMASK
;
1912 /* Handle "generic" ARM flags. */
1913 if (e_flags
& EF_ARM_RELEXEC
)
1915 strcat (buf
, ", relocatable executable");
1916 e_flags
&= ~ EF_ARM_RELEXEC
;
1919 if (e_flags
& EF_ARM_HASENTRY
)
1921 strcat (buf
, ", has entry point");
1922 e_flags
&= ~ EF_ARM_HASENTRY
;
1925 /* Now handle EABI specific flags. */
1929 strcat (buf
, ", <unrecognized EABI>");
1934 case EF_ARM_EABI_VER1
:
1935 strcat (buf
, ", Version1 EABI");
1940 /* Process flags one bit at a time. */
1941 flag
= e_flags
& - e_flags
;
1946 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1947 strcat (buf
, ", sorted symbol tables");
1957 case EF_ARM_EABI_VER2
:
1958 strcat (buf
, ", Version2 EABI");
1963 /* Process flags one bit at a time. */
1964 flag
= e_flags
& - e_flags
;
1969 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1970 strcat (buf
, ", sorted symbol tables");
1973 case EF_ARM_DYNSYMSUSESEGIDX
:
1974 strcat (buf
, ", dynamic symbols use segment index");
1977 case EF_ARM_MAPSYMSFIRST
:
1978 strcat (buf
, ", mapping symbols precede others");
1988 case EF_ARM_EABI_VER3
:
1989 strcat (buf
, ", Version3 EABI");
1992 case EF_ARM_EABI_VER4
:
1993 strcat (buf
, ", Version4 EABI");
1996 case EF_ARM_EABI_VER5
:
1997 strcat (buf
, ", Version5 EABI");
2003 /* Process flags one bit at a time. */
2004 flag
= e_flags
& - e_flags
;
2010 strcat (buf
, ", BE8");
2014 strcat (buf
, ", LE8");
2024 case EF_ARM_EABI_UNKNOWN
:
2025 strcat (buf
, ", GNU EABI");
2030 /* Process flags one bit at a time. */
2031 flag
= e_flags
& - e_flags
;
2036 case EF_ARM_INTERWORK
:
2037 strcat (buf
, ", interworking enabled");
2040 case EF_ARM_APCS_26
:
2041 strcat (buf
, ", uses APCS/26");
2044 case EF_ARM_APCS_FLOAT
:
2045 strcat (buf
, ", uses APCS/float");
2049 strcat (buf
, ", position independent");
2053 strcat (buf
, ", 8 bit structure alignment");
2056 case EF_ARM_NEW_ABI
:
2057 strcat (buf
, ", uses new ABI");
2060 case EF_ARM_OLD_ABI
:
2061 strcat (buf
, ", uses old ABI");
2064 case EF_ARM_SOFT_FLOAT
:
2065 strcat (buf
, ", software FP");
2068 case EF_ARM_VFP_FLOAT
:
2069 strcat (buf
, ", VFP");
2072 case EF_ARM_MAVERICK_FLOAT
:
2073 strcat (buf
, ", Maverick FP");
2084 strcat (buf
,", <unknown>");
2088 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2090 static char buf
[1024];
2102 decode_ARM_machine_flags (e_flags
, buf
);
2106 switch (e_flags
& EF_FRV_CPU_MASK
)
2108 case EF_FRV_CPU_GENERIC
:
2112 strcat (buf
, ", fr???");
2115 case EF_FRV_CPU_FR300
:
2116 strcat (buf
, ", fr300");
2119 case EF_FRV_CPU_FR400
:
2120 strcat (buf
, ", fr400");
2122 case EF_FRV_CPU_FR405
:
2123 strcat (buf
, ", fr405");
2126 case EF_FRV_CPU_FR450
:
2127 strcat (buf
, ", fr450");
2130 case EF_FRV_CPU_FR500
:
2131 strcat (buf
, ", fr500");
2133 case EF_FRV_CPU_FR550
:
2134 strcat (buf
, ", fr550");
2137 case EF_FRV_CPU_SIMPLE
:
2138 strcat (buf
, ", simple");
2140 case EF_FRV_CPU_TOMCAT
:
2141 strcat (buf
, ", tomcat");
2147 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2148 strcat (buf
, ", m68000");
2149 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2150 strcat (buf
, ", cpu32");
2151 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2152 strcat (buf
, ", fido_a");
2155 char const * isa
= _("unknown");
2156 char const * mac
= _("unknown mac");
2157 char const * additional
= NULL
;
2159 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2161 case EF_M68K_CF_ISA_A_NODIV
:
2163 additional
= ", nodiv";
2165 case EF_M68K_CF_ISA_A
:
2168 case EF_M68K_CF_ISA_A_PLUS
:
2171 case EF_M68K_CF_ISA_B_NOUSP
:
2173 additional
= ", nousp";
2175 case EF_M68K_CF_ISA_B
:
2179 strcat (buf
, ", cf, isa ");
2182 strcat (buf
, additional
);
2183 if (e_flags
& EF_M68K_CF_FLOAT
)
2184 strcat (buf
, ", float");
2185 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2190 case EF_M68K_CF_MAC
:
2193 case EF_M68K_CF_EMAC
:
2206 if (e_flags
& EF_PPC_EMB
)
2207 strcat (buf
, ", emb");
2209 if (e_flags
& EF_PPC_RELOCATABLE
)
2210 strcat (buf
, ", relocatable");
2212 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2213 strcat (buf
, ", relocatable-lib");
2217 case EM_CYGNUS_V850
:
2218 switch (e_flags
& EF_V850_ARCH
)
2221 strcat (buf
, ", v850e1");
2224 strcat (buf
, ", v850e");
2227 strcat (buf
, ", v850");
2230 strcat (buf
, ", unknown v850 architecture variant");
2236 case EM_CYGNUS_M32R
:
2237 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2238 strcat (buf
, ", m32r");
2242 case EM_MIPS_RS3_LE
:
2243 if (e_flags
& EF_MIPS_NOREORDER
)
2244 strcat (buf
, ", noreorder");
2246 if (e_flags
& EF_MIPS_PIC
)
2247 strcat (buf
, ", pic");
2249 if (e_flags
& EF_MIPS_CPIC
)
2250 strcat (buf
, ", cpic");
2252 if (e_flags
& EF_MIPS_UCODE
)
2253 strcat (buf
, ", ugen_reserved");
2255 if (e_flags
& EF_MIPS_ABI2
)
2256 strcat (buf
, ", abi2");
2258 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2259 strcat (buf
, ", odk first");
2261 if (e_flags
& EF_MIPS_32BITMODE
)
2262 strcat (buf
, ", 32bitmode");
2264 switch ((e_flags
& EF_MIPS_MACH
))
2266 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2267 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2268 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2269 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2270 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2271 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2272 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2273 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2274 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2275 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2276 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2277 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2278 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2279 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2281 /* We simply ignore the field in this case to avoid confusion:
2282 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2285 default: strcat (buf
, ", unknown CPU"); break;
2288 switch ((e_flags
& EF_MIPS_ABI
))
2290 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2291 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2292 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2293 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2295 /* We simply ignore the field in this case to avoid confusion:
2296 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2297 This means it is likely to be an o32 file, but not for
2300 default: strcat (buf
, ", unknown ABI"); break;
2303 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2304 strcat (buf
, ", mdmx");
2306 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2307 strcat (buf
, ", mips16");
2309 switch ((e_flags
& EF_MIPS_ARCH
))
2311 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2312 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2313 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2314 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2315 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2316 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2317 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2318 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2319 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2320 default: strcat (buf
, ", unknown ISA"); break;
2326 switch ((e_flags
& EF_SH_MACH_MASK
))
2328 case EF_SH1
: strcat (buf
, ", sh1"); break;
2329 case EF_SH2
: strcat (buf
, ", sh2"); break;
2330 case EF_SH3
: strcat (buf
, ", sh3"); break;
2331 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2332 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2333 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2334 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2335 case EF_SH4
: strcat (buf
, ", sh4"); break;
2336 case EF_SH5
: strcat (buf
, ", sh5"); break;
2337 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2338 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2339 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2340 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2341 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2342 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2343 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2344 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2345 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2346 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2347 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2348 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2349 default: strcat (buf
, ", unknown ISA"); break;
2355 if (e_flags
& EF_SPARC_32PLUS
)
2356 strcat (buf
, ", v8+");
2358 if (e_flags
& EF_SPARC_SUN_US1
)
2359 strcat (buf
, ", ultrasparcI");
2361 if (e_flags
& EF_SPARC_SUN_US3
)
2362 strcat (buf
, ", ultrasparcIII");
2364 if (e_flags
& EF_SPARC_HAL_R1
)
2365 strcat (buf
, ", halr1");
2367 if (e_flags
& EF_SPARC_LEDATA
)
2368 strcat (buf
, ", ledata");
2370 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2371 strcat (buf
, ", tso");
2373 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2374 strcat (buf
, ", pso");
2376 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2377 strcat (buf
, ", rmo");
2381 switch (e_flags
& EF_PARISC_ARCH
)
2383 case EFA_PARISC_1_0
:
2384 strcpy (buf
, ", PA-RISC 1.0");
2386 case EFA_PARISC_1_1
:
2387 strcpy (buf
, ", PA-RISC 1.1");
2389 case EFA_PARISC_2_0
:
2390 strcpy (buf
, ", PA-RISC 2.0");
2395 if (e_flags
& EF_PARISC_TRAPNIL
)
2396 strcat (buf
, ", trapnil");
2397 if (e_flags
& EF_PARISC_EXT
)
2398 strcat (buf
, ", ext");
2399 if (e_flags
& EF_PARISC_LSB
)
2400 strcat (buf
, ", lsb");
2401 if (e_flags
& EF_PARISC_WIDE
)
2402 strcat (buf
, ", wide");
2403 if (e_flags
& EF_PARISC_NO_KABP
)
2404 strcat (buf
, ", no kabp");
2405 if (e_flags
& EF_PARISC_LAZYSWAP
)
2406 strcat (buf
, ", lazyswap");
2411 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2412 strcat (buf
, ", new calling convention");
2414 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2415 strcat (buf
, ", gnu calling convention");
2419 if ((e_flags
& EF_IA_64_ABI64
))
2420 strcat (buf
, ", 64-bit");
2422 strcat (buf
, ", 32-bit");
2423 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2424 strcat (buf
, ", reduced fp model");
2425 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2426 strcat (buf
, ", no function descriptors, constant gp");
2427 else if ((e_flags
& EF_IA_64_CONS_GP
))
2428 strcat (buf
, ", constant gp");
2429 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2430 strcat (buf
, ", absolute");
2434 if ((e_flags
& EF_VAX_NONPIC
))
2435 strcat (buf
, ", non-PIC");
2436 if ((e_flags
& EF_VAX_DFLOAT
))
2437 strcat (buf
, ", D-Float");
2438 if ((e_flags
& EF_VAX_GFLOAT
))
2439 strcat (buf
, ", G-Float");
2443 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2444 strcat (buf
, ", 64-bit doubles");
2445 if (e_flags
& E_FLAG_RX_DSP
)
2446 strcat (buf
, ", dsp");
2454 get_osabi_name (unsigned int osabi
)
2456 static char buff
[32];
2460 case ELFOSABI_NONE
: return "UNIX - System V";
2461 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2462 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2463 case ELFOSABI_LINUX
: return "UNIX - Linux";
2464 case ELFOSABI_HURD
: return "GNU/Hurd";
2465 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2466 case ELFOSABI_AIX
: return "UNIX - AIX";
2467 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2468 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2469 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2470 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2471 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2472 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2473 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2474 case ELFOSABI_AROS
: return "AROS";
2475 case ELFOSABI_STANDALONE
: return _("Standalone App");
2476 case ELFOSABI_ARM
: return "ARM";
2478 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2484 get_arm_segment_type (unsigned long type
)
2498 get_mips_segment_type (unsigned long type
)
2502 case PT_MIPS_REGINFO
:
2504 case PT_MIPS_RTPROC
:
2506 case PT_MIPS_OPTIONS
:
2516 get_parisc_segment_type (unsigned long type
)
2520 case PT_HP_TLS
: return "HP_TLS";
2521 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2522 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2523 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2524 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2525 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2526 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2527 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2528 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2529 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2530 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2531 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2532 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2533 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2534 case PT_HP_STACK
: return "HP_STACK";
2535 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2536 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2537 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2538 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2547 get_ia64_segment_type (unsigned long type
)
2551 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2552 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2553 case PT_HP_TLS
: return "HP_TLS";
2554 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2555 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2556 case PT_IA_64_HP_STACK
: return "HP_STACK";
2565 get_segment_type (unsigned long p_type
)
2567 static char buff
[32];
2571 case PT_NULL
: return "NULL";
2572 case PT_LOAD
: return "LOAD";
2573 case PT_DYNAMIC
: return "DYNAMIC";
2574 case PT_INTERP
: return "INTERP";
2575 case PT_NOTE
: return "NOTE";
2576 case PT_SHLIB
: return "SHLIB";
2577 case PT_PHDR
: return "PHDR";
2578 case PT_TLS
: return "TLS";
2580 case PT_GNU_EH_FRAME
:
2581 return "GNU_EH_FRAME";
2582 case PT_GNU_STACK
: return "GNU_STACK";
2583 case PT_GNU_RELRO
: return "GNU_RELRO";
2586 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2588 const char * result
;
2590 switch (elf_header
.e_machine
)
2593 result
= get_arm_segment_type (p_type
);
2596 case EM_MIPS_RS3_LE
:
2597 result
= get_mips_segment_type (p_type
);
2600 result
= get_parisc_segment_type (p_type
);
2603 result
= get_ia64_segment_type (p_type
);
2613 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2615 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2617 const char * result
;
2619 switch (elf_header
.e_machine
)
2622 result
= get_parisc_segment_type (p_type
);
2625 result
= get_ia64_segment_type (p_type
);
2635 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2638 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2645 get_mips_section_type_name (unsigned int sh_type
)
2649 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2650 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2651 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2652 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2653 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2654 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2655 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2656 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2657 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2658 case SHT_MIPS_RELD
: return "MIPS_RELD";
2659 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2660 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2661 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2662 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2663 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2664 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2665 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2666 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2667 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2668 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2669 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2670 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2671 case SHT_MIPS_LINE
: return "MIPS_LINE";
2672 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2673 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2674 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2675 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2676 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2677 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2678 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2679 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2680 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2681 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2682 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2683 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2684 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2685 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2686 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2687 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2695 get_parisc_section_type_name (unsigned int sh_type
)
2699 case SHT_PARISC_EXT
: return "PARISC_EXT";
2700 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2701 case SHT_PARISC_DOC
: return "PARISC_DOC";
2702 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2703 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2704 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2705 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2713 get_ia64_section_type_name (unsigned int sh_type
)
2715 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2716 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2717 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2721 case SHT_IA_64_EXT
: return "IA_64_EXT";
2722 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2723 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2724 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2725 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2726 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2727 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2728 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2729 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2730 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2738 get_x86_64_section_type_name (unsigned int sh_type
)
2742 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2750 get_arm_section_type_name (unsigned int sh_type
)
2754 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2755 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2756 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2757 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2758 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2766 get_section_type_name (unsigned int sh_type
)
2768 static char buff
[32];
2772 case SHT_NULL
: return "NULL";
2773 case SHT_PROGBITS
: return "PROGBITS";
2774 case SHT_SYMTAB
: return "SYMTAB";
2775 case SHT_STRTAB
: return "STRTAB";
2776 case SHT_RELA
: return "RELA";
2777 case SHT_HASH
: return "HASH";
2778 case SHT_DYNAMIC
: return "DYNAMIC";
2779 case SHT_NOTE
: return "NOTE";
2780 case SHT_NOBITS
: return "NOBITS";
2781 case SHT_REL
: return "REL";
2782 case SHT_SHLIB
: return "SHLIB";
2783 case SHT_DYNSYM
: return "DYNSYM";
2784 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2785 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2786 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2787 case SHT_GNU_HASH
: return "GNU_HASH";
2788 case SHT_GROUP
: return "GROUP";
2789 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2790 case SHT_GNU_verdef
: return "VERDEF";
2791 case SHT_GNU_verneed
: return "VERNEED";
2792 case SHT_GNU_versym
: return "VERSYM";
2793 case 0x6ffffff0: return "VERSYM";
2794 case 0x6ffffffc: return "VERDEF";
2795 case 0x7ffffffd: return "AUXILIARY";
2796 case 0x7fffffff: return "FILTER";
2797 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2800 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2802 const char * result
;
2804 switch (elf_header
.e_machine
)
2807 case EM_MIPS_RS3_LE
:
2808 result
= get_mips_section_type_name (sh_type
);
2811 result
= get_parisc_section_type_name (sh_type
);
2814 result
= get_ia64_section_type_name (sh_type
);
2818 result
= get_x86_64_section_type_name (sh_type
);
2821 result
= get_arm_section_type_name (sh_type
);
2831 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2833 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2835 const char * result
;
2837 switch (elf_header
.e_machine
)
2840 result
= get_ia64_section_type_name (sh_type
);
2850 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2852 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2853 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2855 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2861 #define OPTION_DEBUG_DUMP 512
2863 static struct option options
[] =
2865 {"all", no_argument
, 0, 'a'},
2866 {"file-header", no_argument
, 0, 'h'},
2867 {"program-headers", no_argument
, 0, 'l'},
2868 {"headers", no_argument
, 0, 'e'},
2869 {"histogram", no_argument
, 0, 'I'},
2870 {"segments", no_argument
, 0, 'l'},
2871 {"sections", no_argument
, 0, 'S'},
2872 {"section-headers", no_argument
, 0, 'S'},
2873 {"section-groups", no_argument
, 0, 'g'},
2874 {"section-details", no_argument
, 0, 't'},
2875 {"full-section-name",no_argument
, 0, 'N'},
2876 {"symbols", no_argument
, 0, 's'},
2877 {"syms", no_argument
, 0, 's'},
2878 {"relocs", no_argument
, 0, 'r'},
2879 {"notes", no_argument
, 0, 'n'},
2880 {"dynamic", no_argument
, 0, 'd'},
2881 {"arch-specific", no_argument
, 0, 'A'},
2882 {"version-info", no_argument
, 0, 'V'},
2883 {"use-dynamic", no_argument
, 0, 'D'},
2884 {"unwind", no_argument
, 0, 'u'},
2885 {"archive-index", no_argument
, 0, 'c'},
2886 {"hex-dump", required_argument
, 0, 'x'},
2887 {"relocated-dump", required_argument
, 0, 'R'},
2888 {"string-dump", required_argument
, 0, 'p'},
2889 #ifdef SUPPORT_DISASSEMBLY
2890 {"instruction-dump", required_argument
, 0, 'i'},
2892 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2894 {"version", no_argument
, 0, 'v'},
2895 {"wide", no_argument
, 0, 'W'},
2896 {"help", no_argument
, 0, 'H'},
2897 {0, no_argument
, 0, 0}
2901 usage (FILE * stream
)
2903 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2904 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2905 fprintf (stream
, _(" Options are:\n\
2906 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2907 -h --file-header Display the ELF file header\n\
2908 -l --program-headers Display the program headers\n\
2909 --segments An alias for --program-headers\n\
2910 -S --section-headers Display the sections' header\n\
2911 --sections An alias for --section-headers\n\
2912 -g --section-groups Display the section groups\n\
2913 -t --section-details Display the section details\n\
2914 -e --headers Equivalent to: -h -l -S\n\
2915 -s --syms Display the symbol table\n\
2916 --symbols An alias for --syms\n\
2917 -n --notes Display the core notes (if present)\n\
2918 -r --relocs Display the relocations (if present)\n\
2919 -u --unwind Display the unwind info (if present)\n\
2920 -d --dynamic Display the dynamic section (if present)\n\
2921 -V --version-info Display the version sections (if present)\n\
2922 -A --arch-specific Display architecture specific information (if any).\n\
2923 -c --archive-index Display the symbol/file index in an archive\n\
2924 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2925 -x --hex-dump=<number|name>\n\
2926 Dump the contents of section <number|name> as bytes\n\
2927 -p --string-dump=<number|name>\n\
2928 Dump the contents of section <number|name> as strings\n\
2929 -R --relocated-dump=<number|name>\n\
2930 Dump the contents of section <number|name> as relocated bytes\n\
2931 -w[lLiaprmfFsoR] or\n\
2932 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
2933 =frames-interp,=str,=loc,=Ranges]\n\
2934 Display the contents of DWARF2 debug sections\n"));
2935 #ifdef SUPPORT_DISASSEMBLY
2936 fprintf (stream
, _("\
2937 -i --instruction-dump=<number|name>\n\
2938 Disassemble the contents of section <number|name>\n"));
2940 fprintf (stream
, _("\
2941 -I --histogram Display histogram of bucket list lengths\n\
2942 -W --wide Allow output width to exceed 80 characters\n\
2943 @<file> Read options from <file>\n\
2944 -H --help Display this information\n\
2945 -v --version Display the version number of readelf\n"));
2947 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2948 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2950 exit (stream
== stdout
? 0 : 1);
2953 /* Record the fact that the user wants the contents of section number
2954 SECTION to be displayed using the method(s) encoded as flags bits
2955 in TYPE. Note, TYPE can be zero if we are creating the array for
2959 request_dump_bynumber (unsigned int section
, dump_type type
)
2961 if (section
>= num_dump_sects
)
2963 dump_type
* new_dump_sects
;
2965 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
2966 sizeof (* dump_sects
));
2968 if (new_dump_sects
== NULL
)
2969 error (_("Out of memory allocating dump request table.\n"));
2972 /* Copy current flag settings. */
2973 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2977 dump_sects
= new_dump_sects
;
2978 num_dump_sects
= section
+ 1;
2983 dump_sects
[section
] |= type
;
2988 /* Request a dump by section name. */
2991 request_dump_byname (const char * section
, dump_type type
)
2993 struct dump_list_entry
* new_request
;
2995 new_request
= (struct dump_list_entry
*)
2996 malloc (sizeof (struct dump_list_entry
));
2998 error (_("Out of memory allocating dump request table.\n"));
3000 new_request
->name
= strdup (section
);
3001 if (!new_request
->name
)
3002 error (_("Out of memory allocating dump request table.\n"));
3004 new_request
->type
= type
;
3006 new_request
->next
= dump_sects_byname
;
3007 dump_sects_byname
= new_request
;
3011 request_dump (dump_type type
)
3017 section
= strtoul (optarg
, & cp
, 0);
3019 if (! *cp
&& section
>= 0)
3020 request_dump_bynumber (section
, type
);
3022 request_dump_byname (optarg
, type
);
3027 parse_args (int argc
, char ** argv
)
3034 while ((c
= getopt_long
3035 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3053 do_section_groups
++;
3061 do_section_groups
++;
3066 do_section_details
++;
3110 request_dump (HEX_DUMP
);
3113 request_dump (STRING_DUMP
);
3116 request_dump (RELOC_DUMP
);
3123 dwarf_select_sections_all ();
3128 dwarf_select_sections_by_letters (optarg
);
3131 case OPTION_DEBUG_DUMP
:
3138 dwarf_select_sections_by_names (optarg
);
3141 #ifdef SUPPORT_DISASSEMBLY
3143 request_dump (DISASS_DUMP
);
3147 print_version (program_name
);
3156 /* xgettext:c-format */
3157 error (_("Invalid option '-%c'\n"), c
);
3164 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3165 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3166 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3167 && !do_section_groups
&& !do_archive_index
)
3171 warn (_("Nothing to do.\n"));
3177 get_elf_class (unsigned int elf_class
)
3179 static char buff
[32];
3183 case ELFCLASSNONE
: return _("none");
3184 case ELFCLASS32
: return "ELF32";
3185 case ELFCLASS64
: return "ELF64";
3187 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3193 get_data_encoding (unsigned int encoding
)
3195 static char buff
[32];
3199 case ELFDATANONE
: return _("none");
3200 case ELFDATA2LSB
: return _("2's complement, little endian");
3201 case ELFDATA2MSB
: return _("2's complement, big endian");
3203 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3208 /* Decode the data held in 'elf_header'. */
3211 process_file_header (void)
3213 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3214 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3215 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3216 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3219 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3223 init_dwarf_regnames (elf_header
.e_machine
);
3229 printf (_("ELF Header:\n"));
3230 printf (_(" Magic: "));
3231 for (i
= 0; i
< EI_NIDENT
; i
++)
3232 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3234 printf (_(" Class: %s\n"),
3235 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3236 printf (_(" Data: %s\n"),
3237 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3238 printf (_(" Version: %d %s\n"),
3239 elf_header
.e_ident
[EI_VERSION
],
3240 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3242 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3245 printf (_(" OS/ABI: %s\n"),
3246 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3247 printf (_(" ABI Version: %d\n"),
3248 elf_header
.e_ident
[EI_ABIVERSION
]);
3249 printf (_(" Type: %s\n"),
3250 get_file_type (elf_header
.e_type
));
3251 printf (_(" Machine: %s\n"),
3252 get_machine_name (elf_header
.e_machine
));
3253 printf (_(" Version: 0x%lx\n"),
3254 (unsigned long) elf_header
.e_version
);
3256 printf (_(" Entry point address: "));
3257 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3258 printf (_("\n Start of program headers: "));
3259 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3260 printf (_(" (bytes into file)\n Start of section headers: "));
3261 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3262 printf (_(" (bytes into file)\n"));
3264 printf (_(" Flags: 0x%lx%s\n"),
3265 (unsigned long) elf_header
.e_flags
,
3266 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3267 printf (_(" Size of this header: %ld (bytes)\n"),
3268 (long) elf_header
.e_ehsize
);
3269 printf (_(" Size of program headers: %ld (bytes)\n"),
3270 (long) elf_header
.e_phentsize
);
3271 printf (_(" Number of program headers: %ld\n"),
3272 (long) elf_header
.e_phnum
);
3273 printf (_(" Size of section headers: %ld (bytes)\n"),
3274 (long) elf_header
.e_shentsize
);
3275 printf (_(" Number of section headers: %ld"),
3276 (long) elf_header
.e_shnum
);
3277 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3278 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3279 putc ('\n', stdout
);
3280 printf (_(" Section header string table index: %ld"),
3281 (long) elf_header
.e_shstrndx
);
3282 if (section_headers
!= NULL
3283 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3284 printf (" (%u)", section_headers
[0].sh_link
);
3285 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3286 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3287 printf (" <corrupt: out of range>");
3288 putc ('\n', stdout
);
3291 if (section_headers
!= NULL
)
3293 if (elf_header
.e_shnum
== SHN_UNDEF
)
3294 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3295 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3296 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3297 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3298 elf_header
.e_shstrndx
= SHN_UNDEF
;
3299 free (section_headers
);
3300 section_headers
= NULL
;
3308 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3310 Elf32_External_Phdr
* phdrs
;
3311 Elf32_External_Phdr
* external
;
3312 Elf_Internal_Phdr
* internal
;
3315 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3316 elf_header
.e_phentsize
,
3318 _("program headers"));
3322 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3323 i
< elf_header
.e_phnum
;
3324 i
++, internal
++, external
++)
3326 internal
->p_type
= BYTE_GET (external
->p_type
);
3327 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3328 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3329 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3330 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3331 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3332 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3333 internal
->p_align
= BYTE_GET (external
->p_align
);
3342 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3344 Elf64_External_Phdr
* phdrs
;
3345 Elf64_External_Phdr
* external
;
3346 Elf_Internal_Phdr
* internal
;
3349 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3350 elf_header
.e_phentsize
,
3352 _("program headers"));
3356 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3357 i
< elf_header
.e_phnum
;
3358 i
++, internal
++, external
++)
3360 internal
->p_type
= BYTE_GET (external
->p_type
);
3361 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3362 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3363 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3364 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3365 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3366 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3367 internal
->p_align
= BYTE_GET (external
->p_align
);
3375 /* Returns 1 if the program headers were read into `program_headers'. */
3378 get_program_headers (FILE * file
)
3380 Elf_Internal_Phdr
* phdrs
;
3382 /* Check cache of prior read. */
3383 if (program_headers
!= NULL
)
3386 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3387 sizeof (Elf_Internal_Phdr
));
3391 error (_("Out of memory\n"));
3396 ? get_32bit_program_headers (file
, phdrs
)
3397 : get_64bit_program_headers (file
, phdrs
))
3399 program_headers
= phdrs
;
3407 /* Returns 1 if the program headers were loaded. */
3410 process_program_headers (FILE * file
)
3412 Elf_Internal_Phdr
* segment
;
3415 if (elf_header
.e_phnum
== 0)
3418 printf (_("\nThere are no program headers in this file.\n"));
3422 if (do_segments
&& !do_header
)
3424 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3425 printf (_("Entry point "));
3426 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3427 printf (_("\nThere are %d program headers, starting at offset "),
3428 elf_header
.e_phnum
);
3429 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3433 if (! get_program_headers (file
))
3438 if (elf_header
.e_phnum
> 1)
3439 printf (_("\nProgram Headers:\n"));
3441 printf (_("\nProgram Headers:\n"));
3445 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3448 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3452 (_(" Type Offset VirtAddr PhysAddr\n"));
3454 (_(" FileSiz MemSiz Flags Align\n"));
3461 for (i
= 0, segment
= program_headers
;
3462 i
< elf_header
.e_phnum
;
3467 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3471 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3472 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3473 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3474 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3475 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3477 (segment
->p_flags
& PF_R
? 'R' : ' '),
3478 (segment
->p_flags
& PF_W
? 'W' : ' '),
3479 (segment
->p_flags
& PF_X
? 'E' : ' '));
3480 printf ("%#lx", (unsigned long) segment
->p_align
);
3484 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3485 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3488 print_vma (segment
->p_offset
, FULL_HEX
);
3492 print_vma (segment
->p_vaddr
, FULL_HEX
);
3494 print_vma (segment
->p_paddr
, FULL_HEX
);
3497 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3498 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3501 print_vma (segment
->p_filesz
, FULL_HEX
);
3505 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3506 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3509 print_vma (segment
->p_offset
, FULL_HEX
);
3513 (segment
->p_flags
& PF_R
? 'R' : ' '),
3514 (segment
->p_flags
& PF_W
? 'W' : ' '),
3515 (segment
->p_flags
& PF_X
? 'E' : ' '));
3517 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3518 printf ("%#lx", (unsigned long) segment
->p_align
);
3521 print_vma (segment
->p_align
, PREFIX_HEX
);
3526 print_vma (segment
->p_offset
, FULL_HEX
);
3528 print_vma (segment
->p_vaddr
, FULL_HEX
);
3530 print_vma (segment
->p_paddr
, FULL_HEX
);
3532 print_vma (segment
->p_filesz
, FULL_HEX
);
3534 print_vma (segment
->p_memsz
, FULL_HEX
);
3536 (segment
->p_flags
& PF_R
? 'R' : ' '),
3537 (segment
->p_flags
& PF_W
? 'W' : ' '),
3538 (segment
->p_flags
& PF_X
? 'E' : ' '));
3539 print_vma (segment
->p_align
, HEX
);
3543 switch (segment
->p_type
)
3547 error (_("more than one dynamic segment\n"));
3549 /* By default, assume that the .dynamic section is the first
3550 section in the DYNAMIC segment. */
3551 dynamic_addr
= segment
->p_offset
;
3552 dynamic_size
= segment
->p_filesz
;
3554 /* Try to locate the .dynamic section. If there is
3555 a section header table, we can easily locate it. */
3556 if (section_headers
!= NULL
)
3558 Elf_Internal_Shdr
* sec
;
3560 sec
= find_section (".dynamic");
3561 if (sec
== NULL
|| sec
->sh_size
== 0)
3563 error (_("no .dynamic section in the dynamic segment\n"));
3567 if (sec
->sh_type
== SHT_NOBITS
)
3573 dynamic_addr
= sec
->sh_offset
;
3574 dynamic_size
= sec
->sh_size
;
3576 if (dynamic_addr
< segment
->p_offset
3577 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3578 warn (_("the .dynamic section is not contained"
3579 " within the dynamic segment\n"));
3580 else if (dynamic_addr
> segment
->p_offset
)
3581 warn (_("the .dynamic section is not the first section"
3582 " in the dynamic segment.\n"));
3587 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3589 error (_("Unable to find program interpreter name\n"));
3593 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3595 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3596 error (_("Internal error: failed to create format string to display program interpreter\n"));
3598 program_interpreter
[0] = 0;
3599 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3600 error (_("Unable to read program interpreter name\n"));
3603 printf (_("\n [Requesting program interpreter: %s]"),
3604 program_interpreter
);
3610 putc ('\n', stdout
);
3613 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3615 printf (_("\n Section to Segment mapping:\n"));
3616 printf (_(" Segment Sections...\n"));
3618 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3621 Elf_Internal_Shdr
* section
;
3623 segment
= program_headers
+ i
;
3624 section
= section_headers
+ 1;
3626 printf (" %2.2d ", i
);
3628 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3630 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3631 printf ("%s ", SECTION_NAME (section
));
3642 /* Find the file offset corresponding to VMA by using the program headers. */
3645 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3647 Elf_Internal_Phdr
* seg
;
3649 if (! get_program_headers (file
))
3651 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3655 for (seg
= program_headers
;
3656 seg
< program_headers
+ elf_header
.e_phnum
;
3659 if (seg
->p_type
!= PT_LOAD
)
3662 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3663 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3664 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3667 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3668 (unsigned long) vma
);
3674 get_32bit_section_headers (FILE * file
, unsigned int num
)
3676 Elf32_External_Shdr
* shdrs
;
3677 Elf_Internal_Shdr
* internal
;
3680 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3681 elf_header
.e_shentsize
, num
,
3682 _("section headers"));
3686 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3687 sizeof (Elf_Internal_Shdr
));
3689 if (section_headers
== NULL
)
3691 error (_("Out of memory\n"));
3695 for (i
= 0, internal
= section_headers
;
3699 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3700 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3701 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3702 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3703 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3704 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3705 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3706 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3707 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3708 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3717 get_64bit_section_headers (FILE * file
, unsigned int num
)
3719 Elf64_External_Shdr
* shdrs
;
3720 Elf_Internal_Shdr
* internal
;
3723 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3724 elf_header
.e_shentsize
, num
,
3725 _("section headers"));
3729 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3730 sizeof (Elf_Internal_Shdr
));
3732 if (section_headers
== NULL
)
3734 error (_("Out of memory\n"));
3738 for (i
= 0, internal
= section_headers
;
3742 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3743 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3744 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3745 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3746 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3747 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3748 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3749 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3750 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3751 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3759 static Elf_Internal_Sym
*
3760 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3762 unsigned long number
;
3763 Elf32_External_Sym
* esyms
;
3764 Elf_External_Sym_Shndx
* shndx
;
3765 Elf_Internal_Sym
* isyms
;
3766 Elf_Internal_Sym
* psym
;
3769 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3770 section
->sh_size
, _("symbols"));
3775 if (symtab_shndx_hdr
!= NULL
3776 && (symtab_shndx_hdr
->sh_link
3777 == (unsigned long) (section
- section_headers
)))
3779 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3780 symtab_shndx_hdr
->sh_offset
,
3781 1, symtab_shndx_hdr
->sh_size
,
3790 number
= section
->sh_size
/ section
->sh_entsize
;
3791 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3795 error (_("Out of memory\n"));
3802 for (j
= 0, psym
= isyms
;
3806 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3807 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3808 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3809 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3810 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3812 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3813 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3814 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3815 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3816 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3826 static Elf_Internal_Sym
*
3827 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3829 unsigned long number
;
3830 Elf64_External_Sym
* esyms
;
3831 Elf_External_Sym_Shndx
* shndx
;
3832 Elf_Internal_Sym
* isyms
;
3833 Elf_Internal_Sym
* psym
;
3836 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3837 section
->sh_size
, _("symbols"));
3842 if (symtab_shndx_hdr
!= NULL
3843 && (symtab_shndx_hdr
->sh_link
3844 == (unsigned long) (section
- section_headers
)))
3846 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3847 symtab_shndx_hdr
->sh_offset
,
3848 1, symtab_shndx_hdr
->sh_size
,
3857 number
= section
->sh_size
/ section
->sh_entsize
;
3858 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3862 error (_("Out of memory\n"));
3869 for (j
= 0, psym
= isyms
;
3873 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3874 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3875 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3876 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3877 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3879 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3880 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3881 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3882 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3883 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3894 get_elf_section_flags (bfd_vma sh_flags
)
3896 static char buff
[1024];
3898 int field_size
= is_32bit_elf
? 8 : 16;
3899 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3900 bfd_vma os_flags
= 0;
3901 bfd_vma proc_flags
= 0;
3902 bfd_vma unknown_flags
= 0;
3910 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3911 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3912 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3913 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3914 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
3915 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
3916 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
3917 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
3918 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
3919 /* 9 */ { STRING_COMMA_LEN ("TLS") },
3920 /* IA-64 specific. */
3921 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
3922 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
3923 /* IA-64 OpenVMS specific. */
3924 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
3925 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
3926 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
3927 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
3928 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
3929 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
3930 /* SPARC specific. */
3931 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
3932 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
3935 if (do_section_details
)
3937 sprintf (buff
, "[%*.*lx]: ",
3938 field_size
, field_size
, (unsigned long) sh_flags
);
3939 p
+= field_size
+ 4;
3946 flag
= sh_flags
& - sh_flags
;
3949 if (do_section_details
)
3953 case SHF_WRITE
: index
= 0; break;
3954 case SHF_ALLOC
: index
= 1; break;
3955 case SHF_EXECINSTR
: index
= 2; break;
3956 case SHF_MERGE
: index
= 3; break;
3957 case SHF_STRINGS
: index
= 4; break;
3958 case SHF_INFO_LINK
: index
= 5; break;
3959 case SHF_LINK_ORDER
: index
= 6; break;
3960 case SHF_OS_NONCONFORMING
: index
= 7; break;
3961 case SHF_GROUP
: index
= 8; break;
3962 case SHF_TLS
: index
= 9; break;
3966 switch (elf_header
.e_machine
)
3969 if (flag
== SHF_IA_64_SHORT
)
3971 else if (flag
== SHF_IA_64_NORECOV
)
3974 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3977 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3978 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3979 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3980 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3981 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3982 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3991 case EM_OLD_SPARCV9
:
3992 case EM_SPARC32PLUS
:
3995 if (flag
== SHF_EXCLUDE
)
3997 else if (flag
== SHF_ORDERED
)
4007 if (p
!= buff
+ field_size
+ 4)
4009 if (size
< (10 + 2))
4016 size
-= flags
[index
].len
;
4017 p
= stpcpy (p
, flags
[index
].str
);
4019 else if (flag
& SHF_MASKOS
)
4021 else if (flag
& SHF_MASKPROC
)
4024 unknown_flags
|= flag
;
4030 case SHF_WRITE
: *p
= 'W'; break;
4031 case SHF_ALLOC
: *p
= 'A'; break;
4032 case SHF_EXECINSTR
: *p
= 'X'; break;
4033 case SHF_MERGE
: *p
= 'M'; break;
4034 case SHF_STRINGS
: *p
= 'S'; break;
4035 case SHF_INFO_LINK
: *p
= 'I'; break;
4036 case SHF_LINK_ORDER
: *p
= 'L'; break;
4037 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4038 case SHF_GROUP
: *p
= 'G'; break;
4039 case SHF_TLS
: *p
= 'T'; break;
4042 if ((elf_header
.e_machine
== EM_X86_64
4043 || elf_header
.e_machine
== EM_L1OM
)
4044 && flag
== SHF_X86_64_LARGE
)
4046 else if (flag
& SHF_MASKOS
)
4049 sh_flags
&= ~ SHF_MASKOS
;
4051 else if (flag
& SHF_MASKPROC
)
4054 sh_flags
&= ~ SHF_MASKPROC
;
4064 if (do_section_details
)
4068 size
-= 5 + field_size
;
4069 if (p
!= buff
+ field_size
+ 4)
4077 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4078 (unsigned long) os_flags
);
4079 p
+= 5 + field_size
;
4083 size
-= 7 + field_size
;
4084 if (p
!= buff
+ field_size
+ 4)
4092 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4093 (unsigned long) proc_flags
);
4094 p
+= 7 + field_size
;
4098 size
-= 10 + field_size
;
4099 if (p
!= buff
+ field_size
+ 4)
4107 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4108 (unsigned long) unknown_flags
);
4109 p
+= 10 + field_size
;
4118 process_section_headers (FILE * file
)
4120 Elf_Internal_Shdr
* section
;
4123 section_headers
= NULL
;
4125 if (elf_header
.e_shnum
== 0)
4128 printf (_("\nThere are no sections in this file.\n"));
4133 if (do_sections
&& !do_header
)
4134 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4135 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4139 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4142 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4145 /* Read in the string table, so that we have names to display. */
4146 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4147 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4149 section
= section_headers
+ elf_header
.e_shstrndx
;
4151 if (section
->sh_size
!= 0)
4153 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4154 1, section
->sh_size
,
4157 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4161 /* Scan the sections for the dynamic symbol table
4162 and dynamic string table and debug sections. */
4163 dynamic_symbols
= NULL
;
4164 dynamic_strings
= NULL
;
4165 dynamic_syminfo
= NULL
;
4166 symtab_shndx_hdr
= NULL
;
4168 eh_addr_size
= is_32bit_elf
? 4 : 8;
4169 switch (elf_header
.e_machine
)
4172 case EM_MIPS_RS3_LE
:
4173 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4174 FDE addresses. However, the ABI also has a semi-official ILP32
4175 variant for which the normal FDE address size rules apply.
4177 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4178 section, where XX is the size of longs in bits. Unfortunately,
4179 earlier compilers provided no way of distinguishing ILP32 objects
4180 from LP64 objects, so if there's any doubt, we should assume that
4181 the official LP64 form is being used. */
4182 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4183 && find_section (".gcc_compiled_long32") == NULL
)
4189 switch (elf_header
.e_flags
& EF_H8_MACH
)
4191 case E_H8_MACH_H8300
:
4192 case E_H8_MACH_H8300HN
:
4193 case E_H8_MACH_H8300SN
:
4194 case E_H8_MACH_H8300SXN
:
4197 case E_H8_MACH_H8300H
:
4198 case E_H8_MACH_H8300S
:
4199 case E_H8_MACH_H8300SX
:
4207 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4209 case EF_M32C_CPU_M16C
:
4216 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4219 size_t expected_entsize \
4220 = is_32bit_elf ? size32 : size64; \
4221 if (section->sh_entsize != expected_entsize) \
4222 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4223 i, (unsigned long int) section->sh_entsize, \
4224 (unsigned long int) expected_entsize); \
4225 section->sh_entsize = expected_entsize; \
4228 #define CHECK_ENTSIZE(section, i, type) \
4229 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4230 sizeof (Elf64_External_##type))
4232 for (i
= 0, section
= section_headers
;
4233 i
< elf_header
.e_shnum
;
4236 char * name
= SECTION_NAME (section
);
4238 if (section
->sh_type
== SHT_DYNSYM
)
4240 if (dynamic_symbols
!= NULL
)
4242 error (_("File contains multiple dynamic symbol tables\n"));
4246 CHECK_ENTSIZE (section
, i
, Sym
);
4247 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4248 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4250 else if (section
->sh_type
== SHT_STRTAB
4251 && streq (name
, ".dynstr"))
4253 if (dynamic_strings
!= NULL
)
4255 error (_("File contains multiple dynamic string tables\n"));
4259 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4260 1, section
->sh_size
,
4261 _("dynamic strings"));
4262 dynamic_strings_length
= section
->sh_size
;
4264 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4266 if (symtab_shndx_hdr
!= NULL
)
4268 error (_("File contains multiple symtab shndx tables\n"));
4271 symtab_shndx_hdr
= section
;
4273 else if (section
->sh_type
== SHT_SYMTAB
)
4274 CHECK_ENTSIZE (section
, i
, Sym
);
4275 else if (section
->sh_type
== SHT_GROUP
)
4276 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4277 else if (section
->sh_type
== SHT_REL
)
4278 CHECK_ENTSIZE (section
, i
, Rel
);
4279 else if (section
->sh_type
== SHT_RELA
)
4280 CHECK_ENTSIZE (section
, i
, Rela
);
4281 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4282 || do_debug_lines
|| do_debug_pubnames
4283 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4284 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4285 && (const_strneq (name
, ".debug_")
4286 || const_strneq (name
, ".zdebug_")))
4289 name
+= sizeof (".zdebug_") - 1;
4291 name
+= sizeof (".debug_") - 1;
4294 || (do_debug_info
&& streq (name
, "info"))
4295 || (do_debug_info
&& streq (name
, "types"))
4296 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4297 || (do_debug_lines
&& streq (name
, "line"))
4298 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4299 || (do_debug_aranges
&& streq (name
, "aranges"))
4300 || (do_debug_ranges
&& streq (name
, "ranges"))
4301 || (do_debug_frames
&& streq (name
, "frame"))
4302 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4303 || (do_debug_str
&& streq (name
, "str"))
4304 || (do_debug_loc
&& streq (name
, "loc"))
4306 request_dump_bynumber (i
, DEBUG_DUMP
);
4308 /* Linkonce section to be combined with .debug_info at link time. */
4309 else if ((do_debugging
|| do_debug_info
)
4310 && const_strneq (name
, ".gnu.linkonce.wi."))
4311 request_dump_bynumber (i
, DEBUG_DUMP
);
4312 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4313 request_dump_bynumber (i
, DEBUG_DUMP
);
4319 if (elf_header
.e_shnum
> 1)
4320 printf (_("\nSection Headers:\n"));
4322 printf (_("\nSection Header:\n"));
4326 if (do_section_details
)
4328 printf (_(" [Nr] Name\n"));
4329 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4333 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4337 if (do_section_details
)
4339 printf (_(" [Nr] Name\n"));
4340 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4344 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4348 if (do_section_details
)
4350 printf (_(" [Nr] Name\n"));
4351 printf (_(" Type Address Offset Link\n"));
4352 printf (_(" Size EntSize Info Align\n"));
4356 printf (_(" [Nr] Name Type Address Offset\n"));
4357 printf (_(" Size EntSize Flags Link Info Align\n"));
4361 if (do_section_details
)
4362 printf (_(" Flags\n"));
4364 for (i
= 0, section
= section_headers
;
4365 i
< elf_header
.e_shnum
;
4368 if (do_section_details
)
4370 printf (" [%2u] %s\n",
4372 SECTION_NAME (section
));
4373 if (is_32bit_elf
|| do_wide
)
4374 printf (" %-15.15s ",
4375 get_section_type_name (section
->sh_type
));
4378 printf ((do_wide
? " [%2u] %-17s %-15s "
4379 : " [%2u] %-17.17s %-15.15s "),
4381 SECTION_NAME (section
),
4382 get_section_type_name (section
->sh_type
));
4386 const char * link_too_big
= NULL
;
4388 print_vma (section
->sh_addr
, LONG_HEX
);
4390 printf ( " %6.6lx %6.6lx %2.2lx",
4391 (unsigned long) section
->sh_offset
,
4392 (unsigned long) section
->sh_size
,
4393 (unsigned long) section
->sh_entsize
);
4395 if (do_section_details
)
4396 fputs (" ", stdout
);
4398 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4400 if (section
->sh_link
>= elf_header
.e_shnum
)
4403 /* The sh_link value is out of range. Normally this indicates
4404 an error but it can have special values in Solaris binaries. */
4405 switch (elf_header
.e_machine
)
4410 case EM_OLD_SPARCV9
:
4411 case EM_SPARC32PLUS
:
4414 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4415 link_too_big
= "BEFORE";
4416 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4417 link_too_big
= "AFTER";
4424 if (do_section_details
)
4426 if (link_too_big
!= NULL
&& * link_too_big
)
4427 printf ("<%s> ", link_too_big
);
4429 printf ("%2u ", section
->sh_link
);
4430 printf ("%3u %2lu\n", section
->sh_info
,
4431 (unsigned long) section
->sh_addralign
);
4434 printf ("%2u %3u %2lu\n",
4437 (unsigned long) section
->sh_addralign
);
4439 if (link_too_big
&& ! * link_too_big
)
4440 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4441 i
, section
->sh_link
);
4445 print_vma (section
->sh_addr
, LONG_HEX
);
4447 if ((long) section
->sh_offset
== section
->sh_offset
)
4448 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4452 print_vma (section
->sh_offset
, LONG_HEX
);
4455 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4456 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4460 print_vma (section
->sh_size
, LONG_HEX
);
4463 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4464 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4468 print_vma (section
->sh_entsize
, LONG_HEX
);
4471 if (do_section_details
)
4472 fputs (" ", stdout
);
4474 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4476 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4478 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4479 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4482 print_vma (section
->sh_addralign
, DEC
);
4486 else if (do_section_details
)
4488 printf (" %-15.15s ",
4489 get_section_type_name (section
->sh_type
));
4490 print_vma (section
->sh_addr
, LONG_HEX
);
4491 if ((long) section
->sh_offset
== section
->sh_offset
)
4492 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4496 print_vma (section
->sh_offset
, LONG_HEX
);
4498 printf (" %u\n ", section
->sh_link
);
4499 print_vma (section
->sh_size
, LONG_HEX
);
4501 print_vma (section
->sh_entsize
, LONG_HEX
);
4503 printf (" %-16u %lu\n",
4505 (unsigned long) section
->sh_addralign
);
4510 print_vma (section
->sh_addr
, LONG_HEX
);
4511 if ((long) section
->sh_offset
== section
->sh_offset
)
4512 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4516 print_vma (section
->sh_offset
, LONG_HEX
);
4519 print_vma (section
->sh_size
, LONG_HEX
);
4521 print_vma (section
->sh_entsize
, LONG_HEX
);
4523 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4525 printf (" %2u %3u %lu\n",
4528 (unsigned long) section
->sh_addralign
);
4531 if (do_section_details
)
4532 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4535 if (!do_section_details
)
4536 printf (_("Key to Flags:\n\
4537 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4538 I (info), L (link order), G (group), x (unknown)\n\
4539 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4545 get_group_flags (unsigned int flags
)
4547 static char buff
[32];
4554 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4561 process_section_groups (FILE * file
)
4563 Elf_Internal_Shdr
* section
;
4565 struct group
* group
;
4566 Elf_Internal_Shdr
* symtab_sec
;
4567 Elf_Internal_Shdr
* strtab_sec
;
4568 Elf_Internal_Sym
* symtab
;
4572 /* Don't process section groups unless needed. */
4573 if (!do_unwind
&& !do_section_groups
)
4576 if (elf_header
.e_shnum
== 0)
4578 if (do_section_groups
)
4579 printf (_("\nThere are no sections in this file.\n"));
4584 if (section_headers
== NULL
)
4586 error (_("Section headers are not available!\n"));
4590 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4591 sizeof (struct group
*));
4593 if (section_headers_groups
== NULL
)
4595 error (_("Out of memory\n"));
4599 /* Scan the sections for the group section. */
4601 for (i
= 0, section
= section_headers
;
4602 i
< elf_header
.e_shnum
;
4604 if (section
->sh_type
== SHT_GROUP
)
4607 if (group_count
== 0)
4609 if (do_section_groups
)
4610 printf (_("\nThere are no section groups in this file.\n"));
4615 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4617 if (section_groups
== NULL
)
4619 error (_("Out of memory\n"));
4628 for (i
= 0, section
= section_headers
, group
= section_groups
;
4629 i
< elf_header
.e_shnum
;
4632 if (section
->sh_type
== SHT_GROUP
)
4634 char * name
= SECTION_NAME (section
);
4636 unsigned char * start
;
4637 unsigned char * indices
;
4638 unsigned int entry
, j
, size
;
4639 Elf_Internal_Shdr
* sec
;
4640 Elf_Internal_Sym
* sym
;
4642 /* Get the symbol table. */
4643 if (section
->sh_link
>= elf_header
.e_shnum
4644 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4647 error (_("Bad sh_link in group section `%s'\n"), name
);
4651 if (symtab_sec
!= sec
)
4656 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4659 sym
= symtab
+ section
->sh_info
;
4661 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4663 if (sym
->st_shndx
== 0
4664 || sym
->st_shndx
>= elf_header
.e_shnum
)
4666 error (_("Bad sh_info in group section `%s'\n"), name
);
4670 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4679 /* Get the string table. */
4680 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4689 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4694 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4695 1, strtab_sec
->sh_size
,
4697 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4699 group_name
= sym
->st_name
< strtab_size
4700 ? strtab
+ sym
->st_name
: "<corrupt>";
4703 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4704 1, section
->sh_size
,
4708 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4709 entry
= byte_get (indices
, 4);
4712 if (do_section_groups
)
4714 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4715 get_group_flags (entry
), i
, name
, group_name
, size
);
4717 printf (_(" [Index] Name\n"));
4720 group
->group_index
= i
;
4722 for (j
= 0; j
< size
; j
++)
4724 struct group_list
* g
;
4726 entry
= byte_get (indices
, 4);
4729 if (entry
>= elf_header
.e_shnum
)
4731 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4732 entry
, i
, elf_header
.e_shnum
- 1);
4736 if (section_headers_groups
[entry
] != NULL
)
4740 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4742 section_headers_groups
[entry
]->group_index
);
4747 /* Intel C/C++ compiler may put section 0 in a
4748 section group. We just warn it the first time
4749 and ignore it afterwards. */
4750 static int warned
= 0;
4753 error (_("section 0 in group section [%5u]\n"),
4754 section_headers_groups
[entry
]->group_index
);
4760 section_headers_groups
[entry
] = group
;
4762 if (do_section_groups
)
4764 sec
= section_headers
+ entry
;
4765 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4768 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
4769 g
->section_index
= entry
;
4770 g
->next
= group
->root
;
4794 } dynamic_relocations
[] =
4796 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4797 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4798 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4801 /* Process the reloc section. */
4804 process_relocs (FILE * file
)
4806 unsigned long rel_size
;
4807 unsigned long rel_offset
;
4813 if (do_using_dynamic
)
4817 int has_dynamic_reloc
;
4820 has_dynamic_reloc
= 0;
4822 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4824 is_rela
= dynamic_relocations
[i
].rela
;
4825 name
= dynamic_relocations
[i
].name
;
4826 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4827 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4829 has_dynamic_reloc
|= rel_size
;
4831 if (is_rela
== UNKNOWN
)
4833 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4834 switch (dynamic_info
[DT_PLTREL
])
4848 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4849 name
, rel_offset
, rel_size
);
4851 dump_relocations (file
,
4852 offset_from_vma (file
, rel_offset
, rel_size
),
4854 dynamic_symbols
, num_dynamic_syms
,
4855 dynamic_strings
, dynamic_strings_length
, is_rela
);
4859 if (! has_dynamic_reloc
)
4860 printf (_("\nThere are no dynamic relocations in this file.\n"));
4864 Elf_Internal_Shdr
* section
;
4868 for (i
= 0, section
= section_headers
;
4869 i
< elf_header
.e_shnum
;
4872 if ( section
->sh_type
!= SHT_RELA
4873 && section
->sh_type
!= SHT_REL
)
4876 rel_offset
= section
->sh_offset
;
4877 rel_size
= section
->sh_size
;
4881 Elf_Internal_Shdr
* strsec
;
4884 printf (_("\nRelocation section "));
4886 if (string_table
== NULL
)
4887 printf ("%d", section
->sh_name
);
4889 printf (_("'%s'"), SECTION_NAME (section
));
4891 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4892 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4894 is_rela
= section
->sh_type
== SHT_RELA
;
4896 if (section
->sh_link
!= 0
4897 && section
->sh_link
< elf_header
.e_shnum
)
4899 Elf_Internal_Shdr
* symsec
;
4900 Elf_Internal_Sym
* symtab
;
4901 unsigned long nsyms
;
4902 unsigned long strtablen
= 0;
4903 char * strtab
= NULL
;
4905 symsec
= section_headers
+ section
->sh_link
;
4906 if (symsec
->sh_type
!= SHT_SYMTAB
4907 && symsec
->sh_type
!= SHT_DYNSYM
)
4910 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4911 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4916 if (symsec
->sh_link
!= 0
4917 && symsec
->sh_link
< elf_header
.e_shnum
)
4919 strsec
= section_headers
+ symsec
->sh_link
;
4921 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4924 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4927 dump_relocations (file
, rel_offset
, rel_size
,
4928 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4934 dump_relocations (file
, rel_offset
, rel_size
,
4935 NULL
, 0, NULL
, 0, is_rela
);
4942 printf (_("\nThere are no relocations in this file.\n"));
4948 /* Process the unwind section. */
4950 #include "unwind-ia64.h"
4952 /* An absolute address consists of a section and an offset. If the
4953 section is NULL, the offset itself is the address, otherwise, the
4954 address equals to LOAD_ADDRESS(section) + offset. */
4958 unsigned short section
;
4962 #define ABSADDR(a) \
4964 ? section_headers [(a).section].sh_addr + (a).offset \
4967 struct ia64_unw_table_entry
4969 struct absaddr start
;
4971 struct absaddr info
;
4974 struct ia64_unw_aux_info
4977 struct ia64_unw_table_entry
*table
; /* Unwind table. */
4978 unsigned long table_len
; /* Length of unwind table. */
4979 unsigned char * info
; /* Unwind info. */
4980 unsigned long info_size
; /* Size of unwind info. */
4981 bfd_vma info_addr
; /* starting address of unwind info. */
4982 bfd_vma seg_base
; /* Starting address of segment. */
4983 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4984 unsigned long nsyms
; /* Number of symbols. */
4985 char * strtab
; /* The string table. */
4986 unsigned long strtab_size
; /* Size of string table. */
4990 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4991 unsigned long nsyms
,
4992 const char * strtab
,
4993 unsigned long strtab_size
,
4994 struct absaddr addr
,
4995 const char ** symname
,
4998 bfd_vma dist
= 0x100000;
4999 Elf_Internal_Sym
* sym
;
5000 Elf_Internal_Sym
* best
= NULL
;
5003 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5005 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5006 && sym
->st_name
!= 0
5007 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5008 && addr
.offset
>= sym
->st_value
5009 && addr
.offset
- sym
->st_value
< dist
)
5012 dist
= addr
.offset
- sym
->st_value
;
5019 *symname
= (best
->st_name
>= strtab_size
5020 ? "<corrupt>" : strtab
+ best
->st_name
);
5025 *offset
= addr
.offset
;
5029 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5031 struct ia64_unw_table_entry
* tp
;
5034 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5038 const unsigned char * dp
;
5039 const unsigned char * head
;
5040 const char * procname
;
5042 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5043 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5045 fputs ("\n<", stdout
);
5049 fputs (procname
, stdout
);
5052 printf ("+%lx", (unsigned long) offset
);
5055 fputs (">: [", stdout
);
5056 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5057 fputc ('-', stdout
);
5058 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5059 printf ("], info at +0x%lx\n",
5060 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5062 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5063 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5065 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5066 (unsigned) UNW_VER (stamp
),
5067 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5068 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5069 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5070 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5072 if (UNW_VER (stamp
) != 1)
5074 printf ("\tUnknown version.\n");
5079 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5080 dp
= unw_decode (dp
, in_body
, & in_body
);
5085 slurp_ia64_unwind_table (FILE * file
,
5086 struct ia64_unw_aux_info
* aux
,
5087 Elf_Internal_Shdr
* sec
)
5089 unsigned long size
, nrelas
, i
;
5090 Elf_Internal_Phdr
* seg
;
5091 struct ia64_unw_table_entry
* tep
;
5092 Elf_Internal_Shdr
* relsec
;
5093 Elf_Internal_Rela
* rela
;
5094 Elf_Internal_Rela
* rp
;
5095 unsigned char * table
;
5097 Elf_Internal_Sym
* sym
;
5098 const char * relname
;
5100 /* First, find the starting address of the segment that includes
5103 if (elf_header
.e_phnum
)
5105 if (! get_program_headers (file
))
5108 for (seg
= program_headers
;
5109 seg
< program_headers
+ elf_header
.e_phnum
;
5112 if (seg
->p_type
!= PT_LOAD
)
5115 if (sec
->sh_addr
>= seg
->p_vaddr
5116 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5118 aux
->seg_base
= seg
->p_vaddr
;
5124 /* Second, build the unwind table from the contents of the unwind section: */
5125 size
= sec
->sh_size
;
5126 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5131 aux
->table
= (struct ia64_unw_table_entry
*)
5132 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5134 for (tp
= table
; tp
< table
+ size
; ++tep
)
5136 tep
->start
.section
= SHN_UNDEF
;
5137 tep
->end
.section
= SHN_UNDEF
;
5138 tep
->info
.section
= SHN_UNDEF
;
5139 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5140 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5141 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5142 tep
->start
.offset
+= aux
->seg_base
;
5143 tep
->end
.offset
+= aux
->seg_base
;
5144 tep
->info
.offset
+= aux
->seg_base
;
5148 /* Third, apply any relocations to the unwind table: */
5149 for (relsec
= section_headers
;
5150 relsec
< section_headers
+ elf_header
.e_shnum
;
5153 if (relsec
->sh_type
!= SHT_RELA
5154 || relsec
->sh_info
>= elf_header
.e_shnum
5155 || section_headers
+ relsec
->sh_info
!= sec
)
5158 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5162 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5164 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5165 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5167 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5169 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5173 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5175 switch (rp
->r_offset
/eh_addr_size
% 3)
5178 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5179 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5182 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5183 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5186 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5187 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5197 aux
->table_len
= size
/ (3 * eh_addr_size
);
5202 ia64_process_unwind (FILE * file
)
5204 Elf_Internal_Shdr
* sec
;
5205 Elf_Internal_Shdr
* unwsec
= NULL
;
5206 Elf_Internal_Shdr
* strsec
;
5207 unsigned long i
, unwcount
= 0, unwstart
= 0;
5208 struct ia64_unw_aux_info aux
;
5210 memset (& aux
, 0, sizeof (aux
));
5212 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5214 if (sec
->sh_type
== SHT_SYMTAB
5215 && sec
->sh_link
< elf_header
.e_shnum
)
5217 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5218 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5220 strsec
= section_headers
+ sec
->sh_link
;
5221 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5224 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5226 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5231 printf (_("\nThere are no unwind sections in this file.\n"));
5233 while (unwcount
-- > 0)
5238 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5239 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5240 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5247 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5249 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5251 /* We need to find which section group it is in. */
5252 struct group_list
* g
= section_headers_groups
[i
]->root
;
5254 for (; g
!= NULL
; g
= g
->next
)
5256 sec
= section_headers
+ g
->section_index
;
5258 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5263 i
= elf_header
.e_shnum
;
5265 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5267 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5268 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5269 suffix
= SECTION_NAME (unwsec
) + len
;
5270 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5272 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5273 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5278 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5279 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5280 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5281 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5283 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5284 suffix
= SECTION_NAME (unwsec
) + len
;
5285 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5287 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5288 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5292 if (i
== elf_header
.e_shnum
)
5294 printf (_("\nCould not find unwind info section for "));
5296 if (string_table
== NULL
)
5297 printf ("%d", unwsec
->sh_name
);
5299 printf (_("'%s'"), SECTION_NAME (unwsec
));
5303 aux
.info_size
= sec
->sh_size
;
5304 aux
.info_addr
= sec
->sh_addr
;
5305 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5309 printf (_("\nUnwind section "));
5311 if (string_table
== NULL
)
5312 printf ("%d", unwsec
->sh_name
);
5314 printf (_("'%s'"), SECTION_NAME (unwsec
));
5316 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5317 (unsigned long) unwsec
->sh_offset
,
5318 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5320 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5322 if (aux
.table_len
> 0)
5323 dump_ia64_unwind (& aux
);
5326 free ((char *) aux
.table
);
5328 free ((char *) aux
.info
);
5337 free ((char *) aux
.strtab
);
5342 struct hppa_unw_table_entry
5344 struct absaddr start
;
5346 unsigned int Cannot_unwind
:1; /* 0 */
5347 unsigned int Millicode
:1; /* 1 */
5348 unsigned int Millicode_save_sr0
:1; /* 2 */
5349 unsigned int Region_description
:2; /* 3..4 */
5350 unsigned int reserved1
:1; /* 5 */
5351 unsigned int Entry_SR
:1; /* 6 */
5352 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5353 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5354 unsigned int Args_stored
:1; /* 16 */
5355 unsigned int Variable_Frame
:1; /* 17 */
5356 unsigned int Separate_Package_Body
:1; /* 18 */
5357 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5358 unsigned int Stack_Overflow_Check
:1; /* 20 */
5359 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5360 unsigned int Ada_Region
:1; /* 22 */
5361 unsigned int cxx_info
:1; /* 23 */
5362 unsigned int cxx_try_catch
:1; /* 24 */
5363 unsigned int sched_entry_seq
:1; /* 25 */
5364 unsigned int reserved2
:1; /* 26 */
5365 unsigned int Save_SP
:1; /* 27 */
5366 unsigned int Save_RP
:1; /* 28 */
5367 unsigned int Save_MRP_in_frame
:1; /* 29 */
5368 unsigned int extn_ptr_defined
:1; /* 30 */
5369 unsigned int Cleanup_defined
:1; /* 31 */
5371 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5372 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5373 unsigned int Large_frame
:1; /* 2 */
5374 unsigned int Pseudo_SP_Set
:1; /* 3 */
5375 unsigned int reserved4
:1; /* 4 */
5376 unsigned int Total_frame_size
:27; /* 5..31 */
5379 struct hppa_unw_aux_info
5381 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5382 unsigned long table_len
; /* Length of unwind table. */
5383 bfd_vma seg_base
; /* Starting address of segment. */
5384 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5385 unsigned long nsyms
; /* Number of symbols. */
5386 char * strtab
; /* The string table. */
5387 unsigned long strtab_size
; /* Size of string table. */
5391 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5393 struct hppa_unw_table_entry
* tp
;
5395 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5398 const char * procname
;
5400 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5401 aux
->strtab_size
, tp
->start
, &procname
,
5404 fputs ("\n<", stdout
);
5408 fputs (procname
, stdout
);
5411 printf ("+%lx", (unsigned long) offset
);
5414 fputs (">: [", stdout
);
5415 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5416 fputc ('-', stdout
);
5417 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5420 #define PF(_m) if (tp->_m) printf (#_m " ");
5421 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5424 PF(Millicode_save_sr0
);
5425 /* PV(Region_description); */
5431 PF(Separate_Package_Body
);
5432 PF(Frame_Extension_Millicode
);
5433 PF(Stack_Overflow_Check
);
5434 PF(Two_Instruction_SP_Increment
);
5438 PF(sched_entry_seq
);
5441 PF(Save_MRP_in_frame
);
5442 PF(extn_ptr_defined
);
5443 PF(Cleanup_defined
);
5444 PF(MPE_XL_interrupt_marker
);
5445 PF(HP_UX_interrupt_marker
);
5448 PV(Total_frame_size
);
5457 slurp_hppa_unwind_table (FILE * file
,
5458 struct hppa_unw_aux_info
* aux
,
5459 Elf_Internal_Shdr
* sec
)
5461 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5462 Elf_Internal_Phdr
* seg
;
5463 struct hppa_unw_table_entry
* tep
;
5464 Elf_Internal_Shdr
* relsec
;
5465 Elf_Internal_Rela
* rela
;
5466 Elf_Internal_Rela
* rp
;
5467 unsigned char * table
;
5469 Elf_Internal_Sym
* sym
;
5470 const char * relname
;
5472 /* First, find the starting address of the segment that includes
5475 if (elf_header
.e_phnum
)
5477 if (! get_program_headers (file
))
5480 for (seg
= program_headers
;
5481 seg
< program_headers
+ elf_header
.e_phnum
;
5484 if (seg
->p_type
!= PT_LOAD
)
5487 if (sec
->sh_addr
>= seg
->p_vaddr
5488 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5490 aux
->seg_base
= seg
->p_vaddr
;
5496 /* Second, build the unwind table from the contents of the unwind
5498 size
= sec
->sh_size
;
5499 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5505 nentries
= size
/ unw_ent_size
;
5506 size
= unw_ent_size
* nentries
;
5508 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5509 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5511 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5513 unsigned int tmp1
, tmp2
;
5515 tep
->start
.section
= SHN_UNDEF
;
5516 tep
->end
.section
= SHN_UNDEF
;
5518 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5519 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5520 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5521 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5523 tep
->start
.offset
+= aux
->seg_base
;
5524 tep
->end
.offset
+= aux
->seg_base
;
5526 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5527 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5528 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5529 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5530 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5531 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5532 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5533 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5534 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5535 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5536 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5537 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5538 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5539 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5540 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5541 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5542 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5543 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5544 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5545 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5546 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5547 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5548 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5549 tep
->Cleanup_defined
= tmp1
& 0x1;
5551 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5552 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5553 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5554 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5555 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5556 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5560 /* Third, apply any relocations to the unwind table. */
5561 for (relsec
= section_headers
;
5562 relsec
< section_headers
+ elf_header
.e_shnum
;
5565 if (relsec
->sh_type
!= SHT_RELA
5566 || relsec
->sh_info
>= elf_header
.e_shnum
5567 || section_headers
+ relsec
->sh_info
!= sec
)
5570 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5574 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5576 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5577 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5579 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5580 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5582 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5586 i
= rp
->r_offset
/ unw_ent_size
;
5588 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5591 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5592 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
5595 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5596 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
5606 aux
->table_len
= nentries
;
5612 hppa_process_unwind (FILE * file
)
5614 struct hppa_unw_aux_info aux
;
5615 Elf_Internal_Shdr
* unwsec
= NULL
;
5616 Elf_Internal_Shdr
* strsec
;
5617 Elf_Internal_Shdr
* sec
;
5620 memset (& aux
, 0, sizeof (aux
));
5622 if (string_table
== NULL
)
5625 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5627 if (sec
->sh_type
== SHT_SYMTAB
5628 && sec
->sh_link
< elf_header
.e_shnum
)
5630 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5631 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5633 strsec
= section_headers
+ sec
->sh_link
;
5634 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5637 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5639 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5644 printf (_("\nThere are no unwind sections in this file.\n"));
5646 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5648 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5650 printf (_("\nUnwind section "));
5651 printf (_("'%s'"), SECTION_NAME (sec
));
5653 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5654 (unsigned long) sec
->sh_offset
,
5655 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5657 slurp_hppa_unwind_table (file
, &aux
, sec
);
5658 if (aux
.table_len
> 0)
5659 dump_hppa_unwind (&aux
);
5662 free ((char *) aux
.table
);
5670 free ((char *) aux
.strtab
);
5676 process_unwind (FILE * file
)
5678 struct unwind_handler
5681 int (* handler
)(FILE *);
5684 { EM_IA_64
, ia64_process_unwind
},
5685 { EM_PARISC
, hppa_process_unwind
},
5693 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5694 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5695 return handlers
[i
].handler (file
);
5697 printf (_("\nThere are no unwind sections in this file.\n"));
5702 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5704 switch (entry
->d_tag
)
5707 if (entry
->d_un
.d_val
== 0)
5711 static const char * opts
[] =
5713 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5714 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5715 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5716 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5721 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5722 if (entry
->d_un
.d_val
& (1 << cnt
))
5724 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5731 case DT_MIPS_IVERSION
:
5732 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5733 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5735 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5738 case DT_MIPS_TIME_STAMP
:
5743 time_t time
= entry
->d_un
.d_val
;
5744 tmp
= gmtime (&time
);
5745 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5746 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5747 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5748 printf ("Time Stamp: %s\n", timebuf
);
5752 case DT_MIPS_RLD_VERSION
:
5753 case DT_MIPS_LOCAL_GOTNO
:
5754 case DT_MIPS_CONFLICTNO
:
5755 case DT_MIPS_LIBLISTNO
:
5756 case DT_MIPS_SYMTABNO
:
5757 case DT_MIPS_UNREFEXTNO
:
5758 case DT_MIPS_HIPAGENO
:
5759 case DT_MIPS_DELTA_CLASS_NO
:
5760 case DT_MIPS_DELTA_INSTANCE_NO
:
5761 case DT_MIPS_DELTA_RELOC_NO
:
5762 case DT_MIPS_DELTA_SYM_NO
:
5763 case DT_MIPS_DELTA_CLASSSYM_NO
:
5764 case DT_MIPS_COMPACT_SIZE
:
5765 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5769 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5775 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5777 switch (entry
->d_tag
)
5779 case DT_HP_DLD_FLAGS
:
5788 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5789 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5790 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5791 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5792 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5793 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5794 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5795 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5796 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5797 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5798 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5799 { DT_HP_GST
, "HP_GST" },
5800 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5801 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5802 { DT_HP_NODELETE
, "HP_NODELETE" },
5803 { DT_HP_GROUP
, "HP_GROUP" },
5804 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5808 bfd_vma val
= entry
->d_un
.d_val
;
5810 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5811 if (val
& flags
[cnt
].bit
)
5815 fputs (flags
[cnt
].str
, stdout
);
5817 val
^= flags
[cnt
].bit
;
5820 if (val
!= 0 || first
)
5824 print_vma (val
, HEX
);
5830 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5837 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5839 switch (entry
->d_tag
)
5841 case DT_IA_64_PLT_RESERVE
:
5842 /* First 3 slots reserved. */
5843 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5845 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5849 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5856 get_32bit_dynamic_section (FILE * file
)
5858 Elf32_External_Dyn
* edyn
;
5859 Elf32_External_Dyn
* ext
;
5860 Elf_Internal_Dyn
* entry
;
5862 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5863 dynamic_size
, _("dynamic section"));
5867 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5868 might not have the luxury of section headers. Look for the DT_NULL
5869 terminator to determine the number of entries. */
5870 for (ext
= edyn
, dynamic_nent
= 0;
5871 (char *) ext
< (char *) edyn
+ dynamic_size
;
5875 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5879 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5881 if (dynamic_section
== NULL
)
5883 error (_("Out of memory\n"));
5888 for (ext
= edyn
, entry
= dynamic_section
;
5889 entry
< dynamic_section
+ dynamic_nent
;
5892 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5893 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5902 get_64bit_dynamic_section (FILE * file
)
5904 Elf64_External_Dyn
* edyn
;
5905 Elf64_External_Dyn
* ext
;
5906 Elf_Internal_Dyn
* entry
;
5908 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5909 dynamic_size
, _("dynamic section"));
5913 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5914 might not have the luxury of section headers. Look for the DT_NULL
5915 terminator to determine the number of entries. */
5916 for (ext
= edyn
, dynamic_nent
= 0;
5917 (char *) ext
< (char *) edyn
+ dynamic_size
;
5921 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5925 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5927 if (dynamic_section
== NULL
)
5929 error (_("Out of memory\n"));
5934 for (ext
= edyn
, entry
= dynamic_section
;
5935 entry
< dynamic_section
+ dynamic_nent
;
5938 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5939 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5948 print_dynamic_flags (bfd_vma flags
)
5956 flag
= flags
& - flags
;
5966 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5967 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5968 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5969 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5970 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5971 default: fputs ("unknown", stdout
); break;
5977 /* Parse and display the contents of the dynamic section. */
5980 process_dynamic_section (FILE * file
)
5982 Elf_Internal_Dyn
* entry
;
5984 if (dynamic_size
== 0)
5987 printf (_("\nThere is no dynamic section in this file.\n"));
5994 if (! get_32bit_dynamic_section (file
))
5997 else if (! get_64bit_dynamic_section (file
))
6000 /* Find the appropriate symbol table. */
6001 if (dynamic_symbols
== NULL
)
6003 for (entry
= dynamic_section
;
6004 entry
< dynamic_section
+ dynamic_nent
;
6007 Elf_Internal_Shdr section
;
6009 if (entry
->d_tag
!= DT_SYMTAB
)
6012 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6014 /* Since we do not know how big the symbol table is,
6015 we default to reading in the entire file (!) and
6016 processing that. This is overkill, I know, but it
6018 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6020 if (archive_file_offset
!= 0)
6021 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6024 if (fseek (file
, 0, SEEK_END
))
6025 error (_("Unable to seek to end of file!\n"));
6027 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6031 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6033 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6035 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6036 if (num_dynamic_syms
< 1)
6038 error (_("Unable to determine the number of symbols to load\n"));
6042 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6046 /* Similarly find a string table. */
6047 if (dynamic_strings
== NULL
)
6049 for (entry
= dynamic_section
;
6050 entry
< dynamic_section
+ dynamic_nent
;
6053 unsigned long offset
;
6056 if (entry
->d_tag
!= DT_STRTAB
)
6059 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6061 /* Since we do not know how big the string table is,
6062 we default to reading in the entire file (!) and
6063 processing that. This is overkill, I know, but it
6066 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6068 if (archive_file_offset
!= 0)
6069 str_tab_len
= archive_file_size
- offset
;
6072 if (fseek (file
, 0, SEEK_END
))
6073 error (_("Unable to seek to end of file\n"));
6074 str_tab_len
= ftell (file
) - offset
;
6077 if (str_tab_len
< 1)
6080 (_("Unable to determine the length of the dynamic string table\n"));
6084 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6086 _("dynamic string table"));
6087 dynamic_strings_length
= str_tab_len
;
6092 /* And find the syminfo section if available. */
6093 if (dynamic_syminfo
== NULL
)
6095 unsigned long syminsz
= 0;
6097 for (entry
= dynamic_section
;
6098 entry
< dynamic_section
+ dynamic_nent
;
6101 if (entry
->d_tag
== DT_SYMINENT
)
6103 /* Note: these braces are necessary to avoid a syntax
6104 error from the SunOS4 C compiler. */
6105 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6107 else if (entry
->d_tag
== DT_SYMINSZ
)
6108 syminsz
= entry
->d_un
.d_val
;
6109 else if (entry
->d_tag
== DT_SYMINFO
)
6110 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6114 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6116 Elf_External_Syminfo
* extsyminfo
;
6117 Elf_External_Syminfo
* extsym
;
6118 Elf_Internal_Syminfo
* syminfo
;
6120 /* There is a syminfo section. Read the data. */
6121 extsyminfo
= (Elf_External_Syminfo
*)
6122 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6123 _("symbol information"));
6127 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6128 if (dynamic_syminfo
== NULL
)
6130 error (_("Out of memory\n"));
6134 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6135 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6136 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6137 ++syminfo
, ++extsym
)
6139 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6140 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6147 if (do_dynamic
&& dynamic_addr
)
6148 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6149 dynamic_addr
, dynamic_nent
);
6151 printf (_(" Tag Type Name/Value\n"));
6153 for (entry
= dynamic_section
;
6154 entry
< dynamic_section
+ dynamic_nent
;
6162 print_vma (entry
->d_tag
, FULL_HEX
);
6163 dtype
= get_dynamic_type (entry
->d_tag
);
6164 printf (" (%s)%*s", dtype
,
6165 ((is_32bit_elf
? 27 : 19)
6166 - (int) strlen (dtype
)),
6170 switch (entry
->d_tag
)
6174 print_dynamic_flags (entry
->d_un
.d_val
);
6184 switch (entry
->d_tag
)
6187 printf (_("Auxiliary library"));
6191 printf (_("Filter library"));
6195 printf (_("Configuration file"));
6199 printf (_("Dependency audit library"));
6203 printf (_("Audit library"));
6207 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6208 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6212 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6221 printf (_("Flags:"));
6223 if (entry
->d_un
.d_val
== 0)
6224 printf (_(" None\n"));
6227 unsigned long int val
= entry
->d_un
.d_val
;
6229 if (val
& DTF_1_PARINIT
)
6231 printf (" PARINIT");
6232 val
^= DTF_1_PARINIT
;
6234 if (val
& DTF_1_CONFEXP
)
6236 printf (" CONFEXP");
6237 val
^= DTF_1_CONFEXP
;
6240 printf (" %lx", val
);
6249 printf (_("Flags:"));
6251 if (entry
->d_un
.d_val
== 0)
6252 printf (_(" None\n"));
6255 unsigned long int val
= entry
->d_un
.d_val
;
6257 if (val
& DF_P1_LAZYLOAD
)
6259 printf (" LAZYLOAD");
6260 val
^= DF_P1_LAZYLOAD
;
6262 if (val
& DF_P1_GROUPPERM
)
6264 printf (" GROUPPERM");
6265 val
^= DF_P1_GROUPPERM
;
6268 printf (" %lx", val
);
6277 printf (_("Flags:"));
6278 if (entry
->d_un
.d_val
== 0)
6279 printf (_(" None\n"));
6282 unsigned long int val
= entry
->d_un
.d_val
;
6289 if (val
& DF_1_GLOBAL
)
6294 if (val
& DF_1_GROUP
)
6299 if (val
& DF_1_NODELETE
)
6301 printf (" NODELETE");
6302 val
^= DF_1_NODELETE
;
6304 if (val
& DF_1_LOADFLTR
)
6306 printf (" LOADFLTR");
6307 val
^= DF_1_LOADFLTR
;
6309 if (val
& DF_1_INITFIRST
)
6311 printf (" INITFIRST");
6312 val
^= DF_1_INITFIRST
;
6314 if (val
& DF_1_NOOPEN
)
6319 if (val
& DF_1_ORIGIN
)
6324 if (val
& DF_1_DIRECT
)
6329 if (val
& DF_1_TRANS
)
6334 if (val
& DF_1_INTERPOSE
)
6336 printf (" INTERPOSE");
6337 val
^= DF_1_INTERPOSE
;
6339 if (val
& DF_1_NODEFLIB
)
6341 printf (" NODEFLIB");
6342 val
^= DF_1_NODEFLIB
;
6344 if (val
& DF_1_NODUMP
)
6349 if (val
& DF_1_CONLFAT
)
6351 printf (" CONLFAT");
6352 val
^= DF_1_CONLFAT
;
6355 printf (" %lx", val
);
6362 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6364 puts (get_dynamic_type (entry
->d_un
.d_val
));
6384 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6390 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6391 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6397 switch (entry
->d_tag
)
6400 printf (_("Shared library: [%s]"), name
);
6402 if (streq (name
, program_interpreter
))
6403 printf (_(" program interpreter"));
6407 printf (_("Library soname: [%s]"), name
);
6411 printf (_("Library rpath: [%s]"), name
);
6415 printf (_("Library runpath: [%s]"), name
);
6419 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6424 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6437 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6441 case DT_INIT_ARRAYSZ
:
6442 case DT_FINI_ARRAYSZ
:
6443 case DT_GNU_CONFLICTSZ
:
6444 case DT_GNU_LIBLISTSZ
:
6447 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6448 printf (" (bytes)\n");
6458 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6471 if (entry
->d_tag
== DT_USED
6472 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6474 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6478 printf (_("Not needed object: [%s]\n"), name
);
6483 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6489 /* The value of this entry is ignored. */
6494 case DT_GNU_PRELINKED
:
6498 time_t time
= entry
->d_un
.d_val
;
6500 tmp
= gmtime (&time
);
6501 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6502 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6503 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6509 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6512 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6518 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6519 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6524 switch (elf_header
.e_machine
)
6527 case EM_MIPS_RS3_LE
:
6528 dynamic_section_mips_val (entry
);
6531 dynamic_section_parisc_val (entry
);
6534 dynamic_section_ia64_val (entry
);
6537 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6549 get_ver_flags (unsigned int flags
)
6551 static char buff
[32];
6558 if (flags
& VER_FLG_BASE
)
6559 strcat (buff
, "BASE ");
6561 if (flags
& VER_FLG_WEAK
)
6563 if (flags
& VER_FLG_BASE
)
6564 strcat (buff
, "| ");
6566 strcat (buff
, "WEAK ");
6569 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6570 strcat (buff
, "| <unknown>");
6575 /* Display the contents of the version sections. */
6578 process_version_sections (FILE * file
)
6580 Elf_Internal_Shdr
* section
;
6587 for (i
= 0, section
= section_headers
;
6588 i
< elf_header
.e_shnum
;
6591 switch (section
->sh_type
)
6593 case SHT_GNU_verdef
:
6595 Elf_External_Verdef
* edefs
;
6603 (_("\nVersion definition section '%s' contains %u entries:\n"),
6604 SECTION_NAME (section
), section
->sh_info
);
6606 printf (_(" Addr: 0x"));
6607 printf_vma (section
->sh_addr
);
6608 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6609 (unsigned long) section
->sh_offset
, section
->sh_link
,
6610 section
->sh_link
< elf_header
.e_shnum
6611 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6614 edefs
= (Elf_External_Verdef
*)
6615 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
6616 _("version definition section"));
6617 endbuf
= (char *) edefs
+ section
->sh_size
;
6621 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6624 Elf_External_Verdef
* edef
;
6625 Elf_Internal_Verdef ent
;
6626 Elf_External_Verdaux
* eaux
;
6627 Elf_Internal_Verdaux aux
;
6631 vstart
= ((char *) edefs
) + idx
;
6632 if (vstart
+ sizeof (*edef
) > endbuf
)
6635 edef
= (Elf_External_Verdef
*) vstart
;
6637 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6638 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6639 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6640 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6641 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6642 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6643 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6645 printf (_(" %#06x: Rev: %d Flags: %s"),
6646 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6648 printf (_(" Index: %d Cnt: %d "),
6649 ent
.vd_ndx
, ent
.vd_cnt
);
6651 vstart
+= ent
.vd_aux
;
6653 eaux
= (Elf_External_Verdaux
*) vstart
;
6655 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6656 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6658 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6659 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6661 printf (_("Name index: %ld\n"), aux
.vda_name
);
6663 isum
= idx
+ ent
.vd_aux
;
6665 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6667 isum
+= aux
.vda_next
;
6668 vstart
+= aux
.vda_next
;
6670 eaux
= (Elf_External_Verdaux
*) vstart
;
6671 if (vstart
+ sizeof (*eaux
) > endbuf
)
6674 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6675 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6677 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6678 printf (_(" %#06x: Parent %d: %s\n"),
6679 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6681 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6682 isum
, j
, aux
.vda_name
);
6685 printf (_(" Version def aux past end of section\n"));
6689 if (cnt
< section
->sh_info
)
6690 printf (_(" Version definition past end of section\n"));
6696 case SHT_GNU_verneed
:
6698 Elf_External_Verneed
* eneed
;
6705 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6706 SECTION_NAME (section
), section
->sh_info
);
6708 printf (_(" Addr: 0x"));
6709 printf_vma (section
->sh_addr
);
6710 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6711 (unsigned long) section
->sh_offset
, section
->sh_link
,
6712 section
->sh_link
< elf_header
.e_shnum
6713 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6716 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
6717 section
->sh_offset
, 1,
6719 _("version need section"));
6720 endbuf
= (char *) eneed
+ section
->sh_size
;
6724 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6726 Elf_External_Verneed
* entry
;
6727 Elf_Internal_Verneed ent
;
6732 vstart
= ((char *) eneed
) + idx
;
6733 if (vstart
+ sizeof (*entry
) > endbuf
)
6736 entry
= (Elf_External_Verneed
*) vstart
;
6738 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6739 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6740 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6741 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6742 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6744 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6746 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6747 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6749 printf (_(" File: %lx"), ent
.vn_file
);
6751 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6753 vstart
+= ent
.vn_aux
;
6755 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6757 Elf_External_Vernaux
* eaux
;
6758 Elf_Internal_Vernaux aux
;
6760 if (vstart
+ sizeof (*eaux
) > endbuf
)
6762 eaux
= (Elf_External_Vernaux
*) vstart
;
6764 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6765 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6766 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6767 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6768 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6770 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6771 printf (_(" %#06x: Name: %s"),
6772 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6774 printf (_(" %#06x: Name index: %lx"),
6775 isum
, aux
.vna_name
);
6777 printf (_(" Flags: %s Version: %d\n"),
6778 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6780 isum
+= aux
.vna_next
;
6781 vstart
+= aux
.vna_next
;
6784 printf (_(" Version need aux past end of section\n"));
6788 if (cnt
< section
->sh_info
)
6789 printf (_(" Version need past end of section\n"));
6795 case SHT_GNU_versym
:
6797 Elf_Internal_Shdr
* link_section
;
6800 unsigned char * edata
;
6801 unsigned short * data
;
6803 Elf_Internal_Sym
* symbols
;
6804 Elf_Internal_Shdr
* string_sec
;
6807 if (section
->sh_link
>= elf_header
.e_shnum
)
6810 link_section
= section_headers
+ section
->sh_link
;
6811 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6813 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6818 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6820 string_sec
= section_headers
+ link_section
->sh_link
;
6822 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6823 string_sec
->sh_size
,
6824 _("version string table"));
6828 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6829 SECTION_NAME (section
), total
);
6831 printf (_(" Addr: "));
6832 printf_vma (section
->sh_addr
);
6833 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6834 (unsigned long) section
->sh_offset
, section
->sh_link
,
6835 SECTION_NAME (link_section
));
6837 off
= offset_from_vma (file
,
6838 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6839 total
* sizeof (short));
6840 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
6842 _("version symbol data"));
6849 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
6851 for (cnt
= total
; cnt
--;)
6852 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6857 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6860 int check_def
, check_need
;
6863 printf (" %03x:", cnt
);
6865 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6866 switch (data
[cnt
+ j
])
6869 fputs (_(" 0 (*local*) "), stdout
);
6873 fputs (_(" 1 (*global*) "), stdout
);
6877 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
6878 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
6882 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6883 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6886 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6893 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6895 Elf_Internal_Verneed ivn
;
6896 unsigned long offset
;
6898 offset
= offset_from_vma
6899 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6900 sizeof (Elf_External_Verneed
));
6904 Elf_Internal_Vernaux ivna
;
6905 Elf_External_Verneed evn
;
6906 Elf_External_Vernaux evna
;
6907 unsigned long a_off
;
6909 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6912 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6913 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6915 a_off
= offset
+ ivn
.vn_aux
;
6919 get_data (&evna
, file
, a_off
, sizeof (evna
),
6920 1, _("version need aux (2)"));
6922 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6923 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6925 a_off
+= ivna
.vna_next
;
6927 while (ivna
.vna_other
!= data
[cnt
+ j
]
6928 && ivna
.vna_next
!= 0);
6930 if (ivna
.vna_other
== data
[cnt
+ j
])
6932 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6934 if (ivna
.vna_name
>= string_sec
->sh_size
)
6935 name
= _("*invalid*");
6937 name
= strtab
+ ivna
.vna_name
;
6938 nn
+= printf ("(%s%-*s",
6940 12 - (int) strlen (name
),
6946 offset
+= ivn
.vn_next
;
6948 while (ivn
.vn_next
);
6951 if (check_def
&& data
[cnt
+ j
] != 0x8001
6952 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6954 Elf_Internal_Verdef ivd
;
6955 Elf_External_Verdef evd
;
6956 unsigned long offset
;
6958 offset
= offset_from_vma
6959 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6964 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6967 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6968 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6970 offset
+= ivd
.vd_next
;
6972 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
6973 && ivd
.vd_next
!= 0);
6975 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
6977 Elf_External_Verdaux evda
;
6978 Elf_Internal_Verdaux ivda
;
6980 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6982 get_data (&evda
, file
,
6983 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6985 _("version def aux"));
6987 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6989 if (ivda
.vda_name
>= string_sec
->sh_size
)
6990 name
= _("*invalid*");
6992 name
= strtab
+ ivda
.vda_name
;
6993 nn
+= printf ("(%s%-*s",
6995 12 - (int) strlen (name
),
7001 printf ("%*c", 18 - nn
, ' ');
7019 printf (_("\nNo version information found in this file.\n"));
7025 get_symbol_binding (unsigned int binding
)
7027 static char buff
[32];
7031 case STB_LOCAL
: return "LOCAL";
7032 case STB_GLOBAL
: return "GLOBAL";
7033 case STB_WEAK
: return "WEAK";
7035 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7036 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7038 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7040 if (binding
== STB_GNU_UNIQUE
7041 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7042 /* GNU/Linux is still using the default value 0. */
7043 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7045 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7048 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7054 get_symbol_type (unsigned int type
)
7056 static char buff
[32];
7060 case STT_NOTYPE
: return "NOTYPE";
7061 case STT_OBJECT
: return "OBJECT";
7062 case STT_FUNC
: return "FUNC";
7063 case STT_SECTION
: return "SECTION";
7064 case STT_FILE
: return "FILE";
7065 case STT_COMMON
: return "COMMON";
7066 case STT_TLS
: return "TLS";
7067 case STT_RELC
: return "RELC";
7068 case STT_SRELC
: return "SRELC";
7070 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7072 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7073 return "THUMB_FUNC";
7075 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7078 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7079 return "PARISC_MILLI";
7081 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7083 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7085 if (elf_header
.e_machine
== EM_PARISC
)
7087 if (type
== STT_HP_OPAQUE
)
7089 if (type
== STT_HP_STUB
)
7093 if (type
== STT_GNU_IFUNC
7094 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7095 /* GNU/Linux is still using the default value 0. */
7096 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7099 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7102 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7108 get_symbol_visibility (unsigned int visibility
)
7112 case STV_DEFAULT
: return "DEFAULT";
7113 case STV_INTERNAL
: return "INTERNAL";
7114 case STV_HIDDEN
: return "HIDDEN";
7115 case STV_PROTECTED
: return "PROTECTED";
7121 get_mips_symbol_other (unsigned int other
)
7125 case STO_OPTIONAL
: return "OPTIONAL";
7126 case STO_MIPS16
: return "MIPS16";
7127 case STO_MIPS_PLT
: return "MIPS PLT";
7128 case STO_MIPS_PIC
: return "MIPS PIC";
7129 default: return NULL
;
7134 get_symbol_other (unsigned int other
)
7136 const char * result
= NULL
;
7137 static char buff
[32];
7142 switch (elf_header
.e_machine
)
7145 result
= get_mips_symbol_other (other
);
7153 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7158 get_symbol_index_type (unsigned int type
)
7160 static char buff
[32];
7164 case SHN_UNDEF
: return "UND";
7165 case SHN_ABS
: return "ABS";
7166 case SHN_COMMON
: return "COM";
7168 if (type
== SHN_IA_64_ANSI_COMMON
7169 && elf_header
.e_machine
== EM_IA_64
7170 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7172 else if ((elf_header
.e_machine
== EM_X86_64
7173 || elf_header
.e_machine
== EM_L1OM
)
7174 && type
== SHN_X86_64_LCOMMON
)
7176 else if (type
== SHN_MIPS_SCOMMON
7177 && elf_header
.e_machine
== EM_MIPS
)
7179 else if (type
== SHN_MIPS_SUNDEFINED
7180 && elf_header
.e_machine
== EM_MIPS
)
7182 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7183 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7184 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7185 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7186 else if (type
>= SHN_LORESERVE
)
7187 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7189 sprintf (buff
, "%3d", type
);
7197 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7199 unsigned char * e_data
;
7202 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
7206 error (_("Out of memory\n"));
7210 if (fread (e_data
, ent_size
, number
, file
) != number
)
7212 error (_("Unable to read in dynamic data\n"));
7216 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
7220 error (_("Out of memory\n"));
7226 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7234 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7236 Elf_Internal_Sym
* psym
;
7239 psym
= dynamic_symbols
+ si
;
7241 n
= print_vma (si
, DEC_5
);
7243 fputs (" " + n
, stdout
);
7244 printf (" %3lu: ", hn
);
7245 print_vma (psym
->st_value
, LONG_HEX
);
7247 print_vma (psym
->st_size
, DEC_5
);
7249 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7250 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7251 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7252 /* Check to see if any other bits in the st_other field are set.
7253 Note - displaying this information disrupts the layout of the
7254 table being generated, but for the moment this case is very
7256 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7257 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7258 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7259 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7260 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7262 printf (" <corrupt: %14ld>", psym
->st_name
);
7266 /* Dump the symbol table. */
7268 process_symbol_table (FILE * file
)
7270 Elf_Internal_Shdr
* section
;
7271 bfd_vma nbuckets
= 0;
7272 bfd_vma nchains
= 0;
7273 bfd_vma
* buckets
= NULL
;
7274 bfd_vma
* chains
= NULL
;
7275 bfd_vma ngnubuckets
= 0;
7276 bfd_vma
* gnubuckets
= NULL
;
7277 bfd_vma
* gnuchains
= NULL
;
7278 bfd_vma gnusymidx
= 0;
7280 if (! do_syms
&& !do_histogram
)
7283 if (dynamic_info
[DT_HASH
]
7285 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7287 unsigned char nb
[8];
7288 unsigned char nc
[8];
7289 int hash_ent_size
= 4;
7291 if ((elf_header
.e_machine
== EM_ALPHA
7292 || elf_header
.e_machine
== EM_S390
7293 || elf_header
.e_machine
== EM_S390_OLD
)
7294 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7298 (archive_file_offset
7299 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7300 sizeof nb
+ sizeof nc
)),
7303 error (_("Unable to seek to start of dynamic information\n"));
7307 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7309 error (_("Failed to read in number of buckets\n"));
7313 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7315 error (_("Failed to read in number of chains\n"));
7319 nbuckets
= byte_get (nb
, hash_ent_size
);
7320 nchains
= byte_get (nc
, hash_ent_size
);
7322 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7323 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7326 if (buckets
== NULL
|| chains
== NULL
)
7328 if (do_using_dynamic
)
7339 if (dynamic_info_DT_GNU_HASH
7341 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7343 unsigned char nb
[16];
7344 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7345 bfd_vma buckets_vma
;
7348 (archive_file_offset
7349 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7353 error (_("Unable to seek to start of dynamic information\n"));
7357 if (fread (nb
, 16, 1, file
) != 1)
7359 error (_("Failed to read in number of buckets\n"));
7363 ngnubuckets
= byte_get (nb
, 4);
7364 gnusymidx
= byte_get (nb
+ 4, 4);
7365 bitmaskwords
= byte_get (nb
+ 8, 4);
7366 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7368 buckets_vma
+= bitmaskwords
* 4;
7370 buckets_vma
+= bitmaskwords
* 8;
7373 (archive_file_offset
7374 + offset_from_vma (file
, buckets_vma
, 4)),
7377 error (_("Unable to seek to start of dynamic information\n"));
7381 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7383 if (gnubuckets
== NULL
)
7386 for (i
= 0; i
< ngnubuckets
; i
++)
7387 if (gnubuckets
[i
] != 0)
7389 if (gnubuckets
[i
] < gnusymidx
)
7392 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7393 maxchain
= gnubuckets
[i
];
7396 if (maxchain
== 0xffffffff)
7399 maxchain
-= gnusymidx
;
7402 (archive_file_offset
7403 + offset_from_vma (file
, buckets_vma
7404 + 4 * (ngnubuckets
+ maxchain
), 4)),
7407 error (_("Unable to seek to start of dynamic information\n"));
7413 if (fread (nb
, 4, 1, file
) != 1)
7415 error (_("Failed to determine last chain length\n"));
7419 if (maxchain
+ 1 == 0)
7424 while ((byte_get (nb
, 4) & 1) == 0);
7427 (archive_file_offset
7428 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7431 error (_("Unable to seek to start of dynamic information\n"));
7435 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7438 if (gnuchains
== NULL
)
7443 if (do_using_dynamic
)
7448 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7451 && dynamic_strings
!= NULL
)
7455 if (dynamic_info
[DT_HASH
])
7459 printf (_("\nSymbol table for image:\n"));
7461 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7463 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7465 for (hn
= 0; hn
< nbuckets
; hn
++)
7470 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7471 print_dynamic_symbol (si
, hn
);
7475 if (dynamic_info_DT_GNU_HASH
)
7477 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7479 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7481 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7483 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7484 if (gnubuckets
[hn
] != 0)
7486 bfd_vma si
= gnubuckets
[hn
];
7487 bfd_vma off
= si
- gnusymidx
;
7491 print_dynamic_symbol (si
, hn
);
7494 while ((gnuchains
[off
++] & 1) == 0);
7498 else if (do_syms
&& !do_using_dynamic
)
7502 for (i
= 0, section
= section_headers
;
7503 i
< elf_header
.e_shnum
;
7507 char * strtab
= NULL
;
7508 unsigned long int strtab_size
= 0;
7509 Elf_Internal_Sym
* symtab
;
7510 Elf_Internal_Sym
* psym
;
7512 if ( section
->sh_type
!= SHT_SYMTAB
7513 && section
->sh_type
!= SHT_DYNSYM
)
7516 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7517 SECTION_NAME (section
),
7518 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7520 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7522 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7524 symtab
= GET_ELF_SYMBOLS (file
, section
);
7528 if (section
->sh_link
== elf_header
.e_shstrndx
)
7530 strtab
= string_table
;
7531 strtab_size
= string_table_length
;
7533 else if (section
->sh_link
< elf_header
.e_shnum
)
7535 Elf_Internal_Shdr
* string_sec
;
7537 string_sec
= section_headers
+ section
->sh_link
;
7539 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
7540 1, string_sec
->sh_size
,
7542 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7545 for (si
= 0, psym
= symtab
;
7546 si
< section
->sh_size
/ section
->sh_entsize
;
7549 printf ("%6d: ", si
);
7550 print_vma (psym
->st_value
, LONG_HEX
);
7552 print_vma (psym
->st_size
, DEC_5
);
7553 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7554 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7555 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7556 /* Check to see if any other bits in the st_other field are set.
7557 Note - displaying this information disrupts the layout of the
7558 table being generated, but for the moment this case is very rare. */
7559 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7560 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7561 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7562 print_symbol (25, psym
->st_name
< strtab_size
7563 ? strtab
+ psym
->st_name
: "<corrupt>");
7565 if (section
->sh_type
== SHT_DYNSYM
&&
7566 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7568 unsigned char data
[2];
7569 unsigned short vers_data
;
7570 unsigned long offset
;
7574 offset
= offset_from_vma
7575 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7576 sizeof data
+ si
* sizeof (vers_data
));
7578 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7579 sizeof (data
), 1, _("version data"));
7581 vers_data
= byte_get (data
, 2);
7583 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7584 && section_headers
[psym
->st_shndx
].sh_type
7587 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7589 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
7591 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7592 && (is_nobits
|| ! check_def
))
7594 Elf_External_Verneed evn
;
7595 Elf_Internal_Verneed ivn
;
7596 Elf_Internal_Vernaux ivna
;
7598 /* We must test both. */
7599 offset
= offset_from_vma
7600 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7605 unsigned long vna_off
;
7607 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7610 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7611 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7613 vna_off
= offset
+ ivn
.vn_aux
;
7617 Elf_External_Vernaux evna
;
7619 get_data (&evna
, file
, vna_off
,
7621 _("version need aux (3)"));
7623 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7624 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7625 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7627 vna_off
+= ivna
.vna_next
;
7629 while (ivna
.vna_other
!= vers_data
7630 && ivna
.vna_next
!= 0);
7632 if (ivna
.vna_other
== vers_data
)
7635 offset
+= ivn
.vn_next
;
7637 while (ivn
.vn_next
!= 0);
7639 if (ivna
.vna_other
== vers_data
)
7642 ivna
.vna_name
< strtab_size
7643 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7647 else if (! is_nobits
)
7648 error (_("bad dynamic symbol\n"));
7655 if (vers_data
!= 0x8001
7656 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7658 Elf_Internal_Verdef ivd
;
7659 Elf_Internal_Verdaux ivda
;
7660 Elf_External_Verdaux evda
;
7661 unsigned long offset
;
7663 offset
= offset_from_vma
7665 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7666 sizeof (Elf_External_Verdef
));
7670 Elf_External_Verdef evd
;
7672 get_data (&evd
, file
, offset
, sizeof (evd
),
7673 1, _("version def"));
7675 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7676 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7677 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7679 offset
+= ivd
.vd_next
;
7681 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
7682 && ivd
.vd_next
!= 0);
7684 offset
-= ivd
.vd_next
;
7685 offset
+= ivd
.vd_aux
;
7687 get_data (&evda
, file
, offset
, sizeof (evda
),
7688 1, _("version def aux"));
7690 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7692 if (psym
->st_name
!= ivda
.vda_name
)
7693 printf ((vers_data
& VERSYM_HIDDEN
)
7695 ivda
.vda_name
< strtab_size
7696 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7706 if (strtab
!= string_table
)
7712 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7714 if (do_histogram
&& buckets
!= NULL
)
7716 unsigned long * lengths
;
7717 unsigned long * counts
;
7720 unsigned long maxlength
= 0;
7721 unsigned long nzero_counts
= 0;
7722 unsigned long nsyms
= 0;
7724 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7725 (unsigned long) nbuckets
);
7726 printf (_(" Length Number %% of total Coverage\n"));
7728 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
7729 if (lengths
== NULL
)
7731 error (_("Out of memory\n"));
7734 for (hn
= 0; hn
< nbuckets
; ++hn
)
7736 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7739 if (maxlength
< ++lengths
[hn
])
7744 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7747 error (_("Out of memory\n"));
7751 for (hn
= 0; hn
< nbuckets
; ++hn
)
7752 ++counts
[lengths
[hn
]];
7757 printf (" 0 %-10lu (%5.1f%%)\n",
7758 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7759 for (i
= 1; i
<= maxlength
; ++i
)
7761 nzero_counts
+= counts
[i
] * i
;
7762 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7763 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7764 (nzero_counts
* 100.0) / nsyms
);
7772 if (buckets
!= NULL
)
7778 if (do_histogram
&& gnubuckets
!= NULL
)
7780 unsigned long * lengths
;
7781 unsigned long * counts
;
7783 unsigned long maxlength
= 0;
7784 unsigned long nzero_counts
= 0;
7785 unsigned long nsyms
= 0;
7787 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
7788 if (lengths
== NULL
)
7790 error (_("Out of memory\n"));
7794 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7795 (unsigned long) ngnubuckets
);
7796 printf (_(" Length Number %% of total Coverage\n"));
7798 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7799 if (gnubuckets
[hn
] != 0)
7801 bfd_vma off
, length
= 1;
7803 for (off
= gnubuckets
[hn
] - gnusymidx
;
7804 (gnuchains
[off
] & 1) == 0; ++off
)
7806 lengths
[hn
] = length
;
7807 if (length
> maxlength
)
7812 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7815 error (_("Out of memory\n"));
7819 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7820 ++counts
[lengths
[hn
]];
7822 if (ngnubuckets
> 0)
7825 printf (" 0 %-10lu (%5.1f%%)\n",
7826 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7827 for (j
= 1; j
<= maxlength
; ++j
)
7829 nzero_counts
+= counts
[j
] * j
;
7830 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7831 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7832 (nzero_counts
* 100.0) / nsyms
);
7846 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7850 if (dynamic_syminfo
== NULL
7852 /* No syminfo, this is ok. */
7855 /* There better should be a dynamic symbol section. */
7856 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7860 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7861 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7863 printf (_(" Num: Name BoundTo Flags\n"));
7864 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7866 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7868 printf ("%4d: ", i
);
7869 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7870 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7872 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7875 switch (dynamic_syminfo
[i
].si_boundto
)
7877 case SYMINFO_BT_SELF
:
7878 fputs ("SELF ", stdout
);
7880 case SYMINFO_BT_PARENT
:
7881 fputs ("PARENT ", stdout
);
7884 if (dynamic_syminfo
[i
].si_boundto
> 0
7885 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7886 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7888 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7892 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7896 if (flags
& SYMINFO_FLG_DIRECT
)
7898 if (flags
& SYMINFO_FLG_PASSTHRU
)
7899 printf (" PASSTHRU");
7900 if (flags
& SYMINFO_FLG_COPY
)
7902 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7903 printf (" LAZYLOAD");
7911 /* Check to see if the given reloc needs to be handled in a target specific
7912 manner. If so then process the reloc and return TRUE otherwise return
7916 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
7917 unsigned char * start
,
7918 Elf_Internal_Sym
* symtab
)
7920 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
7922 switch (elf_header
.e_machine
)
7925 case EM_CYGNUS_MN10300
:
7927 static Elf_Internal_Sym
* saved_sym
= NULL
;
7931 case 34: /* R_MN10300_ALIGN */
7933 case 33: /* R_MN10300_SYM_DIFF */
7934 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
7936 case 1: /* R_MN10300_32 */
7937 case 2: /* R_MN10300_16 */
7938 if (saved_sym
!= NULL
)
7942 value
= reloc
->r_addend
7943 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
7944 - saved_sym
->st_value
);
7946 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
7953 if (saved_sym
!= NULL
)
7954 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
7964 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7965 DWARF debug sections. This is a target specific test. Note - we do not
7966 go through the whole including-target-headers-multiple-times route, (as
7967 we have already done with <elf/h8.h>) because this would become very
7968 messy and even then this function would have to contain target specific
7969 information (the names of the relocs instead of their numeric values).
7970 FIXME: This is not the correct way to solve this problem. The proper way
7971 is to have target specific reloc sizing and typing functions created by
7972 the reloc-macros.h header, in the same way that it already creates the
7973 reloc naming functions. */
7976 is_32bit_abs_reloc (unsigned int reloc_type
)
7978 switch (elf_header
.e_machine
)
7982 return reloc_type
== 1; /* R_386_32. */
7984 return reloc_type
== 1; /* R_68K_32. */
7986 return reloc_type
== 1; /* R_860_32. */
7988 return reloc_type
== 1; /* XXX Is this right ? */
7990 return reloc_type
== 1; /* R_ARC_32. */
7992 return reloc_type
== 2; /* R_ARM_ABS32 */
7995 return reloc_type
== 1;
7997 return reloc_type
== 0x12; /* R_byte4_data. */
7999 return reloc_type
== 3; /* R_CRIS_32. */
8002 return reloc_type
== 3; /* R_CR16_NUM32. */
8004 return reloc_type
== 15; /* R_CRX_NUM32. */
8006 return reloc_type
== 1;
8007 case EM_CYGNUS_D10V
:
8009 return reloc_type
== 6; /* R_D10V_32. */
8010 case EM_CYGNUS_D30V
:
8012 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8014 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8015 case EM_CYGNUS_FR30
:
8017 return reloc_type
== 3; /* R_FR30_32. */
8021 return reloc_type
== 1; /* R_H8_DIR32. */
8023 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8026 return reloc_type
== 2; /* R_IP2K_32. */
8028 return reloc_type
== 2; /* R_IQ2000_32. */
8029 case EM_LATTICEMICO32
:
8030 return reloc_type
== 3; /* R_LM32_32. */
8033 return reloc_type
== 3; /* R_M32C_32. */
8035 return reloc_type
== 34; /* R_M32R_32_RELA. */
8037 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8039 return reloc_type
== 4; /* R_MEP_32. */
8041 return reloc_type
== 2; /* R_MIPS_32. */
8043 return reloc_type
== 4; /* R_MMIX_32. */
8044 case EM_CYGNUS_MN10200
:
8046 return reloc_type
== 1; /* R_MN10200_32. */
8047 case EM_CYGNUS_MN10300
:
8049 return reloc_type
== 1; /* R_MN10300_32. */
8052 return reloc_type
== 1; /* R_MSP43_32. */
8054 return reloc_type
== 2; /* R_MT_32. */
8055 case EM_ALTERA_NIOS2
:
8057 return reloc_type
== 1; /* R_NIOS_32. */
8060 return reloc_type
== 1; /* R_OR32_32. */
8062 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8063 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8066 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8068 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8070 return reloc_type
== 1; /* R_PPC_ADDR32. */
8072 return reloc_type
== 1; /* R_RX_DIR32. */
8074 return reloc_type
== 1; /* R_I370_ADDR31. */
8077 return reloc_type
== 4; /* R_S390_32. */
8079 return reloc_type
== 8; /* R_SCORE_ABS32. */
8081 return reloc_type
== 1; /* R_SH_DIR32. */
8082 case EM_SPARC32PLUS
:
8085 return reloc_type
== 3 /* R_SPARC_32. */
8086 || reloc_type
== 23; /* R_SPARC_UA32. */
8088 return reloc_type
== 6; /* R_SPU_ADDR32 */
8089 case EM_CYGNUS_V850
:
8091 return reloc_type
== 6; /* R_V850_ABS32. */
8093 return reloc_type
== 1; /* R_VAX_32. */
8096 return reloc_type
== 10; /* R_X86_64_32. */
8098 return reloc_type
== 1; /* R_XSTROMY16_32. */
8101 return reloc_type
== 1; /* R_XTENSA_32. */
8104 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8105 elf_header
.e_machine
);
8110 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8111 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8114 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8116 switch (elf_header
.e_machine
)
8120 return reloc_type
== 2; /* R_386_PC32. */
8122 return reloc_type
== 4; /* R_68K_PC32. */
8124 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8126 return reloc_type
== 3; /* R_ARM_REL32 */
8128 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8130 return reloc_type
== 26; /* R_PPC_REL32. */
8132 return reloc_type
== 26; /* R_PPC64_REL32. */
8135 return reloc_type
== 5; /* R_390_PC32. */
8137 return reloc_type
== 2; /* R_SH_REL32. */
8138 case EM_SPARC32PLUS
:
8141 return reloc_type
== 6; /* R_SPARC_DISP32. */
8143 return reloc_type
== 13; /* R_SPU_REL32. */
8146 return reloc_type
== 2; /* R_X86_64_PC32. */
8149 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8151 /* Do not abort or issue an error message here. Not all targets use
8152 pc-relative 32-bit relocs in their DWARF debug information and we
8153 have already tested for target coverage in is_32bit_abs_reloc. A
8154 more helpful warning message will be generated by apply_relocations
8155 anyway, so just return. */
8160 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8161 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8164 is_64bit_abs_reloc (unsigned int reloc_type
)
8166 switch (elf_header
.e_machine
)
8169 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8171 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8173 return reloc_type
== 80; /* R_PARISC_DIR64. */
8175 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8176 case EM_SPARC32PLUS
:
8179 return reloc_type
== 54; /* R_SPARC_UA64. */
8182 return reloc_type
== 1; /* R_X86_64_64. */
8185 return reloc_type
== 22; /* R_S390_64 */
8187 return reloc_type
== 18; /* R_MIPS_64 */
8193 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8194 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8197 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8199 switch (elf_header
.e_machine
)
8202 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8204 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8206 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8208 return reloc_type
== 44; /* R_PPC64_REL64 */
8209 case EM_SPARC32PLUS
:
8212 return reloc_type
== 46; /* R_SPARC_DISP64 */
8215 return reloc_type
== 24; /* R_X86_64_PC64 */
8218 return reloc_type
== 23; /* R_S390_PC64 */
8224 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8225 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8228 is_24bit_abs_reloc (unsigned int reloc_type
)
8230 switch (elf_header
.e_machine
)
8232 case EM_CYGNUS_MN10200
:
8234 return reloc_type
== 4; /* R_MN10200_24. */
8240 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8241 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8244 is_16bit_abs_reloc (unsigned int reloc_type
)
8246 switch (elf_header
.e_machine
)
8250 return reloc_type
== 4; /* R_AVR_16. */
8251 case EM_CYGNUS_D10V
:
8253 return reloc_type
== 3; /* R_D10V_16. */
8257 return reloc_type
== R_H8_DIR16
;
8260 return reloc_type
== 1; /* R_IP2K_16. */
8263 return reloc_type
== 1; /* R_M32C_16 */
8266 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8267 case EM_ALTERA_NIOS2
:
8269 return reloc_type
== 9; /* R_NIOS_16. */
8275 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8276 relocation entries (possibly formerly used for SHT_GROUP sections). */
8279 is_none_reloc (unsigned int reloc_type
)
8281 switch (elf_header
.e_machine
)
8283 case EM_68K
: /* R_68K_NONE. */
8284 case EM_386
: /* R_386_NONE. */
8285 case EM_SPARC32PLUS
:
8287 case EM_SPARC
: /* R_SPARC_NONE. */
8288 case EM_MIPS
: /* R_MIPS_NONE. */
8289 case EM_PARISC
: /* R_PARISC_NONE. */
8290 case EM_ALPHA
: /* R_ALPHA_NONE. */
8291 case EM_PPC
: /* R_PPC_NONE. */
8292 case EM_PPC64
: /* R_PPC64_NONE. */
8293 case EM_ARM
: /* R_ARM_NONE. */
8294 case EM_IA_64
: /* R_IA64_NONE. */
8295 case EM_SH
: /* R_SH_NONE. */
8297 case EM_S390
: /* R_390_NONE. */
8298 case EM_CRIS
: /* R_CRIS_NONE. */
8299 case EM_X86_64
: /* R_X86_64_NONE. */
8300 case EM_L1OM
: /* R_X86_64_NONE. */
8301 case EM_MN10300
: /* R_MN10300_NONE. */
8302 case EM_M32R
: /* R_M32R_NONE. */
8303 return reloc_type
== 0;
8306 return (reloc_type
== 0 /* R_XTENSA_NONE. */
8307 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
8308 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
8309 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
8314 /* Apply relocations to a section.
8315 Note: So far support has been added only for those relocations
8316 which can be found in debug sections.
8317 FIXME: Add support for more relocations ? */
8320 apply_relocations (void * file
,
8321 Elf_Internal_Shdr
* section
,
8322 unsigned char * start
)
8324 Elf_Internal_Shdr
* relsec
;
8325 unsigned char * end
= start
+ section
->sh_size
;
8327 if (elf_header
.e_type
!= ET_REL
)
8330 /* Find the reloc section associated with the section. */
8331 for (relsec
= section_headers
;
8332 relsec
< section_headers
+ elf_header
.e_shnum
;
8335 bfd_boolean is_rela
;
8336 unsigned long num_relocs
;
8337 Elf_Internal_Rela
* relocs
;
8338 Elf_Internal_Rela
* rp
;
8339 Elf_Internal_Shdr
* symsec
;
8340 Elf_Internal_Sym
* symtab
;
8341 Elf_Internal_Sym
* sym
;
8343 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8344 || relsec
->sh_info
>= elf_header
.e_shnum
8345 || section_headers
+ relsec
->sh_info
!= section
8346 || relsec
->sh_size
== 0
8347 || relsec
->sh_link
>= elf_header
.e_shnum
)
8350 is_rela
= relsec
->sh_type
== SHT_RELA
;
8354 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
8355 relsec
->sh_size
, & relocs
, & num_relocs
))
8360 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
8361 relsec
->sh_size
, & relocs
, & num_relocs
))
8365 /* SH uses RELA but uses in place value instead of the addend field. */
8366 if (elf_header
.e_machine
== EM_SH
)
8369 symsec
= section_headers
+ relsec
->sh_link
;
8370 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
8372 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8375 unsigned int reloc_type
;
8376 unsigned int reloc_size
;
8377 unsigned char * loc
;
8379 reloc_type
= get_reloc_type (rp
->r_info
);
8381 if (target_specific_reloc_handling (rp
, start
, symtab
))
8383 else if (is_none_reloc (reloc_type
))
8385 else if (is_32bit_abs_reloc (reloc_type
)
8386 || is_32bit_pcrel_reloc (reloc_type
))
8388 else if (is_64bit_abs_reloc (reloc_type
)
8389 || is_64bit_pcrel_reloc (reloc_type
))
8391 else if (is_24bit_abs_reloc (reloc_type
))
8393 else if (is_16bit_abs_reloc (reloc_type
))
8397 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8398 reloc_type
, SECTION_NAME (section
));
8402 loc
= start
+ rp
->r_offset
;
8403 if ((loc
+ reloc_size
) > end
)
8405 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8406 (unsigned long) rp
->r_offset
,
8407 SECTION_NAME (section
));
8411 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8413 /* If the reloc has a symbol associated with it,
8414 make sure that it is of an appropriate type.
8416 Relocations against symbols without type can happen.
8417 Gcc -feliminate-dwarf2-dups may generate symbols
8418 without type for debug info.
8420 Icc generates relocations against function symbols
8421 instead of local labels.
8423 Relocations against object symbols can happen, eg when
8424 referencing a global array. For an example of this see
8425 the _clz.o binary in libgcc.a. */
8427 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8429 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8430 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8431 (long int)(rp
- relocs
),
8432 SECTION_NAME (relsec
));
8438 addend
+= rp
->r_addend
;
8439 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8441 || (elf_header
.e_machine
== EM_XTENSA
8443 || ((elf_header
.e_machine
== EM_PJ
8444 || elf_header
.e_machine
== EM_PJ_OLD
)
8445 && reloc_type
== 1))
8446 addend
+= byte_get (loc
, reloc_size
);
8448 if (is_32bit_pcrel_reloc (reloc_type
)
8449 || is_64bit_pcrel_reloc (reloc_type
))
8451 /* On HPPA, all pc-relative relocations are biased by 8. */
8452 if (elf_header
.e_machine
== EM_PARISC
)
8454 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8458 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8467 #ifdef SUPPORT_DISASSEMBLY
8469 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8471 printf (_("\nAssembly dump of section %s\n"),
8472 SECTION_NAME (section
));
8474 /* XXX -- to be done --- XXX */
8480 /* Reads in the contents of SECTION from FILE, returning a pointer
8481 to a malloc'ed buffer or NULL if something went wrong. */
8484 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8486 bfd_size_type num_bytes
;
8488 num_bytes
= section
->sh_size
;
8490 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8492 printf (_("\nSection '%s' has no data to dump.\n"),
8493 SECTION_NAME (section
));
8497 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8498 _("section contents"));
8503 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8505 Elf_Internal_Shdr
* relsec
;
8506 bfd_size_type num_bytes
;
8511 char * name
= SECTION_NAME (section
);
8512 bfd_boolean some_strings_shown
;
8514 start
= get_section_contents (section
, file
);
8518 printf (_("\nString dump of section '%s':\n"), name
);
8520 /* If the section being dumped has relocations against it the user might
8521 be expecting these relocations to have been applied. Check for this
8522 case and issue a warning message in order to avoid confusion.
8523 FIXME: Maybe we ought to have an option that dumps a section with
8525 for (relsec
= section_headers
;
8526 relsec
< section_headers
+ elf_header
.e_shnum
;
8529 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8530 || relsec
->sh_info
>= elf_header
.e_shnum
8531 || section_headers
+ relsec
->sh_info
!= section
8532 || relsec
->sh_size
== 0
8533 || relsec
->sh_link
>= elf_header
.e_shnum
)
8536 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8540 num_bytes
= section
->sh_size
;
8541 addr
= section
->sh_addr
;
8543 end
= start
+ num_bytes
;
8544 some_strings_shown
= FALSE
;
8548 while (!ISPRINT (* data
))
8555 printf (" [%6tx] %s\n", data
- start
, data
);
8557 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8559 data
+= strlen (data
);
8560 some_strings_shown
= TRUE
;
8564 if (! some_strings_shown
)
8565 printf (_(" No strings found in this section."));
8573 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8575 bfd_boolean relocate
)
8577 Elf_Internal_Shdr
* relsec
;
8578 bfd_size_type bytes
;
8580 unsigned char * data
;
8581 unsigned char * start
;
8583 start
= (unsigned char *) get_section_contents (section
, file
);
8587 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8591 apply_relocations (file
, section
, start
);
8595 /* If the section being dumped has relocations against it the user might
8596 be expecting these relocations to have been applied. Check for this
8597 case and issue a warning message in order to avoid confusion.
8598 FIXME: Maybe we ought to have an option that dumps a section with
8600 for (relsec
= section_headers
;
8601 relsec
< section_headers
+ elf_header
.e_shnum
;
8604 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8605 || relsec
->sh_info
>= elf_header
.e_shnum
8606 || section_headers
+ relsec
->sh_info
!= section
8607 || relsec
->sh_size
== 0
8608 || relsec
->sh_link
>= elf_header
.e_shnum
)
8611 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8616 addr
= section
->sh_addr
;
8617 bytes
= section
->sh_size
;
8626 lbytes
= (bytes
> 16 ? 16 : bytes
);
8628 printf (" 0x%8.8lx ", (unsigned long) addr
);
8630 for (j
= 0; j
< 16; j
++)
8633 printf ("%2.2x", data
[j
]);
8641 for (j
= 0; j
< lbytes
; j
++)
8644 if (k
>= ' ' && k
< 0x7f)
8662 /* Uncompresses a section that was compressed using zlib, in place.
8663 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8666 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8669 /* These are just to quiet gcc. */
8674 dwarf_size_type compressed_size
= *size
;
8675 unsigned char * compressed_buffer
= *buffer
;
8676 dwarf_size_type uncompressed_size
;
8677 unsigned char * uncompressed_buffer
;
8680 dwarf_size_type header_size
= 12;
8682 /* Read the zlib header. In this case, it should be "ZLIB" followed
8683 by the uncompressed section size, 8 bytes in big-endian order. */
8684 if (compressed_size
< header_size
8685 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8688 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8689 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8690 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8691 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8692 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8693 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8694 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8695 uncompressed_size
+= compressed_buffer
[11];
8697 /* It is possible the section consists of several compressed
8698 buffers concatenated together, so we uncompress in a loop. */
8702 strm
.avail_in
= compressed_size
- header_size
;
8703 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8704 strm
.avail_out
= uncompressed_size
;
8705 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
8707 rc
= inflateInit (& strm
);
8708 while (strm
.avail_in
> 0)
8712 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8713 + (uncompressed_size
- strm
.avail_out
));
8714 rc
= inflate (&strm
, Z_FINISH
);
8715 if (rc
!= Z_STREAM_END
)
8717 rc
= inflateReset (& strm
);
8719 rc
= inflateEnd (& strm
);
8721 || strm
.avail_out
!= 0)
8724 free (compressed_buffer
);
8725 *buffer
= uncompressed_buffer
;
8726 *size
= uncompressed_size
;
8730 free (uncompressed_buffer
);
8732 #endif /* HAVE_ZLIB_H */
8736 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8737 Elf_Internal_Shdr
* sec
, void * file
)
8739 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8741 int section_is_compressed
;
8743 /* If it is already loaded, do nothing. */
8744 if (section
->start
!= NULL
)
8747 section_is_compressed
= section
->name
== section
->compressed_name
;
8749 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8750 section
->address
= sec
->sh_addr
;
8751 section
->size
= sec
->sh_size
;
8752 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
8755 if (section
->start
== NULL
)
8758 if (section_is_compressed
)
8759 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8762 if (debug_displays
[debug
].relocate
)
8763 apply_relocations ((FILE *) file
, sec
, section
->start
);
8769 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8771 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8772 Elf_Internal_Shdr
* sec
;
8774 /* Locate the debug section. */
8775 sec
= find_section (section
->uncompressed_name
);
8777 section
->name
= section
->uncompressed_name
;
8780 sec
= find_section (section
->compressed_name
);
8782 section
->name
= section
->compressed_name
;
8787 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
8791 free_debug_section (enum dwarf_section_display_enum debug
)
8793 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8795 if (section
->start
== NULL
)
8798 free ((char *) section
->start
);
8799 section
->start
= NULL
;
8800 section
->address
= 0;
8805 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8807 char * name
= SECTION_NAME (section
);
8808 bfd_size_type length
;
8812 length
= section
->sh_size
;
8815 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8818 if (section
->sh_type
== SHT_NOBITS
)
8820 /* There is no point in dumping the contents of a debugging section
8821 which has the NOBITS type - the bits in the file will be random.
8822 This can happen when a file containing a .eh_frame section is
8823 stripped with the --only-keep-debug command line option. */
8824 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8828 if (const_strneq (name
, ".gnu.linkonce.wi."))
8829 name
= ".debug_info";
8831 /* See if we know how to display the contents of this section. */
8832 for (i
= 0; i
< max
; i
++)
8833 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8834 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8836 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8837 int secondary
= (section
!= find_section (name
));
8840 free_debug_section ((enum dwarf_section_display_enum
) i
);
8842 if (streq (sec
->uncompressed_name
, name
))
8843 sec
->name
= sec
->uncompressed_name
;
8845 sec
->name
= sec
->compressed_name
;
8846 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
8849 result
&= debug_displays
[i
].display (sec
, file
);
8851 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8852 free_debug_section ((enum dwarf_section_display_enum
) i
);
8860 printf (_("Unrecognized debug section: %s\n"), name
);
8867 /* Set DUMP_SECTS for all sections where dumps were requested
8868 based on section name. */
8871 initialise_dumps_byname (void)
8873 struct dump_list_entry
* cur
;
8875 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8880 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8881 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8883 request_dump_bynumber (i
, cur
->type
);
8888 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8894 process_section_contents (FILE * file
)
8896 Elf_Internal_Shdr
* section
;
8902 initialise_dumps_byname ();
8904 for (i
= 0, section
= section_headers
;
8905 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8908 #ifdef SUPPORT_DISASSEMBLY
8909 if (dump_sects
[i
] & DISASS_DUMP
)
8910 disassemble_section (section
, file
);
8912 if (dump_sects
[i
] & HEX_DUMP
)
8913 dump_section_as_bytes (section
, file
, FALSE
);
8915 if (dump_sects
[i
] & RELOC_DUMP
)
8916 dump_section_as_bytes (section
, file
, TRUE
);
8918 if (dump_sects
[i
] & STRING_DUMP
)
8919 dump_section_as_strings (section
, file
);
8921 if (dump_sects
[i
] & DEBUG_DUMP
)
8922 display_debug_section (section
, file
);
8925 /* Check to see if the user requested a
8926 dump of a section that does not exist. */
8927 while (i
++ < num_dump_sects
)
8929 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8933 process_mips_fpe_exception (int mask
)
8938 if (mask
& OEX_FPU_INEX
)
8939 fputs ("INEX", stdout
), first
= 0;
8940 if (mask
& OEX_FPU_UFLO
)
8941 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8942 if (mask
& OEX_FPU_OFLO
)
8943 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8944 if (mask
& OEX_FPU_DIV0
)
8945 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8946 if (mask
& OEX_FPU_INVAL
)
8947 printf ("%sINVAL", first
? "" : "|");
8950 fputs ("0", stdout
);
8953 /* ARM EABI attributes section. */
8958 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8960 const char ** table
;
8961 } arm_attr_public_tag
;
8963 static const char * arm_attr_tag_CPU_arch
[] =
8964 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8965 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
8966 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8967 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8968 {"No", "Thumb-1", "Thumb-2"};
8969 static const char * arm_attr_tag_VFP_arch
[] =
8970 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
8971 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8972 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8973 static const char * arm_attr_tag_PCS_config
[] =
8974 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8975 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8976 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8977 {"V6", "SB", "TLS", "Unused"};
8978 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8979 {"Absolute", "PC-relative", "SB-relative", "None"};
8980 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8981 {"Absolute", "PC-relative", "None"};
8982 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8983 {"None", "direct", "GOT-indirect"};
8984 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8985 {"None", "??? 1", "2", "??? 3", "4"};
8986 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8987 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8988 {"Unused", "Needed", "Sign only"};
8989 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8990 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8991 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8992 {"Unused", "Finite", "RTABI", "IEEE 754"};
8993 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8994 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8995 {"No", "Yes, except leaf SP", "Yes"};
8996 static const char * arm_attr_tag_ABI_enum_size
[] =
8997 {"Unused", "small", "int", "forced to int"};
8998 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8999 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9000 static const char * arm_attr_tag_ABI_VFP_args
[] =
9001 {"AAPCS", "VFP registers", "custom"};
9002 static const char * arm_attr_tag_ABI_WMMX_args
[] =
9003 {"AAPCS", "WMMX registers", "custom"};
9004 static const char * arm_attr_tag_ABI_optimization_goals
[] =
9005 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9006 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9007 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
9008 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9009 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9010 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
9011 static const char * arm_attr_tag_VFP_HP_extension
[] =
9012 {"Not Allowed", "Allowed"};
9013 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
9014 {"None", "IEEE 754", "Alternative Format"};
9015 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9016 static const char * arm_attr_tag_Virtualization_use
[] =
9017 {"Not Allowed", "Allowed"};
9018 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
9020 #define LOOKUP(id, name) \
9021 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9022 static arm_attr_public_tag arm_attr_public_tags
[] =
9024 {4, "CPU_raw_name", 1, NULL
},
9025 {5, "CPU_name", 1, NULL
},
9026 LOOKUP(6, CPU_arch
),
9027 {7, "CPU_arch_profile", 0, NULL
},
9028 LOOKUP(8, ARM_ISA_use
),
9029 LOOKUP(9, THUMB_ISA_use
),
9030 LOOKUP(10, VFP_arch
),
9031 LOOKUP(11, WMMX_arch
),
9032 LOOKUP(12, Advanced_SIMD_arch
),
9033 LOOKUP(13, PCS_config
),
9034 LOOKUP(14, ABI_PCS_R9_use
),
9035 LOOKUP(15, ABI_PCS_RW_data
),
9036 LOOKUP(16, ABI_PCS_RO_data
),
9037 LOOKUP(17, ABI_PCS_GOT_use
),
9038 LOOKUP(18, ABI_PCS_wchar_t
),
9039 LOOKUP(19, ABI_FP_rounding
),
9040 LOOKUP(20, ABI_FP_denormal
),
9041 LOOKUP(21, ABI_FP_exceptions
),
9042 LOOKUP(22, ABI_FP_user_exceptions
),
9043 LOOKUP(23, ABI_FP_number_model
),
9044 LOOKUP(24, ABI_align8_needed
),
9045 LOOKUP(25, ABI_align8_preserved
),
9046 LOOKUP(26, ABI_enum_size
),
9047 LOOKUP(27, ABI_HardFP_use
),
9048 LOOKUP(28, ABI_VFP_args
),
9049 LOOKUP(29, ABI_WMMX_args
),
9050 LOOKUP(30, ABI_optimization_goals
),
9051 LOOKUP(31, ABI_FP_optimization_goals
),
9052 {32, "compatibility", 0, NULL
},
9053 LOOKUP(34, CPU_unaligned_access
),
9054 LOOKUP(36, VFP_HP_extension
),
9055 LOOKUP(38, ABI_FP_16bit_format
),
9056 {64, "nodefaults", 0, NULL
},
9057 {65, "also_compatible_with", 0, NULL
},
9058 LOOKUP(66, T2EE_use
),
9059 {67, "conformance", 1, NULL
},
9060 LOOKUP(68, Virtualization_use
),
9061 LOOKUP(70, MPextension_use
)
9065 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9069 read_uleb128 (unsigned char * p
, unsigned int * plen
)
9083 val
|= ((unsigned int)c
& 0x7f) << shift
;
9092 static unsigned char *
9093 display_arm_attribute (unsigned char * p
)
9098 arm_attr_public_tag
* attr
;
9102 tag
= read_uleb128 (p
, &len
);
9105 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9107 if (arm_attr_public_tags
[i
].tag
== tag
)
9109 attr
= &arm_attr_public_tags
[i
];
9116 printf (" Tag_%s: ", attr
->name
);
9122 case 7: /* Tag_CPU_arch_profile. */
9123 val
= read_uleb128 (p
, &len
);
9127 case 0: printf ("None\n"); break;
9128 case 'A': printf ("Application\n"); break;
9129 case 'R': printf ("Realtime\n"); break;
9130 case 'M': printf ("Microcontroller\n"); break;
9131 default: printf ("??? (%d)\n", val
); break;
9135 case 32: /* Tag_compatibility. */
9136 val
= read_uleb128 (p
, &len
);
9138 printf ("flag = %d, vendor = %s\n", val
, p
);
9139 p
+= strlen ((char *) p
) + 1;
9142 case 64: /* Tag_nodefaults. */
9147 case 65: /* Tag_also_compatible_with. */
9148 val
= read_uleb128 (p
, &len
);
9150 if (val
== 6 /* Tag_CPU_arch. */)
9152 val
= read_uleb128 (p
, &len
);
9154 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
9155 printf ("??? (%d)\n", val
);
9157 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9161 while (*(p
++) != '\0' /* NUL terminator. */);
9175 assert (attr
->type
& 0x80);
9176 val
= read_uleb128 (p
, &len
);
9178 type
= attr
->type
& 0x7f;
9180 printf ("??? (%d)\n", val
);
9182 printf ("%s\n", attr
->table
[val
]);
9189 type
= 1; /* String. */
9191 type
= 2; /* uleb128. */
9192 printf (" Tag_unknown_%d: ", tag
);
9197 printf ("\"%s\"\n", p
);
9198 p
+= strlen ((char *) p
) + 1;
9202 val
= read_uleb128 (p
, &len
);
9204 printf ("%d (0x%x)\n", val
, val
);
9210 static unsigned char *
9211 display_gnu_attribute (unsigned char * p
,
9212 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9219 tag
= read_uleb128 (p
, &len
);
9222 /* Tag_compatibility is the only generic GNU attribute defined at
9226 val
= read_uleb128 (p
, &len
);
9228 printf ("flag = %d, vendor = %s\n", val
, p
);
9229 p
+= strlen ((char *) p
) + 1;
9233 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9234 return display_proc_gnu_attribute (p
, tag
);
9237 type
= 1; /* String. */
9239 type
= 2; /* uleb128. */
9240 printf (" Tag_unknown_%d: ", tag
);
9244 printf ("\"%s\"\n", p
);
9245 p
+= strlen ((char *) p
) + 1;
9249 val
= read_uleb128 (p
, &len
);
9251 printf ("%d (0x%x)\n", val
, val
);
9257 static unsigned char *
9258 display_power_gnu_attribute (unsigned char * p
, int tag
)
9264 if (tag
== Tag_GNU_Power_ABI_FP
)
9266 val
= read_uleb128 (p
, &len
);
9268 printf (" Tag_GNU_Power_ABI_FP: ");
9273 printf ("Hard or soft float\n");
9276 printf ("Hard float\n");
9279 printf ("Soft float\n");
9282 printf ("Single-precision hard float\n");
9285 printf ("??? (%d)\n", val
);
9291 if (tag
== Tag_GNU_Power_ABI_Vector
)
9293 val
= read_uleb128 (p
, &len
);
9295 printf (" Tag_GNU_Power_ABI_Vector: ");
9302 printf ("Generic\n");
9305 printf ("AltiVec\n");
9311 printf ("??? (%d)\n", val
);
9317 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9319 val
= read_uleb128 (p
, &len
);
9321 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9331 printf ("Memory\n");
9334 printf ("??? (%d)\n", val
);
9341 type
= 1; /* String. */
9343 type
= 2; /* uleb128. */
9344 printf (" Tag_unknown_%d: ", tag
);
9348 printf ("\"%s\"\n", p
);
9349 p
+= strlen ((char *) p
) + 1;
9353 val
= read_uleb128 (p
, &len
);
9355 printf ("%d (0x%x)\n", val
, val
);
9361 static unsigned char *
9362 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9368 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9370 val
= read_uleb128 (p
, &len
);
9372 printf (" Tag_GNU_MIPS_ABI_FP: ");
9377 printf ("Hard or soft float\n");
9380 printf ("Hard float (-mdouble-float)\n");
9383 printf ("Hard float (-msingle-float)\n");
9386 printf ("Soft float\n");
9389 printf ("64-bit float (-mips32r2 -mfp64)\n");
9392 printf ("??? (%d)\n", val
);
9399 type
= 1; /* String. */
9401 type
= 2; /* uleb128. */
9402 printf (" Tag_unknown_%d: ", tag
);
9406 printf ("\"%s\"\n", p
);
9407 p
+= strlen ((char *) p
) + 1;
9411 val
= read_uleb128 (p
, &len
);
9413 printf ("%d (0x%x)\n", val
, val
);
9420 process_attributes (FILE * file
,
9421 const char * public_name
,
9422 unsigned int proc_type
,
9423 unsigned char * (* display_pub_attribute
) (unsigned char *),
9424 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9426 Elf_Internal_Shdr
* sect
;
9427 unsigned char * contents
;
9429 unsigned char * end
;
9430 bfd_vma section_len
;
9434 /* Find the section header so that we get the size. */
9435 for (i
= 0, sect
= section_headers
;
9436 i
< elf_header
.e_shnum
;
9439 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9442 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
9443 sect
->sh_size
, _("attributes"));
9444 if (contents
== NULL
)
9450 len
= sect
->sh_size
- 1;
9456 bfd_boolean public_section
;
9457 bfd_boolean gnu_section
;
9459 section_len
= byte_get (p
, 4);
9462 if (section_len
> len
)
9464 printf (_("ERROR: Bad section length (%d > %d)\n"),
9465 (int) section_len
, (int) len
);
9470 printf ("Attribute Section: %s\n", p
);
9472 if (public_name
&& streq ((char *) p
, public_name
))
9473 public_section
= TRUE
;
9475 public_section
= FALSE
;
9477 if (streq ((char *) p
, "gnu"))
9480 gnu_section
= FALSE
;
9482 namelen
= strlen ((char *) p
) + 1;
9484 section_len
-= namelen
+ 4;
9486 while (section_len
> 0)
9492 size
= byte_get (p
, 4);
9493 if (size
> section_len
)
9495 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9496 (int) size
, (int) section_len
);
9500 section_len
-= size
;
9507 printf ("File Attributes\n");
9510 printf ("Section Attributes:");
9513 printf ("Symbol Attributes:");
9519 val
= read_uleb128 (p
, &i
);
9523 printf (" %d", val
);
9528 printf ("Unknown tag: %d\n", tag
);
9529 public_section
= FALSE
;
9536 p
= display_pub_attribute (p
);
9538 else if (gnu_section
)
9541 p
= display_gnu_attribute (p
,
9542 display_proc_gnu_attribute
);
9546 /* ??? Do something sensible, like dump hex. */
9547 printf (" Unknown section contexts\n");
9554 printf (_("Unknown format '%c'\n"), *p
);
9562 process_arm_specific (FILE * file
)
9564 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9565 display_arm_attribute
, NULL
);
9569 process_power_specific (FILE * file
)
9571 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9572 display_power_gnu_attribute
);
9575 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9576 Print the Address, Access and Initial fields of an entry at VMA ADDR
9577 and return the VMA of the next entry. */
9580 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9583 print_vma (addr
, LONG_HEX
);
9585 if (addr
< pltgot
+ 0xfff0)
9586 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9588 printf ("%10s", "");
9591 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9596 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9597 print_vma (entry
, LONG_HEX
);
9599 return addr
+ (is_32bit_elf
? 4 : 8);
9602 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9603 PLTGOT. Print the Address and Initial fields of an entry at VMA
9604 ADDR and return the VMA of the next entry. */
9607 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9610 print_vma (addr
, LONG_HEX
);
9613 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9618 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9619 print_vma (entry
, LONG_HEX
);
9621 return addr
+ (is_32bit_elf
? 4 : 8);
9625 process_mips_specific (FILE * file
)
9627 Elf_Internal_Dyn
* entry
;
9628 size_t liblist_offset
= 0;
9629 size_t liblistno
= 0;
9630 size_t conflictsno
= 0;
9631 size_t options_offset
= 0;
9632 size_t conflicts_offset
= 0;
9633 size_t pltrelsz
= 0;
9636 bfd_vma mips_pltgot
= 0;
9638 bfd_vma local_gotno
= 0;
9640 bfd_vma symtabno
= 0;
9642 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9643 display_mips_gnu_attribute
);
9645 /* We have a lot of special sections. Thanks SGI! */
9646 if (dynamic_section
== NULL
)
9647 /* No information available. */
9650 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9651 switch (entry
->d_tag
)
9653 case DT_MIPS_LIBLIST
:
9655 = offset_from_vma (file
, entry
->d_un
.d_val
,
9656 liblistno
* sizeof (Elf32_External_Lib
));
9658 case DT_MIPS_LIBLISTNO
:
9659 liblistno
= entry
->d_un
.d_val
;
9661 case DT_MIPS_OPTIONS
:
9662 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9664 case DT_MIPS_CONFLICT
:
9666 = offset_from_vma (file
, entry
->d_un
.d_val
,
9667 conflictsno
* sizeof (Elf32_External_Conflict
));
9669 case DT_MIPS_CONFLICTNO
:
9670 conflictsno
= entry
->d_un
.d_val
;
9673 pltgot
= entry
->d_un
.d_ptr
;
9675 case DT_MIPS_LOCAL_GOTNO
:
9676 local_gotno
= entry
->d_un
.d_val
;
9678 case DT_MIPS_GOTSYM
:
9679 gotsym
= entry
->d_un
.d_val
;
9681 case DT_MIPS_SYMTABNO
:
9682 symtabno
= entry
->d_un
.d_val
;
9684 case DT_MIPS_PLTGOT
:
9685 mips_pltgot
= entry
->d_un
.d_ptr
;
9688 pltrel
= entry
->d_un
.d_val
;
9691 pltrelsz
= entry
->d_un
.d_val
;
9694 jmprel
= entry
->d_un
.d_ptr
;
9700 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9702 Elf32_External_Lib
* elib
;
9705 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
9707 sizeof (Elf32_External_Lib
),
9711 printf ("\nSection '.liblist' contains %lu entries:\n",
9712 (unsigned long) liblistno
);
9713 fputs (" Library Time Stamp Checksum Version Flags\n",
9716 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9723 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9724 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9725 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9726 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9727 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9729 tmp
= gmtime (&time
);
9730 snprintf (timebuf
, sizeof (timebuf
),
9731 "%04u-%02u-%02uT%02u:%02u:%02u",
9732 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9733 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9735 printf ("%3lu: ", (unsigned long) cnt
);
9736 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9737 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9739 printf ("<corrupt: %9ld>", liblist
.l_name
);
9740 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9743 if (liblist
.l_flags
== 0)
9754 { " EXACT_MATCH", LL_EXACT_MATCH
},
9755 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9756 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9757 { " EXPORTS", LL_EXPORTS
},
9758 { " DELAY_LOAD", LL_DELAY_LOAD
},
9759 { " DELTA", LL_DELTA
}
9761 int flags
= liblist
.l_flags
;
9764 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9765 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9767 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9768 flags
^= l_flags_vals
[fcnt
].bit
;
9771 printf (" %#x", (unsigned int) flags
);
9781 if (options_offset
!= 0)
9783 Elf_External_Options
* eopt
;
9784 Elf_Internal_Shdr
* sect
= section_headers
;
9785 Elf_Internal_Options
* iopt
;
9786 Elf_Internal_Options
* option
;
9790 /* Find the section header so that we get the size. */
9791 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9794 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
9795 sect
->sh_size
, _("options"));
9798 iopt
= (Elf_Internal_Options
*)
9799 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9802 error (_("Out of memory\n"));
9809 while (offset
< sect
->sh_size
)
9811 Elf_External_Options
* eoption
;
9813 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9815 option
->kind
= BYTE_GET (eoption
->kind
);
9816 option
->size
= BYTE_GET (eoption
->size
);
9817 option
->section
= BYTE_GET (eoption
->section
);
9818 option
->info
= BYTE_GET (eoption
->info
);
9820 offset
+= option
->size
;
9826 printf (_("\nSection '%s' contains %d entries:\n"),
9827 SECTION_NAME (sect
), cnt
);
9835 switch (option
->kind
)
9838 /* This shouldn't happen. */
9839 printf (" NULL %d %lx", option
->section
, option
->info
);
9842 printf (" REGINFO ");
9843 if (elf_header
.e_machine
== EM_MIPS
)
9846 Elf32_External_RegInfo
* ereg
;
9847 Elf32_RegInfo reginfo
;
9849 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9850 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9851 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9852 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9853 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9854 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9855 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9857 printf ("GPR %08lx GP 0x%lx\n",
9859 (unsigned long) reginfo
.ri_gp_value
);
9860 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9861 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9862 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9867 Elf64_External_RegInfo
* ereg
;
9868 Elf64_Internal_RegInfo reginfo
;
9870 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9871 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9872 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9873 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9874 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9875 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9876 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9878 printf ("GPR %08lx GP 0x",
9879 reginfo
.ri_gprmask
);
9880 printf_vma (reginfo
.ri_gp_value
);
9883 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9884 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9885 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9889 case ODK_EXCEPTIONS
:
9890 fputs (" EXCEPTIONS fpe_min(", stdout
);
9891 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9892 fputs (") fpe_max(", stdout
);
9893 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9894 fputs (")", stdout
);
9896 if (option
->info
& OEX_PAGE0
)
9897 fputs (" PAGE0", stdout
);
9898 if (option
->info
& OEX_SMM
)
9899 fputs (" SMM", stdout
);
9900 if (option
->info
& OEX_FPDBUG
)
9901 fputs (" FPDBUG", stdout
);
9902 if (option
->info
& OEX_DISMISS
)
9903 fputs (" DISMISS", stdout
);
9906 fputs (" PAD ", stdout
);
9907 if (option
->info
& OPAD_PREFIX
)
9908 fputs (" PREFIX", stdout
);
9909 if (option
->info
& OPAD_POSTFIX
)
9910 fputs (" POSTFIX", stdout
);
9911 if (option
->info
& OPAD_SYMBOL
)
9912 fputs (" SYMBOL", stdout
);
9915 fputs (" HWPATCH ", stdout
);
9916 if (option
->info
& OHW_R4KEOP
)
9917 fputs (" R4KEOP", stdout
);
9918 if (option
->info
& OHW_R8KPFETCH
)
9919 fputs (" R8KPFETCH", stdout
);
9920 if (option
->info
& OHW_R5KEOP
)
9921 fputs (" R5KEOP", stdout
);
9922 if (option
->info
& OHW_R5KCVTL
)
9923 fputs (" R5KCVTL", stdout
);
9926 fputs (" FILL ", stdout
);
9927 /* XXX Print content of info word? */
9930 fputs (" TAGS ", stdout
);
9931 /* XXX Print content of info word? */
9934 fputs (" HWAND ", stdout
);
9935 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9936 fputs (" R4KEOP_CHECKED", stdout
);
9937 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9938 fputs (" R4KEOP_CLEAN", stdout
);
9941 fputs (" HWOR ", stdout
);
9942 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9943 fputs (" R4KEOP_CHECKED", stdout
);
9944 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9945 fputs (" R4KEOP_CLEAN", stdout
);
9948 printf (" GP_GROUP %#06lx self-contained %#06lx",
9949 option
->info
& OGP_GROUP
,
9950 (option
->info
& OGP_SELF
) >> 16);
9953 printf (" IDENT %#06lx self-contained %#06lx",
9954 option
->info
& OGP_GROUP
,
9955 (option
->info
& OGP_SELF
) >> 16);
9958 /* This shouldn't happen. */
9959 printf (" %3d ??? %d %lx",
9960 option
->kind
, option
->section
, option
->info
);
9964 len
= sizeof (* eopt
);
9965 while (len
< option
->size
)
9966 if (((char *) option
)[len
] >= ' '
9967 && ((char *) option
)[len
] < 0x7f)
9968 printf ("%c", ((char *) option
)[len
++]);
9970 printf ("\\%03o", ((char *) option
)[len
++]);
9972 fputs ("\n", stdout
);
9980 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9982 Elf32_Conflict
* iconf
;
9985 if (dynamic_symbols
== NULL
)
9987 error (_("conflict list found without a dynamic symbol table\n"));
9991 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
9994 error (_("Out of memory\n"));
10000 Elf32_External_Conflict
* econf32
;
10002 econf32
= (Elf32_External_Conflict
*)
10003 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10004 sizeof (* econf32
), _("conflict"));
10008 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10009 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10015 Elf64_External_Conflict
* econf64
;
10017 econf64
= (Elf64_External_Conflict
*)
10018 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10019 sizeof (* econf64
), _("conflict"));
10023 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10024 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10029 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10030 (unsigned long) conflictsno
);
10031 puts (_(" Num: Index Value Name"));
10033 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10035 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10037 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10038 print_vma (psym
->st_value
, FULL_HEX
);
10040 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10041 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10043 printf ("<corrupt: %14ld>", psym
->st_name
);
10050 if (pltgot
!= 0 && local_gotno
!= 0)
10052 bfd_vma entry
, local_end
, global_end
;
10054 unsigned char * data
;
10058 addr_size
= (is_32bit_elf
? 4 : 8);
10059 local_end
= pltgot
+ local_gotno
* addr_size
;
10060 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10062 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10063 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10064 global_end
- pltgot
, 1, _("GOT"));
10065 printf (_("\nPrimary GOT:\n"));
10066 printf (_(" Canonical gp value: "));
10067 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10070 printf (_(" Reserved entries:\n"));
10071 printf (_(" %*s %10s %*s Purpose\n"),
10072 addr_size
* 2, "Address", "Access",
10073 addr_size
* 2, "Initial");
10074 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10075 printf (" Lazy resolver\n");
10077 && (byte_get (data
+ entry
- pltgot
, addr_size
)
10078 >> (addr_size
* 8 - 1)) != 0)
10080 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10081 printf (" Module pointer (GNU extension)\n");
10085 if (entry
< local_end
)
10087 printf (_(" Local entries:\n"));
10088 printf (_(" %*s %10s %*s\n"),
10089 addr_size
* 2, "Address", "Access",
10090 addr_size
* 2, "Initial");
10091 while (entry
< local_end
)
10093 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10099 if (gotsym
< symtabno
)
10103 printf (_(" Global entries:\n"));
10104 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10105 addr_size
* 2, "Address", "Access",
10106 addr_size
* 2, "Initial",
10107 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10108 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10109 for (i
= gotsym
; i
< symtabno
; i
++)
10111 Elf_Internal_Sym
* psym
;
10113 psym
= dynamic_symbols
+ i
;
10114 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10116 print_vma (psym
->st_value
, LONG_HEX
);
10117 printf (" %-7s %3s ",
10118 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10119 get_symbol_index_type (psym
->st_shndx
));
10120 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10121 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10123 printf ("<corrupt: %14ld>", psym
->st_name
);
10133 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10135 bfd_vma entry
, end
;
10136 size_t offset
, rel_offset
;
10137 unsigned long count
, i
;
10138 unsigned char * data
;
10139 int addr_size
, sym_width
;
10140 Elf_Internal_Rela
* rels
;
10142 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10143 if (pltrel
== DT_RELA
)
10145 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10150 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10154 entry
= mips_pltgot
;
10155 addr_size
= (is_32bit_elf
? 4 : 8);
10156 end
= mips_pltgot
+ (2 + count
) * addr_size
;
10158 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
10159 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
10161 printf (_("\nPLT GOT:\n\n"));
10162 printf (_(" Reserved entries:\n"));
10163 printf (_(" %*s %*s Purpose\n"),
10164 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10165 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10166 printf (" PLT lazy resolver\n");
10167 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10168 printf (" Module pointer\n");
10171 printf (_(" Entries:\n"));
10172 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10173 addr_size
* 2, "Address",
10174 addr_size
* 2, "Initial",
10175 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10176 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10177 for (i
= 0; i
< count
; i
++)
10179 Elf_Internal_Sym
* psym
;
10181 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10182 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10184 print_vma (psym
->st_value
, LONG_HEX
);
10185 printf (" %-7s %3s ",
10186 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10187 get_symbol_index_type (psym
->st_shndx
));
10188 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10189 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10191 printf ("<corrupt: %14ld>", psym
->st_name
);
10205 process_gnu_liblist (FILE * file
)
10207 Elf_Internal_Shdr
* section
;
10208 Elf_Internal_Shdr
* string_sec
;
10209 Elf32_External_Lib
* elib
;
10211 size_t strtab_size
;
10218 for (i
= 0, section
= section_headers
;
10219 i
< elf_header
.e_shnum
;
10222 switch (section
->sh_type
)
10224 case SHT_GNU_LIBLIST
:
10225 if (section
->sh_link
>= elf_header
.e_shnum
)
10228 elib
= (Elf32_External_Lib
*)
10229 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10234 string_sec
= section_headers
+ section
->sh_link
;
10236 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10237 string_sec
->sh_size
,
10238 _("liblist string table"));
10239 strtab_size
= string_sec
->sh_size
;
10242 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10248 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10249 SECTION_NAME (section
),
10250 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10252 puts (" Library Time Stamp Checksum Version Flags");
10254 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10262 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10263 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10264 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10265 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10266 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10268 tmp
= gmtime (&time
);
10269 snprintf (timebuf
, sizeof (timebuf
),
10270 "%04u-%02u-%02uT%02u:%02u:%02u",
10271 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10272 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10274 printf ("%3lu: ", (unsigned long) cnt
);
10276 printf ("%-20s", liblist
.l_name
< strtab_size
10277 ? strtab
+ liblist
.l_name
: "<corrupt>");
10279 printf ("%-20.20s", liblist
.l_name
< strtab_size
10280 ? strtab
+ liblist
.l_name
: "<corrupt>");
10281 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10282 liblist
.l_version
, liblist
.l_flags
);
10292 static const char *
10293 get_note_type (unsigned e_type
)
10295 static char buff
[64];
10297 if (elf_header
.e_type
== ET_CORE
)
10301 return _("NT_AUXV (auxiliary vector)");
10303 return _("NT_PRSTATUS (prstatus structure)");
10305 return _("NT_FPREGSET (floating point registers)");
10307 return _("NT_PRPSINFO (prpsinfo structure)");
10308 case NT_TASKSTRUCT
:
10309 return _("NT_TASKSTRUCT (task structure)");
10311 return _("NT_PRXFPREG (user_xfpregs structure)");
10313 return _("NT_PPC_VMX (ppc Altivec registers)");
10315 return _("NT_PPC_VSX (ppc VSX registers)");
10317 return _("NT_PSTATUS (pstatus structure)");
10319 return _("NT_FPREGS (floating point registers)");
10321 return _("NT_PSINFO (psinfo structure)");
10323 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10325 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10326 case NT_WIN32PSTATUS
:
10327 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10335 return _("NT_VERSION (version)");
10337 return _("NT_ARCH (architecture)");
10342 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10346 static const char *
10347 get_gnu_elf_note_type (unsigned e_type
)
10349 static char buff
[64];
10353 case NT_GNU_ABI_TAG
:
10354 return _("NT_GNU_ABI_TAG (ABI version tag)");
10356 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10357 case NT_GNU_BUILD_ID
:
10358 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10359 case NT_GNU_GOLD_VERSION
:
10360 return _("NT_GNU_GOLD_VERSION (gold version)");
10365 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10369 static const char *
10370 get_netbsd_elfcore_note_type (unsigned e_type
)
10372 static char buff
[64];
10374 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10376 /* NetBSD core "procinfo" structure. */
10377 return _("NetBSD procinfo structure");
10380 /* As of Jan 2002 there are no other machine-independent notes
10381 defined for NetBSD core files. If the note type is less
10382 than the start of the machine-dependent note types, we don't
10385 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10387 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10391 switch (elf_header
.e_machine
)
10393 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10394 and PT_GETFPREGS == mach+2. */
10399 case EM_SPARC32PLUS
:
10403 case NT_NETBSDCORE_FIRSTMACH
+0:
10404 return _("PT_GETREGS (reg structure)");
10405 case NT_NETBSDCORE_FIRSTMACH
+2:
10406 return _("PT_GETFPREGS (fpreg structure)");
10412 /* On all other arch's, PT_GETREGS == mach+1 and
10413 PT_GETFPREGS == mach+3. */
10417 case NT_NETBSDCORE_FIRSTMACH
+1:
10418 return _("PT_GETREGS (reg structure)");
10419 case NT_NETBSDCORE_FIRSTMACH
+3:
10420 return _("PT_GETFPREGS (fpreg structure)");
10426 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10427 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10431 /* Note that by the ELF standard, the name field is already null byte
10432 terminated, and namesz includes the terminating null byte.
10433 I.E. the value of namesz for the name "FSF" is 4.
10435 If the value of namesz is zero, there is no name present. */
10437 process_note (Elf_Internal_Note
* pnote
)
10439 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10442 if (pnote
->namesz
== 0)
10443 /* If there is no note name, then use the default set of
10444 note type strings. */
10445 nt
= get_note_type (pnote
->type
);
10447 else if (const_strneq (pnote
->namedata
, "GNU"))
10448 /* GNU-specific object file notes. */
10449 nt
= get_gnu_elf_note_type (pnote
->type
);
10451 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10452 /* NetBSD-specific core file notes. */
10453 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10455 else if (strneq (pnote
->namedata
, "SPU/", 4))
10457 /* SPU-specific core file notes. */
10458 nt
= pnote
->namedata
+ 4;
10463 /* Don't recognize this note name; just use the default set of
10464 note type strings. */
10465 nt
= get_note_type (pnote
->type
);
10467 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10473 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10475 Elf_External_Note
* pnotes
;
10476 Elf_External_Note
* external
;
10482 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
10489 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10490 (unsigned long) offset
, (unsigned long) length
);
10491 printf (_(" Owner\t\tData size\tDescription\n"));
10493 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10495 Elf_External_Note
* next
;
10496 Elf_Internal_Note inote
;
10497 char * temp
= NULL
;
10499 inote
.type
= BYTE_GET (external
->type
);
10500 inote
.namesz
= BYTE_GET (external
->namesz
);
10501 inote
.namedata
= external
->name
;
10502 inote
.descsz
= BYTE_GET (external
->descsz
);
10503 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10504 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10506 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10508 if (((char *) next
) > (((char *) pnotes
) + length
))
10510 warn (_("corrupt note found at offset %lx into core notes\n"),
10511 (unsigned long) ((char *) external
- (char *) pnotes
));
10512 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10513 inote
.type
, inote
.namesz
, inote
.descsz
);
10519 /* Verify that name is null terminated. It appears that at least
10520 one version of Linux (RedHat 6.0) generates corefiles that don't
10521 comply with the ELF spec by failing to include the null byte in
10523 if (inote
.namedata
[inote
.namesz
] != '\0')
10525 temp
= (char *) malloc (inote
.namesz
+ 1);
10529 error (_("Out of memory\n"));
10534 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10535 temp
[inote
.namesz
] = 0;
10537 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10538 inote
.namedata
= temp
;
10541 res
&= process_note (& inote
);
10556 process_corefile_note_segments (FILE * file
)
10558 Elf_Internal_Phdr
* segment
;
10562 if (! get_program_headers (file
))
10565 for (i
= 0, segment
= program_headers
;
10566 i
< elf_header
.e_phnum
;
10569 if (segment
->p_type
== PT_NOTE
)
10570 res
&= process_corefile_note_segment (file
,
10571 (bfd_vma
) segment
->p_offset
,
10572 (bfd_vma
) segment
->p_filesz
);
10579 process_note_sections (FILE * file
)
10581 Elf_Internal_Shdr
* section
;
10585 for (i
= 0, section
= section_headers
;
10586 i
< elf_header
.e_shnum
;
10588 if (section
->sh_type
== SHT_NOTE
)
10589 res
&= process_corefile_note_segment (file
,
10590 (bfd_vma
) section
->sh_offset
,
10591 (bfd_vma
) section
->sh_size
);
10597 process_notes (FILE * file
)
10599 /* If we have not been asked to display the notes then do nothing. */
10603 if (elf_header
.e_type
!= ET_CORE
)
10604 return process_note_sections (file
);
10606 /* No program headers means no NOTE segment. */
10607 if (elf_header
.e_phnum
> 0)
10608 return process_corefile_note_segments (file
);
10610 printf (_("No note segments present in the core file.\n"));
10615 process_arch_specific (FILE * file
)
10620 switch (elf_header
.e_machine
)
10623 return process_arm_specific (file
);
10625 case EM_MIPS_RS3_LE
:
10626 return process_mips_specific (file
);
10629 return process_power_specific (file
);
10638 get_file_header (FILE * file
)
10640 /* Read in the identity array. */
10641 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10644 /* Determine how to read the rest of the header. */
10645 switch (elf_header
.e_ident
[EI_DATA
])
10647 default: /* fall through */
10648 case ELFDATANONE
: /* fall through */
10650 byte_get
= byte_get_little_endian
;
10651 byte_put
= byte_put_little_endian
;
10654 byte_get
= byte_get_big_endian
;
10655 byte_put
= byte_put_big_endian
;
10659 /* For now we only support 32 bit and 64 bit ELF files. */
10660 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10662 /* Read in the rest of the header. */
10665 Elf32_External_Ehdr ehdr32
;
10667 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10670 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10671 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10672 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10673 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10674 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10675 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10676 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10677 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10678 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10679 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10680 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10681 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10682 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10686 Elf64_External_Ehdr ehdr64
;
10688 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10689 we will not be able to cope with the 64bit data found in
10690 64 ELF files. Detect this now and abort before we start
10691 overwriting things. */
10692 if (sizeof (bfd_vma
) < 8)
10694 error (_("This instance of readelf has been built without support for a\n\
10695 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10699 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10702 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10703 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10704 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10705 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10706 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10707 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10708 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10709 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10710 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10711 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10712 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10713 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10714 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10717 if (elf_header
.e_shoff
)
10719 /* There may be some extensions in the first section header. Don't
10720 bomb if we can't read it. */
10722 get_32bit_section_headers (file
, 1);
10724 get_64bit_section_headers (file
, 1);
10730 /* Process one ELF object file according to the command line options.
10731 This file may actually be stored in an archive. The file is
10732 positioned at the start of the ELF object. */
10735 process_object (char * file_name
, FILE * file
)
10739 if (! get_file_header (file
))
10741 error (_("%s: Failed to read file header\n"), file_name
);
10745 /* Initialise per file variables. */
10746 for (i
= ARRAY_SIZE (version_info
); i
--;)
10747 version_info
[i
] = 0;
10749 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10750 dynamic_info
[i
] = 0;
10752 /* Process the file. */
10754 printf (_("\nFile: %s\n"), file_name
);
10756 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10757 Note we do this even if cmdline_dump_sects is empty because we
10758 must make sure that the dump_sets array is zeroed out before each
10759 object file is processed. */
10760 if (num_dump_sects
> num_cmdline_dump_sects
)
10761 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10763 if (num_cmdline_dump_sects
> 0)
10765 if (num_dump_sects
== 0)
10766 /* A sneaky way of allocating the dump_sects array. */
10767 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10769 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10770 memcpy (dump_sects
, cmdline_dump_sects
,
10771 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10774 if (! process_file_header ())
10777 if (! process_section_headers (file
))
10779 /* Without loaded section headers we cannot process lots of
10781 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10783 if (! do_using_dynamic
)
10784 do_syms
= do_reloc
= 0;
10787 if (! process_section_groups (file
))
10789 /* Without loaded section groups we cannot process unwind. */
10793 if (process_program_headers (file
))
10794 process_dynamic_section (file
);
10796 process_relocs (file
);
10798 process_unwind (file
);
10800 process_symbol_table (file
);
10802 process_syminfo (file
);
10804 process_version_sections (file
);
10806 process_section_contents (file
);
10808 process_notes (file
);
10810 process_gnu_liblist (file
);
10812 process_arch_specific (file
);
10814 if (program_headers
)
10816 free (program_headers
);
10817 program_headers
= NULL
;
10820 if (section_headers
)
10822 free (section_headers
);
10823 section_headers
= NULL
;
10828 free (string_table
);
10829 string_table
= NULL
;
10830 string_table_length
= 0;
10833 if (dynamic_strings
)
10835 free (dynamic_strings
);
10836 dynamic_strings
= NULL
;
10837 dynamic_strings_length
= 0;
10840 if (dynamic_symbols
)
10842 free (dynamic_symbols
);
10843 dynamic_symbols
= NULL
;
10844 num_dynamic_syms
= 0;
10847 if (dynamic_syminfo
)
10849 free (dynamic_syminfo
);
10850 dynamic_syminfo
= NULL
;
10853 if (section_headers_groups
)
10855 free (section_headers_groups
);
10856 section_headers_groups
= NULL
;
10859 if (section_groups
)
10861 struct group_list
* g
;
10862 struct group_list
* next
;
10864 for (i
= 0; i
< group_count
; i
++)
10866 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10873 free (section_groups
);
10874 section_groups
= NULL
;
10877 free_debug_memory ();
10882 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10883 to the path name of the thin archive itself if necessary. Always returns
10884 a pointer to malloc'ed memory. */
10887 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10889 char * member_file_name
;
10890 const char * base_name
= lbasename (file_name
);
10892 /* This is a proxy entry for a thin archive member.
10893 If the extended name table contains an absolute path
10894 name, or if the archive is in the current directory,
10895 use the path name as given. Otherwise, we need to
10896 find the member relative to the directory where the
10897 archive is located. */
10898 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10900 member_file_name
= (char *) malloc (name_len
+ 1);
10901 if (member_file_name
== NULL
)
10903 error (_("Out of memory\n"));
10906 memcpy (member_file_name
, name
, name_len
);
10907 member_file_name
[name_len
] = '\0';
10911 /* Concatenate the path components of the archive file name
10912 to the relative path name from the extended name table. */
10913 size_t prefix_len
= base_name
- file_name
;
10914 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
10915 if (member_file_name
== NULL
)
10917 error (_("Out of memory\n"));
10920 memcpy (member_file_name
, file_name
, prefix_len
);
10921 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10922 member_file_name
[prefix_len
+ name_len
] = '\0';
10924 return member_file_name
;
10927 /* Structure to hold information about an archive file. */
10929 struct archive_info
10931 char * file_name
; /* Archive file name. */
10932 FILE * file
; /* Open file descriptor. */
10933 unsigned long index_num
; /* Number of symbols in table. */
10934 unsigned long * index_array
; /* The array of member offsets. */
10935 char * sym_table
; /* The symbol table. */
10936 unsigned long sym_size
; /* Size of the symbol table. */
10937 char * longnames
; /* The long file names table. */
10938 unsigned long longnames_size
; /* Size of the long file names table. */
10939 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10940 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10941 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10942 struct ar_hdr arhdr
; /* Current archive header. */
10945 /* Read the symbol table and long-name table from an archive. */
10948 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10949 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10952 unsigned long size
;
10954 arch
->file_name
= strdup (file_name
);
10956 arch
->index_num
= 0;
10957 arch
->index_array
= NULL
;
10958 arch
->sym_table
= NULL
;
10959 arch
->sym_size
= 0;
10960 arch
->longnames
= NULL
;
10961 arch
->longnames_size
= 0;
10962 arch
->nested_member_origin
= 0;
10963 arch
->is_thin_archive
= is_thin_archive
;
10964 arch
->next_arhdr_offset
= SARMAG
;
10966 /* Read the first archive member header. */
10967 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10969 error (_("%s: failed to seek to first archive header\n"), file_name
);
10972 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10973 if (got
!= sizeof arch
->arhdr
)
10978 error (_("%s: failed to read archive header\n"), file_name
);
10982 /* See if this is the archive symbol table. */
10983 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10984 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10986 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10987 size
= size
+ (size
& 1);
10989 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10994 /* A buffer used to hold numbers read in from an archive index.
10995 These are always 4 bytes long and stored in big-endian format. */
10996 #define SIZEOF_AR_INDEX_NUMBERS 4
10997 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10998 unsigned char * index_buffer
;
11000 /* Check the size of the archive index. */
11001 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
11003 error (_("%s: the archive index is empty\n"), file_name
);
11007 /* Read the numer of entries in the archive index. */
11008 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
11009 if (got
!= sizeof (integer_buffer
))
11011 error (_("%s: failed to read archive index\n"), file_name
);
11014 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
11015 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11017 /* Read in the archive index. */
11018 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11020 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11021 file_name
, arch
->index_num
);
11024 index_buffer
= (unsigned char *)
11025 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11026 if (index_buffer
== NULL
)
11028 error (_("Out of memory whilst trying to read archive symbol index\n"));
11031 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11032 if (got
!= arch
->index_num
)
11034 free (index_buffer
);
11035 error (_("%s: failed to read archive index\n"), file_name
);
11038 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11040 /* Convert the index numbers into the host's numeric format. */
11041 arch
->index_array
= (long unsigned int *)
11042 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11043 if (arch
->index_array
== NULL
)
11045 free (index_buffer
);
11046 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11050 for (i
= 0; i
< arch
->index_num
; i
++)
11051 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11052 SIZEOF_AR_INDEX_NUMBERS
);
11053 free (index_buffer
);
11055 /* The remaining space in the header is taken up by the symbol table. */
11058 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11061 arch
->sym_table
= (char *) malloc (size
);
11062 arch
->sym_size
= size
;
11063 if (arch
->sym_table
== NULL
)
11065 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11068 got
= fread (arch
->sym_table
, 1, size
, file
);
11071 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11077 if (fseek (file
, size
, SEEK_CUR
) != 0)
11079 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11084 /* Read the next archive header. */
11085 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11086 if (got
!= sizeof arch
->arhdr
)
11090 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11094 else if (read_symbols
)
11095 printf (_("%s has no archive index\n"), file_name
);
11097 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11099 /* This is the archive string table holding long member names. */
11100 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11101 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11103 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11104 if (arch
->longnames
== NULL
)
11106 error (_("Out of memory reading long symbol names in archive\n"));
11110 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
11112 free (arch
->longnames
);
11113 arch
->longnames
= NULL
;
11114 error (_("%s: failed to read long symbol name string table\n"), file_name
);
11118 if ((arch
->longnames_size
& 1) != 0)
11125 /* Release the memory used for the archive information. */
11128 release_archive (struct archive_info
* arch
)
11130 if (arch
->file_name
!= NULL
)
11131 free (arch
->file_name
);
11132 if (arch
->index_array
!= NULL
)
11133 free (arch
->index_array
);
11134 if (arch
->sym_table
!= NULL
)
11135 free (arch
->sym_table
);
11136 if (arch
->longnames
!= NULL
)
11137 free (arch
->longnames
);
11140 /* Open and setup a nested archive, if not already open. */
11143 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
11145 FILE * member_file
;
11147 /* Have we already setup this archive? */
11148 if (nested_arch
->file_name
!= NULL
11149 && streq (nested_arch
->file_name
, member_file_name
))
11152 /* Close previous file and discard cached information. */
11153 if (nested_arch
->file
!= NULL
)
11154 fclose (nested_arch
->file
);
11155 release_archive (nested_arch
);
11157 member_file
= fopen (member_file_name
, "rb");
11158 if (member_file
== NULL
)
11160 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
11164 get_archive_member_name_at (struct archive_info
* arch
,
11165 unsigned long offset
,
11166 struct archive_info
* nested_arch
);
11168 /* Get the name of an archive member from the current archive header.
11169 For simple names, this will modify the ar_name field of the current
11170 archive header. For long names, it will return a pointer to the
11171 longnames table. For nested archives, it will open the nested archive
11172 and get the name recursively. NESTED_ARCH is a single-entry cache so
11173 we don't keep rereading the same information from a nested archive. */
11176 get_archive_member_name (struct archive_info
* arch
,
11177 struct archive_info
* nested_arch
)
11179 unsigned long j
, k
;
11181 if (arch
->arhdr
.ar_name
[0] == '/')
11183 /* We have a long name. */
11185 char * member_file_name
;
11186 char * member_name
;
11188 arch
->nested_member_origin
= 0;
11189 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11190 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11191 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11193 while ((j
< arch
->longnames_size
)
11194 && (arch
->longnames
[j
] != '\n')
11195 && (arch
->longnames
[j
] != '\0'))
11197 if (arch
->longnames
[j
-1] == '/')
11199 arch
->longnames
[j
] = '\0';
11201 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11202 return arch
->longnames
+ k
;
11204 /* This is a proxy for a member of a nested archive.
11205 Find the name of the member in that archive. */
11206 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11207 if (member_file_name
!= NULL
11208 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11209 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11211 free (member_file_name
);
11212 return member_name
;
11214 free (member_file_name
);
11216 /* Last resort: just return the name of the nested archive. */
11217 return arch
->longnames
+ k
;
11220 /* We have a normal (short) name. */
11222 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11224 arch
->arhdr
.ar_name
[j
] = '\0';
11225 return arch
->arhdr
.ar_name
;
11228 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11231 get_archive_member_name_at (struct archive_info
* arch
,
11232 unsigned long offset
,
11233 struct archive_info
* nested_arch
)
11237 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11239 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11242 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11243 if (got
!= sizeof arch
->arhdr
)
11245 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11248 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11250 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11254 return get_archive_member_name (arch
, nested_arch
);
11257 /* Construct a string showing the name of the archive member, qualified
11258 with the name of the containing archive file. For thin archives, we
11259 use square brackets to denote the indirection. For nested archives,
11260 we show the qualified name of the external member inside the square
11261 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11264 make_qualified_name (struct archive_info
* arch
,
11265 struct archive_info
* nested_arch
,
11266 char * member_name
)
11271 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11272 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11273 len
+= strlen (nested_arch
->file_name
) + 2;
11275 name
= (char *) malloc (len
);
11278 error (_("Out of memory\n"));
11282 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11283 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11284 else if (arch
->is_thin_archive
)
11285 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11287 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11292 /* Process an ELF archive.
11293 On entry the file is positioned just after the ARMAG string. */
11296 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11298 struct archive_info arch
;
11299 struct archive_info nested_arch
;
11301 size_t file_name_size
;
11306 /* The ARCH structure is used to hold information about this archive. */
11307 arch
.file_name
= NULL
;
11309 arch
.index_array
= NULL
;
11310 arch
.sym_table
= NULL
;
11311 arch
.longnames
= NULL
;
11313 /* The NESTED_ARCH structure is used as a single-item cache of information
11314 about a nested archive (when members of a thin archive reside within
11315 another regular archive file). */
11316 nested_arch
.file_name
= NULL
;
11317 nested_arch
.file
= NULL
;
11318 nested_arch
.index_array
= NULL
;
11319 nested_arch
.sym_table
= NULL
;
11320 nested_arch
.longnames
= NULL
;
11322 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11328 if (do_archive_index
)
11330 if (arch
.sym_table
== NULL
)
11331 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11335 unsigned long current_pos
;
11337 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11338 file_name
, arch
.index_num
, arch
.sym_size
);
11339 current_pos
= ftell (file
);
11341 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11343 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11345 char * member_name
;
11347 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11349 if (member_name
!= NULL
)
11351 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11353 if (qualified_name
!= NULL
)
11355 printf (_("Binary %s contains:\n"), qualified_name
);
11356 free (qualified_name
);
11361 if (l
>= arch
.sym_size
)
11363 error (_("%s: end of the symbol table reached before the end of the index\n"),
11367 printf ("\t%s\n", arch
.sym_table
+ l
);
11368 l
+= strlen (arch
.sym_table
+ l
) + 1;
11373 if (l
< arch
.sym_size
)
11374 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11377 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11379 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11385 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11386 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11387 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11388 && !do_section_groups
)
11390 ret
= 0; /* Archive index only. */
11395 file_name_size
= strlen (file_name
);
11402 char * qualified_name
;
11404 /* Read the next archive header. */
11405 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11407 error (_("%s: failed to seek to next archive header\n"), file_name
);
11410 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11411 if (got
!= sizeof arch
.arhdr
)
11415 error (_("%s: failed to read archive header\n"), file_name
);
11419 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11421 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11426 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11428 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11429 if (archive_file_size
& 01)
11430 ++archive_file_size
;
11432 name
= get_archive_member_name (&arch
, &nested_arch
);
11435 error (_("%s: bad archive file name\n"), file_name
);
11439 namelen
= strlen (name
);
11441 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11442 if (qualified_name
== NULL
)
11444 error (_("%s: bad archive file name\n"), file_name
);
11449 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11451 /* This is a proxy for an external member of a thin archive. */
11452 FILE * member_file
;
11453 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11454 if (member_file_name
== NULL
)
11460 member_file
= fopen (member_file_name
, "rb");
11461 if (member_file
== NULL
)
11463 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11464 free (member_file_name
);
11469 archive_file_offset
= arch
.nested_member_origin
;
11471 ret
|= process_object (qualified_name
, member_file
);
11473 fclose (member_file
);
11474 free (member_file_name
);
11476 else if (is_thin_archive
)
11478 /* This is a proxy for a member of a nested archive. */
11479 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11481 /* The nested archive file will have been opened and setup by
11482 get_archive_member_name. */
11483 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11485 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11490 ret
|= process_object (qualified_name
, nested_arch
.file
);
11494 archive_file_offset
= arch
.next_arhdr_offset
;
11495 arch
.next_arhdr_offset
+= archive_file_size
;
11497 ret
|= process_object (qualified_name
, file
);
11500 free (qualified_name
);
11504 if (nested_arch
.file
!= NULL
)
11505 fclose (nested_arch
.file
);
11506 release_archive (&nested_arch
);
11507 release_archive (&arch
);
11513 process_file (char * file_name
)
11516 struct stat statbuf
;
11517 char armag
[SARMAG
];
11520 if (stat (file_name
, &statbuf
) < 0)
11522 if (errno
== ENOENT
)
11523 error (_("'%s': No such file\n"), file_name
);
11525 error (_("Could not locate '%s'. System error message: %s\n"),
11526 file_name
, strerror (errno
));
11530 if (! S_ISREG (statbuf
.st_mode
))
11532 error (_("'%s' is not an ordinary file\n"), file_name
);
11536 file
= fopen (file_name
, "rb");
11539 error (_("Input file '%s' is not readable.\n"), file_name
);
11543 if (fread (armag
, SARMAG
, 1, file
) != 1)
11545 error (_("%s: Failed to read file's magic number\n"), file_name
);
11550 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11551 ret
= process_archive (file_name
, file
, FALSE
);
11552 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11553 ret
= process_archive (file_name
, file
, TRUE
);
11556 if (do_archive_index
)
11557 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11561 archive_file_size
= archive_file_offset
= 0;
11562 ret
= process_object (file_name
, file
);
11570 #ifdef SUPPORT_DISASSEMBLY
11571 /* Needed by the i386 disassembler. For extra credit, someone could
11572 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11576 print_address (unsigned int addr
, FILE * outfile
)
11578 fprintf (outfile
,"0x%8.8x", addr
);
11581 /* Needed by the i386 disassembler. */
11583 db_task_printsym (unsigned int addr
)
11585 print_address (addr
, stderr
);
11590 main (int argc
, char ** argv
)
11594 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11595 setlocale (LC_MESSAGES
, "");
11597 #if defined (HAVE_SETLOCALE)
11598 setlocale (LC_CTYPE
, "");
11600 bindtextdomain (PACKAGE
, LOCALEDIR
);
11601 textdomain (PACKAGE
);
11603 expandargv (&argc
, &argv
);
11605 parse_args (argc
, argv
);
11607 if (num_dump_sects
> 0)
11609 /* Make a copy of the dump_sects array. */
11610 cmdline_dump_sects
= (dump_type
*)
11611 malloc (num_dump_sects
* sizeof (* dump_sects
));
11612 if (cmdline_dump_sects
== NULL
)
11613 error (_("Out of memory allocating dump request table.\n"));
11616 memcpy (cmdline_dump_sects
, dump_sects
,
11617 num_dump_sects
* sizeof (* dump_sects
));
11618 num_cmdline_dump_sects
= num_dump_sects
;
11622 if (optind
< (argc
- 1))
11626 while (optind
< argc
)
11627 err
|= process_file (argv
[optind
++]);
11629 if (dump_sects
!= NULL
)
11631 if (cmdline_dump_sects
!= NULL
)
11632 free (cmdline_dump_sects
);