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"
133 #include "elf/s390.h"
134 #include "elf/score.h"
136 #include "elf/sparc.h"
138 #include "elf/v850.h"
140 #include "elf/x86-64.h"
141 #include "elf/xstormy16.h"
142 #include "elf/xtensa.h"
147 #include "libiberty.h"
148 #include "safe-ctype.h"
149 #include "filenames.h"
151 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_JMPREL
+ 1];
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
:
624 case EM_MICROBLAZE_OLD
:
645 warn (_("Don't know about relocations on this machine architecture\n"));
651 slurp_rela_relocs (FILE * file
,
652 unsigned long rel_offset
,
653 unsigned long rel_size
,
654 Elf_Internal_Rela
** relasp
,
655 unsigned long * nrelasp
)
657 Elf_Internal_Rela
* relas
;
658 unsigned long nrelas
;
663 Elf32_External_Rela
* erelas
;
665 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
669 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
671 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
676 error (_("out of memory parsing relocs\n"));
680 for (i
= 0; i
< nrelas
; i
++)
682 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
683 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
684 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
691 Elf64_External_Rela
* erelas
;
693 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
697 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
699 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
704 error (_("out of memory parsing relocs\n"));
708 for (i
= 0; i
< nrelas
; i
++)
710 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
711 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
712 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
714 /* The #ifdef BFD64 below is to prevent a compile time
715 warning. We know that if we do not have a 64 bit data
716 type that we will never execute this code anyway. */
718 if (elf_header
.e_machine
== EM_MIPS
719 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
721 /* In little-endian objects, r_info isn't really a
722 64-bit little-endian value: it has a 32-bit
723 little-endian symbol index followed by four
724 individual byte fields. Reorder INFO
726 bfd_vma info
= relas
[i
].r_info
;
727 info
= (((info
& 0xffffffff) << 32)
728 | ((info
>> 56) & 0xff)
729 | ((info
>> 40) & 0xff00)
730 | ((info
>> 24) & 0xff0000)
731 | ((info
>> 8) & 0xff000000));
732 relas
[i
].r_info
= info
;
745 slurp_rel_relocs (FILE * file
,
746 unsigned long rel_offset
,
747 unsigned long rel_size
,
748 Elf_Internal_Rela
** relsp
,
749 unsigned long * nrelsp
)
751 Elf_Internal_Rela
* rels
;
757 Elf32_External_Rel
* erels
;
759 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
763 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
765 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
770 error (_("out of memory parsing relocs\n"));
774 for (i
= 0; i
< nrels
; i
++)
776 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
777 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
778 rels
[i
].r_addend
= 0;
785 Elf64_External_Rel
* erels
;
787 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
791 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
793 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
798 error (_("out of memory parsing relocs\n"));
802 for (i
= 0; i
< nrels
; i
++)
804 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
805 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
806 rels
[i
].r_addend
= 0;
808 /* The #ifdef BFD64 below is to prevent a compile time
809 warning. We know that if we do not have a 64 bit data
810 type that we will never execute this code anyway. */
812 if (elf_header
.e_machine
== EM_MIPS
813 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
815 /* In little-endian objects, r_info isn't really a
816 64-bit little-endian value: it has a 32-bit
817 little-endian symbol index followed by four
818 individual byte fields. Reorder INFO
820 bfd_vma info
= rels
[i
].r_info
;
821 info
= (((info
& 0xffffffff) << 32)
822 | ((info
>> 56) & 0xff)
823 | ((info
>> 40) & 0xff00)
824 | ((info
>> 24) & 0xff0000)
825 | ((info
>> 8) & 0xff000000));
826 rels
[i
].r_info
= info
;
838 /* Returns the reloc type extracted from the reloc info field. */
841 get_reloc_type (bfd_vma reloc_info
)
844 return ELF32_R_TYPE (reloc_info
);
846 switch (elf_header
.e_machine
)
849 /* Note: We assume that reloc_info has already been adjusted for us. */
850 return ELF64_MIPS_R_TYPE (reloc_info
);
853 return ELF64_R_TYPE_ID (reloc_info
);
856 return ELF64_R_TYPE (reloc_info
);
860 /* Return the symbol index extracted from the reloc info field. */
863 get_reloc_symindex (bfd_vma reloc_info
)
865 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
868 /* Display the contents of the relocation data found at the specified
872 dump_relocations (FILE * file
,
873 unsigned long rel_offset
,
874 unsigned long rel_size
,
875 Elf_Internal_Sym
* symtab
,
878 unsigned long strtablen
,
882 Elf_Internal_Rela
* rels
;
884 if (is_rela
== UNKNOWN
)
885 is_rela
= guess_is_rela (elf_header
.e_machine
);
889 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
894 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
903 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
905 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
910 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
912 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
920 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
922 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
927 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
929 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
933 for (i
= 0; i
< rel_size
; i
++)
938 bfd_vma symtab_index
;
941 offset
= rels
[i
].r_offset
;
942 info
= rels
[i
].r_info
;
944 type
= get_reloc_type (info
);
945 symtab_index
= get_reloc_symindex (info
);
949 printf ("%8.8lx %8.8lx ",
950 (unsigned long) offset
& 0xffffffff,
951 (unsigned long) info
& 0xffffffff);
955 #if BFD_HOST_64BIT_LONG
957 ? "%16.16lx %16.16lx "
958 : "%12.12lx %12.12lx ",
960 #elif BFD_HOST_64BIT_LONG_LONG
963 ? "%16.16llx %16.16llx "
964 : "%12.12llx %12.12llx ",
968 ? "%16.16I64x %16.16I64x "
969 : "%12.12I64x %12.12I64x ",
974 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
975 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
976 _bfd_int64_high (offset
),
977 _bfd_int64_low (offset
),
978 _bfd_int64_high (info
),
979 _bfd_int64_low (info
));
983 switch (elf_header
.e_machine
)
991 rtype
= elf_m32r_reloc_type (type
);
996 rtype
= elf_i386_reloc_type (type
);
1001 rtype
= elf_m68hc11_reloc_type (type
);
1005 rtype
= elf_m68k_reloc_type (type
);
1009 rtype
= elf_i960_reloc_type (type
);
1014 rtype
= elf_avr_reloc_type (type
);
1017 case EM_OLD_SPARCV9
:
1018 case EM_SPARC32PLUS
:
1021 rtype
= elf_sparc_reloc_type (type
);
1025 rtype
= elf_spu_reloc_type (type
);
1029 case EM_CYGNUS_V850
:
1030 rtype
= v850_reloc_type (type
);
1034 case EM_CYGNUS_D10V
:
1035 rtype
= elf_d10v_reloc_type (type
);
1039 case EM_CYGNUS_D30V
:
1040 rtype
= elf_d30v_reloc_type (type
);
1044 rtype
= elf_dlx_reloc_type (type
);
1048 rtype
= elf_sh_reloc_type (type
);
1052 case EM_CYGNUS_MN10300
:
1053 rtype
= elf_mn10300_reloc_type (type
);
1057 case EM_CYGNUS_MN10200
:
1058 rtype
= elf_mn10200_reloc_type (type
);
1062 case EM_CYGNUS_FR30
:
1063 rtype
= elf_fr30_reloc_type (type
);
1067 rtype
= elf_frv_reloc_type (type
);
1071 rtype
= elf_mcore_reloc_type (type
);
1075 rtype
= elf_mmix_reloc_type (type
);
1080 rtype
= elf_msp430_reloc_type (type
);
1084 rtype
= elf_ppc_reloc_type (type
);
1088 rtype
= elf_ppc64_reloc_type (type
);
1092 case EM_MIPS_RS3_LE
:
1093 rtype
= elf_mips_reloc_type (type
);
1097 rtype
= elf_alpha_reloc_type (type
);
1101 rtype
= elf_arm_reloc_type (type
);
1105 rtype
= elf_arc_reloc_type (type
);
1109 rtype
= elf_hppa_reloc_type (type
);
1115 rtype
= elf_h8_reloc_type (type
);
1120 rtype
= elf_or32_reloc_type (type
);
1125 rtype
= elf_pj_reloc_type (type
);
1128 rtype
= elf_ia64_reloc_type (type
);
1132 rtype
= elf_cris_reloc_type (type
);
1136 rtype
= elf_i860_reloc_type (type
);
1141 rtype
= elf_x86_64_reloc_type (type
);
1145 rtype
= i370_reloc_type (type
);
1150 rtype
= elf_s390_reloc_type (type
);
1154 rtype
= elf_score_reloc_type (type
);
1158 rtype
= elf_xstormy16_reloc_type (type
);
1162 rtype
= elf_crx_reloc_type (type
);
1166 rtype
= elf_vax_reloc_type (type
);
1171 rtype
= elf_ip2k_reloc_type (type
);
1175 rtype
= elf_iq2000_reloc_type (type
);
1180 rtype
= elf_xtensa_reloc_type (type
);
1183 case EM_LATTICEMICO32
:
1184 rtype
= elf_lm32_reloc_type (type
);
1189 rtype
= elf_m32c_reloc_type (type
);
1193 rtype
= elf_mt_reloc_type (type
);
1197 rtype
= elf_bfin_reloc_type (type
);
1201 rtype
= elf_mep_reloc_type (type
);
1206 rtype
= elf_cr16_reloc_type (type
);
1210 case EM_MICROBLAZE_OLD
:
1211 rtype
= elf_microblaze_reloc_type (type
);
1216 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1218 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1220 if (elf_header
.e_machine
== EM_ALPHA
1222 && streq (rtype
, "R_ALPHA_LITUSE")
1225 switch (rels
[i
].r_addend
)
1227 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1228 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1229 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1230 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1231 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1232 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1233 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1234 default: rtype
= NULL
;
1237 printf (" (%s)", rtype
);
1241 printf (_("<unknown addend: %lx>"),
1242 (unsigned long) rels
[i
].r_addend
);
1245 else if (symtab_index
)
1247 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1248 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1251 Elf_Internal_Sym
* psym
;
1253 psym
= symtab
+ symtab_index
;
1257 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1261 unsigned int width
= is_32bit_elf
? 8 : 14;
1263 /* Relocations against GNU_IFUNC symbols do not use the value
1264 of the symbol as the address to relocate against. Instead
1265 they invoke the function named by the symbol and use its
1266 result as the address for relocation.
1268 To indicate this to the user, do not display the value of
1269 the symbol in the "Symbols's Value" field. Instead show
1270 its name followed by () as a hint that the symbol is
1274 || psym
->st_name
== 0
1275 || psym
->st_name
>= strtablen
)
1278 name
= strtab
+ psym
->st_name
;
1280 len
= print_symbol (width
, name
);
1281 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1285 print_vma (psym
->st_value
, LONG_HEX
);
1287 printf (is_32bit_elf
? " " : " ");
1290 if (psym
->st_name
== 0)
1292 const char * sec_name
= "<null>";
1295 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1297 if (psym
->st_shndx
< elf_header
.e_shnum
)
1299 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1300 else if (psym
->st_shndx
== SHN_ABS
)
1302 else if (psym
->st_shndx
== SHN_COMMON
)
1303 sec_name
= "COMMON";
1304 else if (elf_header
.e_machine
== EM_MIPS
1305 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1306 sec_name
= "SCOMMON";
1307 else if (elf_header
.e_machine
== EM_MIPS
1308 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1309 sec_name
= "SUNDEF";
1310 else if ((elf_header
.e_machine
== EM_X86_64
1311 || elf_header
.e_machine
== EM_L1OM
)
1312 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1313 sec_name
= "LARGE_COMMON";
1314 else if (elf_header
.e_machine
== EM_IA_64
1315 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1316 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1317 sec_name
= "ANSI_COM";
1318 else if (elf_header
.e_machine
== EM_IA_64
1319 && (elf_header
.e_ident
[EI_OSABI
]
1320 == ELFOSABI_OPENVMS
)
1321 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1322 sec_name
= "VMS_SYMVEC";
1325 sprintf (name_buf
, "<section 0x%x>",
1326 (unsigned int) psym
->st_shndx
);
1327 sec_name
= name_buf
;
1330 print_symbol (22, sec_name
);
1332 else if (strtab
== NULL
)
1333 printf (_("<string table index: %3ld>"), psym
->st_name
);
1334 else if (psym
->st_name
>= strtablen
)
1335 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1337 print_symbol (22, strtab
+ psym
->st_name
);
1341 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1344 printf (" - %lx", - offset
);
1346 printf (" + %lx", offset
);
1352 printf ("%*c", is_32bit_elf
?
1353 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1354 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1357 if (elf_header
.e_machine
== EM_SPARCV9
1359 && streq (rtype
, "R_SPARC_OLO10"))
1360 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1365 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1367 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1368 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1369 const char * rtype2
= elf_mips_reloc_type (type2
);
1370 const char * rtype3
= elf_mips_reloc_type (type3
);
1372 printf (" Type2: ");
1375 printf (_("unrecognized: %-7lx"),
1376 (unsigned long) type2
& 0xffffffff);
1378 printf ("%-17.17s", rtype2
);
1380 printf ("\n Type3: ");
1383 printf (_("unrecognized: %-7lx"),
1384 (unsigned long) type3
& 0xffffffff);
1386 printf ("%-17.17s", rtype3
);
1397 get_mips_dynamic_type (unsigned long type
)
1401 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1402 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1403 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1404 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1405 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1406 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1407 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1408 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1409 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1410 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1411 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1412 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1413 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1414 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1415 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1416 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1417 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1418 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1419 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1420 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1421 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1422 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1423 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1424 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1425 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1426 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1427 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1428 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1429 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1430 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1431 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1432 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1433 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1434 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1435 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1436 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1437 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1438 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1439 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1440 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1441 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1442 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1443 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1444 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1445 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1452 get_sparc64_dynamic_type (unsigned long type
)
1456 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1463 get_ppc_dynamic_type (unsigned long type
)
1467 case DT_PPC_GOT
: return "PPC_GOT";
1474 get_ppc64_dynamic_type (unsigned long type
)
1478 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1479 case DT_PPC64_OPD
: return "PPC64_OPD";
1480 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1487 get_parisc_dynamic_type (unsigned long type
)
1491 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1492 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1493 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1494 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1495 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1496 case DT_HP_PREINIT
: return "HP_PREINIT";
1497 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1498 case DT_HP_NEEDED
: return "HP_NEEDED";
1499 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1500 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1501 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1502 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1503 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1504 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1505 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1506 case DT_HP_FILTERED
: return "HP_FILTERED";
1507 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1508 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1509 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1510 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1511 case DT_PLT
: return "PLT";
1512 case DT_PLT_SIZE
: return "PLT_SIZE";
1513 case DT_DLT
: return "DLT";
1514 case DT_DLT_SIZE
: return "DLT_SIZE";
1521 get_ia64_dynamic_type (unsigned long type
)
1525 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1526 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1527 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1528 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1529 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1530 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1531 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1532 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1533 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1534 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1535 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1536 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1537 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1538 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1539 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1540 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1541 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1542 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1543 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1544 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1545 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1546 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1547 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1548 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1549 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1550 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1551 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1552 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1553 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1554 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1555 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1562 get_alpha_dynamic_type (unsigned long type
)
1566 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1573 get_score_dynamic_type (unsigned long type
)
1577 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1578 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1579 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1580 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1581 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1582 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1590 get_dynamic_type (unsigned long type
)
1592 static char buff
[64];
1596 case DT_NULL
: return "NULL";
1597 case DT_NEEDED
: return "NEEDED";
1598 case DT_PLTRELSZ
: return "PLTRELSZ";
1599 case DT_PLTGOT
: return "PLTGOT";
1600 case DT_HASH
: return "HASH";
1601 case DT_STRTAB
: return "STRTAB";
1602 case DT_SYMTAB
: return "SYMTAB";
1603 case DT_RELA
: return "RELA";
1604 case DT_RELASZ
: return "RELASZ";
1605 case DT_RELAENT
: return "RELAENT";
1606 case DT_STRSZ
: return "STRSZ";
1607 case DT_SYMENT
: return "SYMENT";
1608 case DT_INIT
: return "INIT";
1609 case DT_FINI
: return "FINI";
1610 case DT_SONAME
: return "SONAME";
1611 case DT_RPATH
: return "RPATH";
1612 case DT_SYMBOLIC
: return "SYMBOLIC";
1613 case DT_REL
: return "REL";
1614 case DT_RELSZ
: return "RELSZ";
1615 case DT_RELENT
: return "RELENT";
1616 case DT_PLTREL
: return "PLTREL";
1617 case DT_DEBUG
: return "DEBUG";
1618 case DT_TEXTREL
: return "TEXTREL";
1619 case DT_JMPREL
: return "JMPREL";
1620 case DT_BIND_NOW
: return "BIND_NOW";
1621 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1622 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1623 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1624 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1625 case DT_RUNPATH
: return "RUNPATH";
1626 case DT_FLAGS
: return "FLAGS";
1628 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1629 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1631 case DT_CHECKSUM
: return "CHECKSUM";
1632 case DT_PLTPADSZ
: return "PLTPADSZ";
1633 case DT_MOVEENT
: return "MOVEENT";
1634 case DT_MOVESZ
: return "MOVESZ";
1635 case DT_FEATURE
: return "FEATURE";
1636 case DT_POSFLAG_1
: return "POSFLAG_1";
1637 case DT_SYMINSZ
: return "SYMINSZ";
1638 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1640 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1641 case DT_CONFIG
: return "CONFIG";
1642 case DT_DEPAUDIT
: return "DEPAUDIT";
1643 case DT_AUDIT
: return "AUDIT";
1644 case DT_PLTPAD
: return "PLTPAD";
1645 case DT_MOVETAB
: return "MOVETAB";
1646 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1648 case DT_VERSYM
: return "VERSYM";
1650 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1651 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1652 case DT_RELACOUNT
: return "RELACOUNT";
1653 case DT_RELCOUNT
: return "RELCOUNT";
1654 case DT_FLAGS_1
: return "FLAGS_1";
1655 case DT_VERDEF
: return "VERDEF";
1656 case DT_VERDEFNUM
: return "VERDEFNUM";
1657 case DT_VERNEED
: return "VERNEED";
1658 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1660 case DT_AUXILIARY
: return "AUXILIARY";
1661 case DT_USED
: return "USED";
1662 case DT_FILTER
: return "FILTER";
1664 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1665 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1666 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1667 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1668 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1669 case DT_GNU_HASH
: return "GNU_HASH";
1672 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1674 const char * result
;
1676 switch (elf_header
.e_machine
)
1679 case EM_MIPS_RS3_LE
:
1680 result
= get_mips_dynamic_type (type
);
1683 result
= get_sparc64_dynamic_type (type
);
1686 result
= get_ppc_dynamic_type (type
);
1689 result
= get_ppc64_dynamic_type (type
);
1692 result
= get_ia64_dynamic_type (type
);
1695 result
= get_alpha_dynamic_type (type
);
1698 result
= get_score_dynamic_type (type
);
1708 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1710 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1711 || (elf_header
.e_machine
== EM_PARISC
1712 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1714 const char * result
;
1716 switch (elf_header
.e_machine
)
1719 result
= get_parisc_dynamic_type (type
);
1722 result
= get_ia64_dynamic_type (type
);
1732 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1736 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1743 get_file_type (unsigned e_type
)
1745 static char buff
[32];
1749 case ET_NONE
: return _("NONE (None)");
1750 case ET_REL
: return _("REL (Relocatable file)");
1751 case ET_EXEC
: return _("EXEC (Executable file)");
1752 case ET_DYN
: return _("DYN (Shared object file)");
1753 case ET_CORE
: return _("CORE (Core file)");
1756 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1757 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1758 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1759 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1761 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1767 get_machine_name (unsigned e_machine
)
1769 static char buff
[64]; /* XXX */
1773 case EM_NONE
: return _("None");
1774 case EM_M32
: return "WE32100";
1775 case EM_SPARC
: return "Sparc";
1776 case EM_SPU
: return "SPU";
1777 case EM_386
: return "Intel 80386";
1778 case EM_68K
: return "MC68000";
1779 case EM_88K
: return "MC88000";
1780 case EM_486
: return "Intel 80486";
1781 case EM_860
: return "Intel 80860";
1782 case EM_MIPS
: return "MIPS R3000";
1783 case EM_S370
: return "IBM System/370";
1784 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1785 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1786 case EM_PARISC
: return "HPPA";
1787 case EM_PPC_OLD
: return "Power PC (old)";
1788 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1789 case EM_960
: return "Intel 90860";
1790 case EM_PPC
: return "PowerPC";
1791 case EM_PPC64
: return "PowerPC64";
1792 case EM_V800
: return "NEC V800";
1793 case EM_FR20
: return "Fujitsu FR20";
1794 case EM_RH32
: return "TRW RH32";
1795 case EM_MCORE
: return "MCORE";
1796 case EM_ARM
: return "ARM";
1797 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1798 case EM_SH
: return "Renesas / SuperH SH";
1799 case EM_SPARCV9
: return "Sparc v9";
1800 case EM_TRICORE
: return "Siemens Tricore";
1801 case EM_ARC
: return "ARC";
1802 case EM_H8_300
: return "Renesas H8/300";
1803 case EM_H8_300H
: return "Renesas H8/300H";
1804 case EM_H8S
: return "Renesas H8S";
1805 case EM_H8_500
: return "Renesas H8/500";
1806 case EM_IA_64
: return "Intel IA-64";
1807 case EM_MIPS_X
: return "Stanford MIPS-X";
1808 case EM_COLDFIRE
: return "Motorola Coldfire";
1809 case EM_68HC12
: return "Motorola M68HC12";
1810 case EM_ALPHA
: return "Alpha";
1811 case EM_CYGNUS_D10V
:
1812 case EM_D10V
: return "d10v";
1813 case EM_CYGNUS_D30V
:
1814 case EM_D30V
: return "d30v";
1815 case EM_CYGNUS_M32R
:
1816 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1817 case EM_CYGNUS_V850
:
1818 case EM_V850
: return "NEC v850";
1819 case EM_CYGNUS_MN10300
:
1820 case EM_MN10300
: return "mn10300";
1821 case EM_CYGNUS_MN10200
:
1822 case EM_MN10200
: return "mn10200";
1823 case EM_CYGNUS_FR30
:
1824 case EM_FR30
: return "Fujitsu FR30";
1825 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1827 case EM_PJ
: return "picoJava";
1828 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1829 case EM_PCP
: return "Siemens PCP";
1830 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1831 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1832 case EM_STARCORE
: return "Motorola Star*Core processor";
1833 case EM_ME16
: return "Toyota ME16 processor";
1834 case EM_ST100
: return "STMicroelectronics ST100 processor";
1835 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1836 case EM_FX66
: return "Siemens FX66 microcontroller";
1837 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1838 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1839 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1840 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1841 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1842 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1843 case EM_SVX
: return "Silicon Graphics SVx";
1844 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1845 case EM_VAX
: return "Digital VAX";
1847 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1848 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1849 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1850 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1851 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1852 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1853 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1854 case EM_PRISM
: return "Vitesse Prism";
1855 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1856 case EM_L1OM
: return "Intel L1OM";
1858 case EM_S390
: return "IBM S/390";
1859 case EM_SCORE
: return "SUNPLUS S+Core";
1860 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1862 case EM_OR32
: return "OpenRISC";
1863 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1864 case EM_DLX
: return "OpenDLX";
1866 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1867 case EM_IQ2000
: return "Vitesse IQ2000";
1869 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1870 case EM_LATTICEMICO32
: return "Lattice Mico32";
1872 case EM_M32C
: return "Renesas M32c";
1873 case EM_MT
: return "Morpho Techologies MT processor";
1874 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1875 case EM_NIOS32
: return "Altera Nios";
1876 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1877 case EM_XC16X
: return "Infineon Technologies xc16x";
1878 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1880 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1881 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1882 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1884 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1890 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1895 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1896 e_flags
&= ~ EF_ARM_EABIMASK
;
1898 /* Handle "generic" ARM flags. */
1899 if (e_flags
& EF_ARM_RELEXEC
)
1901 strcat (buf
, ", relocatable executable");
1902 e_flags
&= ~ EF_ARM_RELEXEC
;
1905 if (e_flags
& EF_ARM_HASENTRY
)
1907 strcat (buf
, ", has entry point");
1908 e_flags
&= ~ EF_ARM_HASENTRY
;
1911 /* Now handle EABI specific flags. */
1915 strcat (buf
, ", <unrecognized EABI>");
1920 case EF_ARM_EABI_VER1
:
1921 strcat (buf
, ", Version1 EABI");
1926 /* Process flags one bit at a time. */
1927 flag
= e_flags
& - e_flags
;
1932 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1933 strcat (buf
, ", sorted symbol tables");
1943 case EF_ARM_EABI_VER2
:
1944 strcat (buf
, ", Version2 EABI");
1949 /* Process flags one bit at a time. */
1950 flag
= e_flags
& - e_flags
;
1955 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1956 strcat (buf
, ", sorted symbol tables");
1959 case EF_ARM_DYNSYMSUSESEGIDX
:
1960 strcat (buf
, ", dynamic symbols use segment index");
1963 case EF_ARM_MAPSYMSFIRST
:
1964 strcat (buf
, ", mapping symbols precede others");
1974 case EF_ARM_EABI_VER3
:
1975 strcat (buf
, ", Version3 EABI");
1978 case EF_ARM_EABI_VER4
:
1979 strcat (buf
, ", Version4 EABI");
1982 case EF_ARM_EABI_VER5
:
1983 strcat (buf
, ", Version5 EABI");
1989 /* Process flags one bit at a time. */
1990 flag
= e_flags
& - e_flags
;
1996 strcat (buf
, ", BE8");
2000 strcat (buf
, ", LE8");
2010 case EF_ARM_EABI_UNKNOWN
:
2011 strcat (buf
, ", GNU EABI");
2016 /* Process flags one bit at a time. */
2017 flag
= e_flags
& - e_flags
;
2022 case EF_ARM_INTERWORK
:
2023 strcat (buf
, ", interworking enabled");
2026 case EF_ARM_APCS_26
:
2027 strcat (buf
, ", uses APCS/26");
2030 case EF_ARM_APCS_FLOAT
:
2031 strcat (buf
, ", uses APCS/float");
2035 strcat (buf
, ", position independent");
2039 strcat (buf
, ", 8 bit structure alignment");
2042 case EF_ARM_NEW_ABI
:
2043 strcat (buf
, ", uses new ABI");
2046 case EF_ARM_OLD_ABI
:
2047 strcat (buf
, ", uses old ABI");
2050 case EF_ARM_SOFT_FLOAT
:
2051 strcat (buf
, ", software FP");
2054 case EF_ARM_VFP_FLOAT
:
2055 strcat (buf
, ", VFP");
2058 case EF_ARM_MAVERICK_FLOAT
:
2059 strcat (buf
, ", Maverick FP");
2070 strcat (buf
,", <unknown>");
2074 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2076 static char buf
[1024];
2088 decode_ARM_machine_flags (e_flags
, buf
);
2092 switch (e_flags
& EF_FRV_CPU_MASK
)
2094 case EF_FRV_CPU_GENERIC
:
2098 strcat (buf
, ", fr???");
2101 case EF_FRV_CPU_FR300
:
2102 strcat (buf
, ", fr300");
2105 case EF_FRV_CPU_FR400
:
2106 strcat (buf
, ", fr400");
2108 case EF_FRV_CPU_FR405
:
2109 strcat (buf
, ", fr405");
2112 case EF_FRV_CPU_FR450
:
2113 strcat (buf
, ", fr450");
2116 case EF_FRV_CPU_FR500
:
2117 strcat (buf
, ", fr500");
2119 case EF_FRV_CPU_FR550
:
2120 strcat (buf
, ", fr550");
2123 case EF_FRV_CPU_SIMPLE
:
2124 strcat (buf
, ", simple");
2126 case EF_FRV_CPU_TOMCAT
:
2127 strcat (buf
, ", tomcat");
2133 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2134 strcat (buf
, ", m68000");
2135 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2136 strcat (buf
, ", cpu32");
2137 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2138 strcat (buf
, ", fido_a");
2141 char const * isa
= _("unknown");
2142 char const * mac
= _("unknown mac");
2143 char const * additional
= NULL
;
2145 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2147 case EF_M68K_CF_ISA_A_NODIV
:
2149 additional
= ", nodiv";
2151 case EF_M68K_CF_ISA_A
:
2154 case EF_M68K_CF_ISA_A_PLUS
:
2157 case EF_M68K_CF_ISA_B_NOUSP
:
2159 additional
= ", nousp";
2161 case EF_M68K_CF_ISA_B
:
2165 strcat (buf
, ", cf, isa ");
2168 strcat (buf
, additional
);
2169 if (e_flags
& EF_M68K_CF_FLOAT
)
2170 strcat (buf
, ", float");
2171 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2176 case EF_M68K_CF_MAC
:
2179 case EF_M68K_CF_EMAC
:
2192 if (e_flags
& EF_PPC_EMB
)
2193 strcat (buf
, ", emb");
2195 if (e_flags
& EF_PPC_RELOCATABLE
)
2196 strcat (buf
, ", relocatable");
2198 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2199 strcat (buf
, ", relocatable-lib");
2203 case EM_CYGNUS_V850
:
2204 switch (e_flags
& EF_V850_ARCH
)
2207 strcat (buf
, ", v850e1");
2210 strcat (buf
, ", v850e");
2213 strcat (buf
, ", v850");
2216 strcat (buf
, ", unknown v850 architecture variant");
2222 case EM_CYGNUS_M32R
:
2223 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2224 strcat (buf
, ", m32r");
2228 case EM_MIPS_RS3_LE
:
2229 if (e_flags
& EF_MIPS_NOREORDER
)
2230 strcat (buf
, ", noreorder");
2232 if (e_flags
& EF_MIPS_PIC
)
2233 strcat (buf
, ", pic");
2235 if (e_flags
& EF_MIPS_CPIC
)
2236 strcat (buf
, ", cpic");
2238 if (e_flags
& EF_MIPS_UCODE
)
2239 strcat (buf
, ", ugen_reserved");
2241 if (e_flags
& EF_MIPS_ABI2
)
2242 strcat (buf
, ", abi2");
2244 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2245 strcat (buf
, ", odk first");
2247 if (e_flags
& EF_MIPS_32BITMODE
)
2248 strcat (buf
, ", 32bitmode");
2250 switch ((e_flags
& EF_MIPS_MACH
))
2252 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2253 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2254 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2255 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2256 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2257 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2258 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2259 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2260 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2261 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2262 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2263 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2264 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2265 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2267 /* We simply ignore the field in this case to avoid confusion:
2268 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2271 default: strcat (buf
, ", unknown CPU"); break;
2274 switch ((e_flags
& EF_MIPS_ABI
))
2276 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2277 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2278 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2279 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2281 /* We simply ignore the field in this case to avoid confusion:
2282 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2283 This means it is likely to be an o32 file, but not for
2286 default: strcat (buf
, ", unknown ABI"); break;
2289 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2290 strcat (buf
, ", mdmx");
2292 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2293 strcat (buf
, ", mips16");
2295 switch ((e_flags
& EF_MIPS_ARCH
))
2297 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2298 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2299 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2300 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2301 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2302 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2303 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2304 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2305 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2306 default: strcat (buf
, ", unknown ISA"); break;
2312 switch ((e_flags
& EF_SH_MACH_MASK
))
2314 case EF_SH1
: strcat (buf
, ", sh1"); break;
2315 case EF_SH2
: strcat (buf
, ", sh2"); break;
2316 case EF_SH3
: strcat (buf
, ", sh3"); break;
2317 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2318 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2319 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2320 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2321 case EF_SH4
: strcat (buf
, ", sh4"); break;
2322 case EF_SH5
: strcat (buf
, ", sh5"); break;
2323 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2324 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2325 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2326 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2327 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2328 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2329 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2330 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2331 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2332 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2333 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2334 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2335 default: strcat (buf
, ", unknown ISA"); break;
2341 if (e_flags
& EF_SPARC_32PLUS
)
2342 strcat (buf
, ", v8+");
2344 if (e_flags
& EF_SPARC_SUN_US1
)
2345 strcat (buf
, ", ultrasparcI");
2347 if (e_flags
& EF_SPARC_SUN_US3
)
2348 strcat (buf
, ", ultrasparcIII");
2350 if (e_flags
& EF_SPARC_HAL_R1
)
2351 strcat (buf
, ", halr1");
2353 if (e_flags
& EF_SPARC_LEDATA
)
2354 strcat (buf
, ", ledata");
2356 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2357 strcat (buf
, ", tso");
2359 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2360 strcat (buf
, ", pso");
2362 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2363 strcat (buf
, ", rmo");
2367 switch (e_flags
& EF_PARISC_ARCH
)
2369 case EFA_PARISC_1_0
:
2370 strcpy (buf
, ", PA-RISC 1.0");
2372 case EFA_PARISC_1_1
:
2373 strcpy (buf
, ", PA-RISC 1.1");
2375 case EFA_PARISC_2_0
:
2376 strcpy (buf
, ", PA-RISC 2.0");
2381 if (e_flags
& EF_PARISC_TRAPNIL
)
2382 strcat (buf
, ", trapnil");
2383 if (e_flags
& EF_PARISC_EXT
)
2384 strcat (buf
, ", ext");
2385 if (e_flags
& EF_PARISC_LSB
)
2386 strcat (buf
, ", lsb");
2387 if (e_flags
& EF_PARISC_WIDE
)
2388 strcat (buf
, ", wide");
2389 if (e_flags
& EF_PARISC_NO_KABP
)
2390 strcat (buf
, ", no kabp");
2391 if (e_flags
& EF_PARISC_LAZYSWAP
)
2392 strcat (buf
, ", lazyswap");
2397 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2398 strcat (buf
, ", new calling convention");
2400 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2401 strcat (buf
, ", gnu calling convention");
2405 if ((e_flags
& EF_IA_64_ABI64
))
2406 strcat (buf
, ", 64-bit");
2408 strcat (buf
, ", 32-bit");
2409 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2410 strcat (buf
, ", reduced fp model");
2411 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2412 strcat (buf
, ", no function descriptors, constant gp");
2413 else if ((e_flags
& EF_IA_64_CONS_GP
))
2414 strcat (buf
, ", constant gp");
2415 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2416 strcat (buf
, ", absolute");
2420 if ((e_flags
& EF_VAX_NONPIC
))
2421 strcat (buf
, ", non-PIC");
2422 if ((e_flags
& EF_VAX_DFLOAT
))
2423 strcat (buf
, ", D-Float");
2424 if ((e_flags
& EF_VAX_GFLOAT
))
2425 strcat (buf
, ", G-Float");
2434 get_osabi_name (unsigned int osabi
)
2436 static char buff
[32];
2440 case ELFOSABI_NONE
: return "UNIX - System V";
2441 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2442 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2443 case ELFOSABI_LINUX
: return "UNIX - Linux";
2444 case ELFOSABI_HURD
: return "GNU/Hurd";
2445 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2446 case ELFOSABI_AIX
: return "UNIX - AIX";
2447 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2448 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2449 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2450 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2451 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2452 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2453 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2454 case ELFOSABI_AROS
: return "AROS";
2455 case ELFOSABI_STANDALONE
: return _("Standalone App");
2456 case ELFOSABI_ARM
: return "ARM";
2458 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2464 get_arm_segment_type (unsigned long type
)
2478 get_mips_segment_type (unsigned long type
)
2482 case PT_MIPS_REGINFO
:
2484 case PT_MIPS_RTPROC
:
2486 case PT_MIPS_OPTIONS
:
2496 get_parisc_segment_type (unsigned long type
)
2500 case PT_HP_TLS
: return "HP_TLS";
2501 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2502 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2503 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2504 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2505 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2506 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2507 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2508 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2509 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2510 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2511 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2512 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2513 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2514 case PT_HP_STACK
: return "HP_STACK";
2515 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2516 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2517 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2518 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2527 get_ia64_segment_type (unsigned long type
)
2531 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2532 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2533 case PT_HP_TLS
: return "HP_TLS";
2534 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2535 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2536 case PT_IA_64_HP_STACK
: return "HP_STACK";
2545 get_segment_type (unsigned long p_type
)
2547 static char buff
[32];
2551 case PT_NULL
: return "NULL";
2552 case PT_LOAD
: return "LOAD";
2553 case PT_DYNAMIC
: return "DYNAMIC";
2554 case PT_INTERP
: return "INTERP";
2555 case PT_NOTE
: return "NOTE";
2556 case PT_SHLIB
: return "SHLIB";
2557 case PT_PHDR
: return "PHDR";
2558 case PT_TLS
: return "TLS";
2560 case PT_GNU_EH_FRAME
:
2561 return "GNU_EH_FRAME";
2562 case PT_GNU_STACK
: return "GNU_STACK";
2563 case PT_GNU_RELRO
: return "GNU_RELRO";
2566 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2568 const char * result
;
2570 switch (elf_header
.e_machine
)
2573 result
= get_arm_segment_type (p_type
);
2576 case EM_MIPS_RS3_LE
:
2577 result
= get_mips_segment_type (p_type
);
2580 result
= get_parisc_segment_type (p_type
);
2583 result
= get_ia64_segment_type (p_type
);
2593 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2595 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2597 const char * result
;
2599 switch (elf_header
.e_machine
)
2602 result
= get_parisc_segment_type (p_type
);
2605 result
= get_ia64_segment_type (p_type
);
2615 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2618 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2625 get_mips_section_type_name (unsigned int sh_type
)
2629 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2630 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2631 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2632 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2633 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2634 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2635 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2636 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2637 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2638 case SHT_MIPS_RELD
: return "MIPS_RELD";
2639 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2640 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2641 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2642 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2643 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2644 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2645 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2646 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2647 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2648 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2649 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2650 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2651 case SHT_MIPS_LINE
: return "MIPS_LINE";
2652 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2653 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2654 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2655 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2656 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2657 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2658 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2659 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2660 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2661 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2662 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2663 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2664 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2665 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2666 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2667 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2675 get_parisc_section_type_name (unsigned int sh_type
)
2679 case SHT_PARISC_EXT
: return "PARISC_EXT";
2680 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2681 case SHT_PARISC_DOC
: return "PARISC_DOC";
2682 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2683 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2684 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2685 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2693 get_ia64_section_type_name (unsigned int sh_type
)
2695 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2696 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2697 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2701 case SHT_IA_64_EXT
: return "IA_64_EXT";
2702 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2703 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2704 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2705 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2706 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2707 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2708 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2709 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2710 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2718 get_x86_64_section_type_name (unsigned int sh_type
)
2722 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2730 get_arm_section_type_name (unsigned int sh_type
)
2734 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2735 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2736 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2737 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2738 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2746 get_section_type_name (unsigned int sh_type
)
2748 static char buff
[32];
2752 case SHT_NULL
: return "NULL";
2753 case SHT_PROGBITS
: return "PROGBITS";
2754 case SHT_SYMTAB
: return "SYMTAB";
2755 case SHT_STRTAB
: return "STRTAB";
2756 case SHT_RELA
: return "RELA";
2757 case SHT_HASH
: return "HASH";
2758 case SHT_DYNAMIC
: return "DYNAMIC";
2759 case SHT_NOTE
: return "NOTE";
2760 case SHT_NOBITS
: return "NOBITS";
2761 case SHT_REL
: return "REL";
2762 case SHT_SHLIB
: return "SHLIB";
2763 case SHT_DYNSYM
: return "DYNSYM";
2764 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2765 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2766 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2767 case SHT_GNU_HASH
: return "GNU_HASH";
2768 case SHT_GROUP
: return "GROUP";
2769 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2770 case SHT_GNU_verdef
: return "VERDEF";
2771 case SHT_GNU_verneed
: return "VERNEED";
2772 case SHT_GNU_versym
: return "VERSYM";
2773 case 0x6ffffff0: return "VERSYM";
2774 case 0x6ffffffc: return "VERDEF";
2775 case 0x7ffffffd: return "AUXILIARY";
2776 case 0x7fffffff: return "FILTER";
2777 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2780 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2782 const char * result
;
2784 switch (elf_header
.e_machine
)
2787 case EM_MIPS_RS3_LE
:
2788 result
= get_mips_section_type_name (sh_type
);
2791 result
= get_parisc_section_type_name (sh_type
);
2794 result
= get_ia64_section_type_name (sh_type
);
2798 result
= get_x86_64_section_type_name (sh_type
);
2801 result
= get_arm_section_type_name (sh_type
);
2811 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2813 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2815 const char * result
;
2817 switch (elf_header
.e_machine
)
2820 result
= get_ia64_section_type_name (sh_type
);
2830 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2832 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2833 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2835 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2841 #define OPTION_DEBUG_DUMP 512
2843 static struct option options
[] =
2845 {"all", no_argument
, 0, 'a'},
2846 {"file-header", no_argument
, 0, 'h'},
2847 {"program-headers", no_argument
, 0, 'l'},
2848 {"headers", no_argument
, 0, 'e'},
2849 {"histogram", no_argument
, 0, 'I'},
2850 {"segments", no_argument
, 0, 'l'},
2851 {"sections", no_argument
, 0, 'S'},
2852 {"section-headers", no_argument
, 0, 'S'},
2853 {"section-groups", no_argument
, 0, 'g'},
2854 {"section-details", no_argument
, 0, 't'},
2855 {"full-section-name",no_argument
, 0, 'N'},
2856 {"symbols", no_argument
, 0, 's'},
2857 {"syms", no_argument
, 0, 's'},
2858 {"relocs", no_argument
, 0, 'r'},
2859 {"notes", no_argument
, 0, 'n'},
2860 {"dynamic", no_argument
, 0, 'd'},
2861 {"arch-specific", no_argument
, 0, 'A'},
2862 {"version-info", no_argument
, 0, 'V'},
2863 {"use-dynamic", no_argument
, 0, 'D'},
2864 {"unwind", no_argument
, 0, 'u'},
2865 {"archive-index", no_argument
, 0, 'c'},
2866 {"hex-dump", required_argument
, 0, 'x'},
2867 {"relocated-dump", required_argument
, 0, 'R'},
2868 {"string-dump", required_argument
, 0, 'p'},
2869 #ifdef SUPPORT_DISASSEMBLY
2870 {"instruction-dump", required_argument
, 0, 'i'},
2872 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2874 {"version", no_argument
, 0, 'v'},
2875 {"wide", no_argument
, 0, 'W'},
2876 {"help", no_argument
, 0, 'H'},
2877 {0, no_argument
, 0, 0}
2881 usage (FILE * stream
)
2883 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2884 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2885 fprintf (stream
, _(" Options are:\n\
2886 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2887 -h --file-header Display the ELF file header\n\
2888 -l --program-headers Display the program headers\n\
2889 --segments An alias for --program-headers\n\
2890 -S --section-headers Display the sections' header\n\
2891 --sections An alias for --section-headers\n\
2892 -g --section-groups Display the section groups\n\
2893 -t --section-details Display the section details\n\
2894 -e --headers Equivalent to: -h -l -S\n\
2895 -s --syms Display the symbol table\n\
2896 --symbols An alias for --syms\n\
2897 -n --notes Display the core notes (if present)\n\
2898 -r --relocs Display the relocations (if present)\n\
2899 -u --unwind Display the unwind info (if present)\n\
2900 -d --dynamic Display the dynamic section (if present)\n\
2901 -V --version-info Display the version sections (if present)\n\
2902 -A --arch-specific Display architecture specific information (if any).\n\
2903 -c --archive-index Display the symbol/file index in an archive\n\
2904 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2905 -x --hex-dump=<number|name>\n\
2906 Dump the contents of section <number|name> as bytes\n\
2907 -p --string-dump=<number|name>\n\
2908 Dump the contents of section <number|name> as strings\n\
2909 -R --relocated-dump=<number|name>\n\
2910 Dump the contents of section <number|name> as relocated bytes\n\
2911 -w[lLiaprmfFsoR] or\n\
2912 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2913 Display the contents of DWARF2 debug sections\n"));
2914 #ifdef SUPPORT_DISASSEMBLY
2915 fprintf (stream
, _("\
2916 -i --instruction-dump=<number|name>\n\
2917 Disassemble the contents of section <number|name>\n"));
2919 fprintf (stream
, _("\
2920 -I --histogram Display histogram of bucket list lengths\n\
2921 -W --wide Allow output width to exceed 80 characters\n\
2922 @<file> Read options from <file>\n\
2923 -H --help Display this information\n\
2924 -v --version Display the version number of readelf\n"));
2926 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2927 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2929 exit (stream
== stdout
? 0 : 1);
2932 /* Record the fact that the user wants the contents of section number
2933 SECTION to be displayed using the method(s) encoded as flags bits
2934 in TYPE. Note, TYPE can be zero if we are creating the array for
2938 request_dump_bynumber (unsigned int section
, dump_type type
)
2940 if (section
>= num_dump_sects
)
2942 dump_type
* new_dump_sects
;
2944 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2946 if (new_dump_sects
== NULL
)
2947 error (_("Out of memory allocating dump request table.\n"));
2950 /* Copy current flag settings. */
2951 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2955 dump_sects
= new_dump_sects
;
2956 num_dump_sects
= section
+ 1;
2961 dump_sects
[section
] |= type
;
2966 /* Request a dump by section name. */
2969 request_dump_byname (const char * section
, dump_type type
)
2971 struct dump_list_entry
* new_request
;
2973 new_request
= malloc (sizeof (struct dump_list_entry
));
2975 error (_("Out of memory allocating dump request table.\n"));
2977 new_request
->name
= strdup (section
);
2978 if (!new_request
->name
)
2979 error (_("Out of memory allocating dump request table.\n"));
2981 new_request
->type
= type
;
2983 new_request
->next
= dump_sects_byname
;
2984 dump_sects_byname
= new_request
;
2988 request_dump (dump_type type
)
2994 section
= strtoul (optarg
, & cp
, 0);
2996 if (! *cp
&& section
>= 0)
2997 request_dump_bynumber (section
, type
);
2999 request_dump_byname (optarg
, type
);
3004 parse_args (int argc
, char ** argv
)
3011 while ((c
= getopt_long
3012 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3030 do_section_groups
++;
3038 do_section_groups
++;
3043 do_section_details
++;
3087 request_dump (HEX_DUMP
);
3090 request_dump (STRING_DUMP
);
3093 request_dump (RELOC_DUMP
);
3100 dwarf_select_sections_all ();
3105 dwarf_select_sections_by_letters (optarg
);
3108 case OPTION_DEBUG_DUMP
:
3115 dwarf_select_sections_by_names (optarg
);
3118 #ifdef SUPPORT_DISASSEMBLY
3120 request_dump (DISASS_DUMP
);
3124 print_version (program_name
);
3133 /* xgettext:c-format */
3134 error (_("Invalid option '-%c'\n"), c
);
3141 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3142 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3143 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3144 && !do_section_groups
&& !do_archive_index
)
3148 warn (_("Nothing to do.\n"));
3154 get_elf_class (unsigned int elf_class
)
3156 static char buff
[32];
3160 case ELFCLASSNONE
: return _("none");
3161 case ELFCLASS32
: return "ELF32";
3162 case ELFCLASS64
: return "ELF64";
3164 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3170 get_data_encoding (unsigned int encoding
)
3172 static char buff
[32];
3176 case ELFDATANONE
: return _("none");
3177 case ELFDATA2LSB
: return _("2's complement, little endian");
3178 case ELFDATA2MSB
: return _("2's complement, big endian");
3180 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3185 /* Decode the data held in 'elf_header'. */
3188 process_file_header (void)
3190 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3191 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3192 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3193 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3196 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3200 init_dwarf_regnames (elf_header
.e_machine
);
3206 printf (_("ELF Header:\n"));
3207 printf (_(" Magic: "));
3208 for (i
= 0; i
< EI_NIDENT
; i
++)
3209 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3211 printf (_(" Class: %s\n"),
3212 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3213 printf (_(" Data: %s\n"),
3214 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3215 printf (_(" Version: %d %s\n"),
3216 elf_header
.e_ident
[EI_VERSION
],
3217 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3219 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3222 printf (_(" OS/ABI: %s\n"),
3223 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3224 printf (_(" ABI Version: %d\n"),
3225 elf_header
.e_ident
[EI_ABIVERSION
]);
3226 printf (_(" Type: %s\n"),
3227 get_file_type (elf_header
.e_type
));
3228 printf (_(" Machine: %s\n"),
3229 get_machine_name (elf_header
.e_machine
));
3230 printf (_(" Version: 0x%lx\n"),
3231 (unsigned long) elf_header
.e_version
);
3233 printf (_(" Entry point address: "));
3234 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3235 printf (_("\n Start of program headers: "));
3236 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3237 printf (_(" (bytes into file)\n Start of section headers: "));
3238 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3239 printf (_(" (bytes into file)\n"));
3241 printf (_(" Flags: 0x%lx%s\n"),
3242 (unsigned long) elf_header
.e_flags
,
3243 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3244 printf (_(" Size of this header: %ld (bytes)\n"),
3245 (long) elf_header
.e_ehsize
);
3246 printf (_(" Size of program headers: %ld (bytes)\n"),
3247 (long) elf_header
.e_phentsize
);
3248 printf (_(" Number of program headers: %ld\n"),
3249 (long) elf_header
.e_phnum
);
3250 printf (_(" Size of section headers: %ld (bytes)\n"),
3251 (long) elf_header
.e_shentsize
);
3252 printf (_(" Number of section headers: %ld"),
3253 (long) elf_header
.e_shnum
);
3254 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3255 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3256 putc ('\n', stdout
);
3257 printf (_(" Section header string table index: %ld"),
3258 (long) elf_header
.e_shstrndx
);
3259 if (section_headers
!= NULL
3260 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3261 printf (" (%u)", section_headers
[0].sh_link
);
3262 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3263 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3264 printf (" <corrupt: out of range>");
3265 putc ('\n', stdout
);
3268 if (section_headers
!= NULL
)
3270 if (elf_header
.e_shnum
== SHN_UNDEF
)
3271 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3272 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3273 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3274 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3275 elf_header
.e_shstrndx
= SHN_UNDEF
;
3276 free (section_headers
);
3277 section_headers
= NULL
;
3285 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3287 Elf32_External_Phdr
* phdrs
;
3288 Elf32_External_Phdr
* external
;
3289 Elf_Internal_Phdr
* internal
;
3292 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3293 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3294 _("program headers"));
3298 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3299 i
< elf_header
.e_phnum
;
3300 i
++, internal
++, external
++)
3302 internal
->p_type
= BYTE_GET (external
->p_type
);
3303 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3304 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3305 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3306 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3307 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3308 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3309 internal
->p_align
= BYTE_GET (external
->p_align
);
3318 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3320 Elf64_External_Phdr
* phdrs
;
3321 Elf64_External_Phdr
* external
;
3322 Elf_Internal_Phdr
* internal
;
3325 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3326 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3327 _("program headers"));
3331 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3332 i
< elf_header
.e_phnum
;
3333 i
++, internal
++, external
++)
3335 internal
->p_type
= BYTE_GET (external
->p_type
);
3336 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3337 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3338 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3339 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3340 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3341 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3342 internal
->p_align
= BYTE_GET (external
->p_align
);
3350 /* Returns 1 if the program headers were read into `program_headers'. */
3353 get_program_headers (FILE * file
)
3355 Elf_Internal_Phdr
* phdrs
;
3357 /* Check cache of prior read. */
3358 if (program_headers
!= NULL
)
3361 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3365 error (_("Out of memory\n"));
3370 ? get_32bit_program_headers (file
, phdrs
)
3371 : get_64bit_program_headers (file
, phdrs
))
3373 program_headers
= phdrs
;
3381 /* Returns 1 if the program headers were loaded. */
3384 process_program_headers (FILE * file
)
3386 Elf_Internal_Phdr
* segment
;
3389 if (elf_header
.e_phnum
== 0)
3392 printf (_("\nThere are no program headers in this file.\n"));
3396 if (do_segments
&& !do_header
)
3398 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3399 printf (_("Entry point "));
3400 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3401 printf (_("\nThere are %d program headers, starting at offset "),
3402 elf_header
.e_phnum
);
3403 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3407 if (! get_program_headers (file
))
3412 if (elf_header
.e_phnum
> 1)
3413 printf (_("\nProgram Headers:\n"));
3415 printf (_("\nProgram Headers:\n"));
3419 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3422 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3426 (_(" Type Offset VirtAddr PhysAddr\n"));
3428 (_(" FileSiz MemSiz Flags Align\n"));
3435 for (i
= 0, segment
= program_headers
;
3436 i
< elf_header
.e_phnum
;
3441 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3445 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3446 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3447 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3448 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3449 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3451 (segment
->p_flags
& PF_R
? 'R' : ' '),
3452 (segment
->p_flags
& PF_W
? 'W' : ' '),
3453 (segment
->p_flags
& PF_X
? 'E' : ' '));
3454 printf ("%#lx", (unsigned long) segment
->p_align
);
3458 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3459 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3462 print_vma (segment
->p_offset
, FULL_HEX
);
3466 print_vma (segment
->p_vaddr
, FULL_HEX
);
3468 print_vma (segment
->p_paddr
, FULL_HEX
);
3471 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3472 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3475 print_vma (segment
->p_filesz
, FULL_HEX
);
3479 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3480 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3483 print_vma (segment
->p_offset
, FULL_HEX
);
3487 (segment
->p_flags
& PF_R
? 'R' : ' '),
3488 (segment
->p_flags
& PF_W
? 'W' : ' '),
3489 (segment
->p_flags
& PF_X
? 'E' : ' '));
3491 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3492 printf ("%#lx", (unsigned long) segment
->p_align
);
3495 print_vma (segment
->p_align
, PREFIX_HEX
);
3500 print_vma (segment
->p_offset
, FULL_HEX
);
3502 print_vma (segment
->p_vaddr
, FULL_HEX
);
3504 print_vma (segment
->p_paddr
, FULL_HEX
);
3506 print_vma (segment
->p_filesz
, FULL_HEX
);
3508 print_vma (segment
->p_memsz
, FULL_HEX
);
3510 (segment
->p_flags
& PF_R
? 'R' : ' '),
3511 (segment
->p_flags
& PF_W
? 'W' : ' '),
3512 (segment
->p_flags
& PF_X
? 'E' : ' '));
3513 print_vma (segment
->p_align
, HEX
);
3517 switch (segment
->p_type
)
3521 error (_("more than one dynamic segment\n"));
3523 /* By default, assume that the .dynamic section is the first
3524 section in the DYNAMIC segment. */
3525 dynamic_addr
= segment
->p_offset
;
3526 dynamic_size
= segment
->p_filesz
;
3528 /* Try to locate the .dynamic section. If there is
3529 a section header table, we can easily locate it. */
3530 if (section_headers
!= NULL
)
3532 Elf_Internal_Shdr
* sec
;
3534 sec
= find_section (".dynamic");
3535 if (sec
== NULL
|| sec
->sh_size
== 0)
3537 error (_("no .dynamic section in the dynamic segment\n"));
3541 if (sec
->sh_type
== SHT_NOBITS
)
3547 dynamic_addr
= sec
->sh_offset
;
3548 dynamic_size
= sec
->sh_size
;
3550 if (dynamic_addr
< segment
->p_offset
3551 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3552 warn (_("the .dynamic section is not contained"
3553 " within the dynamic segment\n"));
3554 else if (dynamic_addr
> segment
->p_offset
)
3555 warn (_("the .dynamic section is not the first section"
3556 " in the dynamic segment.\n"));
3561 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3563 error (_("Unable to find program interpreter name\n"));
3567 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3569 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3570 error (_("Internal error: failed to create format string to display program interpreter\n"));
3572 program_interpreter
[0] = 0;
3573 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3574 error (_("Unable to read program interpreter name\n"));
3577 printf (_("\n [Requesting program interpreter: %s]"),
3578 program_interpreter
);
3584 putc ('\n', stdout
);
3587 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3589 printf (_("\n Section to Segment mapping:\n"));
3590 printf (_(" Segment Sections...\n"));
3592 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3595 Elf_Internal_Shdr
* section
;
3597 segment
= program_headers
+ i
;
3598 section
= section_headers
+ 1;
3600 printf (" %2.2d ", i
);
3602 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3604 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3605 printf ("%s ", SECTION_NAME (section
));
3616 /* Find the file offset corresponding to VMA by using the program headers. */
3619 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3621 Elf_Internal_Phdr
* seg
;
3623 if (! get_program_headers (file
))
3625 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3629 for (seg
= program_headers
;
3630 seg
< program_headers
+ elf_header
.e_phnum
;
3633 if (seg
->p_type
!= PT_LOAD
)
3636 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3637 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3638 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3641 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3642 (unsigned long) vma
);
3648 get_32bit_section_headers (FILE * file
, unsigned int num
)
3650 Elf32_External_Shdr
* shdrs
;
3651 Elf_Internal_Shdr
* internal
;
3654 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3655 elf_header
.e_shentsize
, num
, _("section headers"));
3659 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3661 if (section_headers
== NULL
)
3663 error (_("Out of memory\n"));
3667 for (i
= 0, internal
= section_headers
;
3671 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3672 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3673 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3674 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3675 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3676 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3677 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3678 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3679 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3680 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3689 get_64bit_section_headers (FILE * file
, unsigned int num
)
3691 Elf64_External_Shdr
* shdrs
;
3692 Elf_Internal_Shdr
* internal
;
3695 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3696 elf_header
.e_shentsize
, num
, _("section headers"));
3700 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3702 if (section_headers
== NULL
)
3704 error (_("Out of memory\n"));
3708 for (i
= 0, internal
= section_headers
;
3712 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3713 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3714 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3715 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3716 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3717 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3718 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3719 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3720 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3721 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3729 static Elf_Internal_Sym
*
3730 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3732 unsigned long number
;
3733 Elf32_External_Sym
* esyms
;
3734 Elf_External_Sym_Shndx
* shndx
;
3735 Elf_Internal_Sym
* isyms
;
3736 Elf_Internal_Sym
* psym
;
3739 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3745 if (symtab_shndx_hdr
!= NULL
3746 && (symtab_shndx_hdr
->sh_link
3747 == (unsigned long) (section
- section_headers
)))
3749 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3750 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3758 number
= section
->sh_size
/ section
->sh_entsize
;
3759 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3763 error (_("Out of memory\n"));
3770 for (j
= 0, psym
= isyms
;
3774 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3775 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3776 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3777 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3778 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3780 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3781 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3782 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3783 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3784 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3794 static Elf_Internal_Sym
*
3795 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3797 unsigned long number
;
3798 Elf64_External_Sym
* esyms
;
3799 Elf_External_Sym_Shndx
* shndx
;
3800 Elf_Internal_Sym
* isyms
;
3801 Elf_Internal_Sym
* psym
;
3804 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3810 if (symtab_shndx_hdr
!= NULL
3811 && (symtab_shndx_hdr
->sh_link
3812 == (unsigned long) (section
- section_headers
)))
3814 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3815 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3823 number
= section
->sh_size
/ section
->sh_entsize
;
3824 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3828 error (_("Out of memory\n"));
3835 for (j
= 0, psym
= isyms
;
3839 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3840 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3841 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3842 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3843 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3845 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3846 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3847 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3848 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3849 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3860 get_elf_section_flags (bfd_vma sh_flags
)
3862 static char buff
[1024];
3864 int field_size
= is_32bit_elf
? 8 : 16;
3865 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3866 bfd_vma os_flags
= 0;
3867 bfd_vma proc_flags
= 0;
3868 bfd_vma unknown_flags
= 0;
3882 { "LINK ORDER", 10 },
3883 { "OS NONCONF", 10 },
3886 /* IA-64 specific. */
3889 /* IA-64 OpenVMS specific. */
3890 { "VMS_GLOBAL", 10 },
3891 { "VMS_OVERLAID", 12 },
3892 { "VMS_SHARED", 10 },
3893 { "VMS_VECTOR", 10 },
3894 { "VMS_ALLOC_64BIT", 15 },
3895 { "VMS_PROTECTED", 13}
3898 if (do_section_details
)
3900 sprintf (buff
, "[%*.*lx]: ",
3901 field_size
, field_size
, (unsigned long) sh_flags
);
3902 p
+= field_size
+ 4;
3909 flag
= sh_flags
& - sh_flags
;
3912 if (do_section_details
)
3916 case SHF_WRITE
: index
= 0; break;
3917 case SHF_ALLOC
: index
= 1; break;
3918 case SHF_EXECINSTR
: index
= 2; break;
3919 case SHF_MERGE
: index
= 3; break;
3920 case SHF_STRINGS
: index
= 4; break;
3921 case SHF_INFO_LINK
: index
= 5; break;
3922 case SHF_LINK_ORDER
: index
= 6; break;
3923 case SHF_OS_NONCONFORMING
: index
= 7; break;
3924 case SHF_GROUP
: index
= 8; break;
3925 case SHF_TLS
: index
= 9; break;
3929 if (elf_header
.e_machine
== EM_IA_64
)
3931 if (flag
== SHF_IA_64_SHORT
)
3933 else if (flag
== SHF_IA_64_NORECOV
)
3936 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3939 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3940 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3941 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3942 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3943 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3944 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3954 if (p
!= buff
+ field_size
+ 4)
3956 if (size
< (10 + 2))
3963 size
-= flags
[index
].len
;
3964 p
= stpcpy (p
, flags
[index
].str
);
3966 else if (flag
& SHF_MASKOS
)
3968 else if (flag
& SHF_MASKPROC
)
3971 unknown_flags
|= flag
;
3977 case SHF_WRITE
: *p
= 'W'; break;
3978 case SHF_ALLOC
: *p
= 'A'; break;
3979 case SHF_EXECINSTR
: *p
= 'X'; break;
3980 case SHF_MERGE
: *p
= 'M'; break;
3981 case SHF_STRINGS
: *p
= 'S'; break;
3982 case SHF_INFO_LINK
: *p
= 'I'; break;
3983 case SHF_LINK_ORDER
: *p
= 'L'; break;
3984 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3985 case SHF_GROUP
: *p
= 'G'; break;
3986 case SHF_TLS
: *p
= 'T'; break;
3989 if ((elf_header
.e_machine
== EM_X86_64
3990 || elf_header
.e_machine
== EM_L1OM
)
3991 && flag
== SHF_X86_64_LARGE
)
3993 else if (flag
& SHF_MASKOS
)
3996 sh_flags
&= ~ SHF_MASKOS
;
3998 else if (flag
& SHF_MASKPROC
)
4001 sh_flags
&= ~ SHF_MASKPROC
;
4011 if (do_section_details
)
4015 size
-= 5 + field_size
;
4016 if (p
!= buff
+ field_size
+ 4)
4024 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4025 (unsigned long) os_flags
);
4026 p
+= 5 + field_size
;
4030 size
-= 7 + field_size
;
4031 if (p
!= buff
+ field_size
+ 4)
4039 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4040 (unsigned long) proc_flags
);
4041 p
+= 7 + field_size
;
4045 size
-= 10 + field_size
;
4046 if (p
!= buff
+ field_size
+ 4)
4054 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4055 (unsigned long) unknown_flags
);
4056 p
+= 10 + field_size
;
4065 process_section_headers (FILE * file
)
4067 Elf_Internal_Shdr
* section
;
4070 section_headers
= NULL
;
4072 if (elf_header
.e_shnum
== 0)
4075 printf (_("\nThere are no sections in this file.\n"));
4080 if (do_sections
&& !do_header
)
4081 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4082 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4086 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4089 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4092 /* Read in the string table, so that we have names to display. */
4093 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4094 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4096 section
= section_headers
+ elf_header
.e_shstrndx
;
4098 if (section
->sh_size
!= 0)
4100 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4101 1, section
->sh_size
, _("string table"));
4103 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4107 /* Scan the sections for the dynamic symbol table
4108 and dynamic string table and debug sections. */
4109 dynamic_symbols
= NULL
;
4110 dynamic_strings
= NULL
;
4111 dynamic_syminfo
= NULL
;
4112 symtab_shndx_hdr
= NULL
;
4114 eh_addr_size
= is_32bit_elf
? 4 : 8;
4115 switch (elf_header
.e_machine
)
4118 case EM_MIPS_RS3_LE
:
4119 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4120 FDE addresses. However, the ABI also has a semi-official ILP32
4121 variant for which the normal FDE address size rules apply.
4123 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4124 section, where XX is the size of longs in bits. Unfortunately,
4125 earlier compilers provided no way of distinguishing ILP32 objects
4126 from LP64 objects, so if there's any doubt, we should assume that
4127 the official LP64 form is being used. */
4128 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4129 && find_section (".gcc_compiled_long32") == NULL
)
4135 switch (elf_header
.e_flags
& EF_H8_MACH
)
4137 case E_H8_MACH_H8300
:
4138 case E_H8_MACH_H8300HN
:
4139 case E_H8_MACH_H8300SN
:
4140 case E_H8_MACH_H8300SXN
:
4143 case E_H8_MACH_H8300H
:
4144 case E_H8_MACH_H8300S
:
4145 case E_H8_MACH_H8300SX
:
4153 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4155 case EF_M32C_CPU_M16C
:
4162 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4165 size_t expected_entsize \
4166 = is_32bit_elf ? size32 : size64; \
4167 if (section->sh_entsize != expected_entsize) \
4168 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4169 i, (unsigned long int) section->sh_entsize, \
4170 (unsigned long int) expected_entsize); \
4171 section->sh_entsize = expected_entsize; \
4174 #define CHECK_ENTSIZE(section, i, type) \
4175 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4176 sizeof (Elf64_External_##type))
4178 for (i
= 0, section
= section_headers
;
4179 i
< elf_header
.e_shnum
;
4182 char * name
= SECTION_NAME (section
);
4184 if (section
->sh_type
== SHT_DYNSYM
)
4186 if (dynamic_symbols
!= NULL
)
4188 error (_("File contains multiple dynamic symbol tables\n"));
4192 CHECK_ENTSIZE (section
, i
, Sym
);
4193 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4194 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4196 else if (section
->sh_type
== SHT_STRTAB
4197 && streq (name
, ".dynstr"))
4199 if (dynamic_strings
!= NULL
)
4201 error (_("File contains multiple dynamic string tables\n"));
4205 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4206 1, section
->sh_size
, _("dynamic strings"));
4207 dynamic_strings_length
= section
->sh_size
;
4209 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4211 if (symtab_shndx_hdr
!= NULL
)
4213 error (_("File contains multiple symtab shndx tables\n"));
4216 symtab_shndx_hdr
= section
;
4218 else if (section
->sh_type
== SHT_SYMTAB
)
4219 CHECK_ENTSIZE (section
, i
, Sym
);
4220 else if (section
->sh_type
== SHT_GROUP
)
4221 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4222 else if (section
->sh_type
== SHT_REL
)
4223 CHECK_ENTSIZE (section
, i
, Rel
);
4224 else if (section
->sh_type
== SHT_RELA
)
4225 CHECK_ENTSIZE (section
, i
, Rela
);
4226 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4227 || do_debug_lines
|| do_debug_pubnames
4228 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4229 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4230 && (const_strneq (name
, ".debug_")
4231 || const_strneq (name
, ".zdebug_")))
4234 name
+= sizeof (".zdebug_") - 1;
4236 name
+= sizeof (".debug_") - 1;
4239 || (do_debug_info
&& streq (name
, "info"))
4240 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4241 || (do_debug_lines
&& streq (name
, "line"))
4242 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4243 || (do_debug_aranges
&& streq (name
, "aranges"))
4244 || (do_debug_ranges
&& streq (name
, "ranges"))
4245 || (do_debug_frames
&& streq (name
, "frame"))
4246 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4247 || (do_debug_str
&& streq (name
, "str"))
4248 || (do_debug_loc
&& streq (name
, "loc"))
4250 request_dump_bynumber (i
, DEBUG_DUMP
);
4252 /* Linkonce section to be combined with .debug_info at link time. */
4253 else if ((do_debugging
|| do_debug_info
)
4254 && const_strneq (name
, ".gnu.linkonce.wi."))
4255 request_dump_bynumber (i
, DEBUG_DUMP
);
4256 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4257 request_dump_bynumber (i
, DEBUG_DUMP
);
4263 if (elf_header
.e_shnum
> 1)
4264 printf (_("\nSection Headers:\n"));
4266 printf (_("\nSection Header:\n"));
4270 if (do_section_details
)
4272 printf (_(" [Nr] Name\n"));
4273 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4277 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4281 if (do_section_details
)
4283 printf (_(" [Nr] Name\n"));
4284 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4288 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4292 if (do_section_details
)
4294 printf (_(" [Nr] Name\n"));
4295 printf (_(" Type Address Offset Link\n"));
4296 printf (_(" Size EntSize Info Align\n"));
4300 printf (_(" [Nr] Name Type Address Offset\n"));
4301 printf (_(" Size EntSize Flags Link Info Align\n"));
4305 if (do_section_details
)
4306 printf (_(" Flags\n"));
4308 for (i
= 0, section
= section_headers
;
4309 i
< elf_header
.e_shnum
;
4312 if (do_section_details
)
4314 printf (" [%2u] %s\n",
4316 SECTION_NAME (section
));
4317 if (is_32bit_elf
|| do_wide
)
4318 printf (" %-15.15s ",
4319 get_section_type_name (section
->sh_type
));
4322 printf ((do_wide
? " [%2u] %-17s %-15s "
4323 : " [%2u] %-17.17s %-15.15s "),
4325 SECTION_NAME (section
),
4326 get_section_type_name (section
->sh_type
));
4330 print_vma (section
->sh_addr
, LONG_HEX
);
4332 printf ( " %6.6lx %6.6lx %2.2lx",
4333 (unsigned long) section
->sh_offset
,
4334 (unsigned long) section
->sh_size
,
4335 (unsigned long) section
->sh_entsize
);
4337 if (do_section_details
)
4338 fputs (" ", stdout
);
4340 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4342 printf ("%2u %3u %2lu\n",
4345 (unsigned long) section
->sh_addralign
);
4349 print_vma (section
->sh_addr
, LONG_HEX
);
4351 if ((long) section
->sh_offset
== section
->sh_offset
)
4352 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4356 print_vma (section
->sh_offset
, LONG_HEX
);
4359 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4360 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4364 print_vma (section
->sh_size
, LONG_HEX
);
4367 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4368 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4372 print_vma (section
->sh_entsize
, LONG_HEX
);
4375 if (do_section_details
)
4376 fputs (" ", stdout
);
4378 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4380 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4382 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4383 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4386 print_vma (section
->sh_addralign
, DEC
);
4390 else if (do_section_details
)
4392 printf (" %-15.15s ",
4393 get_section_type_name (section
->sh_type
));
4394 print_vma (section
->sh_addr
, LONG_HEX
);
4395 if ((long) section
->sh_offset
== section
->sh_offset
)
4396 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4400 print_vma (section
->sh_offset
, LONG_HEX
);
4402 printf (" %u\n ", section
->sh_link
);
4403 print_vma (section
->sh_size
, LONG_HEX
);
4405 print_vma (section
->sh_entsize
, LONG_HEX
);
4407 printf (" %-16u %lu\n",
4409 (unsigned long) section
->sh_addralign
);
4414 print_vma (section
->sh_addr
, LONG_HEX
);
4415 if ((long) section
->sh_offset
== section
->sh_offset
)
4416 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4420 print_vma (section
->sh_offset
, LONG_HEX
);
4423 print_vma (section
->sh_size
, LONG_HEX
);
4425 print_vma (section
->sh_entsize
, LONG_HEX
);
4427 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4429 printf (" %2u %3u %lu\n",
4432 (unsigned long) section
->sh_addralign
);
4435 if (do_section_details
)
4436 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4439 if (!do_section_details
)
4440 printf (_("Key to Flags:\n\
4441 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4442 I (info), L (link order), G (group), x (unknown)\n\
4443 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4449 get_group_flags (unsigned int flags
)
4451 static char buff
[32];
4458 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4465 process_section_groups (FILE * file
)
4467 Elf_Internal_Shdr
* section
;
4469 struct group
* group
;
4470 Elf_Internal_Shdr
* symtab_sec
;
4471 Elf_Internal_Shdr
* strtab_sec
;
4472 Elf_Internal_Sym
* symtab
;
4476 /* Don't process section groups unless needed. */
4477 if (!do_unwind
&& !do_section_groups
)
4480 if (elf_header
.e_shnum
== 0)
4482 if (do_section_groups
)
4483 printf (_("\nThere are no sections in this file.\n"));
4488 if (section_headers
== NULL
)
4490 error (_("Section headers are not available!\n"));
4494 section_headers_groups
= calloc (elf_header
.e_shnum
,
4495 sizeof (struct group
*));
4497 if (section_headers_groups
== NULL
)
4499 error (_("Out of memory\n"));
4503 /* Scan the sections for the group section. */
4505 for (i
= 0, section
= section_headers
;
4506 i
< elf_header
.e_shnum
;
4508 if (section
->sh_type
== SHT_GROUP
)
4511 if (group_count
== 0)
4513 if (do_section_groups
)
4514 printf (_("\nThere are no section groups in this file.\n"));
4519 section_groups
= calloc (group_count
, sizeof (struct group
));
4521 if (section_groups
== NULL
)
4523 error (_("Out of memory\n"));
4532 for (i
= 0, section
= section_headers
, group
= section_groups
;
4533 i
< elf_header
.e_shnum
;
4536 if (section
->sh_type
== SHT_GROUP
)
4538 char * name
= SECTION_NAME (section
);
4540 unsigned char * start
;
4541 unsigned char * indices
;
4542 unsigned int entry
, j
, size
;
4543 Elf_Internal_Shdr
* sec
;
4544 Elf_Internal_Sym
* sym
;
4546 /* Get the symbol table. */
4547 if (section
->sh_link
>= elf_header
.e_shnum
4548 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4551 error (_("Bad sh_link in group section `%s'\n"), name
);
4555 if (symtab_sec
!= sec
)
4560 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4563 sym
= symtab
+ section
->sh_info
;
4565 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4567 if (sym
->st_shndx
== 0
4568 || sym
->st_shndx
>= elf_header
.e_shnum
)
4570 error (_("Bad sh_info in group section `%s'\n"), name
);
4574 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4583 /* Get the string table. */
4584 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4593 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4598 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4599 1, strtab_sec
->sh_size
,
4601 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4603 group_name
= sym
->st_name
< strtab_size
4604 ? strtab
+ sym
->st_name
: "<corrupt>";
4607 start
= get_data (NULL
, file
, section
->sh_offset
,
4608 1, section
->sh_size
, _("section data"));
4611 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4612 entry
= byte_get (indices
, 4);
4615 if (do_section_groups
)
4617 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4618 get_group_flags (entry
), i
, name
, group_name
, size
);
4620 printf (_(" [Index] Name\n"));
4623 group
->group_index
= i
;
4625 for (j
= 0; j
< size
; j
++)
4627 struct group_list
* g
;
4629 entry
= byte_get (indices
, 4);
4632 if (entry
>= elf_header
.e_shnum
)
4634 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4635 entry
, i
, elf_header
.e_shnum
- 1);
4639 if (section_headers_groups
[entry
] != NULL
)
4643 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4645 section_headers_groups
[entry
]->group_index
);
4650 /* Intel C/C++ compiler may put section 0 in a
4651 section group. We just warn it the first time
4652 and ignore it afterwards. */
4653 static int warned
= 0;
4656 error (_("section 0 in group section [%5u]\n"),
4657 section_headers_groups
[entry
]->group_index
);
4663 section_headers_groups
[entry
] = group
;
4665 if (do_section_groups
)
4667 sec
= section_headers
+ entry
;
4668 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4671 g
= xmalloc (sizeof (struct group_list
));
4672 g
->section_index
= entry
;
4673 g
->next
= group
->root
;
4697 } dynamic_relocations
[] =
4699 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4700 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4701 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4704 /* Process the reloc section. */
4707 process_relocs (FILE * file
)
4709 unsigned long rel_size
;
4710 unsigned long rel_offset
;
4716 if (do_using_dynamic
)
4720 int has_dynamic_reloc
;
4723 has_dynamic_reloc
= 0;
4725 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4727 is_rela
= dynamic_relocations
[i
].rela
;
4728 name
= dynamic_relocations
[i
].name
;
4729 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4730 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4732 has_dynamic_reloc
|= rel_size
;
4734 if (is_rela
== UNKNOWN
)
4736 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4737 switch (dynamic_info
[DT_PLTREL
])
4751 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4752 name
, rel_offset
, rel_size
);
4754 dump_relocations (file
,
4755 offset_from_vma (file
, rel_offset
, rel_size
),
4757 dynamic_symbols
, num_dynamic_syms
,
4758 dynamic_strings
, dynamic_strings_length
, is_rela
);
4762 if (! has_dynamic_reloc
)
4763 printf (_("\nThere are no dynamic relocations in this file.\n"));
4767 Elf_Internal_Shdr
* section
;
4771 for (i
= 0, section
= section_headers
;
4772 i
< elf_header
.e_shnum
;
4775 if ( section
->sh_type
!= SHT_RELA
4776 && section
->sh_type
!= SHT_REL
)
4779 rel_offset
= section
->sh_offset
;
4780 rel_size
= section
->sh_size
;
4784 Elf_Internal_Shdr
* strsec
;
4787 printf (_("\nRelocation section "));
4789 if (string_table
== NULL
)
4790 printf ("%d", section
->sh_name
);
4792 printf (_("'%s'"), SECTION_NAME (section
));
4794 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4795 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4797 is_rela
= section
->sh_type
== SHT_RELA
;
4799 if (section
->sh_link
!= 0
4800 && section
->sh_link
< elf_header
.e_shnum
)
4802 Elf_Internal_Shdr
* symsec
;
4803 Elf_Internal_Sym
* symtab
;
4804 unsigned long nsyms
;
4805 unsigned long strtablen
= 0;
4806 char * strtab
= NULL
;
4808 symsec
= section_headers
+ section
->sh_link
;
4809 if (symsec
->sh_type
!= SHT_SYMTAB
4810 && symsec
->sh_type
!= SHT_DYNSYM
)
4813 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4814 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4819 if (symsec
->sh_link
!= 0
4820 && symsec
->sh_link
< elf_header
.e_shnum
)
4822 strsec
= section_headers
+ symsec
->sh_link
;
4824 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4827 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4830 dump_relocations (file
, rel_offset
, rel_size
,
4831 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4837 dump_relocations (file
, rel_offset
, rel_size
,
4838 NULL
, 0, NULL
, 0, is_rela
);
4845 printf (_("\nThere are no relocations in this file.\n"));
4851 /* Process the unwind section. */
4853 #include "unwind-ia64.h"
4855 /* An absolute address consists of a section and an offset. If the
4856 section is NULL, the offset itself is the address, otherwise, the
4857 address equals to LOAD_ADDRESS(section) + offset. */
4861 unsigned short section
;
4865 #define ABSADDR(a) \
4867 ? section_headers [(a).section].sh_addr + (a).offset \
4870 struct ia64_unw_aux_info
4872 struct ia64_unw_table_entry
4874 struct absaddr start
;
4876 struct absaddr info
;
4878 *table
; /* Unwind table. */
4879 unsigned long table_len
; /* Length of unwind table. */
4880 unsigned char * info
; /* Unwind info. */
4881 unsigned long info_size
; /* Size of unwind info. */
4882 bfd_vma info_addr
; /* starting address of unwind info. */
4883 bfd_vma seg_base
; /* Starting address of segment. */
4884 Elf_Internal_Sym
* symtab
; /* The symbol table. */
4885 unsigned long nsyms
; /* Number of symbols. */
4886 char * strtab
; /* The string table. */
4887 unsigned long strtab_size
; /* Size of string table. */
4891 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
4892 unsigned long nsyms
,
4893 const char * strtab
,
4894 unsigned long strtab_size
,
4895 struct absaddr addr
,
4896 const char ** symname
,
4899 bfd_vma dist
= 0x100000;
4900 Elf_Internal_Sym
* sym
;
4901 Elf_Internal_Sym
* best
= NULL
;
4904 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4906 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4907 && sym
->st_name
!= 0
4908 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4909 && addr
.offset
>= sym
->st_value
4910 && addr
.offset
- sym
->st_value
< dist
)
4913 dist
= addr
.offset
- sym
->st_value
;
4920 *symname
= (best
->st_name
>= strtab_size
4921 ? "<corrupt>" : strtab
+ best
->st_name
);
4926 *offset
= addr
.offset
;
4930 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
4932 struct ia64_unw_table_entry
* tp
;
4935 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4939 const unsigned char * dp
;
4940 const unsigned char * head
;
4941 const char * procname
;
4943 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4944 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4946 fputs ("\n<", stdout
);
4950 fputs (procname
, stdout
);
4953 printf ("+%lx", (unsigned long) offset
);
4956 fputs (">: [", stdout
);
4957 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4958 fputc ('-', stdout
);
4959 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4960 printf ("], info at +0x%lx\n",
4961 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4963 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4964 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4966 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4967 (unsigned) UNW_VER (stamp
),
4968 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4969 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4970 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4971 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4973 if (UNW_VER (stamp
) != 1)
4975 printf ("\tUnknown version.\n");
4980 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4981 dp
= unw_decode (dp
, in_body
, & in_body
);
4986 slurp_ia64_unwind_table (FILE * file
,
4987 struct ia64_unw_aux_info
* aux
,
4988 Elf_Internal_Shdr
* sec
)
4990 unsigned long size
, nrelas
, i
;
4991 Elf_Internal_Phdr
* seg
;
4992 struct ia64_unw_table_entry
* tep
;
4993 Elf_Internal_Shdr
* relsec
;
4994 Elf_Internal_Rela
* rela
;
4995 Elf_Internal_Rela
* rp
;
4996 unsigned char * table
;
4998 Elf_Internal_Sym
* sym
;
4999 const char * relname
;
5001 /* First, find the starting address of the segment that includes
5004 if (elf_header
.e_phnum
)
5006 if (! get_program_headers (file
))
5009 for (seg
= program_headers
;
5010 seg
< program_headers
+ elf_header
.e_phnum
;
5013 if (seg
->p_type
!= PT_LOAD
)
5016 if (sec
->sh_addr
>= seg
->p_vaddr
5017 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5019 aux
->seg_base
= seg
->p_vaddr
;
5025 /* Second, build the unwind table from the contents of the unwind section: */
5026 size
= sec
->sh_size
;
5027 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5031 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5033 for (tp
= table
; tp
< table
+ size
; ++tep
)
5035 tep
->start
.section
= SHN_UNDEF
;
5036 tep
->end
.section
= SHN_UNDEF
;
5037 tep
->info
.section
= SHN_UNDEF
;
5038 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5039 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5040 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5041 tep
->start
.offset
+= aux
->seg_base
;
5042 tep
->end
.offset
+= aux
->seg_base
;
5043 tep
->info
.offset
+= aux
->seg_base
;
5047 /* Third, apply any relocations to the unwind table: */
5048 for (relsec
= section_headers
;
5049 relsec
< section_headers
+ elf_header
.e_shnum
;
5052 if (relsec
->sh_type
!= SHT_RELA
5053 || relsec
->sh_info
>= elf_header
.e_shnum
5054 || section_headers
+ relsec
->sh_info
!= sec
)
5057 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5061 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5063 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5064 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5066 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5068 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5072 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5074 switch (rp
->r_offset
/eh_addr_size
% 3)
5077 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5078 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5081 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5082 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5085 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5086 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5096 aux
->table_len
= size
/ (3 * eh_addr_size
);
5101 ia64_process_unwind (FILE * file
)
5103 Elf_Internal_Shdr
* sec
;
5104 Elf_Internal_Shdr
* unwsec
= NULL
;
5105 Elf_Internal_Shdr
* strsec
;
5106 unsigned long i
, unwcount
= 0, unwstart
= 0;
5107 struct ia64_unw_aux_info aux
;
5109 memset (& aux
, 0, sizeof (aux
));
5111 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5113 if (sec
->sh_type
== SHT_SYMTAB
5114 && sec
->sh_link
< elf_header
.e_shnum
)
5116 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5117 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5119 strsec
= section_headers
+ sec
->sh_link
;
5120 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5121 1, strsec
->sh_size
, _("string table"));
5122 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5124 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5129 printf (_("\nThere are no unwind sections in this file.\n"));
5131 while (unwcount
-- > 0)
5136 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5137 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5138 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5145 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5147 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5149 /* We need to find which section group it is in. */
5150 struct group_list
* g
= section_headers_groups
[i
]->root
;
5152 for (; g
!= NULL
; g
= g
->next
)
5154 sec
= section_headers
+ g
->section_index
;
5156 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5161 i
= elf_header
.e_shnum
;
5163 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5165 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5166 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5167 suffix
= SECTION_NAME (unwsec
) + len
;
5168 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5170 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5171 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5176 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5177 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5178 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5179 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5181 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5182 suffix
= SECTION_NAME (unwsec
) + len
;
5183 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5185 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5186 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5190 if (i
== elf_header
.e_shnum
)
5192 printf (_("\nCould not find unwind info section for "));
5194 if (string_table
== NULL
)
5195 printf ("%d", unwsec
->sh_name
);
5197 printf (_("'%s'"), SECTION_NAME (unwsec
));
5201 aux
.info_size
= sec
->sh_size
;
5202 aux
.info_addr
= sec
->sh_addr
;
5203 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5206 printf (_("\nUnwind section "));
5208 if (string_table
== NULL
)
5209 printf ("%d", unwsec
->sh_name
);
5211 printf (_("'%s'"), SECTION_NAME (unwsec
));
5213 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5214 (unsigned long) unwsec
->sh_offset
,
5215 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5217 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5219 if (aux
.table_len
> 0)
5220 dump_ia64_unwind (& aux
);
5223 free ((char *) aux
.table
);
5225 free ((char *) aux
.info
);
5234 free ((char *) aux
.strtab
);
5239 struct hppa_unw_aux_info
5241 struct hppa_unw_table_entry
5243 struct absaddr start
;
5245 unsigned int Cannot_unwind
:1; /* 0 */
5246 unsigned int Millicode
:1; /* 1 */
5247 unsigned int Millicode_save_sr0
:1; /* 2 */
5248 unsigned int Region_description
:2; /* 3..4 */
5249 unsigned int reserved1
:1; /* 5 */
5250 unsigned int Entry_SR
:1; /* 6 */
5251 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5252 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5253 unsigned int Args_stored
:1; /* 16 */
5254 unsigned int Variable_Frame
:1; /* 17 */
5255 unsigned int Separate_Package_Body
:1; /* 18 */
5256 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5257 unsigned int Stack_Overflow_Check
:1; /* 20 */
5258 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5259 unsigned int Ada_Region
:1; /* 22 */
5260 unsigned int cxx_info
:1; /* 23 */
5261 unsigned int cxx_try_catch
:1; /* 24 */
5262 unsigned int sched_entry_seq
:1; /* 25 */
5263 unsigned int reserved2
:1; /* 26 */
5264 unsigned int Save_SP
:1; /* 27 */
5265 unsigned int Save_RP
:1; /* 28 */
5266 unsigned int Save_MRP_in_frame
:1; /* 29 */
5267 unsigned int extn_ptr_defined
:1; /* 30 */
5268 unsigned int Cleanup_defined
:1; /* 31 */
5270 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5271 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5272 unsigned int Large_frame
:1; /* 2 */
5273 unsigned int Pseudo_SP_Set
:1; /* 3 */
5274 unsigned int reserved4
:1; /* 4 */
5275 unsigned int Total_frame_size
:27; /* 5..31 */
5277 *table
; /* Unwind table. */
5278 unsigned long table_len
; /* Length of unwind table. */
5279 bfd_vma seg_base
; /* Starting address of segment. */
5280 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5281 unsigned long nsyms
; /* Number of symbols. */
5282 char * strtab
; /* The string table. */
5283 unsigned long strtab_size
; /* Size of string table. */
5287 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5289 struct hppa_unw_table_entry
* tp
;
5291 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5294 const char * procname
;
5296 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5297 aux
->strtab_size
, tp
->start
, &procname
,
5300 fputs ("\n<", stdout
);
5304 fputs (procname
, stdout
);
5307 printf ("+%lx", (unsigned long) offset
);
5310 fputs (">: [", stdout
);
5311 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5312 fputc ('-', stdout
);
5313 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5316 #define PF(_m) if (tp->_m) printf (#_m " ");
5317 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5320 PF(Millicode_save_sr0
);
5321 /* PV(Region_description); */
5327 PF(Separate_Package_Body
);
5328 PF(Frame_Extension_Millicode
);
5329 PF(Stack_Overflow_Check
);
5330 PF(Two_Instruction_SP_Increment
);
5334 PF(sched_entry_seq
);
5337 PF(Save_MRP_in_frame
);
5338 PF(extn_ptr_defined
);
5339 PF(Cleanup_defined
);
5340 PF(MPE_XL_interrupt_marker
);
5341 PF(HP_UX_interrupt_marker
);
5344 PV(Total_frame_size
);
5353 slurp_hppa_unwind_table (FILE * file
,
5354 struct hppa_unw_aux_info
* aux
,
5355 Elf_Internal_Shdr
* sec
)
5357 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5358 Elf_Internal_Phdr
* seg
;
5359 struct hppa_unw_table_entry
* tep
;
5360 Elf_Internal_Shdr
* relsec
;
5361 Elf_Internal_Rela
* rela
;
5362 Elf_Internal_Rela
* rp
;
5363 unsigned char * table
;
5365 Elf_Internal_Sym
* sym
;
5366 const char * relname
;
5368 /* First, find the starting address of the segment that includes
5371 if (elf_header
.e_phnum
)
5373 if (! get_program_headers (file
))
5376 for (seg
= program_headers
;
5377 seg
< program_headers
+ elf_header
.e_phnum
;
5380 if (seg
->p_type
!= PT_LOAD
)
5383 if (sec
->sh_addr
>= seg
->p_vaddr
5384 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5386 aux
->seg_base
= seg
->p_vaddr
;
5392 /* Second, build the unwind table from the contents of the unwind
5394 size
= sec
->sh_size
;
5395 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5400 nentries
= size
/ unw_ent_size
;
5401 size
= unw_ent_size
* nentries
;
5403 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5405 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5407 unsigned int tmp1
, tmp2
;
5409 tep
->start
.section
= SHN_UNDEF
;
5410 tep
->end
.section
= SHN_UNDEF
;
5412 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5413 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5414 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5415 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5417 tep
->start
.offset
+= aux
->seg_base
;
5418 tep
->end
.offset
+= aux
->seg_base
;
5420 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5421 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5422 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5423 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5424 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5425 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5426 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5427 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5428 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5429 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5430 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5431 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5432 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5433 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5434 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5435 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5436 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5437 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5438 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5439 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5440 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5441 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5442 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5443 tep
->Cleanup_defined
= tmp1
& 0x1;
5445 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5446 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5447 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5448 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5449 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5450 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5454 /* Third, apply any relocations to the unwind table. */
5455 for (relsec
= section_headers
;
5456 relsec
< section_headers
+ elf_header
.e_shnum
;
5459 if (relsec
->sh_type
!= SHT_RELA
5460 || relsec
->sh_info
>= elf_header
.e_shnum
5461 || section_headers
+ relsec
->sh_info
!= sec
)
5464 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5468 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5470 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5471 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5473 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5474 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5476 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5480 i
= rp
->r_offset
/ unw_ent_size
;
5482 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5485 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5486 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5489 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5490 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5500 aux
->table_len
= nentries
;
5506 hppa_process_unwind (FILE * file
)
5508 struct hppa_unw_aux_info aux
;
5509 Elf_Internal_Shdr
* unwsec
= NULL
;
5510 Elf_Internal_Shdr
* strsec
;
5511 Elf_Internal_Shdr
* sec
;
5514 memset (& aux
, 0, sizeof (aux
));
5516 if (string_table
== NULL
)
5519 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5521 if (sec
->sh_type
== SHT_SYMTAB
5522 && sec
->sh_link
< elf_header
.e_shnum
)
5524 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5525 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5527 strsec
= section_headers
+ sec
->sh_link
;
5528 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5529 1, strsec
->sh_size
, _("string table"));
5530 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5532 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5537 printf (_("\nThere are no unwind sections in this file.\n"));
5539 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5541 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5543 printf (_("\nUnwind section "));
5544 printf (_("'%s'"), SECTION_NAME (sec
));
5546 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5547 (unsigned long) sec
->sh_offset
,
5548 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5550 slurp_hppa_unwind_table (file
, &aux
, sec
);
5551 if (aux
.table_len
> 0)
5552 dump_hppa_unwind (&aux
);
5555 free ((char *) aux
.table
);
5563 free ((char *) aux
.strtab
);
5569 process_unwind (FILE * file
)
5571 struct unwind_handler
5574 int (* handler
)(FILE *);
5577 { EM_IA_64
, ia64_process_unwind
},
5578 { EM_PARISC
, hppa_process_unwind
},
5586 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5587 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5588 return handlers
[i
].handler (file
);
5590 printf (_("\nThere are no unwind sections in this file.\n"));
5595 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5597 switch (entry
->d_tag
)
5600 if (entry
->d_un
.d_val
== 0)
5604 static const char * opts
[] =
5606 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5607 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5608 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5609 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5614 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5615 if (entry
->d_un
.d_val
& (1 << cnt
))
5617 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5624 case DT_MIPS_IVERSION
:
5625 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5626 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5628 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5631 case DT_MIPS_TIME_STAMP
:
5636 time_t time
= entry
->d_un
.d_val
;
5637 tmp
= gmtime (&time
);
5638 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5639 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5640 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5641 printf ("Time Stamp: %s\n", timebuf
);
5645 case DT_MIPS_RLD_VERSION
:
5646 case DT_MIPS_LOCAL_GOTNO
:
5647 case DT_MIPS_CONFLICTNO
:
5648 case DT_MIPS_LIBLISTNO
:
5649 case DT_MIPS_SYMTABNO
:
5650 case DT_MIPS_UNREFEXTNO
:
5651 case DT_MIPS_HIPAGENO
:
5652 case DT_MIPS_DELTA_CLASS_NO
:
5653 case DT_MIPS_DELTA_INSTANCE_NO
:
5654 case DT_MIPS_DELTA_RELOC_NO
:
5655 case DT_MIPS_DELTA_SYM_NO
:
5656 case DT_MIPS_DELTA_CLASSSYM_NO
:
5657 case DT_MIPS_COMPACT_SIZE
:
5658 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5662 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5668 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5670 switch (entry
->d_tag
)
5672 case DT_HP_DLD_FLAGS
:
5681 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5682 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5683 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5684 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5685 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5686 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5687 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5688 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5689 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5690 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5691 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5692 { DT_HP_GST
, "HP_GST" },
5693 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5694 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5695 { DT_HP_NODELETE
, "HP_NODELETE" },
5696 { DT_HP_GROUP
, "HP_GROUP" },
5697 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5701 bfd_vma val
= entry
->d_un
.d_val
;
5703 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5704 if (val
& flags
[cnt
].bit
)
5708 fputs (flags
[cnt
].str
, stdout
);
5710 val
^= flags
[cnt
].bit
;
5713 if (val
!= 0 || first
)
5717 print_vma (val
, HEX
);
5723 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5730 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5732 switch (entry
->d_tag
)
5734 case DT_IA_64_PLT_RESERVE
:
5735 /* First 3 slots reserved. */
5736 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5738 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5742 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5749 get_32bit_dynamic_section (FILE * file
)
5751 Elf32_External_Dyn
* edyn
;
5752 Elf32_External_Dyn
* ext
;
5753 Elf_Internal_Dyn
* entry
;
5755 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5756 _("dynamic section"));
5760 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5761 might not have the luxury of section headers. Look for the DT_NULL
5762 terminator to determine the number of entries. */
5763 for (ext
= edyn
, dynamic_nent
= 0;
5764 (char *) ext
< (char *) edyn
+ dynamic_size
;
5768 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5772 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5773 if (dynamic_section
== NULL
)
5775 error (_("Out of memory\n"));
5780 for (ext
= edyn
, entry
= dynamic_section
;
5781 entry
< dynamic_section
+ dynamic_nent
;
5784 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5785 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5794 get_64bit_dynamic_section (FILE * file
)
5796 Elf64_External_Dyn
* edyn
;
5797 Elf64_External_Dyn
* ext
;
5798 Elf_Internal_Dyn
* entry
;
5800 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5801 _("dynamic section"));
5805 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5806 might not have the luxury of section headers. Look for the DT_NULL
5807 terminator to determine the number of entries. */
5808 for (ext
= edyn
, dynamic_nent
= 0;
5809 (char *) ext
< (char *) edyn
+ dynamic_size
;
5813 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5817 dynamic_section
= cmalloc (dynamic_nent
, sizeof (* entry
));
5818 if (dynamic_section
== NULL
)
5820 error (_("Out of memory\n"));
5825 for (ext
= edyn
, entry
= dynamic_section
;
5826 entry
< dynamic_section
+ dynamic_nent
;
5829 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5830 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5839 print_dynamic_flags (bfd_vma flags
)
5847 flag
= flags
& - flags
;
5857 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5858 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5859 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5860 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5861 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5862 default: fputs ("unknown", stdout
); break;
5868 /* Parse and display the contents of the dynamic section. */
5871 process_dynamic_section (FILE * file
)
5873 Elf_Internal_Dyn
* entry
;
5875 if (dynamic_size
== 0)
5878 printf (_("\nThere is no dynamic section in this file.\n"));
5885 if (! get_32bit_dynamic_section (file
))
5888 else if (! get_64bit_dynamic_section (file
))
5891 /* Find the appropriate symbol table. */
5892 if (dynamic_symbols
== NULL
)
5894 for (entry
= dynamic_section
;
5895 entry
< dynamic_section
+ dynamic_nent
;
5898 Elf_Internal_Shdr section
;
5900 if (entry
->d_tag
!= DT_SYMTAB
)
5903 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5905 /* Since we do not know how big the symbol table is,
5906 we default to reading in the entire file (!) and
5907 processing that. This is overkill, I know, but it
5909 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5911 if (archive_file_offset
!= 0)
5912 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5915 if (fseek (file
, 0, SEEK_END
))
5916 error (_("Unable to seek to end of file!\n"));
5918 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5922 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5924 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5926 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5927 if (num_dynamic_syms
< 1)
5929 error (_("Unable to determine the number of symbols to load\n"));
5933 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5937 /* Similarly find a string table. */
5938 if (dynamic_strings
== NULL
)
5940 for (entry
= dynamic_section
;
5941 entry
< dynamic_section
+ dynamic_nent
;
5944 unsigned long offset
;
5947 if (entry
->d_tag
!= DT_STRTAB
)
5950 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5952 /* Since we do not know how big the string table is,
5953 we default to reading in the entire file (!) and
5954 processing that. This is overkill, I know, but it
5957 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5959 if (archive_file_offset
!= 0)
5960 str_tab_len
= archive_file_size
- offset
;
5963 if (fseek (file
, 0, SEEK_END
))
5964 error (_("Unable to seek to end of file\n"));
5965 str_tab_len
= ftell (file
) - offset
;
5968 if (str_tab_len
< 1)
5971 (_("Unable to determine the length of the dynamic string table\n"));
5975 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5976 _("dynamic string table"));
5977 dynamic_strings_length
= str_tab_len
;
5982 /* And find the syminfo section if available. */
5983 if (dynamic_syminfo
== NULL
)
5985 unsigned long syminsz
= 0;
5987 for (entry
= dynamic_section
;
5988 entry
< dynamic_section
+ dynamic_nent
;
5991 if (entry
->d_tag
== DT_SYMINENT
)
5993 /* Note: these braces are necessary to avoid a syntax
5994 error from the SunOS4 C compiler. */
5995 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5997 else if (entry
->d_tag
== DT_SYMINSZ
)
5998 syminsz
= entry
->d_un
.d_val
;
5999 else if (entry
->d_tag
== DT_SYMINFO
)
6000 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6004 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6006 Elf_External_Syminfo
* extsyminfo
;
6007 Elf_External_Syminfo
* extsym
;
6008 Elf_Internal_Syminfo
* syminfo
;
6010 /* There is a syminfo section. Read the data. */
6011 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
6012 syminsz
, _("symbol information"));
6016 dynamic_syminfo
= malloc (syminsz
);
6017 if (dynamic_syminfo
== NULL
)
6019 error (_("Out of memory\n"));
6023 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6024 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6025 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6026 ++syminfo
, ++extsym
)
6028 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6029 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6036 if (do_dynamic
&& dynamic_addr
)
6037 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6038 dynamic_addr
, dynamic_nent
);
6040 printf (_(" Tag Type Name/Value\n"));
6042 for (entry
= dynamic_section
;
6043 entry
< dynamic_section
+ dynamic_nent
;
6051 print_vma (entry
->d_tag
, FULL_HEX
);
6052 dtype
= get_dynamic_type (entry
->d_tag
);
6053 printf (" (%s)%*s", dtype
,
6054 ((is_32bit_elf
? 27 : 19)
6055 - (int) strlen (dtype
)),
6059 switch (entry
->d_tag
)
6063 print_dynamic_flags (entry
->d_un
.d_val
);
6073 switch (entry
->d_tag
)
6076 printf (_("Auxiliary library"));
6080 printf (_("Filter library"));
6084 printf (_("Configuration file"));
6088 printf (_("Dependency audit library"));
6092 printf (_("Audit library"));
6096 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6097 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6101 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6110 printf (_("Flags:"));
6112 if (entry
->d_un
.d_val
== 0)
6113 printf (_(" None\n"));
6116 unsigned long int val
= entry
->d_un
.d_val
;
6118 if (val
& DTF_1_PARINIT
)
6120 printf (" PARINIT");
6121 val
^= DTF_1_PARINIT
;
6123 if (val
& DTF_1_CONFEXP
)
6125 printf (" CONFEXP");
6126 val
^= DTF_1_CONFEXP
;
6129 printf (" %lx", val
);
6138 printf (_("Flags:"));
6140 if (entry
->d_un
.d_val
== 0)
6141 printf (_(" None\n"));
6144 unsigned long int val
= entry
->d_un
.d_val
;
6146 if (val
& DF_P1_LAZYLOAD
)
6148 printf (" LAZYLOAD");
6149 val
^= DF_P1_LAZYLOAD
;
6151 if (val
& DF_P1_GROUPPERM
)
6153 printf (" GROUPPERM");
6154 val
^= DF_P1_GROUPPERM
;
6157 printf (" %lx", val
);
6166 printf (_("Flags:"));
6167 if (entry
->d_un
.d_val
== 0)
6168 printf (_(" None\n"));
6171 unsigned long int val
= entry
->d_un
.d_val
;
6178 if (val
& DF_1_GLOBAL
)
6183 if (val
& DF_1_GROUP
)
6188 if (val
& DF_1_NODELETE
)
6190 printf (" NODELETE");
6191 val
^= DF_1_NODELETE
;
6193 if (val
& DF_1_LOADFLTR
)
6195 printf (" LOADFLTR");
6196 val
^= DF_1_LOADFLTR
;
6198 if (val
& DF_1_INITFIRST
)
6200 printf (" INITFIRST");
6201 val
^= DF_1_INITFIRST
;
6203 if (val
& DF_1_NOOPEN
)
6208 if (val
& DF_1_ORIGIN
)
6213 if (val
& DF_1_DIRECT
)
6218 if (val
& DF_1_TRANS
)
6223 if (val
& DF_1_INTERPOSE
)
6225 printf (" INTERPOSE");
6226 val
^= DF_1_INTERPOSE
;
6228 if (val
& DF_1_NODEFLIB
)
6230 printf (" NODEFLIB");
6231 val
^= DF_1_NODEFLIB
;
6233 if (val
& DF_1_NODUMP
)
6238 if (val
& DF_1_CONLFAT
)
6240 printf (" CONLFAT");
6241 val
^= DF_1_CONLFAT
;
6244 printf (" %lx", val
);
6251 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6253 puts (get_dynamic_type (entry
->d_un
.d_val
));
6273 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6279 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6280 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6286 switch (entry
->d_tag
)
6289 printf (_("Shared library: [%s]"), name
);
6291 if (streq (name
, program_interpreter
))
6292 printf (_(" program interpreter"));
6296 printf (_("Library soname: [%s]"), name
);
6300 printf (_("Library rpath: [%s]"), name
);
6304 printf (_("Library runpath: [%s]"), name
);
6308 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6313 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6326 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6330 case DT_INIT_ARRAYSZ
:
6331 case DT_FINI_ARRAYSZ
:
6332 case DT_GNU_CONFLICTSZ
:
6333 case DT_GNU_LIBLISTSZ
:
6336 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6337 printf (" (bytes)\n");
6347 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6360 if (entry
->d_tag
== DT_USED
6361 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6363 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6367 printf (_("Not needed object: [%s]\n"), name
);
6372 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6378 /* The value of this entry is ignored. */
6383 case DT_GNU_PRELINKED
:
6387 time_t time
= entry
->d_un
.d_val
;
6389 tmp
= gmtime (&time
);
6390 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6391 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6392 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6398 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6401 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6407 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6408 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6413 switch (elf_header
.e_machine
)
6416 case EM_MIPS_RS3_LE
:
6417 dynamic_section_mips_val (entry
);
6420 dynamic_section_parisc_val (entry
);
6423 dynamic_section_ia64_val (entry
);
6426 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6438 get_ver_flags (unsigned int flags
)
6440 static char buff
[32];
6447 if (flags
& VER_FLG_BASE
)
6448 strcat (buff
, "BASE ");
6450 if (flags
& VER_FLG_WEAK
)
6452 if (flags
& VER_FLG_BASE
)
6453 strcat (buff
, "| ");
6455 strcat (buff
, "WEAK ");
6458 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6459 strcat (buff
, "| <unknown>");
6464 /* Display the contents of the version sections. */
6467 process_version_sections (FILE * file
)
6469 Elf_Internal_Shdr
* section
;
6476 for (i
= 0, section
= section_headers
;
6477 i
< elf_header
.e_shnum
;
6480 switch (section
->sh_type
)
6482 case SHT_GNU_verdef
:
6484 Elf_External_Verdef
* edefs
;
6492 (_("\nVersion definition section '%s' contains %u entries:\n"),
6493 SECTION_NAME (section
), section
->sh_info
);
6495 printf (_(" Addr: 0x"));
6496 printf_vma (section
->sh_addr
);
6497 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6498 (unsigned long) section
->sh_offset
, section
->sh_link
,
6499 section
->sh_link
< elf_header
.e_shnum
6500 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6503 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6505 _("version definition section"));
6506 endbuf
= (char *) edefs
+ section
->sh_size
;
6510 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6513 Elf_External_Verdef
* edef
;
6514 Elf_Internal_Verdef ent
;
6515 Elf_External_Verdaux
* eaux
;
6516 Elf_Internal_Verdaux aux
;
6520 vstart
= ((char *) edefs
) + idx
;
6521 if (vstart
+ sizeof (*edef
) > endbuf
)
6524 edef
= (Elf_External_Verdef
*) vstart
;
6526 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6527 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6528 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6529 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6530 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6531 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6532 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6534 printf (_(" %#06x: Rev: %d Flags: %s"),
6535 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6537 printf (_(" Index: %d Cnt: %d "),
6538 ent
.vd_ndx
, ent
.vd_cnt
);
6540 vstart
+= ent
.vd_aux
;
6542 eaux
= (Elf_External_Verdaux
*) vstart
;
6544 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6545 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6547 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6548 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6550 printf (_("Name index: %ld\n"), aux
.vda_name
);
6552 isum
= idx
+ ent
.vd_aux
;
6554 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6556 isum
+= aux
.vda_next
;
6557 vstart
+= aux
.vda_next
;
6559 eaux
= (Elf_External_Verdaux
*) vstart
;
6560 if (vstart
+ sizeof (*eaux
) > endbuf
)
6563 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6564 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6566 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6567 printf (_(" %#06x: Parent %d: %s\n"),
6568 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6570 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6571 isum
, j
, aux
.vda_name
);
6574 printf (_(" Version def aux past end of section\n"));
6578 if (cnt
< section
->sh_info
)
6579 printf (_(" Version definition past end of section\n"));
6585 case SHT_GNU_verneed
:
6587 Elf_External_Verneed
* eneed
;
6594 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6595 SECTION_NAME (section
), section
->sh_info
);
6597 printf (_(" Addr: 0x"));
6598 printf_vma (section
->sh_addr
);
6599 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6600 (unsigned long) section
->sh_offset
, section
->sh_link
,
6601 section
->sh_link
< elf_header
.e_shnum
6602 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6605 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6607 _("version need section"));
6608 endbuf
= (char *) eneed
+ section
->sh_size
;
6612 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6614 Elf_External_Verneed
* entry
;
6615 Elf_Internal_Verneed ent
;
6620 vstart
= ((char *) eneed
) + idx
;
6621 if (vstart
+ sizeof (*entry
) > endbuf
)
6624 entry
= (Elf_External_Verneed
*) vstart
;
6626 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6627 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6628 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6629 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6630 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6632 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6634 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6635 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6637 printf (_(" File: %lx"), ent
.vn_file
);
6639 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6641 vstart
+= ent
.vn_aux
;
6643 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6645 Elf_External_Vernaux
* eaux
;
6646 Elf_Internal_Vernaux aux
;
6648 if (vstart
+ sizeof (*eaux
) > endbuf
)
6650 eaux
= (Elf_External_Vernaux
*) vstart
;
6652 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6653 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6654 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6655 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6656 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6658 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6659 printf (_(" %#06x: Name: %s"),
6660 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6662 printf (_(" %#06x: Name index: %lx"),
6663 isum
, aux
.vna_name
);
6665 printf (_(" Flags: %s Version: %d\n"),
6666 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6668 isum
+= aux
.vna_next
;
6669 vstart
+= aux
.vna_next
;
6672 printf (_(" Version need aux past end of section\n"));
6676 if (cnt
< section
->sh_info
)
6677 printf (_(" Version need past end of section\n"));
6683 case SHT_GNU_versym
:
6685 Elf_Internal_Shdr
* link_section
;
6688 unsigned char * edata
;
6689 unsigned short * data
;
6691 Elf_Internal_Sym
* symbols
;
6692 Elf_Internal_Shdr
* string_sec
;
6695 if (section
->sh_link
>= elf_header
.e_shnum
)
6698 link_section
= section_headers
+ section
->sh_link
;
6699 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6701 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6706 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6708 string_sec
= section_headers
+ link_section
->sh_link
;
6710 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6711 string_sec
->sh_size
, _("version string table"));
6715 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6716 SECTION_NAME (section
), total
);
6718 printf (_(" Addr: "));
6719 printf_vma (section
->sh_addr
);
6720 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6721 (unsigned long) section
->sh_offset
, section
->sh_link
,
6722 SECTION_NAME (link_section
));
6724 off
= offset_from_vma (file
,
6725 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6726 total
* sizeof (short));
6727 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6728 _("version symbol data"));
6735 data
= cmalloc (total
, sizeof (short));
6737 for (cnt
= total
; cnt
--;)
6738 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6743 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6746 int check_def
, check_need
;
6749 printf (" %03x:", cnt
);
6751 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6752 switch (data
[cnt
+ j
])
6755 fputs (_(" 0 (*local*) "), stdout
);
6759 fputs (_(" 1 (*global*) "), stdout
);
6763 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6764 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6768 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6769 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6772 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6779 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6781 Elf_Internal_Verneed ivn
;
6782 unsigned long offset
;
6784 offset
= offset_from_vma
6785 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6786 sizeof (Elf_External_Verneed
));
6790 Elf_Internal_Vernaux ivna
;
6791 Elf_External_Verneed evn
;
6792 Elf_External_Vernaux evna
;
6793 unsigned long a_off
;
6795 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6798 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6799 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6801 a_off
= offset
+ ivn
.vn_aux
;
6805 get_data (&evna
, file
, a_off
, sizeof (evna
),
6806 1, _("version need aux (2)"));
6808 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6809 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6811 a_off
+= ivna
.vna_next
;
6813 while (ivna
.vna_other
!= data
[cnt
+ j
]
6814 && ivna
.vna_next
!= 0);
6816 if (ivna
.vna_other
== data
[cnt
+ j
])
6818 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6820 if (ivna
.vna_name
>= string_sec
->sh_size
)
6821 name
= _("*invalid*");
6823 name
= strtab
+ ivna
.vna_name
;
6824 nn
+= printf ("(%s%-*s",
6826 12 - (int) strlen (name
),
6832 offset
+= ivn
.vn_next
;
6834 while (ivn
.vn_next
);
6837 if (check_def
&& data
[cnt
+ j
] != 0x8001
6838 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6840 Elf_Internal_Verdef ivd
;
6841 Elf_External_Verdef evd
;
6842 unsigned long offset
;
6844 offset
= offset_from_vma
6845 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6850 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6853 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6854 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6856 offset
+= ivd
.vd_next
;
6858 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6859 && ivd
.vd_next
!= 0);
6861 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6863 Elf_External_Verdaux evda
;
6864 Elf_Internal_Verdaux ivda
;
6866 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6868 get_data (&evda
, file
,
6869 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6871 _("version def aux"));
6873 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6875 if (ivda
.vda_name
>= string_sec
->sh_size
)
6876 name
= _("*invalid*");
6878 name
= strtab
+ ivda
.vda_name
;
6879 nn
+= printf ("(%s%-*s",
6881 12 - (int) strlen (name
),
6887 printf ("%*c", 18 - nn
, ' ');
6905 printf (_("\nNo version information found in this file.\n"));
6911 get_symbol_binding (unsigned int binding
)
6913 static char buff
[32];
6917 case STB_LOCAL
: return "LOCAL";
6918 case STB_GLOBAL
: return "GLOBAL";
6919 case STB_WEAK
: return "WEAK";
6921 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6922 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6924 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6926 if (binding
== STB_GNU_UNIQUE
6927 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
6928 /* GNU/Linux is still using the default value 0. */
6929 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
6931 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6934 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6940 get_symbol_type (unsigned int type
)
6942 static char buff
[32];
6946 case STT_NOTYPE
: return "NOTYPE";
6947 case STT_OBJECT
: return "OBJECT";
6948 case STT_FUNC
: return "FUNC";
6949 case STT_SECTION
: return "SECTION";
6950 case STT_FILE
: return "FILE";
6951 case STT_COMMON
: return "COMMON";
6952 case STT_TLS
: return "TLS";
6953 case STT_RELC
: return "RELC";
6954 case STT_SRELC
: return "SRELC";
6956 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6958 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6959 return "THUMB_FUNC";
6961 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6964 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6965 return "PARISC_MILLI";
6967 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6969 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6971 if (elf_header
.e_machine
== EM_PARISC
)
6973 if (type
== STT_HP_OPAQUE
)
6975 if (type
== STT_HP_STUB
)
6979 if (type
== STT_GNU_IFUNC
6980 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
6981 /* GNU/Linux is still using the default value 0. */
6982 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
6985 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6988 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6994 get_symbol_visibility (unsigned int visibility
)
6998 case STV_DEFAULT
: return "DEFAULT";
6999 case STV_INTERNAL
: return "INTERNAL";
7000 case STV_HIDDEN
: return "HIDDEN";
7001 case STV_PROTECTED
: return "PROTECTED";
7007 get_mips_symbol_other (unsigned int other
)
7011 case STO_OPTIONAL
: return "OPTIONAL";
7012 case STO_MIPS16
: return "MIPS16";
7013 case STO_MIPS_PLT
: return "MIPS PLT";
7014 case STO_MIPS_PIC
: return "MIPS PIC";
7015 default: return NULL
;
7020 get_symbol_other (unsigned int other
)
7022 const char * result
= NULL
;
7023 static char buff
[32];
7028 switch (elf_header
.e_machine
)
7031 result
= get_mips_symbol_other (other
);
7039 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7044 get_symbol_index_type (unsigned int type
)
7046 static char buff
[32];
7050 case SHN_UNDEF
: return "UND";
7051 case SHN_ABS
: return "ABS";
7052 case SHN_COMMON
: return "COM";
7054 if (type
== SHN_IA_64_ANSI_COMMON
7055 && elf_header
.e_machine
== EM_IA_64
7056 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7058 else if ((elf_header
.e_machine
== EM_X86_64
7059 || elf_header
.e_machine
== EM_L1OM
)
7060 && type
== SHN_X86_64_LCOMMON
)
7062 else if (type
== SHN_MIPS_SCOMMON
7063 && elf_header
.e_machine
== EM_MIPS
)
7065 else if (type
== SHN_MIPS_SUNDEFINED
7066 && elf_header
.e_machine
== EM_MIPS
)
7068 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7069 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7070 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7071 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7072 else if (type
>= SHN_LORESERVE
)
7073 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7075 sprintf (buff
, "%3d", type
);
7083 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7085 unsigned char * e_data
;
7088 e_data
= cmalloc (number
, ent_size
);
7092 error (_("Out of memory\n"));
7096 if (fread (e_data
, ent_size
, number
, file
) != number
)
7098 error (_("Unable to read in dynamic data\n"));
7102 i_data
= cmalloc (number
, sizeof (*i_data
));
7106 error (_("Out of memory\n"));
7112 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7120 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7122 Elf_Internal_Sym
* psym
;
7125 psym
= dynamic_symbols
+ si
;
7127 n
= print_vma (si
, DEC_5
);
7129 fputs (" " + n
, stdout
);
7130 printf (" %3lu: ", hn
);
7131 print_vma (psym
->st_value
, LONG_HEX
);
7133 print_vma (psym
->st_size
, DEC_5
);
7135 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7136 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7137 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7138 /* Check to see if any other bits in the st_other field are set.
7139 Note - displaying this information disrupts the layout of the
7140 table being generated, but for the moment this case is very
7142 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7143 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7144 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7145 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7146 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7148 printf (" <corrupt: %14ld>", psym
->st_name
);
7152 /* Dump the symbol table. */
7154 process_symbol_table (FILE * file
)
7156 Elf_Internal_Shdr
* section
;
7157 bfd_vma nbuckets
= 0;
7158 bfd_vma nchains
= 0;
7159 bfd_vma
* buckets
= NULL
;
7160 bfd_vma
* chains
= NULL
;
7161 bfd_vma ngnubuckets
= 0;
7162 bfd_vma
* gnubuckets
= NULL
;
7163 bfd_vma
* gnuchains
= NULL
;
7164 bfd_vma gnusymidx
= 0;
7166 if (! do_syms
&& !do_histogram
)
7169 if (dynamic_info
[DT_HASH
]
7171 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7173 unsigned char nb
[8];
7174 unsigned char nc
[8];
7175 int hash_ent_size
= 4;
7177 if ((elf_header
.e_machine
== EM_ALPHA
7178 || elf_header
.e_machine
== EM_S390
7179 || elf_header
.e_machine
== EM_S390_OLD
)
7180 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7184 (archive_file_offset
7185 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7186 sizeof nb
+ sizeof nc
)),
7189 error (_("Unable to seek to start of dynamic information\n"));
7193 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7195 error (_("Failed to read in number of buckets\n"));
7199 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7201 error (_("Failed to read in number of chains\n"));
7205 nbuckets
= byte_get (nb
, hash_ent_size
);
7206 nchains
= byte_get (nc
, hash_ent_size
);
7208 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7209 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7212 if (buckets
== NULL
|| chains
== NULL
)
7214 if (do_using_dynamic
)
7225 if (dynamic_info_DT_GNU_HASH
7227 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7229 unsigned char nb
[16];
7230 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7231 bfd_vma buckets_vma
;
7234 (archive_file_offset
7235 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7239 error (_("Unable to seek to start of dynamic information\n"));
7243 if (fread (nb
, 16, 1, file
) != 1)
7245 error (_("Failed to read in number of buckets\n"));
7249 ngnubuckets
= byte_get (nb
, 4);
7250 gnusymidx
= byte_get (nb
+ 4, 4);
7251 bitmaskwords
= byte_get (nb
+ 8, 4);
7252 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7254 buckets_vma
+= bitmaskwords
* 4;
7256 buckets_vma
+= bitmaskwords
* 8;
7259 (archive_file_offset
7260 + offset_from_vma (file
, buckets_vma
, 4)),
7263 error (_("Unable to seek to start of dynamic information\n"));
7267 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7269 if (gnubuckets
== NULL
)
7272 for (i
= 0; i
< ngnubuckets
; i
++)
7273 if (gnubuckets
[i
] != 0)
7275 if (gnubuckets
[i
] < gnusymidx
)
7278 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7279 maxchain
= gnubuckets
[i
];
7282 if (maxchain
== 0xffffffff)
7285 maxchain
-= gnusymidx
;
7288 (archive_file_offset
7289 + offset_from_vma (file
, buckets_vma
7290 + 4 * (ngnubuckets
+ maxchain
), 4)),
7293 error (_("Unable to seek to start of dynamic information\n"));
7299 if (fread (nb
, 4, 1, file
) != 1)
7301 error (_("Failed to determine last chain length\n"));
7305 if (maxchain
+ 1 == 0)
7310 while ((byte_get (nb
, 4) & 1) == 0);
7313 (archive_file_offset
7314 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7317 error (_("Unable to seek to start of dynamic information\n"));
7321 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7324 if (gnuchains
== NULL
)
7329 if (do_using_dynamic
)
7334 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7337 && dynamic_strings
!= NULL
)
7341 if (dynamic_info
[DT_HASH
])
7345 printf (_("\nSymbol table for image:\n"));
7347 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7349 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7351 for (hn
= 0; hn
< nbuckets
; hn
++)
7356 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7357 print_dynamic_symbol (si
, hn
);
7361 if (dynamic_info_DT_GNU_HASH
)
7363 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7365 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7367 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7369 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7370 if (gnubuckets
[hn
] != 0)
7372 bfd_vma si
= gnubuckets
[hn
];
7373 bfd_vma off
= si
- gnusymidx
;
7377 print_dynamic_symbol (si
, hn
);
7380 while ((gnuchains
[off
++] & 1) == 0);
7384 else if (do_syms
&& !do_using_dynamic
)
7388 for (i
= 0, section
= section_headers
;
7389 i
< elf_header
.e_shnum
;
7393 char * strtab
= NULL
;
7394 unsigned long int strtab_size
= 0;
7395 Elf_Internal_Sym
* symtab
;
7396 Elf_Internal_Sym
* psym
;
7398 if ( section
->sh_type
!= SHT_SYMTAB
7399 && section
->sh_type
!= SHT_DYNSYM
)
7402 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7403 SECTION_NAME (section
),
7404 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7406 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7408 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7410 symtab
= GET_ELF_SYMBOLS (file
, section
);
7414 if (section
->sh_link
== elf_header
.e_shstrndx
)
7416 strtab
= string_table
;
7417 strtab_size
= string_table_length
;
7419 else if (section
->sh_link
< elf_header
.e_shnum
)
7421 Elf_Internal_Shdr
* string_sec
;
7423 string_sec
= section_headers
+ section
->sh_link
;
7425 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7426 1, string_sec
->sh_size
, _("string table"));
7427 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7430 for (si
= 0, psym
= symtab
;
7431 si
< section
->sh_size
/ section
->sh_entsize
;
7434 printf ("%6d: ", si
);
7435 print_vma (psym
->st_value
, LONG_HEX
);
7437 print_vma (psym
->st_size
, DEC_5
);
7438 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7439 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7440 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7441 /* Check to see if any other bits in the st_other field are set.
7442 Note - displaying this information disrupts the layout of the
7443 table being generated, but for the moment this case is very rare. */
7444 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7445 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7446 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7447 print_symbol (25, psym
->st_name
< strtab_size
7448 ? strtab
+ psym
->st_name
: "<corrupt>");
7450 if (section
->sh_type
== SHT_DYNSYM
&&
7451 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7453 unsigned char data
[2];
7454 unsigned short vers_data
;
7455 unsigned long offset
;
7459 offset
= offset_from_vma
7460 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7461 sizeof data
+ si
* sizeof (vers_data
));
7463 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7464 sizeof (data
), 1, _("version data"));
7466 vers_data
= byte_get (data
, 2);
7468 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7469 && section_headers
[psym
->st_shndx
].sh_type
7472 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7474 if ((vers_data
& 0x8000) || vers_data
> 1)
7476 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7477 && (is_nobits
|| ! check_def
))
7479 Elf_External_Verneed evn
;
7480 Elf_Internal_Verneed ivn
;
7481 Elf_Internal_Vernaux ivna
;
7483 /* We must test both. */
7484 offset
= offset_from_vma
7485 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7490 unsigned long vna_off
;
7492 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7495 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7496 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7498 vna_off
= offset
+ ivn
.vn_aux
;
7502 Elf_External_Vernaux evna
;
7504 get_data (&evna
, file
, vna_off
,
7506 _("version need aux (3)"));
7508 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7509 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7510 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7512 vna_off
+= ivna
.vna_next
;
7514 while (ivna
.vna_other
!= vers_data
7515 && ivna
.vna_next
!= 0);
7517 if (ivna
.vna_other
== vers_data
)
7520 offset
+= ivn
.vn_next
;
7522 while (ivn
.vn_next
!= 0);
7524 if (ivna
.vna_other
== vers_data
)
7527 ivna
.vna_name
< strtab_size
7528 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7532 else if (! is_nobits
)
7533 error (_("bad dynamic symbol\n"));
7540 if (vers_data
!= 0x8001
7541 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7543 Elf_Internal_Verdef ivd
;
7544 Elf_Internal_Verdaux ivda
;
7545 Elf_External_Verdaux evda
;
7546 unsigned long offset
;
7548 offset
= offset_from_vma
7550 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7551 sizeof (Elf_External_Verdef
));
7555 Elf_External_Verdef evd
;
7557 get_data (&evd
, file
, offset
, sizeof (evd
),
7558 1, _("version def"));
7560 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7561 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7562 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7564 offset
+= ivd
.vd_next
;
7566 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7567 && ivd
.vd_next
!= 0);
7569 offset
-= ivd
.vd_next
;
7570 offset
+= ivd
.vd_aux
;
7572 get_data (&evda
, file
, offset
, sizeof (evda
),
7573 1, _("version def aux"));
7575 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7577 if (psym
->st_name
!= ivda
.vda_name
)
7578 printf ((vers_data
& 0x8000)
7580 ivda
.vda_name
< strtab_size
7581 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7591 if (strtab
!= string_table
)
7597 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7599 if (do_histogram
&& buckets
!= NULL
)
7601 unsigned long * lengths
;
7602 unsigned long * counts
;
7605 unsigned long maxlength
= 0;
7606 unsigned long nzero_counts
= 0;
7607 unsigned long nsyms
= 0;
7609 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7610 (unsigned long) nbuckets
);
7611 printf (_(" Length Number %% of total Coverage\n"));
7613 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7614 if (lengths
== NULL
)
7616 error (_("Out of memory\n"));
7619 for (hn
= 0; hn
< nbuckets
; ++hn
)
7621 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7624 if (maxlength
< ++lengths
[hn
])
7629 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7632 error (_("Out of memory\n"));
7636 for (hn
= 0; hn
< nbuckets
; ++hn
)
7637 ++counts
[lengths
[hn
]];
7642 printf (" 0 %-10lu (%5.1f%%)\n",
7643 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7644 for (i
= 1; i
<= maxlength
; ++i
)
7646 nzero_counts
+= counts
[i
] * i
;
7647 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7648 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7649 (nzero_counts
* 100.0) / nsyms
);
7657 if (buckets
!= NULL
)
7663 if (do_histogram
&& gnubuckets
!= NULL
)
7665 unsigned long * lengths
;
7666 unsigned long * counts
;
7668 unsigned long maxlength
= 0;
7669 unsigned long nzero_counts
= 0;
7670 unsigned long nsyms
= 0;
7672 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7673 if (lengths
== NULL
)
7675 error (_("Out of memory\n"));
7679 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7680 (unsigned long) ngnubuckets
);
7681 printf (_(" Length Number %% of total Coverage\n"));
7683 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7684 if (gnubuckets
[hn
] != 0)
7686 bfd_vma off
, length
= 1;
7688 for (off
= gnubuckets
[hn
] - gnusymidx
;
7689 (gnuchains
[off
] & 1) == 0; ++off
)
7691 lengths
[hn
] = length
;
7692 if (length
> maxlength
)
7697 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7700 error (_("Out of memory\n"));
7704 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7705 ++counts
[lengths
[hn
]];
7707 if (ngnubuckets
> 0)
7710 printf (" 0 %-10lu (%5.1f%%)\n",
7711 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7712 for (j
= 1; j
<= maxlength
; ++j
)
7714 nzero_counts
+= counts
[j
] * j
;
7715 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7716 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7717 (nzero_counts
* 100.0) / nsyms
);
7731 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7735 if (dynamic_syminfo
== NULL
7737 /* No syminfo, this is ok. */
7740 /* There better should be a dynamic symbol section. */
7741 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7745 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7746 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7748 printf (_(" Num: Name BoundTo Flags\n"));
7749 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7751 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7753 printf ("%4d: ", i
);
7754 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7755 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7757 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7760 switch (dynamic_syminfo
[i
].si_boundto
)
7762 case SYMINFO_BT_SELF
:
7763 fputs ("SELF ", stdout
);
7765 case SYMINFO_BT_PARENT
:
7766 fputs ("PARENT ", stdout
);
7769 if (dynamic_syminfo
[i
].si_boundto
> 0
7770 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7771 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7773 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7777 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7781 if (flags
& SYMINFO_FLG_DIRECT
)
7783 if (flags
& SYMINFO_FLG_PASSTHRU
)
7784 printf (" PASSTHRU");
7785 if (flags
& SYMINFO_FLG_COPY
)
7787 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7788 printf (" LAZYLOAD");
7796 /* Check to see if the given reloc needs to be handled in a target specific
7797 manner. If so then process the reloc and return TRUE otherwise return
7801 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
7802 unsigned char * start
,
7803 Elf_Internal_Sym
* symtab
)
7805 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
7807 switch (elf_header
.e_machine
)
7810 case EM_CYGNUS_MN10300
:
7812 static Elf_Internal_Sym
* saved_sym
= NULL
;
7816 case 34: /* R_MN10300_ALIGN */
7818 case 33: /* R_MN10300_SYM_DIFF */
7819 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
7821 case 1: /* R_MN10300_32 */
7822 case 2: /* R_MN10300_16 */
7823 if (saved_sym
!= NULL
)
7827 value
= reloc
->r_addend
7828 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
7829 - saved_sym
->st_value
);
7831 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
7838 if (saved_sym
!= NULL
)
7839 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
7849 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7850 DWARF debug sections. This is a target specific test. Note - we do not
7851 go through the whole including-target-headers-multiple-times route, (as
7852 we have already done with <elf/h8.h>) because this would become very
7853 messy and even then this function would have to contain target specific
7854 information (the names of the relocs instead of their numeric values).
7855 FIXME: This is not the correct way to solve this problem. The proper way
7856 is to have target specific reloc sizing and typing functions created by
7857 the reloc-macros.h header, in the same way that it already creates the
7858 reloc naming functions. */
7861 is_32bit_abs_reloc (unsigned int reloc_type
)
7863 switch (elf_header
.e_machine
)
7867 return reloc_type
== 1; /* R_386_32. */
7869 return reloc_type
== 1; /* R_68K_32. */
7871 return reloc_type
== 1; /* R_860_32. */
7873 return reloc_type
== 1; /* XXX Is this right ? */
7875 return reloc_type
== 1; /* R_ARC_32. */
7877 return reloc_type
== 2; /* R_ARM_ABS32 */
7880 return reloc_type
== 1;
7882 return reloc_type
== 0x12; /* R_byte4_data. */
7884 return reloc_type
== 3; /* R_CRIS_32. */
7887 return reloc_type
== 3; /* R_CR16_NUM32. */
7889 return reloc_type
== 15; /* R_CRX_NUM32. */
7891 return reloc_type
== 1;
7892 case EM_CYGNUS_D10V
:
7894 return reloc_type
== 6; /* R_D10V_32. */
7895 case EM_CYGNUS_D30V
:
7897 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7899 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7900 case EM_CYGNUS_FR30
:
7902 return reloc_type
== 3; /* R_FR30_32. */
7906 return reloc_type
== 1; /* R_H8_DIR32. */
7908 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
7911 return reloc_type
== 2; /* R_IP2K_32. */
7913 return reloc_type
== 2; /* R_IQ2000_32. */
7914 case EM_LATTICEMICO32
:
7915 return reloc_type
== 3; /* R_LM32_32. */
7918 return reloc_type
== 3; /* R_M32C_32. */
7920 return reloc_type
== 34; /* R_M32R_32_RELA. */
7922 return reloc_type
== 1; /* R_MCORE_ADDR32. */
7924 return reloc_type
== 4; /* R_MEP_32. */
7926 return reloc_type
== 2; /* R_MIPS_32. */
7928 return reloc_type
== 4; /* R_MMIX_32. */
7929 case EM_CYGNUS_MN10200
:
7931 return reloc_type
== 1; /* R_MN10200_32. */
7932 case EM_CYGNUS_MN10300
:
7934 return reloc_type
== 1; /* R_MN10300_32. */
7937 return reloc_type
== 1; /* R_MSP43_32. */
7939 return reloc_type
== 2; /* R_MT_32. */
7940 case EM_ALTERA_NIOS2
:
7942 return reloc_type
== 1; /* R_NIOS_32. */
7945 return reloc_type
== 1; /* R_OR32_32. */
7947 return (reloc_type
== 1 /* R_PARISC_DIR32. */
7948 || reloc_type
== 41); /* R_PARISC_SECREL32. */
7951 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
7953 return reloc_type
== 1; /* R_PPC64_ADDR32. */
7955 return reloc_type
== 1; /* R_PPC_ADDR32. */
7957 return reloc_type
== 1; /* R_I370_ADDR31. */
7960 return reloc_type
== 4; /* R_S390_32. */
7962 return reloc_type
== 8; /* R_SCORE_ABS32. */
7964 return reloc_type
== 1; /* R_SH_DIR32. */
7965 case EM_SPARC32PLUS
:
7968 return reloc_type
== 3 /* R_SPARC_32. */
7969 || reloc_type
== 23; /* R_SPARC_UA32. */
7971 return reloc_type
== 6; /* R_SPU_ADDR32 */
7972 case EM_CYGNUS_V850
:
7974 return reloc_type
== 6; /* R_V850_ABS32. */
7976 return reloc_type
== 1; /* R_VAX_32. */
7979 return reloc_type
== 10; /* R_X86_64_32. */
7981 return reloc_type
== 1; /* R_XSTROMY16_32. */
7984 return reloc_type
== 1; /* R_XTENSA_32. */
7987 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
7988 elf_header
.e_machine
);
7993 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
7994 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
7997 is_32bit_pcrel_reloc (unsigned int reloc_type
)
7999 switch (elf_header
.e_machine
)
8003 return reloc_type
== 2; /* R_386_PC32. */
8005 return reloc_type
== 4; /* R_68K_PC32. */
8007 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8009 return reloc_type
== 3; /* R_ARM_REL32 */
8011 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8013 return reloc_type
== 26; /* R_PPC_REL32. */
8015 return reloc_type
== 26; /* R_PPC64_REL32. */
8018 return reloc_type
== 5; /* R_390_PC32. */
8020 return reloc_type
== 2; /* R_SH_REL32. */
8021 case EM_SPARC32PLUS
:
8024 return reloc_type
== 6; /* R_SPARC_DISP32. */
8026 return reloc_type
== 13; /* R_SPU_REL32. */
8029 return reloc_type
== 2; /* R_X86_64_PC32. */
8032 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8034 /* Do not abort or issue an error message here. Not all targets use
8035 pc-relative 32-bit relocs in their DWARF debug information and we
8036 have already tested for target coverage in is_32bit_abs_reloc. A
8037 more helpful warning message will be generated by apply_relocations
8038 anyway, so just return. */
8043 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8044 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8047 is_64bit_abs_reloc (unsigned int reloc_type
)
8049 switch (elf_header
.e_machine
)
8052 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8054 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8056 return reloc_type
== 80; /* R_PARISC_DIR64. */
8058 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8059 case EM_SPARC32PLUS
:
8062 return reloc_type
== 54; /* R_SPARC_UA64. */
8065 return reloc_type
== 1; /* R_X86_64_64. */
8068 return reloc_type
== 22; /* R_S390_64 */
8070 return reloc_type
== 18; /* R_MIPS_64 */
8076 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8077 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8080 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8082 switch (elf_header
.e_machine
)
8085 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8087 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8089 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8091 return reloc_type
== 44; /* R_PPC64_REL64 */
8092 case EM_SPARC32PLUS
:
8095 return reloc_type
== 46; /* R_SPARC_DISP64 */
8098 return reloc_type
== 24; /* R_X86_64_PC64 */
8101 return reloc_type
== 23; /* R_S390_PC64 */
8107 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8108 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8111 is_24bit_abs_reloc (unsigned int reloc_type
)
8113 switch (elf_header
.e_machine
)
8115 case EM_CYGNUS_MN10200
:
8117 return reloc_type
== 4; /* R_MN10200_24. */
8123 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8124 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8127 is_16bit_abs_reloc (unsigned int reloc_type
)
8129 switch (elf_header
.e_machine
)
8133 return reloc_type
== 4; /* R_AVR_16. */
8134 case EM_CYGNUS_D10V
:
8136 return reloc_type
== 3; /* R_D10V_16. */
8140 return reloc_type
== R_H8_DIR16
;
8143 return reloc_type
== 1; /* R_IP2K_16. */
8146 return reloc_type
== 1; /* R_M32C_16 */
8149 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8150 case EM_ALTERA_NIOS2
:
8152 return reloc_type
== 9; /* R_NIOS_16. */
8158 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8159 relocation entries (possibly formerly used for SHT_GROUP sections). */
8162 is_none_reloc (unsigned int reloc_type
)
8164 switch (elf_header
.e_machine
)
8166 case EM_68K
: /* R_68K_NONE. */
8167 case EM_386
: /* R_386_NONE. */
8168 case EM_SPARC32PLUS
:
8170 case EM_SPARC
: /* R_SPARC_NONE. */
8171 case EM_MIPS
: /* R_MIPS_NONE. */
8172 case EM_PARISC
: /* R_PARISC_NONE. */
8173 case EM_ALPHA
: /* R_ALPHA_NONE. */
8174 case EM_PPC
: /* R_PPC_NONE. */
8175 case EM_PPC64
: /* R_PPC64_NONE. */
8176 case EM_ARM
: /* R_ARM_NONE. */
8177 case EM_IA_64
: /* R_IA64_NONE. */
8178 case EM_SH
: /* R_SH_NONE. */
8180 case EM_S390
: /* R_390_NONE. */
8181 case EM_CRIS
: /* R_CRIS_NONE. */
8182 case EM_X86_64
: /* R_X86_64_NONE. */
8183 case EM_L1OM
: /* R_X86_64_NONE. */
8184 case EM_MN10300
: /* R_MN10300_NONE. */
8185 case EM_M32R
: /* R_M32R_NONE. */
8186 return reloc_type
== 0;
8189 return (reloc_type
== 0 /* R_XTENSA_NONE. */
8190 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
8191 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
8192 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
8197 /* Apply relocations to a section.
8198 Note: So far support has been added only for those relocations
8199 which can be found in debug sections.
8200 FIXME: Add support for more relocations ? */
8203 apply_relocations (void * file
,
8204 Elf_Internal_Shdr
* section
,
8205 unsigned char * start
)
8207 Elf_Internal_Shdr
* relsec
;
8208 unsigned char * end
= start
+ section
->sh_size
;
8210 if (elf_header
.e_type
!= ET_REL
)
8213 /* Find the reloc section associated with the section. */
8214 for (relsec
= section_headers
;
8215 relsec
< section_headers
+ elf_header
.e_shnum
;
8218 bfd_boolean is_rela
;
8219 unsigned long num_relocs
;
8220 Elf_Internal_Rela
* relocs
;
8221 Elf_Internal_Rela
* rp
;
8222 Elf_Internal_Shdr
* symsec
;
8223 Elf_Internal_Sym
* symtab
;
8224 Elf_Internal_Sym
* sym
;
8226 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8227 || relsec
->sh_info
>= elf_header
.e_shnum
8228 || section_headers
+ relsec
->sh_info
!= section
8229 || relsec
->sh_size
== 0
8230 || relsec
->sh_link
>= elf_header
.e_shnum
)
8233 is_rela
= relsec
->sh_type
== SHT_RELA
;
8237 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8238 & relocs
, & num_relocs
))
8243 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8244 & relocs
, & num_relocs
))
8248 /* SH uses RELA but uses in place value instead of the addend field. */
8249 if (elf_header
.e_machine
== EM_SH
)
8252 symsec
= section_headers
+ relsec
->sh_link
;
8253 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8255 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8258 unsigned int reloc_type
;
8259 unsigned int reloc_size
;
8260 unsigned char * loc
;
8262 reloc_type
= get_reloc_type (rp
->r_info
);
8264 if (target_specific_reloc_handling (rp
, start
, symtab
))
8266 else if (is_none_reloc (reloc_type
))
8268 else if (is_32bit_abs_reloc (reloc_type
)
8269 || is_32bit_pcrel_reloc (reloc_type
))
8271 else if (is_64bit_abs_reloc (reloc_type
)
8272 || is_64bit_pcrel_reloc (reloc_type
))
8274 else if (is_24bit_abs_reloc (reloc_type
))
8276 else if (is_16bit_abs_reloc (reloc_type
))
8280 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8281 reloc_type
, SECTION_NAME (section
));
8285 loc
= start
+ rp
->r_offset
;
8286 if ((loc
+ reloc_size
) > end
)
8288 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8289 (unsigned long) rp
->r_offset
,
8290 SECTION_NAME (section
));
8294 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8296 /* If the reloc has a symbol associated with it,
8297 make sure that it is of an appropriate type.
8299 Relocations against symbols without type can happen.
8300 Gcc -feliminate-dwarf2-dups may generate symbols
8301 without type for debug info.
8303 Icc generates relocations against function symbols
8304 instead of local labels.
8306 Relocations against object symbols can happen, eg when
8307 referencing a global array. For an example of this see
8308 the _clz.o binary in libgcc.a. */
8310 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8312 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8313 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8314 (long int)(rp
- relocs
),
8315 SECTION_NAME (relsec
));
8321 addend
+= rp
->r_addend
;
8322 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8324 || (elf_header
.e_machine
== EM_XTENSA
8326 || ((elf_header
.e_machine
== EM_PJ
8327 || elf_header
.e_machine
== EM_PJ_OLD
)
8328 && reloc_type
== 1))
8329 addend
+= byte_get (loc
, reloc_size
);
8331 if (is_32bit_pcrel_reloc (reloc_type
)
8332 || is_64bit_pcrel_reloc (reloc_type
))
8334 /* On HPPA, all pc-relative relocations are biased by 8. */
8335 if (elf_header
.e_machine
== EM_PARISC
)
8337 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8341 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8350 #ifdef SUPPORT_DISASSEMBLY
8352 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8354 printf (_("\nAssembly dump of section %s\n"),
8355 SECTION_NAME (section
));
8357 /* XXX -- to be done --- XXX */
8363 /* Reads in the contents of SECTION from FILE, returning a pointer
8364 to a malloc'ed buffer or NULL if something went wrong. */
8367 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8369 bfd_size_type num_bytes
;
8371 num_bytes
= section
->sh_size
;
8373 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8375 printf (_("\nSection '%s' has no data to dump.\n"),
8376 SECTION_NAME (section
));
8380 return get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8381 _("section contents"));
8386 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8388 Elf_Internal_Shdr
* relsec
;
8389 bfd_size_type num_bytes
;
8394 char * name
= SECTION_NAME (section
);
8395 bfd_boolean some_strings_shown
;
8397 start
= get_section_contents (section
, file
);
8401 printf (_("\nString dump of section '%s':\n"), name
);
8403 /* If the section being dumped has relocations against it the user might
8404 be expecting these relocations to have been applied. Check for this
8405 case and issue a warning message in order to avoid confusion.
8406 FIXME: Maybe we ought to have an option that dumps a section with
8408 for (relsec
= section_headers
;
8409 relsec
< section_headers
+ elf_header
.e_shnum
;
8412 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8413 || relsec
->sh_info
>= elf_header
.e_shnum
8414 || section_headers
+ relsec
->sh_info
!= section
8415 || relsec
->sh_size
== 0
8416 || relsec
->sh_link
>= elf_header
.e_shnum
)
8419 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8423 num_bytes
= section
->sh_size
;
8424 addr
= section
->sh_addr
;
8426 end
= start
+ num_bytes
;
8427 some_strings_shown
= FALSE
;
8431 while (!ISPRINT (* data
))
8438 printf (" [%6tx] %s\n", data
- start
, data
);
8440 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8442 data
+= strlen (data
);
8443 some_strings_shown
= TRUE
;
8447 if (! some_strings_shown
)
8448 printf (_(" No strings found in this section."));
8456 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8458 bfd_boolean relocate
)
8460 Elf_Internal_Shdr
* relsec
;
8461 bfd_size_type bytes
;
8463 unsigned char * data
;
8464 unsigned char * start
;
8466 start
= (unsigned char *) get_section_contents (section
, file
);
8470 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8474 apply_relocations (file
, section
, start
);
8478 /* If the section being dumped has relocations against it the user might
8479 be expecting these relocations to have been applied. Check for this
8480 case and issue a warning message in order to avoid confusion.
8481 FIXME: Maybe we ought to have an option that dumps a section with
8483 for (relsec
= section_headers
;
8484 relsec
< section_headers
+ elf_header
.e_shnum
;
8487 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8488 || relsec
->sh_info
>= elf_header
.e_shnum
8489 || section_headers
+ relsec
->sh_info
!= section
8490 || relsec
->sh_size
== 0
8491 || relsec
->sh_link
>= elf_header
.e_shnum
)
8494 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8499 addr
= section
->sh_addr
;
8500 bytes
= section
->sh_size
;
8509 lbytes
= (bytes
> 16 ? 16 : bytes
);
8511 printf (" 0x%8.8lx ", (unsigned long) addr
);
8513 for (j
= 0; j
< 16; j
++)
8516 printf ("%2.2x", data
[j
]);
8524 for (j
= 0; j
< lbytes
; j
++)
8527 if (k
>= ' ' && k
< 0x7f)
8545 /* Uncompresses a section that was compressed using zlib, in place.
8546 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8549 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8552 /* These are just to quiet gcc. */
8557 dwarf_size_type compressed_size
= *size
;
8558 unsigned char * compressed_buffer
= *buffer
;
8559 dwarf_size_type uncompressed_size
;
8560 unsigned char * uncompressed_buffer
;
8563 dwarf_size_type header_size
= 12;
8565 /* Read the zlib header. In this case, it should be "ZLIB" followed
8566 by the uncompressed section size, 8 bytes in big-endian order. */
8567 if (compressed_size
< header_size
8568 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8571 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8572 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8573 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8574 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8575 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8576 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8577 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8578 uncompressed_size
+= compressed_buffer
[11];
8580 /* It is possible the section consists of several compressed
8581 buffers concatenated together, so we uncompress in a loop. */
8585 strm
.avail_in
= compressed_size
- header_size
;
8586 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8587 strm
.avail_out
= uncompressed_size
;
8588 uncompressed_buffer
= xmalloc (uncompressed_size
);
8590 rc
= inflateInit (& strm
);
8591 while (strm
.avail_in
> 0)
8595 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8596 + (uncompressed_size
- strm
.avail_out
));
8597 rc
= inflate (&strm
, Z_FINISH
);
8598 if (rc
!= Z_STREAM_END
)
8600 rc
= inflateReset (& strm
);
8602 rc
= inflateEnd (& strm
);
8604 || strm
.avail_out
!= 0)
8607 free (compressed_buffer
);
8608 *buffer
= uncompressed_buffer
;
8609 *size
= uncompressed_size
;
8613 free (uncompressed_buffer
);
8615 #endif /* HAVE_ZLIB_H */
8619 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8620 Elf_Internal_Shdr
* sec
, void * file
)
8622 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8624 int section_is_compressed
;
8626 /* If it is already loaded, do nothing. */
8627 if (section
->start
!= NULL
)
8630 section_is_compressed
= section
->name
== section
->compressed_name
;
8632 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8633 section
->address
= sec
->sh_addr
;
8634 section
->size
= sec
->sh_size
;
8635 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8637 if (section
->start
== NULL
)
8640 if (section_is_compressed
)
8641 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8644 if (debug_displays
[debug
].relocate
)
8645 apply_relocations (file
, sec
, section
->start
);
8651 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8653 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8654 Elf_Internal_Shdr
* sec
;
8656 /* Locate the debug section. */
8657 sec
= find_section (section
->uncompressed_name
);
8659 section
->name
= section
->uncompressed_name
;
8662 sec
= find_section (section
->compressed_name
);
8664 section
->name
= section
->compressed_name
;
8669 return load_specific_debug_section (debug
, sec
, file
);
8673 free_debug_section (enum dwarf_section_display_enum debug
)
8675 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8677 if (section
->start
== NULL
)
8680 free ((char *) section
->start
);
8681 section
->start
= NULL
;
8682 section
->address
= 0;
8687 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8689 char * name
= SECTION_NAME (section
);
8690 bfd_size_type length
;
8692 enum dwarf_section_display_enum i
;
8694 length
= section
->sh_size
;
8697 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8700 if (section
->sh_type
== SHT_NOBITS
)
8702 /* There is no point in dumping the contents of a debugging section
8703 which has the NOBITS type - the bits in the file will be random.
8704 This can happen when a file containing a .eh_frame section is
8705 stripped with the --only-keep-debug command line option. */
8706 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8710 if (const_strneq (name
, ".gnu.linkonce.wi."))
8711 name
= ".debug_info";
8713 /* See if we know how to display the contents of this section. */
8714 for (i
= 0; i
< max
; i
++)
8715 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8716 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8718 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8719 int secondary
= (section
!= find_section (name
));
8722 free_debug_section (i
);
8724 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8725 sec
->name
= sec
->uncompressed_name
;
8727 sec
->name
= sec
->compressed_name
;
8728 if (load_specific_debug_section (i
, section
, file
))
8730 result
&= debug_displays
[i
].display (sec
, file
);
8732 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8733 free_debug_section (i
);
8741 printf (_("Unrecognized debug section: %s\n"), name
);
8748 /* Set DUMP_SECTS for all sections where dumps were requested
8749 based on section name. */
8752 initialise_dumps_byname (void)
8754 struct dump_list_entry
* cur
;
8756 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8761 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8762 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8764 request_dump_bynumber (i
, cur
->type
);
8769 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8775 process_section_contents (FILE * file
)
8777 Elf_Internal_Shdr
* section
;
8783 initialise_dumps_byname ();
8785 for (i
= 0, section
= section_headers
;
8786 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8789 #ifdef SUPPORT_DISASSEMBLY
8790 if (dump_sects
[i
] & DISASS_DUMP
)
8791 disassemble_section (section
, file
);
8793 if (dump_sects
[i
] & HEX_DUMP
)
8794 dump_section_as_bytes (section
, file
, FALSE
);
8796 if (dump_sects
[i
] & RELOC_DUMP
)
8797 dump_section_as_bytes (section
, file
, TRUE
);
8799 if (dump_sects
[i
] & STRING_DUMP
)
8800 dump_section_as_strings (section
, file
);
8802 if (dump_sects
[i
] & DEBUG_DUMP
)
8803 display_debug_section (section
, file
);
8806 /* Check to see if the user requested a
8807 dump of a section that does not exist. */
8808 while (i
++ < num_dump_sects
)
8810 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8814 process_mips_fpe_exception (int mask
)
8819 if (mask
& OEX_FPU_INEX
)
8820 fputs ("INEX", stdout
), first
= 0;
8821 if (mask
& OEX_FPU_UFLO
)
8822 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8823 if (mask
& OEX_FPU_OFLO
)
8824 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8825 if (mask
& OEX_FPU_DIV0
)
8826 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8827 if (mask
& OEX_FPU_INVAL
)
8828 printf ("%sINVAL", first
? "" : "|");
8831 fputs ("0", stdout
);
8834 /* ARM EABI attributes section. */
8839 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8841 const char ** table
;
8842 } arm_attr_public_tag
;
8844 static const char * arm_attr_tag_CPU_arch
[] =
8845 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8846 "v6K", "v7", "v6-M", "v6S-M"};
8847 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8848 static const char * arm_attr_tag_THUMB_ISA_use
[] =
8849 {"No", "Thumb-1", "Thumb-2"};
8850 static const char * arm_attr_tag_VFP_arch
[] =
8851 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8852 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8853 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8854 static const char * arm_attr_tag_PCS_config
[] =
8855 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8856 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8857 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
8858 {"V6", "SB", "TLS", "Unused"};
8859 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
8860 {"Absolute", "PC-relative", "SB-relative", "None"};
8861 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
8862 {"Absolute", "PC-relative", "None"};
8863 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
8864 {"None", "direct", "GOT-indirect"};
8865 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
8866 {"None", "??? 1", "2", "??? 3", "4"};
8867 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8868 static const char * arm_attr_tag_ABI_FP_denormal
[] =
8869 {"Unused", "Needed", "Sign only"};
8870 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8871 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8872 static const char * arm_attr_tag_ABI_FP_number_model
[] =
8873 {"Unused", "Finite", "RTABI", "IEEE 754"};
8874 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8875 static const char * arm_attr_tag_ABI_align8_preserved
[] =
8876 {"No", "Yes, except leaf SP", "Yes"};
8877 static const char * arm_attr_tag_ABI_enum_size
[] =
8878 {"Unused", "small", "int", "forced to int"};
8879 static const char * arm_attr_tag_ABI_HardFP_use
[] =
8880 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8881 static const char * arm_attr_tag_ABI_VFP_args
[] =
8882 {"AAPCS", "VFP registers", "custom"};
8883 static const char * arm_attr_tag_ABI_WMMX_args
[] =
8884 {"AAPCS", "WMMX registers", "custom"};
8885 static const char * arm_attr_tag_ABI_optimization_goals
[] =
8886 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8887 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8888 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
8889 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8890 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8891 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8892 static const char * arm_attr_tag_VFP_HP_extension
[] =
8893 {"Not Allowed", "Allowed"};
8894 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
8895 {"None", "IEEE 754", "Alternative Format"};
8896 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8897 static const char * arm_attr_tag_Virtualization_use
[] =
8898 {"Not Allowed", "Allowed"};
8899 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8901 #define LOOKUP(id, name) \
8902 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8903 static arm_attr_public_tag arm_attr_public_tags
[] =
8905 {4, "CPU_raw_name", 1, NULL
},
8906 {5, "CPU_name", 1, NULL
},
8907 LOOKUP(6, CPU_arch
),
8908 {7, "CPU_arch_profile", 0, NULL
},
8909 LOOKUP(8, ARM_ISA_use
),
8910 LOOKUP(9, THUMB_ISA_use
),
8911 LOOKUP(10, VFP_arch
),
8912 LOOKUP(11, WMMX_arch
),
8913 LOOKUP(12, Advanced_SIMD_arch
),
8914 LOOKUP(13, PCS_config
),
8915 LOOKUP(14, ABI_PCS_R9_use
),
8916 LOOKUP(15, ABI_PCS_RW_data
),
8917 LOOKUP(16, ABI_PCS_RO_data
),
8918 LOOKUP(17, ABI_PCS_GOT_use
),
8919 LOOKUP(18, ABI_PCS_wchar_t
),
8920 LOOKUP(19, ABI_FP_rounding
),
8921 LOOKUP(20, ABI_FP_denormal
),
8922 LOOKUP(21, ABI_FP_exceptions
),
8923 LOOKUP(22, ABI_FP_user_exceptions
),
8924 LOOKUP(23, ABI_FP_number_model
),
8925 LOOKUP(24, ABI_align8_needed
),
8926 LOOKUP(25, ABI_align8_preserved
),
8927 LOOKUP(26, ABI_enum_size
),
8928 LOOKUP(27, ABI_HardFP_use
),
8929 LOOKUP(28, ABI_VFP_args
),
8930 LOOKUP(29, ABI_WMMX_args
),
8931 LOOKUP(30, ABI_optimization_goals
),
8932 LOOKUP(31, ABI_FP_optimization_goals
),
8933 {32, "compatibility", 0, NULL
},
8934 LOOKUP(34, CPU_unaligned_access
),
8935 LOOKUP(36, VFP_HP_extension
),
8936 LOOKUP(38, ABI_FP_16bit_format
),
8937 {64, "nodefaults", 0, NULL
},
8938 {65, "also_compatible_with", 0, NULL
},
8939 LOOKUP(66, T2EE_use
),
8940 {67, "conformance", 1, NULL
},
8941 LOOKUP(68, Virtualization_use
),
8942 LOOKUP(70, MPextension_use
)
8946 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8950 read_uleb128 (unsigned char * p
, unsigned int * plen
)
8964 val
|= ((unsigned int)c
& 0x7f) << shift
;
8973 static unsigned char *
8974 display_arm_attribute (unsigned char * p
)
8979 arm_attr_public_tag
* attr
;
8983 tag
= read_uleb128 (p
, &len
);
8986 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
8988 if (arm_attr_public_tags
[i
].tag
== tag
)
8990 attr
= &arm_attr_public_tags
[i
];
8997 printf (" Tag_%s: ", attr
->name
);
9003 case 7: /* Tag_CPU_arch_profile. */
9004 val
= read_uleb128 (p
, &len
);
9008 case 0: printf ("None\n"); break;
9009 case 'A': printf ("Application\n"); break;
9010 case 'R': printf ("Realtime\n"); break;
9011 case 'M': printf ("Microcontroller\n"); break;
9012 default: printf ("??? (%d)\n", val
); break;
9016 case 32: /* Tag_compatibility. */
9017 val
= read_uleb128 (p
, &len
);
9019 printf ("flag = %d, vendor = %s\n", val
, p
);
9020 p
+= strlen ((char *) p
) + 1;
9023 case 64: /* Tag_nodefaults. */
9028 case 65: /* Tag_also_compatible_with. */
9029 val
= read_uleb128 (p
, &len
);
9031 if (val
== 6 /* Tag_CPU_arch. */)
9033 val
= read_uleb128 (p
, &len
);
9035 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
9036 printf ("??? (%d)\n", val
);
9038 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9042 while (*(p
++) != '\0' /* NUL terminator. */);
9056 assert (attr
->type
& 0x80);
9057 val
= read_uleb128 (p
, &len
);
9059 type
= attr
->type
& 0x7f;
9061 printf ("??? (%d)\n", val
);
9063 printf ("%s\n", attr
->table
[val
]);
9070 type
= 1; /* String. */
9072 type
= 2; /* uleb128. */
9073 printf (" Tag_unknown_%d: ", tag
);
9078 printf ("\"%s\"\n", p
);
9079 p
+= strlen ((char *) p
) + 1;
9083 val
= read_uleb128 (p
, &len
);
9085 printf ("%d (0x%x)\n", val
, val
);
9091 static unsigned char *
9092 display_gnu_attribute (unsigned char * p
,
9093 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9100 tag
= read_uleb128 (p
, &len
);
9103 /* Tag_compatibility is the only generic GNU attribute defined at
9107 val
= read_uleb128 (p
, &len
);
9109 printf ("flag = %d, vendor = %s\n", val
, p
);
9110 p
+= strlen ((char *) p
) + 1;
9114 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9115 return display_proc_gnu_attribute (p
, tag
);
9118 type
= 1; /* String. */
9120 type
= 2; /* uleb128. */
9121 printf (" Tag_unknown_%d: ", tag
);
9125 printf ("\"%s\"\n", p
);
9126 p
+= strlen ((char *) p
) + 1;
9130 val
= read_uleb128 (p
, &len
);
9132 printf ("%d (0x%x)\n", val
, val
);
9138 static unsigned char *
9139 display_power_gnu_attribute (unsigned char * p
, int tag
)
9145 if (tag
== Tag_GNU_Power_ABI_FP
)
9147 val
= read_uleb128 (p
, &len
);
9149 printf (" Tag_GNU_Power_ABI_FP: ");
9154 printf ("Hard or soft float\n");
9157 printf ("Hard float\n");
9160 printf ("Soft float\n");
9163 printf ("Single-precision hard float\n");
9166 printf ("??? (%d)\n", val
);
9172 if (tag
== Tag_GNU_Power_ABI_Vector
)
9174 val
= read_uleb128 (p
, &len
);
9176 printf (" Tag_GNU_Power_ABI_Vector: ");
9183 printf ("Generic\n");
9186 printf ("AltiVec\n");
9192 printf ("??? (%d)\n", val
);
9198 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9200 val
= read_uleb128 (p
, &len
);
9202 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9212 printf ("Memory\n");
9215 printf ("??? (%d)\n", val
);
9222 type
= 1; /* String. */
9224 type
= 2; /* uleb128. */
9225 printf (" Tag_unknown_%d: ", tag
);
9229 printf ("\"%s\"\n", p
);
9230 p
+= strlen ((char *) p
) + 1;
9234 val
= read_uleb128 (p
, &len
);
9236 printf ("%d (0x%x)\n", val
, val
);
9242 static unsigned char *
9243 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9249 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9251 val
= read_uleb128 (p
, &len
);
9253 printf (" Tag_GNU_MIPS_ABI_FP: ");
9258 printf ("Hard or soft float\n");
9261 printf ("Hard float (-mdouble-float)\n");
9264 printf ("Hard float (-msingle-float)\n");
9267 printf ("Soft float\n");
9270 printf ("64-bit float (-mips32r2 -mfp64)\n");
9273 printf ("??? (%d)\n", val
);
9280 type
= 1; /* String. */
9282 type
= 2; /* uleb128. */
9283 printf (" Tag_unknown_%d: ", tag
);
9287 printf ("\"%s\"\n", p
);
9288 p
+= strlen ((char *) p
) + 1;
9292 val
= read_uleb128 (p
, &len
);
9294 printf ("%d (0x%x)\n", val
, val
);
9301 process_attributes (FILE * file
,
9302 const char * public_name
,
9303 unsigned int proc_type
,
9304 unsigned char * (* display_pub_attribute
) (unsigned char *),
9305 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9307 Elf_Internal_Shdr
* sect
;
9308 unsigned char * contents
;
9310 unsigned char * end
;
9311 bfd_vma section_len
;
9315 /* Find the section header so that we get the size. */
9316 for (i
= 0, sect
= section_headers
;
9317 i
< elf_header
.e_shnum
;
9320 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9323 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9325 if (contents
== NULL
)
9331 len
= sect
->sh_size
- 1;
9337 bfd_boolean public_section
;
9338 bfd_boolean gnu_section
;
9340 section_len
= byte_get (p
, 4);
9343 if (section_len
> len
)
9345 printf (_("ERROR: Bad section length (%d > %d)\n"),
9346 (int) section_len
, (int) len
);
9351 printf ("Attribute Section: %s\n", p
);
9353 if (public_name
&& streq ((char *) p
, public_name
))
9354 public_section
= TRUE
;
9356 public_section
= FALSE
;
9358 if (streq ((char *) p
, "gnu"))
9361 gnu_section
= FALSE
;
9363 namelen
= strlen ((char *) p
) + 1;
9365 section_len
-= namelen
+ 4;
9367 while (section_len
> 0)
9373 size
= byte_get (p
, 4);
9374 if (size
> section_len
)
9376 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9377 (int) size
, (int) section_len
);
9381 section_len
-= size
;
9388 printf ("File Attributes\n");
9391 printf ("Section Attributes:");
9394 printf ("Symbol Attributes:");
9400 val
= read_uleb128 (p
, &i
);
9404 printf (" %d", val
);
9409 printf ("Unknown tag: %d\n", tag
);
9410 public_section
= FALSE
;
9417 p
= display_pub_attribute (p
);
9419 else if (gnu_section
)
9422 p
= display_gnu_attribute (p
,
9423 display_proc_gnu_attribute
);
9427 /* ??? Do something sensible, like dump hex. */
9428 printf (" Unknown section contexts\n");
9435 printf (_("Unknown format '%c'\n"), *p
);
9443 process_arm_specific (FILE * file
)
9445 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9446 display_arm_attribute
, NULL
);
9450 process_power_specific (FILE * file
)
9452 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9453 display_power_gnu_attribute
);
9456 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9457 Print the Address, Access and Initial fields of an entry at VMA ADDR
9458 and return the VMA of the next entry. */
9461 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9464 print_vma (addr
, LONG_HEX
);
9466 if (addr
< pltgot
+ 0xfff0)
9467 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9469 printf ("%10s", "");
9472 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9477 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9478 print_vma (entry
, LONG_HEX
);
9480 return addr
+ (is_32bit_elf
? 4 : 8);
9483 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9484 PLTGOT. Print the Address and Initial fields of an entry at VMA
9485 ADDR and return the VMA of the next entry. */
9488 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9491 print_vma (addr
, LONG_HEX
);
9494 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9499 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9500 print_vma (entry
, LONG_HEX
);
9502 return addr
+ (is_32bit_elf
? 4 : 8);
9506 process_mips_specific (FILE * file
)
9508 Elf_Internal_Dyn
* entry
;
9509 size_t liblist_offset
= 0;
9510 size_t liblistno
= 0;
9511 size_t conflictsno
= 0;
9512 size_t options_offset
= 0;
9513 size_t conflicts_offset
= 0;
9514 size_t pltrelsz
= 0;
9517 bfd_vma mips_pltgot
= 0;
9519 bfd_vma local_gotno
= 0;
9521 bfd_vma symtabno
= 0;
9523 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9524 display_mips_gnu_attribute
);
9526 /* We have a lot of special sections. Thanks SGI! */
9527 if (dynamic_section
== NULL
)
9528 /* No information available. */
9531 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9532 switch (entry
->d_tag
)
9534 case DT_MIPS_LIBLIST
:
9536 = offset_from_vma (file
, entry
->d_un
.d_val
,
9537 liblistno
* sizeof (Elf32_External_Lib
));
9539 case DT_MIPS_LIBLISTNO
:
9540 liblistno
= entry
->d_un
.d_val
;
9542 case DT_MIPS_OPTIONS
:
9543 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9545 case DT_MIPS_CONFLICT
:
9547 = offset_from_vma (file
, entry
->d_un
.d_val
,
9548 conflictsno
* sizeof (Elf32_External_Conflict
));
9550 case DT_MIPS_CONFLICTNO
:
9551 conflictsno
= entry
->d_un
.d_val
;
9554 pltgot
= entry
->d_un
.d_ptr
;
9556 case DT_MIPS_LOCAL_GOTNO
:
9557 local_gotno
= entry
->d_un
.d_val
;
9559 case DT_MIPS_GOTSYM
:
9560 gotsym
= entry
->d_un
.d_val
;
9562 case DT_MIPS_SYMTABNO
:
9563 symtabno
= entry
->d_un
.d_val
;
9565 case DT_MIPS_PLTGOT
:
9566 mips_pltgot
= entry
->d_un
.d_ptr
;
9569 pltrel
= entry
->d_un
.d_val
;
9572 pltrelsz
= entry
->d_un
.d_val
;
9575 jmprel
= entry
->d_un
.d_ptr
;
9581 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9583 Elf32_External_Lib
* elib
;
9586 elib
= get_data (NULL
, file
, liblist_offset
,
9587 liblistno
, sizeof (Elf32_External_Lib
),
9591 printf ("\nSection '.liblist' contains %lu entries:\n",
9592 (unsigned long) liblistno
);
9593 fputs (" Library Time Stamp Checksum Version Flags\n",
9596 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9603 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9604 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9605 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9606 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9607 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9609 tmp
= gmtime (&time
);
9610 snprintf (timebuf
, sizeof (timebuf
),
9611 "%04u-%02u-%02uT%02u:%02u:%02u",
9612 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9613 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9615 printf ("%3lu: ", (unsigned long) cnt
);
9616 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9617 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9619 printf ("<corrupt: %9ld>", liblist
.l_name
);
9620 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9623 if (liblist
.l_flags
== 0)
9634 { " EXACT_MATCH", LL_EXACT_MATCH
},
9635 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9636 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9637 { " EXPORTS", LL_EXPORTS
},
9638 { " DELAY_LOAD", LL_DELAY_LOAD
},
9639 { " DELTA", LL_DELTA
}
9641 int flags
= liblist
.l_flags
;
9644 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9645 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9647 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9648 flags
^= l_flags_vals
[fcnt
].bit
;
9651 printf (" %#x", (unsigned int) flags
);
9661 if (options_offset
!= 0)
9663 Elf_External_Options
* eopt
;
9664 Elf_Internal_Shdr
* sect
= section_headers
;
9665 Elf_Internal_Options
* iopt
;
9666 Elf_Internal_Options
* option
;
9670 /* Find the section header so that we get the size. */
9671 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9674 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9678 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9681 error (_("Out of memory\n"));
9688 while (offset
< sect
->sh_size
)
9690 Elf_External_Options
* eoption
;
9692 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9694 option
->kind
= BYTE_GET (eoption
->kind
);
9695 option
->size
= BYTE_GET (eoption
->size
);
9696 option
->section
= BYTE_GET (eoption
->section
);
9697 option
->info
= BYTE_GET (eoption
->info
);
9699 offset
+= option
->size
;
9705 printf (_("\nSection '%s' contains %d entries:\n"),
9706 SECTION_NAME (sect
), cnt
);
9714 switch (option
->kind
)
9717 /* This shouldn't happen. */
9718 printf (" NULL %d %lx", option
->section
, option
->info
);
9721 printf (" REGINFO ");
9722 if (elf_header
.e_machine
== EM_MIPS
)
9725 Elf32_External_RegInfo
* ereg
;
9726 Elf32_RegInfo reginfo
;
9728 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9729 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9730 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9731 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9732 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9733 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9734 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9736 printf ("GPR %08lx GP 0x%lx\n",
9738 (unsigned long) reginfo
.ri_gp_value
);
9739 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9740 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9741 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9746 Elf64_External_RegInfo
* ereg
;
9747 Elf64_Internal_RegInfo reginfo
;
9749 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9750 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9751 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9752 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9753 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9754 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9755 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9757 printf ("GPR %08lx GP 0x",
9758 reginfo
.ri_gprmask
);
9759 printf_vma (reginfo
.ri_gp_value
);
9762 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9763 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9764 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9768 case ODK_EXCEPTIONS
:
9769 fputs (" EXCEPTIONS fpe_min(", stdout
);
9770 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9771 fputs (") fpe_max(", stdout
);
9772 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9773 fputs (")", stdout
);
9775 if (option
->info
& OEX_PAGE0
)
9776 fputs (" PAGE0", stdout
);
9777 if (option
->info
& OEX_SMM
)
9778 fputs (" SMM", stdout
);
9779 if (option
->info
& OEX_FPDBUG
)
9780 fputs (" FPDBUG", stdout
);
9781 if (option
->info
& OEX_DISMISS
)
9782 fputs (" DISMISS", stdout
);
9785 fputs (" PAD ", stdout
);
9786 if (option
->info
& OPAD_PREFIX
)
9787 fputs (" PREFIX", stdout
);
9788 if (option
->info
& OPAD_POSTFIX
)
9789 fputs (" POSTFIX", stdout
);
9790 if (option
->info
& OPAD_SYMBOL
)
9791 fputs (" SYMBOL", stdout
);
9794 fputs (" HWPATCH ", stdout
);
9795 if (option
->info
& OHW_R4KEOP
)
9796 fputs (" R4KEOP", stdout
);
9797 if (option
->info
& OHW_R8KPFETCH
)
9798 fputs (" R8KPFETCH", stdout
);
9799 if (option
->info
& OHW_R5KEOP
)
9800 fputs (" R5KEOP", stdout
);
9801 if (option
->info
& OHW_R5KCVTL
)
9802 fputs (" R5KCVTL", stdout
);
9805 fputs (" FILL ", stdout
);
9806 /* XXX Print content of info word? */
9809 fputs (" TAGS ", stdout
);
9810 /* XXX Print content of info word? */
9813 fputs (" HWAND ", stdout
);
9814 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9815 fputs (" R4KEOP_CHECKED", stdout
);
9816 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9817 fputs (" R4KEOP_CLEAN", stdout
);
9820 fputs (" HWOR ", stdout
);
9821 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9822 fputs (" R4KEOP_CHECKED", stdout
);
9823 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9824 fputs (" R4KEOP_CLEAN", stdout
);
9827 printf (" GP_GROUP %#06lx self-contained %#06lx",
9828 option
->info
& OGP_GROUP
,
9829 (option
->info
& OGP_SELF
) >> 16);
9832 printf (" IDENT %#06lx self-contained %#06lx",
9833 option
->info
& OGP_GROUP
,
9834 (option
->info
& OGP_SELF
) >> 16);
9837 /* This shouldn't happen. */
9838 printf (" %3d ??? %d %lx",
9839 option
->kind
, option
->section
, option
->info
);
9843 len
= sizeof (* eopt
);
9844 while (len
< option
->size
)
9845 if (((char *) option
)[len
] >= ' '
9846 && ((char *) option
)[len
] < 0x7f)
9847 printf ("%c", ((char *) option
)[len
++]);
9849 printf ("\\%03o", ((char *) option
)[len
++]);
9851 fputs ("\n", stdout
);
9859 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9861 Elf32_Conflict
* iconf
;
9864 if (dynamic_symbols
== NULL
)
9866 error (_("conflict list found without a dynamic symbol table\n"));
9870 iconf
= cmalloc (conflictsno
, sizeof (* iconf
));
9873 error (_("Out of memory\n"));
9879 Elf32_External_Conflict
* econf32
;
9881 econf32
= get_data (NULL
, file
, conflicts_offset
,
9882 conflictsno
, sizeof (* econf32
), _("conflict"));
9886 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9887 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9893 Elf64_External_Conflict
* econf64
;
9895 econf64
= get_data (NULL
, file
, conflicts_offset
,
9896 conflictsno
, sizeof (* econf64
), _("conflict"));
9900 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9901 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9906 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9907 (unsigned long) conflictsno
);
9908 puts (_(" Num: Index Value Name"));
9910 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9912 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9914 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9915 print_vma (psym
->st_value
, FULL_HEX
);
9917 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9918 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9920 printf ("<corrupt: %14ld>", psym
->st_name
);
9927 if (pltgot
!= 0 && local_gotno
!= 0)
9929 bfd_vma entry
, local_end
, global_end
;
9931 unsigned char * data
;
9935 addr_size
= (is_32bit_elf
? 4 : 8);
9936 local_end
= pltgot
+ local_gotno
* addr_size
;
9937 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9939 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9940 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9941 printf (_("\nPrimary GOT:\n"));
9942 printf (_(" Canonical gp value: "));
9943 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9946 printf (_(" Reserved entries:\n"));
9947 printf (_(" %*s %10s %*s Purpose\n"),
9948 addr_size
* 2, "Address", "Access",
9949 addr_size
* 2, "Initial");
9950 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9951 printf (" Lazy resolver\n");
9953 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9954 >> (addr_size
* 8 - 1)) != 0)
9956 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9957 printf (" Module pointer (GNU extension)\n");
9961 if (entry
< local_end
)
9963 printf (_(" Local entries:\n"));
9964 printf (_(" %*s %10s %*s\n"),
9965 addr_size
* 2, "Address", "Access",
9966 addr_size
* 2, "Initial");
9967 while (entry
< local_end
)
9969 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9975 if (gotsym
< symtabno
)
9979 printf (_(" Global entries:\n"));
9980 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9981 addr_size
* 2, "Address", "Access",
9982 addr_size
* 2, "Initial",
9983 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9984 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9985 for (i
= gotsym
; i
< symtabno
; i
++)
9987 Elf_Internal_Sym
* psym
;
9989 psym
= dynamic_symbols
+ i
;
9990 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9992 print_vma (psym
->st_value
, LONG_HEX
);
9993 printf (" %-7s %3s ",
9994 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9995 get_symbol_index_type (psym
->st_shndx
));
9996 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9997 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9999 printf ("<corrupt: %14ld>", psym
->st_name
);
10009 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10011 bfd_vma entry
, end
;
10012 size_t offset
, rel_offset
;
10013 unsigned long count
, i
;
10014 unsigned char * data
;
10015 int addr_size
, sym_width
;
10016 Elf_Internal_Rela
* rels
;
10018 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10019 if (pltrel
== DT_RELA
)
10021 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10026 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10030 entry
= mips_pltgot
;
10031 addr_size
= (is_32bit_elf
? 4 : 8);
10032 end
= mips_pltgot
+ (2 + count
) * addr_size
;
10034 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
10035 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
10036 printf (_("\nPLT GOT:\n\n"));
10037 printf (_(" Reserved entries:\n"));
10038 printf (_(" %*s %*s Purpose\n"),
10039 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10040 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10041 printf (" PLT lazy resolver\n");
10042 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10043 printf (" Module pointer\n");
10046 printf (_(" Entries:\n"));
10047 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10048 addr_size
* 2, "Address",
10049 addr_size
* 2, "Initial",
10050 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10051 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10052 for (i
= 0; i
< count
; i
++)
10054 Elf_Internal_Sym
* psym
;
10056 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10057 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10059 print_vma (psym
->st_value
, LONG_HEX
);
10060 printf (" %-7s %3s ",
10061 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10062 get_symbol_index_type (psym
->st_shndx
));
10063 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10064 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10066 printf ("<corrupt: %14ld>", psym
->st_name
);
10080 process_gnu_liblist (FILE * file
)
10082 Elf_Internal_Shdr
* section
;
10083 Elf_Internal_Shdr
* string_sec
;
10084 Elf32_External_Lib
* elib
;
10086 size_t strtab_size
;
10093 for (i
= 0, section
= section_headers
;
10094 i
< elf_header
.e_shnum
;
10097 switch (section
->sh_type
)
10099 case SHT_GNU_LIBLIST
:
10100 if (section
->sh_link
>= elf_header
.e_shnum
)
10103 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10108 string_sec
= section_headers
+ section
->sh_link
;
10110 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10111 string_sec
->sh_size
, _("liblist string table"));
10112 strtab_size
= string_sec
->sh_size
;
10115 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10121 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10122 SECTION_NAME (section
),
10123 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10125 puts (" Library Time Stamp Checksum Version Flags");
10127 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10135 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10136 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10137 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10138 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10139 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10141 tmp
= gmtime (&time
);
10142 snprintf (timebuf
, sizeof (timebuf
),
10143 "%04u-%02u-%02uT%02u:%02u:%02u",
10144 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10145 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10147 printf ("%3lu: ", (unsigned long) cnt
);
10149 printf ("%-20s", liblist
.l_name
< strtab_size
10150 ? strtab
+ liblist
.l_name
: "<corrupt>");
10152 printf ("%-20.20s", liblist
.l_name
< strtab_size
10153 ? strtab
+ liblist
.l_name
: "<corrupt>");
10154 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10155 liblist
.l_version
, liblist
.l_flags
);
10165 static const char *
10166 get_note_type (unsigned e_type
)
10168 static char buff
[64];
10170 if (elf_header
.e_type
== ET_CORE
)
10174 return _("NT_AUXV (auxiliary vector)");
10176 return _("NT_PRSTATUS (prstatus structure)");
10178 return _("NT_FPREGSET (floating point registers)");
10180 return _("NT_PRPSINFO (prpsinfo structure)");
10181 case NT_TASKSTRUCT
:
10182 return _("NT_TASKSTRUCT (task structure)");
10184 return _("NT_PRXFPREG (user_xfpregs structure)");
10186 return _("NT_PPC_VMX (ppc Altivec registers)");
10188 return _("NT_PPC_VSX (ppc VSX registers)");
10190 return _("NT_PSTATUS (pstatus structure)");
10192 return _("NT_FPREGS (floating point registers)");
10194 return _("NT_PSINFO (psinfo structure)");
10196 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10198 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10199 case NT_WIN32PSTATUS
:
10200 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10208 return _("NT_VERSION (version)");
10210 return _("NT_ARCH (architecture)");
10215 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10219 static const char *
10220 get_gnu_elf_note_type (unsigned e_type
)
10222 static char buff
[64];
10226 case NT_GNU_ABI_TAG
:
10227 return _("NT_GNU_ABI_TAG (ABI version tag)");
10229 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10230 case NT_GNU_BUILD_ID
:
10231 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10232 case NT_GNU_GOLD_VERSION
:
10233 return _("NT_GNU_GOLD_VERSION (gold version)");
10238 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10242 static const char *
10243 get_netbsd_elfcore_note_type (unsigned e_type
)
10245 static char buff
[64];
10247 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10249 /* NetBSD core "procinfo" structure. */
10250 return _("NetBSD procinfo structure");
10253 /* As of Jan 2002 there are no other machine-independent notes
10254 defined for NetBSD core files. If the note type is less
10255 than the start of the machine-dependent note types, we don't
10258 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10260 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10264 switch (elf_header
.e_machine
)
10266 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10267 and PT_GETFPREGS == mach+2. */
10272 case EM_SPARC32PLUS
:
10276 case NT_NETBSDCORE_FIRSTMACH
+0:
10277 return _("PT_GETREGS (reg structure)");
10278 case NT_NETBSDCORE_FIRSTMACH
+2:
10279 return _("PT_GETFPREGS (fpreg structure)");
10285 /* On all other arch's, PT_GETREGS == mach+1 and
10286 PT_GETFPREGS == mach+3. */
10290 case NT_NETBSDCORE_FIRSTMACH
+1:
10291 return _("PT_GETREGS (reg structure)");
10292 case NT_NETBSDCORE_FIRSTMACH
+3:
10293 return _("PT_GETFPREGS (fpreg structure)");
10299 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10300 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10304 /* Note that by the ELF standard, the name field is already null byte
10305 terminated, and namesz includes the terminating null byte.
10306 I.E. the value of namesz for the name "FSF" is 4.
10308 If the value of namesz is zero, there is no name present. */
10310 process_note (Elf_Internal_Note
* pnote
)
10312 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10315 if (pnote
->namesz
== 0)
10316 /* If there is no note name, then use the default set of
10317 note type strings. */
10318 nt
= get_note_type (pnote
->type
);
10320 else if (const_strneq (pnote
->namedata
, "GNU"))
10321 /* GNU-specific object file notes. */
10322 nt
= get_gnu_elf_note_type (pnote
->type
);
10324 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10325 /* NetBSD-specific core file notes. */
10326 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10328 else if (strneq (pnote
->namedata
, "SPU/", 4))
10330 /* SPU-specific core file notes. */
10331 nt
= pnote
->namedata
+ 4;
10336 /* Don't recognize this note name; just use the default set of
10337 note type strings. */
10338 nt
= get_note_type (pnote
->type
);
10340 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10346 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10348 Elf_External_Note
* pnotes
;
10349 Elf_External_Note
* external
;
10355 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10361 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10362 (unsigned long) offset
, (unsigned long) length
);
10363 printf (_(" Owner\t\tData size\tDescription\n"));
10365 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10367 Elf_External_Note
* next
;
10368 Elf_Internal_Note inote
;
10369 char * temp
= NULL
;
10371 inote
.type
= BYTE_GET (external
->type
);
10372 inote
.namesz
= BYTE_GET (external
->namesz
);
10373 inote
.namedata
= external
->name
;
10374 inote
.descsz
= BYTE_GET (external
->descsz
);
10375 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10376 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10378 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10380 if (((char *) next
) > (((char *) pnotes
) + length
))
10382 warn (_("corrupt note found at offset %lx into core notes\n"),
10383 (unsigned long) ((char *) external
- (char *) pnotes
));
10384 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10385 inote
.type
, inote
.namesz
, inote
.descsz
);
10391 /* Verify that name is null terminated. It appears that at least
10392 one version of Linux (RedHat 6.0) generates corefiles that don't
10393 comply with the ELF spec by failing to include the null byte in
10395 if (inote
.namedata
[inote
.namesz
] != '\0')
10397 temp
= malloc (inote
.namesz
+ 1);
10401 error (_("Out of memory\n"));
10406 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10407 temp
[inote
.namesz
] = 0;
10409 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10410 inote
.namedata
= temp
;
10413 res
&= process_note (& inote
);
10428 process_corefile_note_segments (FILE * file
)
10430 Elf_Internal_Phdr
* segment
;
10434 if (! get_program_headers (file
))
10437 for (i
= 0, segment
= program_headers
;
10438 i
< elf_header
.e_phnum
;
10441 if (segment
->p_type
== PT_NOTE
)
10442 res
&= process_corefile_note_segment (file
,
10443 (bfd_vma
) segment
->p_offset
,
10444 (bfd_vma
) segment
->p_filesz
);
10451 process_note_sections (FILE * file
)
10453 Elf_Internal_Shdr
* section
;
10457 for (i
= 0, section
= section_headers
;
10458 i
< elf_header
.e_shnum
;
10460 if (section
->sh_type
== SHT_NOTE
)
10461 res
&= process_corefile_note_segment (file
,
10462 (bfd_vma
) section
->sh_offset
,
10463 (bfd_vma
) section
->sh_size
);
10469 process_notes (FILE * file
)
10471 /* If we have not been asked to display the notes then do nothing. */
10475 if (elf_header
.e_type
!= ET_CORE
)
10476 return process_note_sections (file
);
10478 /* No program headers means no NOTE segment. */
10479 if (elf_header
.e_phnum
> 0)
10480 return process_corefile_note_segments (file
);
10482 printf (_("No note segments present in the core file.\n"));
10487 process_arch_specific (FILE * file
)
10492 switch (elf_header
.e_machine
)
10495 return process_arm_specific (file
);
10497 case EM_MIPS_RS3_LE
:
10498 return process_mips_specific (file
);
10501 return process_power_specific (file
);
10510 get_file_header (FILE * file
)
10512 /* Read in the identity array. */
10513 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10516 /* Determine how to read the rest of the header. */
10517 switch (elf_header
.e_ident
[EI_DATA
])
10519 default: /* fall through */
10520 case ELFDATANONE
: /* fall through */
10522 byte_get
= byte_get_little_endian
;
10523 byte_put
= byte_put_little_endian
;
10526 byte_get
= byte_get_big_endian
;
10527 byte_put
= byte_put_big_endian
;
10531 /* For now we only support 32 bit and 64 bit ELF files. */
10532 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10534 /* Read in the rest of the header. */
10537 Elf32_External_Ehdr ehdr32
;
10539 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10542 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10543 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10544 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10545 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10546 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10547 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10548 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10549 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10550 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10551 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10552 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10553 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10554 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10558 Elf64_External_Ehdr ehdr64
;
10560 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10561 we will not be able to cope with the 64bit data found in
10562 64 ELF files. Detect this now and abort before we start
10563 overwriting things. */
10564 if (sizeof (bfd_vma
) < 8)
10566 error (_("This instance of readelf has been built without support for a\n\
10567 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10571 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10574 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10575 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10576 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10577 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10578 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10579 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10580 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10581 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10582 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10583 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10584 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10585 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10586 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10589 if (elf_header
.e_shoff
)
10591 /* There may be some extensions in the first section header. Don't
10592 bomb if we can't read it. */
10594 get_32bit_section_headers (file
, 1);
10596 get_64bit_section_headers (file
, 1);
10602 /* Process one ELF object file according to the command line options.
10603 This file may actually be stored in an archive. The file is
10604 positioned at the start of the ELF object. */
10607 process_object (char * file_name
, FILE * file
)
10611 if (! get_file_header (file
))
10613 error (_("%s: Failed to read file header\n"), file_name
);
10617 /* Initialise per file variables. */
10618 for (i
= ARRAY_SIZE (version_info
); i
--;)
10619 version_info
[i
] = 0;
10621 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10622 dynamic_info
[i
] = 0;
10624 /* Process the file. */
10626 printf (_("\nFile: %s\n"), file_name
);
10628 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10629 Note we do this even if cmdline_dump_sects is empty because we
10630 must make sure that the dump_sets array is zeroed out before each
10631 object file is processed. */
10632 if (num_dump_sects
> num_cmdline_dump_sects
)
10633 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10635 if (num_cmdline_dump_sects
> 0)
10637 if (num_dump_sects
== 0)
10638 /* A sneaky way of allocating the dump_sects array. */
10639 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10641 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10642 memcpy (dump_sects
, cmdline_dump_sects
,
10643 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10646 if (! process_file_header ())
10649 if (! process_section_headers (file
))
10651 /* Without loaded section headers we cannot process lots of
10653 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10655 if (! do_using_dynamic
)
10656 do_syms
= do_reloc
= 0;
10659 if (! process_section_groups (file
))
10661 /* Without loaded section groups we cannot process unwind. */
10665 if (process_program_headers (file
))
10666 process_dynamic_section (file
);
10668 process_relocs (file
);
10670 process_unwind (file
);
10672 process_symbol_table (file
);
10674 process_syminfo (file
);
10676 process_version_sections (file
);
10678 process_section_contents (file
);
10680 process_notes (file
);
10682 process_gnu_liblist (file
);
10684 process_arch_specific (file
);
10686 if (program_headers
)
10688 free (program_headers
);
10689 program_headers
= NULL
;
10692 if (section_headers
)
10694 free (section_headers
);
10695 section_headers
= NULL
;
10700 free (string_table
);
10701 string_table
= NULL
;
10702 string_table_length
= 0;
10705 if (dynamic_strings
)
10707 free (dynamic_strings
);
10708 dynamic_strings
= NULL
;
10709 dynamic_strings_length
= 0;
10712 if (dynamic_symbols
)
10714 free (dynamic_symbols
);
10715 dynamic_symbols
= NULL
;
10716 num_dynamic_syms
= 0;
10719 if (dynamic_syminfo
)
10721 free (dynamic_syminfo
);
10722 dynamic_syminfo
= NULL
;
10725 if (section_headers_groups
)
10727 free (section_headers_groups
);
10728 section_headers_groups
= NULL
;
10731 if (section_groups
)
10733 struct group_list
* g
;
10734 struct group_list
* next
;
10736 for (i
= 0; i
< group_count
; i
++)
10738 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10745 free (section_groups
);
10746 section_groups
= NULL
;
10749 free_debug_memory ();
10754 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10755 to the path name of the thin archive itself if necessary. Always returns
10756 a pointer to malloc'ed memory. */
10759 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10761 char * member_file_name
;
10762 const char * base_name
= lbasename (file_name
);
10764 /* This is a proxy entry for a thin archive member.
10765 If the extended name table contains an absolute path
10766 name, or if the archive is in the current directory,
10767 use the path name as given. Otherwise, we need to
10768 find the member relative to the directory where the
10769 archive is located. */
10770 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10772 member_file_name
= malloc (name_len
+ 1);
10773 if (member_file_name
== NULL
)
10775 error (_("Out of memory\n"));
10778 memcpy (member_file_name
, name
, name_len
);
10779 member_file_name
[name_len
] = '\0';
10783 /* Concatenate the path components of the archive file name
10784 to the relative path name from the extended name table. */
10785 size_t prefix_len
= base_name
- file_name
;
10786 member_file_name
= malloc (prefix_len
+ name_len
+ 1);
10787 if (member_file_name
== NULL
)
10789 error (_("Out of memory\n"));
10792 memcpy (member_file_name
, file_name
, prefix_len
);
10793 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10794 member_file_name
[prefix_len
+ name_len
] = '\0';
10796 return member_file_name
;
10799 /* Structure to hold information about an archive file. */
10801 struct archive_info
10803 char * file_name
; /* Archive file name. */
10804 FILE * file
; /* Open file descriptor. */
10805 unsigned long index_num
; /* Number of symbols in table. */
10806 unsigned long * index_array
; /* The array of member offsets. */
10807 char * sym_table
; /* The symbol table. */
10808 unsigned long sym_size
; /* Size of the symbol table. */
10809 char * longnames
; /* The long file names table. */
10810 unsigned long longnames_size
; /* Size of the long file names table. */
10811 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
10812 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
10813 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
10814 struct ar_hdr arhdr
; /* Current archive header. */
10817 /* Read the symbol table and long-name table from an archive. */
10820 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
10821 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
10824 unsigned long size
;
10826 arch
->file_name
= strdup (file_name
);
10828 arch
->index_num
= 0;
10829 arch
->index_array
= NULL
;
10830 arch
->sym_table
= NULL
;
10831 arch
->sym_size
= 0;
10832 arch
->longnames
= NULL
;
10833 arch
->longnames_size
= 0;
10834 arch
->nested_member_origin
= 0;
10835 arch
->is_thin_archive
= is_thin_archive
;
10836 arch
->next_arhdr_offset
= SARMAG
;
10838 /* Read the first archive member header. */
10839 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
10841 error (_("%s: failed to seek to first archive header\n"), file_name
);
10844 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10845 if (got
!= sizeof arch
->arhdr
)
10850 error (_("%s: failed to read archive header\n"), file_name
);
10854 /* See if this is the archive symbol table. */
10855 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
10856 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
10858 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10859 size
= size
+ (size
& 1);
10861 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
10866 /* A buffer used to hold numbers read in from an archive index.
10867 These are always 4 bytes long and stored in big-endian format. */
10868 #define SIZEOF_AR_INDEX_NUMBERS 4
10869 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10870 unsigned char * index_buffer
;
10872 /* Check the size of the archive index. */
10873 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10875 error (_("%s: the archive index is empty\n"), file_name
);
10879 /* Read the numer of entries in the archive index. */
10880 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10881 if (got
!= sizeof (integer_buffer
))
10883 error (_("%s: failed to read archive index\n"), file_name
);
10886 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10887 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10889 /* Read in the archive index. */
10890 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10892 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10893 file_name
, arch
->index_num
);
10896 index_buffer
= malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10897 if (index_buffer
== NULL
)
10899 error (_("Out of memory whilst trying to read archive symbol index\n"));
10902 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
10903 if (got
!= arch
->index_num
)
10905 free (index_buffer
);
10906 error (_("%s: failed to read archive index\n"), file_name
);
10909 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10911 /* Convert the index numbers into the host's numeric format. */
10912 arch
->index_array
= malloc (arch
->index_num
* sizeof (* arch
->index_array
));
10913 if (arch
->index_array
== NULL
)
10915 free (index_buffer
);
10916 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10920 for (i
= 0; i
< arch
->index_num
; i
++)
10921 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10922 SIZEOF_AR_INDEX_NUMBERS
);
10923 free (index_buffer
);
10925 /* The remaining space in the header is taken up by the symbol table. */
10928 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10931 arch
->sym_table
= malloc (size
);
10932 arch
->sym_size
= size
;
10933 if (arch
->sym_table
== NULL
)
10935 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10938 got
= fread (arch
->sym_table
, 1, size
, file
);
10941 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10947 if (fseek (file
, size
, SEEK_CUR
) != 0)
10949 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10954 /* Read the next archive header. */
10955 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
10956 if (got
!= sizeof arch
->arhdr
)
10960 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10964 else if (read_symbols
)
10965 printf (_("%s has no archive index\n"), file_name
);
10967 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
10969 /* This is the archive string table holding long member names. */
10970 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
10971 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
10973 arch
->longnames
= malloc (arch
->longnames_size
);
10974 if (arch
->longnames
== NULL
)
10976 error (_("Out of memory reading long symbol names in archive\n"));
10980 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
10982 free (arch
->longnames
);
10983 arch
->longnames
= NULL
;
10984 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10988 if ((arch
->longnames_size
& 1) != 0)
10995 /* Release the memory used for the archive information. */
10998 release_archive (struct archive_info
* arch
)
11000 if (arch
->file_name
!= NULL
)
11001 free (arch
->file_name
);
11002 if (arch
->index_array
!= NULL
)
11003 free (arch
->index_array
);
11004 if (arch
->sym_table
!= NULL
)
11005 free (arch
->sym_table
);
11006 if (arch
->longnames
!= NULL
)
11007 free (arch
->longnames
);
11010 /* Open and setup a nested archive, if not already open. */
11013 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
11015 FILE * member_file
;
11017 /* Have we already setup this archive? */
11018 if (nested_arch
->file_name
!= NULL
11019 && streq (nested_arch
->file_name
, member_file_name
))
11022 /* Close previous file and discard cached information. */
11023 if (nested_arch
->file
!= NULL
)
11024 fclose (nested_arch
->file
);
11025 release_archive (nested_arch
);
11027 member_file
= fopen (member_file_name
, "rb");
11028 if (member_file
== NULL
)
11030 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
11034 get_archive_member_name_at (struct archive_info
* arch
,
11035 unsigned long offset
,
11036 struct archive_info
* nested_arch
);
11038 /* Get the name of an archive member from the current archive header.
11039 For simple names, this will modify the ar_name field of the current
11040 archive header. For long names, it will return a pointer to the
11041 longnames table. For nested archives, it will open the nested archive
11042 and get the name recursively. NESTED_ARCH is a single-entry cache so
11043 we don't keep rereading the same information from a nested archive. */
11046 get_archive_member_name (struct archive_info
* arch
,
11047 struct archive_info
* nested_arch
)
11049 unsigned long j
, k
;
11051 if (arch
->arhdr
.ar_name
[0] == '/')
11053 /* We have a long name. */
11055 char * member_file_name
;
11056 char * member_name
;
11058 arch
->nested_member_origin
= 0;
11059 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11060 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11061 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11063 while ((j
< arch
->longnames_size
)
11064 && (arch
->longnames
[j
] != '\n')
11065 && (arch
->longnames
[j
] != '\0'))
11067 if (arch
->longnames
[j
-1] == '/')
11069 arch
->longnames
[j
] = '\0';
11071 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11072 return arch
->longnames
+ k
;
11074 /* This is a proxy for a member of a nested archive.
11075 Find the name of the member in that archive. */
11076 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11077 if (member_file_name
!= NULL
11078 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11079 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11081 free (member_file_name
);
11082 return member_name
;
11084 free (member_file_name
);
11086 /* Last resort: just return the name of the nested archive. */
11087 return arch
->longnames
+ k
;
11090 /* We have a normal (short) name. */
11092 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11094 arch
->arhdr
.ar_name
[j
] = '\0';
11095 return arch
->arhdr
.ar_name
;
11098 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11101 get_archive_member_name_at (struct archive_info
* arch
,
11102 unsigned long offset
,
11103 struct archive_info
* nested_arch
)
11107 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11109 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11112 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11113 if (got
!= sizeof arch
->arhdr
)
11115 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11118 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11120 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11124 return get_archive_member_name (arch
, nested_arch
);
11127 /* Construct a string showing the name of the archive member, qualified
11128 with the name of the containing archive file. For thin archives, we
11129 use square brackets to denote the indirection. For nested archives,
11130 we show the qualified name of the external member inside the square
11131 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11134 make_qualified_name (struct archive_info
* arch
,
11135 struct archive_info
* nested_arch
,
11136 char * member_name
)
11141 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11142 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11143 len
+= strlen (nested_arch
->file_name
) + 2;
11145 name
= malloc (len
);
11148 error (_("Out of memory\n"));
11152 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11153 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11154 else if (arch
->is_thin_archive
)
11155 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11157 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11162 /* Process an ELF archive.
11163 On entry the file is positioned just after the ARMAG string. */
11166 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11168 struct archive_info arch
;
11169 struct archive_info nested_arch
;
11171 size_t file_name_size
;
11176 /* The ARCH structure is used to hold information about this archive. */
11177 arch
.file_name
= NULL
;
11179 arch
.index_array
= NULL
;
11180 arch
.sym_table
= NULL
;
11181 arch
.longnames
= NULL
;
11183 /* The NESTED_ARCH structure is used as a single-item cache of information
11184 about a nested archive (when members of a thin archive reside within
11185 another regular archive file). */
11186 nested_arch
.file_name
= NULL
;
11187 nested_arch
.file
= NULL
;
11188 nested_arch
.index_array
= NULL
;
11189 nested_arch
.sym_table
= NULL
;
11190 nested_arch
.longnames
= NULL
;
11192 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11198 if (do_archive_index
)
11200 if (arch
.sym_table
== NULL
)
11201 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11205 unsigned long current_pos
;
11207 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11208 file_name
, arch
.index_num
, arch
.sym_size
);
11209 current_pos
= ftell (file
);
11211 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11213 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11215 char * member_name
;
11217 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11219 if (member_name
!= NULL
)
11221 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11223 if (qualified_name
!= NULL
)
11225 printf (_("Binary %s contains:\n"), qualified_name
);
11226 free (qualified_name
);
11231 if (l
>= arch
.sym_size
)
11233 error (_("%s: end of the symbol table reached before the end of the index\n"),
11237 printf ("\t%s\n", arch
.sym_table
+ l
);
11238 l
+= strlen (arch
.sym_table
+ l
) + 1;
11243 if (l
< arch
.sym_size
)
11244 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11247 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11249 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11255 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11256 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11257 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11258 && !do_section_groups
)
11260 ret
= 0; /* Archive index only. */
11265 file_name_size
= strlen (file_name
);
11272 char * qualified_name
;
11274 /* Read the next archive header. */
11275 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11277 error (_("%s: failed to seek to next archive header\n"), file_name
);
11280 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11281 if (got
!= sizeof arch
.arhdr
)
11285 error (_("%s: failed to read archive header\n"), file_name
);
11289 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11291 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11296 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11298 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11299 if (archive_file_size
& 01)
11300 ++archive_file_size
;
11302 name
= get_archive_member_name (&arch
, &nested_arch
);
11305 error (_("%s: bad archive file name\n"), file_name
);
11309 namelen
= strlen (name
);
11311 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11312 if (qualified_name
== NULL
)
11314 error (_("%s: bad archive file name\n"), file_name
);
11319 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11321 /* This is a proxy for an external member of a thin archive. */
11322 FILE * member_file
;
11323 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11324 if (member_file_name
== NULL
)
11330 member_file
= fopen (member_file_name
, "rb");
11331 if (member_file
== NULL
)
11333 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11334 free (member_file_name
);
11339 archive_file_offset
= arch
.nested_member_origin
;
11341 ret
|= process_object (qualified_name
, member_file
);
11343 fclose (member_file
);
11344 free (member_file_name
);
11346 else if (is_thin_archive
)
11348 /* This is a proxy for a member of a nested archive. */
11349 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11351 /* The nested archive file will have been opened and setup by
11352 get_archive_member_name. */
11353 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11355 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11360 ret
|= process_object (qualified_name
, nested_arch
.file
);
11364 archive_file_offset
= arch
.next_arhdr_offset
;
11365 arch
.next_arhdr_offset
+= archive_file_size
;
11367 ret
|= process_object (qualified_name
, file
);
11370 free (qualified_name
);
11374 if (nested_arch
.file
!= NULL
)
11375 fclose (nested_arch
.file
);
11376 release_archive (&nested_arch
);
11377 release_archive (&arch
);
11383 process_file (char * file_name
)
11386 struct stat statbuf
;
11387 char armag
[SARMAG
];
11390 if (stat (file_name
, &statbuf
) < 0)
11392 if (errno
== ENOENT
)
11393 error (_("'%s': No such file\n"), file_name
);
11395 error (_("Could not locate '%s'. System error message: %s\n"),
11396 file_name
, strerror (errno
));
11400 if (! S_ISREG (statbuf
.st_mode
))
11402 error (_("'%s' is not an ordinary file\n"), file_name
);
11406 file
= fopen (file_name
, "rb");
11409 error (_("Input file '%s' is not readable.\n"), file_name
);
11413 if (fread (armag
, SARMAG
, 1, file
) != 1)
11415 error (_("%s: Failed to read file's magic number\n"), file_name
);
11420 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11421 ret
= process_archive (file_name
, file
, FALSE
);
11422 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11423 ret
= process_archive (file_name
, file
, TRUE
);
11426 if (do_archive_index
)
11427 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11431 archive_file_size
= archive_file_offset
= 0;
11432 ret
= process_object (file_name
, file
);
11440 #ifdef SUPPORT_DISASSEMBLY
11441 /* Needed by the i386 disassembler. For extra credit, someone could
11442 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11446 print_address (unsigned int addr
, FILE * outfile
)
11448 fprintf (outfile
,"0x%8.8x", addr
);
11451 /* Needed by the i386 disassembler. */
11453 db_task_printsym (unsigned int addr
)
11455 print_address (addr
, stderr
);
11460 main (int argc
, char ** argv
)
11464 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11465 setlocale (LC_MESSAGES
, "");
11467 #if defined (HAVE_SETLOCALE)
11468 setlocale (LC_CTYPE
, "");
11470 bindtextdomain (PACKAGE
, LOCALEDIR
);
11471 textdomain (PACKAGE
);
11473 expandargv (&argc
, &argv
);
11475 parse_args (argc
, argv
);
11477 if (num_dump_sects
> 0)
11479 /* Make a copy of the dump_sects array. */
11480 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
11481 if (cmdline_dump_sects
== NULL
)
11482 error (_("Out of memory allocating dump request table.\n"));
11485 memcpy (cmdline_dump_sects
, dump_sects
,
11486 num_dump_sects
* sizeof (* dump_sects
));
11487 num_cmdline_dump_sects
= num_dump_sects
;
11491 if (optind
< (argc
- 1))
11495 while (optind
< argc
)
11496 err
|= process_file (argv
[optind
++]);
11498 if (dump_sects
!= NULL
)
11500 if (cmdline_dump_sects
!= NULL
)
11501 free (cmdline_dump_sects
);