1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 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. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
109 #include "elf/ft32.h"
111 #include "elf/hppa.h"
112 #include "elf/i386.h"
113 #include "elf/i370.h"
114 #include "elf/i860.h"
115 #include "elf/i960.h"
116 #include "elf/ia64.h"
117 #include "elf/ip2k.h"
118 #include "elf/lm32.h"
119 #include "elf/iq2000.h"
120 #include "elf/m32c.h"
121 #include "elf/m32r.h"
122 #include "elf/m68k.h"
123 #include "elf/m68hc11.h"
124 #include "elf/mcore.h"
126 #include "elf/metag.h"
127 #include "elf/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
134 #include "elf/msp430.h"
135 #include "elf/nds32.h"
136 #include "elf/nios2.h"
137 #include "elf/or1k.h"
140 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/x86-64.h"
155 #include "elf/xc16x.h"
156 #include "elf/xgate.h"
157 #include "elf/xstormy16.h"
158 #include "elf/xtensa.h"
161 #include "libiberty.h"
162 #include "safe-ctype.h"
163 #include "filenames.h"
166 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
169 char * program_name
= "readelf";
170 static unsigned long archive_file_offset
;
171 static unsigned long archive_file_size
;
172 static bfd_size_type current_file_size
;
173 static unsigned long dynamic_addr
;
174 static bfd_size_type dynamic_size
;
175 static size_t dynamic_nent
;
176 static char * dynamic_strings
;
177 static unsigned long dynamic_strings_length
;
178 static char * string_table
;
179 static unsigned long string_table_length
;
180 static unsigned long num_dynamic_syms
;
181 static Elf_Internal_Sym
* dynamic_symbols
;
182 static Elf_Internal_Syminfo
* dynamic_syminfo
;
183 static unsigned long dynamic_syminfo_offset
;
184 static unsigned int dynamic_syminfo_nent
;
185 static char program_interpreter
[PATH_MAX
];
186 static bfd_vma dynamic_info
[DT_ENCODING
];
187 static bfd_vma dynamic_info_DT_GNU_HASH
;
188 static bfd_vma version_info
[16];
189 static Elf_Internal_Ehdr elf_header
;
190 static Elf_Internal_Shdr
* section_headers
;
191 static Elf_Internal_Phdr
* program_headers
;
192 static Elf_Internal_Dyn
* dynamic_section
;
193 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
194 static int show_name
;
195 static int do_dynamic
;
197 static int do_dyn_syms
;
199 static int do_sections
;
200 static int do_section_groups
;
201 static int do_section_details
;
202 static int do_segments
;
203 static int do_unwind
;
204 static int do_using_dynamic
;
205 static int do_header
;
207 static int do_version
;
208 static int do_histogram
;
209 static int do_debugging
;
212 static int do_archive_index
;
213 static int is_32bit_elf
;
217 struct group_list
* next
;
218 unsigned int section_index
;
223 struct group_list
* root
;
224 unsigned int group_index
;
227 static size_t group_count
;
228 static struct group
* section_groups
;
229 static struct group
** section_headers_groups
;
232 /* Flag bits indicating particular types of dump. */
233 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
234 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
235 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
236 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
237 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
239 typedef unsigned char dump_type
;
241 /* A linked list of the section names for which dumps were requested. */
242 struct dump_list_entry
246 struct dump_list_entry
* next
;
248 static struct dump_list_entry
* dump_sects_byname
;
250 /* A dynamic array of flags indicating for which sections a dump
251 has been requested via command line switches. */
252 static dump_type
* cmdline_dump_sects
= NULL
;
253 static unsigned int num_cmdline_dump_sects
= 0;
255 /* A dynamic array of flags indicating for which sections a dump of
256 some kind has been requested. It is reset on a per-object file
257 basis and then initialised from the cmdline_dump_sects array,
258 the results of interpreting the -w switch, and the
259 dump_sects_byname list. */
260 static dump_type
* dump_sects
= NULL
;
261 static unsigned int num_dump_sects
= 0;
264 /* How to print a vma value. */
265 typedef enum print_mode
277 /* Versioned symbol info. */
278 enum versioned_symbol_info
285 static const char *get_symbol_version_string
286 (FILE *file
, int is_dynsym
, const char *strtab
,
287 unsigned long int strtab_size
, unsigned int si
,
288 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
289 unsigned short *vna_other
);
293 #define SECTION_NAME(X) \
294 ((X) == NULL ? _("<none>") \
295 : string_table == NULL ? _("<no-name>") \
296 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
297 : string_table + (X)->sh_name))
299 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
301 #define GET_ELF_SYMBOLS(file, section, sym_count) \
302 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
303 : get_64bit_elf_symbols (file, section, sym_count))
305 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
306 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
307 already been called and verified that the string exists. */
308 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
310 #define REMOVE_ARCH_BITS(ADDR) \
313 if (elf_header.e_machine == EM_ARM) \
318 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
319 the offset of the current archive member, if we are examining an archive.
320 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
321 using malloc and fill that. In either case return the pointer to the start of
322 the retrieved data or NULL if something went wrong. If something does go wrong
323 and REASON is not NULL then emit an error message using REASON as part of the
327 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
328 bfd_size_type nmemb
, const char * reason
)
331 bfd_size_type amt
= size
* nmemb
;
333 if (size
== 0 || nmemb
== 0)
336 /* If the size_t type is smaller than the bfd_size_type, eg because
337 you are building a 32-bit tool on a 64-bit host, then make sure
338 that when the sizes are cast to (size_t) no information is lost. */
339 if (sizeof (size_t) < sizeof (bfd_size_type
)
340 && ( (bfd_size_type
) ((size_t) size
) != size
341 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
344 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
345 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
349 /* Check for size overflow. */
353 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
354 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
358 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
359 attempting to allocate memory when the read is bound to fail. */
360 if (amt
> current_file_size
361 || offset
+ archive_file_offset
+ amt
> current_file_size
)
364 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
365 (unsigned long long) amt
, reason
);
369 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
372 error (_("Unable to seek to 0x%lx for %s\n"),
373 (unsigned long) archive_file_offset
+ offset
, reason
);
380 /* Check for overflow. */
381 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
382 /* + 1 so that we can '\0' terminate invalid string table sections. */
383 mvar
= malloc ((size_t) amt
+ 1);
388 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
389 (unsigned long long) amt
, reason
);
393 ((char *) mvar
)[amt
] = '\0';
396 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
399 error (_("Unable to read in 0x%llx bytes of %s\n"),
400 (unsigned long long) amt
, reason
);
409 /* Print a VMA value. */
412 print_vma (bfd_vma vma
, print_mode mode
)
425 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
432 return printf ("%5" BFD_VMA_FMT
"d", vma
);
440 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
443 return printf ("%" BFD_VMA_FMT
"d", vma
);
446 return printf ("%" BFD_VMA_FMT
"u", vma
);
451 /* Display a symbol on stdout. Handles the display of control characters and
452 multibye characters (assuming the host environment supports them).
454 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
456 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
457 padding as necessary.
459 Returns the number of emitted characters. */
462 print_symbol (int width
, const char *symbol
)
464 bfd_boolean extra_padding
= FALSE
;
466 #ifdef HAVE_MBSTATE_T
473 /* Keep the width positive. This also helps. */
475 extra_padding
= TRUE
;
480 /* Set the remaining width to a very large value.
481 This simplifies the code below. */
482 width_remaining
= INT_MAX
;
484 width_remaining
= width
;
486 #ifdef HAVE_MBSTATE_T
487 /* Initialise the multibyte conversion state. */
488 memset (& state
, 0, sizeof (state
));
491 while (width_remaining
)
494 const char c
= *symbol
++;
499 /* Do not print control characters directly as they can affect terminal
500 settings. Such characters usually appear in the names generated
501 by the assembler for local labels. */
504 if (width_remaining
< 2)
507 printf ("^%c", c
+ 0x40);
508 width_remaining
-= 2;
511 else if (ISPRINT (c
))
519 #ifdef HAVE_MBSTATE_T
522 /* Let printf do the hard work of displaying multibyte characters. */
523 printf ("%.1s", symbol
- 1);
527 #ifdef HAVE_MBSTATE_T
528 /* Try to find out how many bytes made up the character that was
529 just printed. Advance the symbol pointer past the bytes that
531 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
535 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
540 if (extra_padding
&& num_printed
< width
)
542 /* Fill in the remaining spaces. */
543 printf ("%-*s", width
- num_printed
, " ");
550 /* Returns a pointer to a static buffer containing a printable version of
551 the given section's name. Like print_symbol, except that it does not try
552 to print multibyte characters, it just interprets them as hex values. */
555 printable_section_name (Elf_Internal_Shdr
* sec
)
557 #define MAX_PRINT_SEC_NAME_LEN 128
558 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
559 const char * name
= SECTION_NAME (sec
);
560 char * buf
= sec_name_buf
;
562 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
564 while ((c
= * name
++) != 0)
575 else if (ISPRINT (c
))
582 static char hex
[17] = "0123456789ABCDEF";
587 * buf
++ = hex
[(c
& 0xf0) >> 4];
588 * buf
++ = hex
[c
& 0x0f];
602 printable_section_name_from_index (unsigned long ndx
)
604 if (ndx
>= elf_header
.e_shnum
)
605 return _("<corrupt>");
607 return printable_section_name (section_headers
+ ndx
);
610 /* Return a pointer to section NAME, or NULL if no such section exists. */
612 static Elf_Internal_Shdr
*
613 find_section (const char * name
)
617 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
618 if (streq (SECTION_NAME (section_headers
+ i
), name
))
619 return section_headers
+ i
;
624 /* Return a pointer to a section containing ADDR, or NULL if no such
627 static Elf_Internal_Shdr
*
628 find_section_by_address (bfd_vma addr
)
632 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
634 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
635 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
642 static Elf_Internal_Shdr
*
643 find_section_by_type (unsigned int type
)
647 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
649 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
650 if (sec
->sh_type
== type
)
657 /* Return a pointer to section NAME, or NULL if no such section exists,
658 restricted to the list of sections given in SET. */
660 static Elf_Internal_Shdr
*
661 find_section_in_set (const char * name
, unsigned int * set
)
667 while ((i
= *set
++) > 0)
668 if (streq (SECTION_NAME (section_headers
+ i
), name
))
669 return section_headers
+ i
;
672 return find_section (name
);
675 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
678 static inline unsigned long
679 read_uleb128 (unsigned char *data
,
680 unsigned int *length_return
,
681 const unsigned char * const end
)
683 return read_leb128 (data
, length_return
, FALSE
, end
);
686 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
687 This OS has so many departures from the ELF standard that we test it at
693 return elf_header
.e_machine
== EM_IA_64
694 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
697 /* Guess the relocation size commonly used by the specific machines. */
700 guess_is_rela (unsigned int e_machine
)
704 /* Targets that use REL relocations. */
719 /* Targets that use RELA relocations. */
723 case EM_ADAPTEVA_EPIPHANY
:
725 case EM_ALTERA_NIOS2
:
745 case EM_LATTICEMICO32
:
754 case EM_CYGNUS_MN10200
:
756 case EM_CYGNUS_MN10300
:
790 case EM_MICROBLAZE_OLD
:
811 warn (_("Don't know about relocations on this machine architecture\n"));
817 slurp_rela_relocs (FILE * file
,
818 unsigned long rel_offset
,
819 unsigned long rel_size
,
820 Elf_Internal_Rela
** relasp
,
821 unsigned long * nrelasp
)
823 Elf_Internal_Rela
* relas
;
829 Elf32_External_Rela
* erelas
;
831 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
832 rel_size
, _("32-bit relocation data"));
836 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
838 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
839 sizeof (Elf_Internal_Rela
));
844 error (_("out of memory parsing relocs\n"));
848 for (i
= 0; i
< nrelas
; i
++)
850 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
851 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
852 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
859 Elf64_External_Rela
* erelas
;
861 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
862 rel_size
, _("64-bit relocation data"));
866 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
868 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
869 sizeof (Elf_Internal_Rela
));
874 error (_("out of memory parsing relocs\n"));
878 for (i
= 0; i
< nrelas
; i
++)
880 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
881 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
882 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
884 /* The #ifdef BFD64 below is to prevent a compile time
885 warning. We know that if we do not have a 64 bit data
886 type that we will never execute this code anyway. */
888 if (elf_header
.e_machine
== EM_MIPS
889 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
891 /* In little-endian objects, r_info isn't really a
892 64-bit little-endian value: it has a 32-bit
893 little-endian symbol index followed by four
894 individual byte fields. Reorder INFO
896 bfd_vma inf
= relas
[i
].r_info
;
897 inf
= (((inf
& 0xffffffff) << 32)
898 | ((inf
>> 56) & 0xff)
899 | ((inf
>> 40) & 0xff00)
900 | ((inf
>> 24) & 0xff0000)
901 | ((inf
>> 8) & 0xff000000));
902 relas
[i
].r_info
= inf
;
915 slurp_rel_relocs (FILE * file
,
916 unsigned long rel_offset
,
917 unsigned long rel_size
,
918 Elf_Internal_Rela
** relsp
,
919 unsigned long * nrelsp
)
921 Elf_Internal_Rela
* rels
;
927 Elf32_External_Rel
* erels
;
929 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
930 rel_size
, _("32-bit relocation data"));
934 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
936 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
941 error (_("out of memory parsing relocs\n"));
945 for (i
= 0; i
< nrels
; i
++)
947 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
948 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
949 rels
[i
].r_addend
= 0;
956 Elf64_External_Rel
* erels
;
958 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
959 rel_size
, _("64-bit relocation data"));
963 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
965 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
970 error (_("out of memory parsing relocs\n"));
974 for (i
= 0; i
< nrels
; i
++)
976 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
977 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
978 rels
[i
].r_addend
= 0;
980 /* The #ifdef BFD64 below is to prevent a compile time
981 warning. We know that if we do not have a 64 bit data
982 type that we will never execute this code anyway. */
984 if (elf_header
.e_machine
== EM_MIPS
985 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
987 /* In little-endian objects, r_info isn't really a
988 64-bit little-endian value: it has a 32-bit
989 little-endian symbol index followed by four
990 individual byte fields. Reorder INFO
992 bfd_vma inf
= rels
[i
].r_info
;
993 inf
= (((inf
& 0xffffffff) << 32)
994 | ((inf
>> 56) & 0xff)
995 | ((inf
>> 40) & 0xff00)
996 | ((inf
>> 24) & 0xff0000)
997 | ((inf
>> 8) & 0xff000000));
998 rels
[i
].r_info
= inf
;
1010 /* Returns the reloc type extracted from the reloc info field. */
1013 get_reloc_type (bfd_vma reloc_info
)
1016 return ELF32_R_TYPE (reloc_info
);
1018 switch (elf_header
.e_machine
)
1021 /* Note: We assume that reloc_info has already been adjusted for us. */
1022 return ELF64_MIPS_R_TYPE (reloc_info
);
1025 return ELF64_R_TYPE_ID (reloc_info
);
1028 return ELF64_R_TYPE (reloc_info
);
1032 /* Return the symbol index extracted from the reloc info field. */
1035 get_reloc_symindex (bfd_vma reloc_info
)
1037 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1040 static inline bfd_boolean
1041 uses_msp430x_relocs (void)
1044 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1045 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1046 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1047 /* TI compiler uses ELFOSABI_NONE. */
1048 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1051 /* Display the contents of the relocation data found at the specified
1055 dump_relocations (FILE * file
,
1056 unsigned long rel_offset
,
1057 unsigned long rel_size
,
1058 Elf_Internal_Sym
* symtab
,
1059 unsigned long nsyms
,
1061 unsigned long strtablen
,
1066 Elf_Internal_Rela
* rels
;
1068 if (is_rela
== UNKNOWN
)
1069 is_rela
= guess_is_rela (elf_header
.e_machine
);
1073 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1078 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1087 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1089 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1094 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1096 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1104 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1106 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1111 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1113 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1117 for (i
= 0; i
< rel_size
; i
++)
1122 bfd_vma symtab_index
;
1125 offset
= rels
[i
].r_offset
;
1126 inf
= rels
[i
].r_info
;
1128 type
= get_reloc_type (inf
);
1129 symtab_index
= get_reloc_symindex (inf
);
1133 printf ("%8.8lx %8.8lx ",
1134 (unsigned long) offset
& 0xffffffff,
1135 (unsigned long) inf
& 0xffffffff);
1139 #if BFD_HOST_64BIT_LONG
1141 ? "%16.16lx %16.16lx "
1142 : "%12.12lx %12.12lx ",
1144 #elif BFD_HOST_64BIT_LONG_LONG
1147 ? "%16.16llx %16.16llx "
1148 : "%12.12llx %12.12llx ",
1152 ? "%16.16I64x %16.16I64x "
1153 : "%12.12I64x %12.12I64x ",
1158 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1159 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1160 _bfd_int64_high (offset
),
1161 _bfd_int64_low (offset
),
1162 _bfd_int64_high (inf
),
1163 _bfd_int64_low (inf
));
1167 switch (elf_header
.e_machine
)
1174 rtype
= elf_aarch64_reloc_type (type
);
1178 case EM_CYGNUS_M32R
:
1179 rtype
= elf_m32r_reloc_type (type
);
1184 rtype
= elf_i386_reloc_type (type
);
1189 rtype
= elf_m68hc11_reloc_type (type
);
1193 rtype
= elf_m68k_reloc_type (type
);
1197 rtype
= elf_i960_reloc_type (type
);
1202 rtype
= elf_avr_reloc_type (type
);
1205 case EM_OLD_SPARCV9
:
1206 case EM_SPARC32PLUS
:
1209 rtype
= elf_sparc_reloc_type (type
);
1213 rtype
= elf_spu_reloc_type (type
);
1217 rtype
= v800_reloc_type (type
);
1220 case EM_CYGNUS_V850
:
1221 rtype
= v850_reloc_type (type
);
1225 case EM_CYGNUS_D10V
:
1226 rtype
= elf_d10v_reloc_type (type
);
1230 case EM_CYGNUS_D30V
:
1231 rtype
= elf_d30v_reloc_type (type
);
1235 rtype
= elf_dlx_reloc_type (type
);
1239 rtype
= elf_sh_reloc_type (type
);
1243 case EM_CYGNUS_MN10300
:
1244 rtype
= elf_mn10300_reloc_type (type
);
1248 case EM_CYGNUS_MN10200
:
1249 rtype
= elf_mn10200_reloc_type (type
);
1253 case EM_CYGNUS_FR30
:
1254 rtype
= elf_fr30_reloc_type (type
);
1258 rtype
= elf_frv_reloc_type (type
);
1262 rtype
= elf_ft32_reloc_type (type
);
1266 rtype
= elf_mcore_reloc_type (type
);
1270 rtype
= elf_mmix_reloc_type (type
);
1274 rtype
= elf_moxie_reloc_type (type
);
1278 if (uses_msp430x_relocs ())
1280 rtype
= elf_msp430x_reloc_type (type
);
1284 rtype
= elf_msp430_reloc_type (type
);
1288 rtype
= elf_nds32_reloc_type (type
);
1292 rtype
= elf_ppc_reloc_type (type
);
1296 rtype
= elf_ppc64_reloc_type (type
);
1300 case EM_MIPS_RS3_LE
:
1301 rtype
= elf_mips_reloc_type (type
);
1305 rtype
= elf_alpha_reloc_type (type
);
1309 rtype
= elf_arm_reloc_type (type
);
1313 rtype
= elf_arc_reloc_type (type
);
1317 rtype
= elf_hppa_reloc_type (type
);
1323 rtype
= elf_h8_reloc_type (type
);
1327 rtype
= elf_or1k_reloc_type (type
);
1332 rtype
= elf_pj_reloc_type (type
);
1335 rtype
= elf_ia64_reloc_type (type
);
1339 rtype
= elf_cris_reloc_type (type
);
1343 rtype
= elf_i860_reloc_type (type
);
1349 rtype
= elf_x86_64_reloc_type (type
);
1353 rtype
= i370_reloc_type (type
);
1358 rtype
= elf_s390_reloc_type (type
);
1362 rtype
= elf_score_reloc_type (type
);
1366 rtype
= elf_xstormy16_reloc_type (type
);
1370 rtype
= elf_crx_reloc_type (type
);
1374 rtype
= elf_vax_reloc_type (type
);
1378 rtype
= elf_visium_reloc_type (type
);
1381 case EM_ADAPTEVA_EPIPHANY
:
1382 rtype
= elf_epiphany_reloc_type (type
);
1387 rtype
= elf_ip2k_reloc_type (type
);
1391 rtype
= elf_iq2000_reloc_type (type
);
1396 rtype
= elf_xtensa_reloc_type (type
);
1399 case EM_LATTICEMICO32
:
1400 rtype
= elf_lm32_reloc_type (type
);
1405 rtype
= elf_m32c_reloc_type (type
);
1409 rtype
= elf_mt_reloc_type (type
);
1413 rtype
= elf_bfin_reloc_type (type
);
1417 rtype
= elf_mep_reloc_type (type
);
1421 rtype
= elf_cr16_reloc_type (type
);
1425 case EM_MICROBLAZE_OLD
:
1426 rtype
= elf_microblaze_reloc_type (type
);
1430 rtype
= elf_rl78_reloc_type (type
);
1434 rtype
= elf_rx_reloc_type (type
);
1438 rtype
= elf_metag_reloc_type (type
);
1443 rtype
= elf_xc16x_reloc_type (type
);
1447 rtype
= elf_tic6x_reloc_type (type
);
1451 rtype
= elf_tilegx_reloc_type (type
);
1455 rtype
= elf_tilepro_reloc_type (type
);
1459 rtype
= elf_xgate_reloc_type (type
);
1462 case EM_ALTERA_NIOS2
:
1463 rtype
= elf_nios2_reloc_type (type
);
1468 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1470 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1472 if (elf_header
.e_machine
== EM_ALPHA
1474 && streq (rtype
, "R_ALPHA_LITUSE")
1477 switch (rels
[i
].r_addend
)
1479 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1480 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1481 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1482 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1483 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1484 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1485 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1486 default: rtype
= NULL
;
1489 printf (" (%s)", rtype
);
1493 printf (_("<unknown addend: %lx>"),
1494 (unsigned long) rels
[i
].r_addend
);
1497 else if (symtab_index
)
1499 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1500 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1503 Elf_Internal_Sym
* psym
;
1504 const char * version_string
;
1505 enum versioned_symbol_info sym_info
;
1506 unsigned short vna_other
;
1508 psym
= symtab
+ symtab_index
;
1511 = get_symbol_version_string (file
, is_dynsym
,
1520 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1524 unsigned int width
= is_32bit_elf
? 8 : 14;
1526 /* Relocations against GNU_IFUNC symbols do not use the value
1527 of the symbol as the address to relocate against. Instead
1528 they invoke the function named by the symbol and use its
1529 result as the address for relocation.
1531 To indicate this to the user, do not display the value of
1532 the symbol in the "Symbols's Value" field. Instead show
1533 its name followed by () as a hint that the symbol is
1537 || psym
->st_name
== 0
1538 || psym
->st_name
>= strtablen
)
1541 name
= strtab
+ psym
->st_name
;
1543 len
= print_symbol (width
, name
);
1545 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1547 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1551 print_vma (psym
->st_value
, LONG_HEX
);
1553 printf (is_32bit_elf
? " " : " ");
1556 if (psym
->st_name
== 0)
1558 const char * sec_name
= "<null>";
1561 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1563 if (psym
->st_shndx
< elf_header
.e_shnum
)
1564 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1565 else if (psym
->st_shndx
== SHN_ABS
)
1567 else if (psym
->st_shndx
== SHN_COMMON
)
1568 sec_name
= "COMMON";
1569 else if ((elf_header
.e_machine
== EM_MIPS
1570 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1571 || (elf_header
.e_machine
== EM_TI_C6000
1572 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1573 sec_name
= "SCOMMON";
1574 else if (elf_header
.e_machine
== EM_MIPS
1575 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1576 sec_name
= "SUNDEF";
1577 else if ((elf_header
.e_machine
== EM_X86_64
1578 || elf_header
.e_machine
== EM_L1OM
1579 || elf_header
.e_machine
== EM_K1OM
)
1580 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1581 sec_name
= "LARGE_COMMON";
1582 else if (elf_header
.e_machine
== EM_IA_64
1583 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1584 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1585 sec_name
= "ANSI_COM";
1586 else if (is_ia64_vms ()
1587 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1588 sec_name
= "VMS_SYMVEC";
1591 sprintf (name_buf
, "<section 0x%x>",
1592 (unsigned int) psym
->st_shndx
);
1593 sec_name
= name_buf
;
1596 print_symbol (22, sec_name
);
1598 else if (strtab
== NULL
)
1599 printf (_("<string table index: %3ld>"), psym
->st_name
);
1600 else if (psym
->st_name
>= strtablen
)
1601 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1604 print_symbol (22, strtab
+ psym
->st_name
);
1606 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1612 bfd_signed_vma off
= rels
[i
].r_addend
;
1614 /* PR 17531: file: 2e63226f. */
1615 if (off
== ((bfd_signed_vma
) 1) << ((sizeof (bfd_signed_vma
) * 8) - 1))
1616 printf (" + %" BFD_VMA_FMT
"x", off
);
1618 printf (" - %" BFD_VMA_FMT
"x", - off
);
1620 printf (" + %" BFD_VMA_FMT
"x", off
);
1626 bfd_signed_vma off
= rels
[i
].r_addend
;
1628 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1629 /* PR 17531: file: 2e63226f. */
1630 if (off
== ((bfd_signed_vma
) 1) << ((sizeof (bfd_signed_vma
) * 8) - 1))
1631 printf ("%" BFD_VMA_FMT
"x", off
);
1633 printf ("-%" BFD_VMA_FMT
"x", - off
);
1635 printf ("%" BFD_VMA_FMT
"x", off
);
1638 if (elf_header
.e_machine
== EM_SPARCV9
1640 && streq (rtype
, "R_SPARC_OLO10"))
1641 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1646 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1648 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1649 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1650 const char * rtype2
= elf_mips_reloc_type (type2
);
1651 const char * rtype3
= elf_mips_reloc_type (type3
);
1653 printf (" Type2: ");
1656 printf (_("unrecognized: %-7lx"),
1657 (unsigned long) type2
& 0xffffffff);
1659 printf ("%-17.17s", rtype2
);
1661 printf ("\n Type3: ");
1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type3
& 0xffffffff);
1667 printf ("%-17.17s", rtype3
);
1678 get_mips_dynamic_type (unsigned long type
)
1682 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1683 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1684 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1685 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1686 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1687 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1688 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1689 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1690 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1691 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1692 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1693 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1694 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1695 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1696 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1697 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1698 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1699 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1700 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1701 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1702 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1703 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1704 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1705 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1706 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1707 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1708 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1709 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1710 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1711 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1712 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1713 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1714 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1715 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1716 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1717 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1718 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1719 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1720 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1722 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1723 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1724 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1725 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1726 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1733 get_sparc64_dynamic_type (unsigned long type
)
1737 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1744 get_ppc_dynamic_type (unsigned long type
)
1748 case DT_PPC_GOT
: return "PPC_GOT";
1749 case DT_PPC_OPT
: return "PPC_OPT";
1756 get_ppc64_dynamic_type (unsigned long type
)
1760 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1761 case DT_PPC64_OPD
: return "PPC64_OPD";
1762 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1763 case DT_PPC64_OPT
: return "PPC64_OPT";
1770 get_parisc_dynamic_type (unsigned long type
)
1774 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1775 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1776 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1777 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1778 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1779 case DT_HP_PREINIT
: return "HP_PREINIT";
1780 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1781 case DT_HP_NEEDED
: return "HP_NEEDED";
1782 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1783 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1784 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1785 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1786 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1787 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1788 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1789 case DT_HP_FILTERED
: return "HP_FILTERED";
1790 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1791 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1792 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1793 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1794 case DT_PLT
: return "PLT";
1795 case DT_PLT_SIZE
: return "PLT_SIZE";
1796 case DT_DLT
: return "DLT";
1797 case DT_DLT_SIZE
: return "DLT_SIZE";
1804 get_ia64_dynamic_type (unsigned long type
)
1808 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1809 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1810 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1811 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1812 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1813 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1814 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1815 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1816 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1818 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1819 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1820 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1821 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1822 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1823 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1824 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1825 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1826 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1827 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1828 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1829 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1830 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1831 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1832 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1833 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1834 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1835 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1836 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1837 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1838 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1845 get_alpha_dynamic_type (unsigned long type
)
1849 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1856 get_score_dynamic_type (unsigned long type
)
1860 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1861 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1862 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1863 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1864 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1865 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1872 get_tic6x_dynamic_type (unsigned long type
)
1876 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1877 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1878 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1879 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1880 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1881 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1888 get_nios2_dynamic_type (unsigned long type
)
1892 case DT_NIOS2_GP
: return "NIOS2_GP";
1899 get_dynamic_type (unsigned long type
)
1901 static char buff
[64];
1905 case DT_NULL
: return "NULL";
1906 case DT_NEEDED
: return "NEEDED";
1907 case DT_PLTRELSZ
: return "PLTRELSZ";
1908 case DT_PLTGOT
: return "PLTGOT";
1909 case DT_HASH
: return "HASH";
1910 case DT_STRTAB
: return "STRTAB";
1911 case DT_SYMTAB
: return "SYMTAB";
1912 case DT_RELA
: return "RELA";
1913 case DT_RELASZ
: return "RELASZ";
1914 case DT_RELAENT
: return "RELAENT";
1915 case DT_STRSZ
: return "STRSZ";
1916 case DT_SYMENT
: return "SYMENT";
1917 case DT_INIT
: return "INIT";
1918 case DT_FINI
: return "FINI";
1919 case DT_SONAME
: return "SONAME";
1920 case DT_RPATH
: return "RPATH";
1921 case DT_SYMBOLIC
: return "SYMBOLIC";
1922 case DT_REL
: return "REL";
1923 case DT_RELSZ
: return "RELSZ";
1924 case DT_RELENT
: return "RELENT";
1925 case DT_PLTREL
: return "PLTREL";
1926 case DT_DEBUG
: return "DEBUG";
1927 case DT_TEXTREL
: return "TEXTREL";
1928 case DT_JMPREL
: return "JMPREL";
1929 case DT_BIND_NOW
: return "BIND_NOW";
1930 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1931 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1932 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1933 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1934 case DT_RUNPATH
: return "RUNPATH";
1935 case DT_FLAGS
: return "FLAGS";
1937 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1938 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1940 case DT_CHECKSUM
: return "CHECKSUM";
1941 case DT_PLTPADSZ
: return "PLTPADSZ";
1942 case DT_MOVEENT
: return "MOVEENT";
1943 case DT_MOVESZ
: return "MOVESZ";
1944 case DT_FEATURE
: return "FEATURE";
1945 case DT_POSFLAG_1
: return "POSFLAG_1";
1946 case DT_SYMINSZ
: return "SYMINSZ";
1947 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1949 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1950 case DT_CONFIG
: return "CONFIG";
1951 case DT_DEPAUDIT
: return "DEPAUDIT";
1952 case DT_AUDIT
: return "AUDIT";
1953 case DT_PLTPAD
: return "PLTPAD";
1954 case DT_MOVETAB
: return "MOVETAB";
1955 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1957 case DT_VERSYM
: return "VERSYM";
1959 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1960 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1961 case DT_RELACOUNT
: return "RELACOUNT";
1962 case DT_RELCOUNT
: return "RELCOUNT";
1963 case DT_FLAGS_1
: return "FLAGS_1";
1964 case DT_VERDEF
: return "VERDEF";
1965 case DT_VERDEFNUM
: return "VERDEFNUM";
1966 case DT_VERNEED
: return "VERNEED";
1967 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1969 case DT_AUXILIARY
: return "AUXILIARY";
1970 case DT_USED
: return "USED";
1971 case DT_FILTER
: return "FILTER";
1973 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1974 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1975 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1976 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1977 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1978 case DT_GNU_HASH
: return "GNU_HASH";
1981 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1983 const char * result
;
1985 switch (elf_header
.e_machine
)
1988 case EM_MIPS_RS3_LE
:
1989 result
= get_mips_dynamic_type (type
);
1992 result
= get_sparc64_dynamic_type (type
);
1995 result
= get_ppc_dynamic_type (type
);
1998 result
= get_ppc64_dynamic_type (type
);
2001 result
= get_ia64_dynamic_type (type
);
2004 result
= get_alpha_dynamic_type (type
);
2007 result
= get_score_dynamic_type (type
);
2010 result
= get_tic6x_dynamic_type (type
);
2012 case EM_ALTERA_NIOS2
:
2013 result
= get_nios2_dynamic_type (type
);
2023 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2025 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2026 || (elf_header
.e_machine
== EM_PARISC
2027 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2029 const char * result
;
2031 switch (elf_header
.e_machine
)
2034 result
= get_parisc_dynamic_type (type
);
2037 result
= get_ia64_dynamic_type (type
);
2047 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2051 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2058 get_file_type (unsigned e_type
)
2060 static char buff
[32];
2064 case ET_NONE
: return _("NONE (None)");
2065 case ET_REL
: return _("REL (Relocatable file)");
2066 case ET_EXEC
: return _("EXEC (Executable file)");
2067 case ET_DYN
: return _("DYN (Shared object file)");
2068 case ET_CORE
: return _("CORE (Core file)");
2071 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2072 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2073 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2074 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2076 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2082 get_machine_name (unsigned e_machine
)
2084 static char buff
[64]; /* XXX */
2088 case EM_NONE
: return _("None");
2089 case EM_AARCH64
: return "AArch64";
2090 case EM_M32
: return "WE32100";
2091 case EM_SPARC
: return "Sparc";
2092 case EM_SPU
: return "SPU";
2093 case EM_386
: return "Intel 80386";
2094 case EM_68K
: return "MC68000";
2095 case EM_88K
: return "MC88000";
2096 case EM_486
: return "Intel 80486";
2097 case EM_860
: return "Intel 80860";
2098 case EM_MIPS
: return "MIPS R3000";
2099 case EM_S370
: return "IBM System/370";
2100 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2101 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2102 case EM_PARISC
: return "HPPA";
2103 case EM_PPC_OLD
: return "Power PC (old)";
2104 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2105 case EM_960
: return "Intel 90860";
2106 case EM_PPC
: return "PowerPC";
2107 case EM_PPC64
: return "PowerPC64";
2108 case EM_FR20
: return "Fujitsu FR20";
2109 case EM_FT32
: return "FTDI FT32";
2110 case EM_RH32
: return "TRW RH32";
2111 case EM_MCORE
: return "MCORE";
2112 case EM_ARM
: return "ARM";
2113 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2114 case EM_SH
: return "Renesas / SuperH SH";
2115 case EM_SPARCV9
: return "Sparc v9";
2116 case EM_TRICORE
: return "Siemens Tricore";
2117 case EM_ARC
: return "ARC";
2118 case EM_H8_300
: return "Renesas H8/300";
2119 case EM_H8_300H
: return "Renesas H8/300H";
2120 case EM_H8S
: return "Renesas H8S";
2121 case EM_H8_500
: return "Renesas H8/500";
2122 case EM_IA_64
: return "Intel IA-64";
2123 case EM_MIPS_X
: return "Stanford MIPS-X";
2124 case EM_COLDFIRE
: return "Motorola Coldfire";
2125 case EM_ALPHA
: return "Alpha";
2126 case EM_CYGNUS_D10V
:
2127 case EM_D10V
: return "d10v";
2128 case EM_CYGNUS_D30V
:
2129 case EM_D30V
: return "d30v";
2130 case EM_CYGNUS_M32R
:
2131 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2132 case EM_CYGNUS_V850
:
2133 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2134 case EM_V850
: return "Renesas V850";
2135 case EM_CYGNUS_MN10300
:
2136 case EM_MN10300
: return "mn10300";
2137 case EM_CYGNUS_MN10200
:
2138 case EM_MN10200
: return "mn10200";
2139 case EM_MOXIE
: return "Moxie";
2140 case EM_CYGNUS_FR30
:
2141 case EM_FR30
: return "Fujitsu FR30";
2142 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2144 case EM_PJ
: return "picoJava";
2145 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2146 case EM_PCP
: return "Siemens PCP";
2147 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2148 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2149 case EM_STARCORE
: return "Motorola Star*Core processor";
2150 case EM_ME16
: return "Toyota ME16 processor";
2151 case EM_ST100
: return "STMicroelectronics ST100 processor";
2152 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2153 case EM_PDSP
: return "Sony DSP processor";
2154 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2155 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2156 case EM_FX66
: return "Siemens FX66 microcontroller";
2157 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2159 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2160 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2161 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2162 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2163 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2164 case EM_SVX
: return "Silicon Graphics SVx";
2165 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2166 case EM_VAX
: return "Digital VAX";
2167 case EM_VISIUM
: return "CDS VISIUMcore processor";
2169 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2170 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2171 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2172 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2173 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2174 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2175 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2176 case EM_PRISM
: return "Vitesse Prism";
2177 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2178 case EM_L1OM
: return "Intel L1OM";
2179 case EM_K1OM
: return "Intel K1OM";
2181 case EM_S390
: return "IBM S/390";
2182 case EM_SCORE
: return "SUNPLUS S+Core";
2183 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2184 case EM_OR1K
: return "OpenRISC 1000";
2185 case EM_ARC_A5
: return "ARC International ARCompact processor";
2186 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2187 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2188 case EM_DLX
: return "OpenDLX";
2190 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2191 case EM_IQ2000
: return "Vitesse IQ2000";
2193 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2194 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2195 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2196 case EM_NS32K
: return "National Semiconductor 32000 series";
2197 case EM_TPC
: return "Tenor Network TPC processor";
2198 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2199 case EM_MAX
: return "MAX Processor";
2200 case EM_CR
: return "National Semiconductor CompactRISC";
2201 case EM_F2MC16
: return "Fujitsu F2MC16";
2202 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2203 case EM_LATTICEMICO32
: return "Lattice Mico32";
2205 case EM_M32C
: return "Renesas M32c";
2206 case EM_MT
: return "Morpho Techologies MT processor";
2207 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2208 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2209 case EM_SEP
: return "Sharp embedded microprocessor";
2210 case EM_ARCA
: return "Arca RISC microprocessor";
2211 case EM_UNICORE
: return "Unicore";
2212 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2213 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2214 case EM_NIOS32
: return "Altera Nios";
2215 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2217 case EM_XC16X
: return "Infineon Technologies xc16x";
2218 case EM_M16C
: return "Renesas M16C series microprocessors";
2219 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2220 case EM_CE
: return "Freescale Communication Engine RISC core";
2221 case EM_TSK3000
: return "Altium TSK3000 core";
2222 case EM_RS08
: return "Freescale RS08 embedded processor";
2223 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2224 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2225 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2226 case EM_SE_C17
: return "Seiko Epson C17 family";
2227 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2228 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2229 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2230 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2232 case EM_R32C
: return "Renesas R32C series microprocessors";
2233 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2234 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2235 case EM_8051
: return "Intel 8051 and variants";
2236 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2237 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2238 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2239 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2241 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2242 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2243 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2246 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2247 case EM_RL78
: return "Renesas RL78";
2248 case EM_RX
: return "Renesas RX";
2249 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2250 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2251 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2252 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2253 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2254 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2255 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2256 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2257 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2258 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2259 case EM_CUDA
: return "NVIDIA CUDA architecture";
2260 case EM_XGATE
: return "Motorola XGATE embedded processor";
2262 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2268 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2273 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2274 e_flags
&= ~ EF_ARM_EABIMASK
;
2276 /* Handle "generic" ARM flags. */
2277 if (e_flags
& EF_ARM_RELEXEC
)
2279 strcat (buf
, ", relocatable executable");
2280 e_flags
&= ~ EF_ARM_RELEXEC
;
2283 if (e_flags
& EF_ARM_HASENTRY
)
2285 strcat (buf
, ", has entry point");
2286 e_flags
&= ~ EF_ARM_HASENTRY
;
2289 /* Now handle EABI specific flags. */
2293 strcat (buf
, ", <unrecognized EABI>");
2298 case EF_ARM_EABI_VER1
:
2299 strcat (buf
, ", Version1 EABI");
2304 /* Process flags one bit at a time. */
2305 flag
= e_flags
& - e_flags
;
2310 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2311 strcat (buf
, ", sorted symbol tables");
2321 case EF_ARM_EABI_VER2
:
2322 strcat (buf
, ", Version2 EABI");
2327 /* Process flags one bit at a time. */
2328 flag
= e_flags
& - e_flags
;
2333 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf
, ", sorted symbol tables");
2337 case EF_ARM_DYNSYMSUSESEGIDX
:
2338 strcat (buf
, ", dynamic symbols use segment index");
2341 case EF_ARM_MAPSYMSFIRST
:
2342 strcat (buf
, ", mapping symbols precede others");
2352 case EF_ARM_EABI_VER3
:
2353 strcat (buf
, ", Version3 EABI");
2356 case EF_ARM_EABI_VER4
:
2357 strcat (buf
, ", Version4 EABI");
2362 /* Process flags one bit at a time. */
2363 flag
= e_flags
& - e_flags
;
2369 strcat (buf
, ", BE8");
2373 strcat (buf
, ", LE8");
2384 case EF_ARM_EABI_VER5
:
2385 strcat (buf
, ", Version5 EABI");
2390 /* Process flags one bit at a time. */
2391 flag
= e_flags
& - e_flags
;
2397 strcat (buf
, ", BE8");
2401 strcat (buf
, ", LE8");
2404 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf
, ", soft-float ABI");
2408 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf
, ", hard-float ABI");
2419 case EF_ARM_EABI_UNKNOWN
:
2420 strcat (buf
, ", GNU EABI");
2425 /* Process flags one bit at a time. */
2426 flag
= e_flags
& - e_flags
;
2431 case EF_ARM_INTERWORK
:
2432 strcat (buf
, ", interworking enabled");
2435 case EF_ARM_APCS_26
:
2436 strcat (buf
, ", uses APCS/26");
2439 case EF_ARM_APCS_FLOAT
:
2440 strcat (buf
, ", uses APCS/float");
2444 strcat (buf
, ", position independent");
2448 strcat (buf
, ", 8 bit structure alignment");
2451 case EF_ARM_NEW_ABI
:
2452 strcat (buf
, ", uses new ABI");
2455 case EF_ARM_OLD_ABI
:
2456 strcat (buf
, ", uses old ABI");
2459 case EF_ARM_SOFT_FLOAT
:
2460 strcat (buf
, ", software FP");
2463 case EF_ARM_VFP_FLOAT
:
2464 strcat (buf
, ", VFP");
2467 case EF_ARM_MAVERICK_FLOAT
:
2468 strcat (buf
, ", Maverick FP");
2479 strcat (buf
,_(", <unknown>"));
2483 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2485 --size
; /* Leave space for null terminator. */
2487 switch (e_flags
& EF_AVR_MACH
)
2489 case E_AVR_MACH_AVR1
:
2490 strncat (buf
, ", avr:1", size
);
2492 case E_AVR_MACH_AVR2
:
2493 strncat (buf
, ", avr:2", size
);
2495 case E_AVR_MACH_AVR25
:
2496 strncat (buf
, ", avr:25", size
);
2498 case E_AVR_MACH_AVR3
:
2499 strncat (buf
, ", avr:3", size
);
2501 case E_AVR_MACH_AVR31
:
2502 strncat (buf
, ", avr:31", size
);
2504 case E_AVR_MACH_AVR35
:
2505 strncat (buf
, ", avr:35", size
);
2507 case E_AVR_MACH_AVR4
:
2508 strncat (buf
, ", avr:4", size
);
2510 case E_AVR_MACH_AVR5
:
2511 strncat (buf
, ", avr:5", size
);
2513 case E_AVR_MACH_AVR51
:
2514 strncat (buf
, ", avr:51", size
);
2516 case E_AVR_MACH_AVR6
:
2517 strncat (buf
, ", avr:6", size
);
2519 case E_AVR_MACH_AVRTINY
:
2520 strncat (buf
, ", avr:100", size
);
2522 case E_AVR_MACH_XMEGA1
:
2523 strncat (buf
, ", avr:101", size
);
2525 case E_AVR_MACH_XMEGA2
:
2526 strncat (buf
, ", avr:102", size
);
2528 case E_AVR_MACH_XMEGA3
:
2529 strncat (buf
, ", avr:103", size
);
2531 case E_AVR_MACH_XMEGA4
:
2532 strncat (buf
, ", avr:104", size
);
2534 case E_AVR_MACH_XMEGA5
:
2535 strncat (buf
, ", avr:105", size
);
2537 case E_AVR_MACH_XMEGA6
:
2538 strncat (buf
, ", avr:106", size
);
2540 case E_AVR_MACH_XMEGA7
:
2541 strncat (buf
, ", avr:107", size
);
2544 strncat (buf
, ", avr:<unknown>", size
);
2548 size
-= strlen (buf
);
2549 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2550 strncat (buf
, ", link-relax", size
);
2554 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2563 static const char *ABI_STRINGS
[] =
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
2572 static const char *VER_STRINGS
[] =
2574 "Andes ELF V1.3 or older",
2578 static const char *ARCH_STRINGS
[] =
2587 abi
= EF_NDS_ABI
& e_flags
;
2588 arch
= EF_NDS_ARCH
& e_flags
;
2589 config
= EF_NDS_INST
& e_flags
;
2590 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2592 memset (buf
, 0, size
);
2599 case E_NDS_ABI_V2FP
:
2600 case E_NDS_ABI_AABI
:
2601 case E_NDS_ABI_V2FP_PLUS
:
2602 /* In case there are holes in the array. */
2603 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2607 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2613 case E_NDS32_ELF_VER_1_2
:
2614 case E_NDS32_ELF_VER_1_3
:
2615 case E_NDS32_ELF_VER_1_4
:
2616 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2620 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2624 if (E_NDS_ABI_V0
== abi
)
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2629 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2635 case E_NDS_ARCH_STAR_V1_0
:
2636 case E_NDS_ARCH_STAR_V2_0
:
2637 case E_NDS_ARCH_STAR_V3_0
:
2638 case E_NDS_ARCH_STAR_V3_M
:
2639 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2643 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2652 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2653 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2655 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2656 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2658 if (config
& E_NDS32_HAS_DIV_INST
)
2659 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2661 if (config
& E_NDS32_HAS_16BIT_INST
)
2662 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2666 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2668 if (version
<= E_NDS32_ELF_VER_1_3
)
2669 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2671 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2674 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2675 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2677 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2678 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2680 if (config
& E_NDS32_HAS_16BIT_INST
)
2682 if (version
<= E_NDS32_ELF_VER_1_3
)
2683 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2685 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2689 if (config
& E_NDS32_HAS_EXT_INST
)
2690 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2692 if (config
& E_NDS32_HAS_EXT2_INST
)
2693 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2695 if (config
& E_NDS32_HAS_FPU_INST
)
2698 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2701 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2704 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2707 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2710 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2715 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2717 case E_NDS32_FPU_REG_8SP_4DP
:
2718 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2720 case E_NDS32_FPU_REG_16SP_8DP
:
2721 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2723 case E_NDS32_FPU_REG_32SP_16DP
:
2724 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2726 case E_NDS32_FPU_REG_32SP_32DP
:
2727 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2732 if (config
& E_NDS32_HAS_AUDIO_INST
)
2733 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2735 if (config
& E_NDS32_HAS_STRING_INST
)
2736 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2738 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2739 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2741 if (config
& E_NDS32_HAS_VIDEO_INST
)
2743 if (version
<= E_NDS32_ELF_VER_1_3
)
2744 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2746 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2749 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2750 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2752 if (config
& E_NDS32_HAS_L2C_INST
)
2753 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2757 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2759 static char buf
[1024];
2771 decode_ARM_machine_flags (e_flags
, buf
);
2775 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2779 if (e_flags
& EF_BFIN_PIC
)
2780 strcat (buf
, ", PIC");
2782 if (e_flags
& EF_BFIN_FDPIC
)
2783 strcat (buf
, ", FDPIC");
2785 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2786 strcat (buf
, ", code in L1");
2788 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2789 strcat (buf
, ", data in L1");
2794 switch (e_flags
& EF_FRV_CPU_MASK
)
2796 case EF_FRV_CPU_GENERIC
:
2800 strcat (buf
, ", fr???");
2803 case EF_FRV_CPU_FR300
:
2804 strcat (buf
, ", fr300");
2807 case EF_FRV_CPU_FR400
:
2808 strcat (buf
, ", fr400");
2810 case EF_FRV_CPU_FR405
:
2811 strcat (buf
, ", fr405");
2814 case EF_FRV_CPU_FR450
:
2815 strcat (buf
, ", fr450");
2818 case EF_FRV_CPU_FR500
:
2819 strcat (buf
, ", fr500");
2821 case EF_FRV_CPU_FR550
:
2822 strcat (buf
, ", fr550");
2825 case EF_FRV_CPU_SIMPLE
:
2826 strcat (buf
, ", simple");
2828 case EF_FRV_CPU_TOMCAT
:
2829 strcat (buf
, ", tomcat");
2835 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2836 strcat (buf
, ", m68000");
2837 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2838 strcat (buf
, ", cpu32");
2839 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2840 strcat (buf
, ", fido_a");
2843 char const * isa
= _("unknown");
2844 char const * mac
= _("unknown mac");
2845 char const * additional
= NULL
;
2847 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2849 case EF_M68K_CF_ISA_A_NODIV
:
2851 additional
= ", nodiv";
2853 case EF_M68K_CF_ISA_A
:
2856 case EF_M68K_CF_ISA_A_PLUS
:
2859 case EF_M68K_CF_ISA_B_NOUSP
:
2861 additional
= ", nousp";
2863 case EF_M68K_CF_ISA_B
:
2866 case EF_M68K_CF_ISA_C
:
2869 case EF_M68K_CF_ISA_C_NODIV
:
2871 additional
= ", nodiv";
2874 strcat (buf
, ", cf, isa ");
2877 strcat (buf
, additional
);
2878 if (e_flags
& EF_M68K_CF_FLOAT
)
2879 strcat (buf
, ", float");
2880 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2885 case EF_M68K_CF_MAC
:
2888 case EF_M68K_CF_EMAC
:
2891 case EF_M68K_CF_EMAC_B
:
2904 if (e_flags
& EF_PPC_EMB
)
2905 strcat (buf
, ", emb");
2907 if (e_flags
& EF_PPC_RELOCATABLE
)
2908 strcat (buf
, _(", relocatable"));
2910 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2911 strcat (buf
, _(", relocatable-lib"));
2915 if (e_flags
& EF_PPC64_ABI
)
2917 char abi
[] = ", abiv0";
2919 abi
[6] += e_flags
& EF_PPC64_ABI
;
2925 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2926 strcat (buf
, ", RH850 ABI");
2928 if (e_flags
& EF_V800_850E3
)
2929 strcat (buf
, ", V3 architecture");
2931 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2932 strcat (buf
, ", FPU not used");
2934 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2935 strcat (buf
, ", regmode: COMMON");
2937 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2938 strcat (buf
, ", r4 not used");
2940 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2941 strcat (buf
, ", r30 not used");
2943 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2944 strcat (buf
, ", r5 not used");
2946 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2947 strcat (buf
, ", r2 not used");
2949 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2951 switch (e_flags
& - e_flags
)
2953 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2954 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2955 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2956 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2957 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2958 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2959 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2960 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2961 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2962 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2963 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2964 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2971 case EM_CYGNUS_V850
:
2972 switch (e_flags
& EF_V850_ARCH
)
2974 case E_V850E3V5_ARCH
:
2975 strcat (buf
, ", v850e3v5");
2977 case E_V850E2V3_ARCH
:
2978 strcat (buf
, ", v850e2v3");
2981 strcat (buf
, ", v850e2");
2984 strcat (buf
, ", v850e1");
2987 strcat (buf
, ", v850e");
2990 strcat (buf
, ", v850");
2993 strcat (buf
, _(", unknown v850 architecture variant"));
2999 case EM_CYGNUS_M32R
:
3000 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3001 strcat (buf
, ", m32r");
3005 case EM_MIPS_RS3_LE
:
3006 if (e_flags
& EF_MIPS_NOREORDER
)
3007 strcat (buf
, ", noreorder");
3009 if (e_flags
& EF_MIPS_PIC
)
3010 strcat (buf
, ", pic");
3012 if (e_flags
& EF_MIPS_CPIC
)
3013 strcat (buf
, ", cpic");
3015 if (e_flags
& EF_MIPS_UCODE
)
3016 strcat (buf
, ", ugen_reserved");
3018 if (e_flags
& EF_MIPS_ABI2
)
3019 strcat (buf
, ", abi2");
3021 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3022 strcat (buf
, ", odk first");
3024 if (e_flags
& EF_MIPS_32BITMODE
)
3025 strcat (buf
, ", 32bitmode");
3027 if (e_flags
& EF_MIPS_NAN2008
)
3028 strcat (buf
, ", nan2008");
3030 if (e_flags
& EF_MIPS_FP64
)
3031 strcat (buf
, ", fp64");
3033 switch ((e_flags
& EF_MIPS_MACH
))
3035 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3036 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3037 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3038 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3039 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3040 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3041 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3042 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3043 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3044 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3045 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3046 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3047 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3048 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3049 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3050 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3051 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3053 /* We simply ignore the field in this case to avoid confusion:
3054 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3057 default: strcat (buf
, _(", unknown CPU")); break;
3060 switch ((e_flags
& EF_MIPS_ABI
))
3062 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3063 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3064 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3065 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3067 /* We simply ignore the field in this case to avoid confusion:
3068 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3069 This means it is likely to be an o32 file, but not for
3072 default: strcat (buf
, _(", unknown ABI")); break;
3075 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3076 strcat (buf
, ", mdmx");
3078 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3079 strcat (buf
, ", mips16");
3081 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3082 strcat (buf
, ", micromips");
3084 switch ((e_flags
& EF_MIPS_ARCH
))
3086 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3087 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3088 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3089 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3090 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3091 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3092 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3093 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3094 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3095 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3096 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3097 default: strcat (buf
, _(", unknown ISA")); break;
3102 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3106 switch ((e_flags
& EF_SH_MACH_MASK
))
3108 case EF_SH1
: strcat (buf
, ", sh1"); break;
3109 case EF_SH2
: strcat (buf
, ", sh2"); break;
3110 case EF_SH3
: strcat (buf
, ", sh3"); break;
3111 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3112 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3113 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3114 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3115 case EF_SH4
: strcat (buf
, ", sh4"); break;
3116 case EF_SH5
: strcat (buf
, ", sh5"); break;
3117 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3118 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3119 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3120 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3121 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3122 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3123 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3124 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3125 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3126 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3127 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3128 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3129 default: strcat (buf
, _(", unknown ISA")); break;
3132 if (e_flags
& EF_SH_PIC
)
3133 strcat (buf
, ", pic");
3135 if (e_flags
& EF_SH_FDPIC
)
3136 strcat (buf
, ", fdpic");
3140 if (e_flags
& EF_OR1K_NODELAY
)
3141 strcat (buf
, ", no delay");
3145 if (e_flags
& EF_SPARC_32PLUS
)
3146 strcat (buf
, ", v8+");
3148 if (e_flags
& EF_SPARC_SUN_US1
)
3149 strcat (buf
, ", ultrasparcI");
3151 if (e_flags
& EF_SPARC_SUN_US3
)
3152 strcat (buf
, ", ultrasparcIII");
3154 if (e_flags
& EF_SPARC_HAL_R1
)
3155 strcat (buf
, ", halr1");
3157 if (e_flags
& EF_SPARC_LEDATA
)
3158 strcat (buf
, ", ledata");
3160 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3161 strcat (buf
, ", tso");
3163 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3164 strcat (buf
, ", pso");
3166 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3167 strcat (buf
, ", rmo");
3171 switch (e_flags
& EF_PARISC_ARCH
)
3173 case EFA_PARISC_1_0
:
3174 strcpy (buf
, ", PA-RISC 1.0");
3176 case EFA_PARISC_1_1
:
3177 strcpy (buf
, ", PA-RISC 1.1");
3179 case EFA_PARISC_2_0
:
3180 strcpy (buf
, ", PA-RISC 2.0");
3185 if (e_flags
& EF_PARISC_TRAPNIL
)
3186 strcat (buf
, ", trapnil");
3187 if (e_flags
& EF_PARISC_EXT
)
3188 strcat (buf
, ", ext");
3189 if (e_flags
& EF_PARISC_LSB
)
3190 strcat (buf
, ", lsb");
3191 if (e_flags
& EF_PARISC_WIDE
)
3192 strcat (buf
, ", wide");
3193 if (e_flags
& EF_PARISC_NO_KABP
)
3194 strcat (buf
, ", no kabp");
3195 if (e_flags
& EF_PARISC_LAZYSWAP
)
3196 strcat (buf
, ", lazyswap");
3201 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3202 strcat (buf
, ", new calling convention");
3204 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3205 strcat (buf
, ", gnu calling convention");
3209 if ((e_flags
& EF_IA_64_ABI64
))
3210 strcat (buf
, ", 64-bit");
3212 strcat (buf
, ", 32-bit");
3213 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3214 strcat (buf
, ", reduced fp model");
3215 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3216 strcat (buf
, ", no function descriptors, constant gp");
3217 else if ((e_flags
& EF_IA_64_CONS_GP
))
3218 strcat (buf
, ", constant gp");
3219 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3220 strcat (buf
, ", absolute");
3221 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3223 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3224 strcat (buf
, ", vms_linkages");
3225 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3227 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3229 case EF_IA_64_VMS_COMCOD_WARNING
:
3230 strcat (buf
, ", warning");
3232 case EF_IA_64_VMS_COMCOD_ERROR
:
3233 strcat (buf
, ", error");
3235 case EF_IA_64_VMS_COMCOD_ABORT
:
3236 strcat (buf
, ", abort");
3239 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3240 e_flags
& EF_IA_64_VMS_COMCOD
);
3241 strcat (buf
, ", <unknown>");
3247 if ((e_flags
& EF_VAX_NONPIC
))
3248 strcat (buf
, ", non-PIC");
3249 if ((e_flags
& EF_VAX_DFLOAT
))
3250 strcat (buf
, ", D-Float");
3251 if ((e_flags
& EF_VAX_GFLOAT
))
3252 strcat (buf
, ", G-Float");
3256 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3257 strcat (buf
, ", mcm");
3258 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3259 strcat (buf
, ", mcm24");
3260 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3261 strcat (buf
, ", gr6");
3265 if (e_flags
& E_FLAG_RL78_G10
)
3266 strcat (buf
, ", G10");
3267 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3268 strcat (buf
, ", 64-bit doubles");
3272 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3273 strcat (buf
, ", 64-bit doubles");
3274 if (e_flags
& E_FLAG_RX_DSP
)
3275 strcat (buf
, ", dsp");
3276 if (e_flags
& E_FLAG_RX_PID
)
3277 strcat (buf
, ", pid");
3278 if (e_flags
& E_FLAG_RX_ABI
)
3279 strcat (buf
, ", RX ABI");
3283 if (e_flags
& EF_S390_HIGH_GPRS
)
3284 strcat (buf
, ", highgprs");
3288 if ((e_flags
& EF_C6000_REL
))
3289 strcat (buf
, ", relocatable module");
3293 strcat (buf
, _(": architecture variant: "));
3294 switch (e_flags
& EF_MSP430_MACH
)
3296 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3297 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3298 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3299 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3300 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3301 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3302 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3303 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3304 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3305 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3306 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3307 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3308 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3309 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3310 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3312 strcat (buf
, _(": unknown")); break;
3315 if (e_flags
& ~ EF_MSP430_MACH
)
3316 strcat (buf
, _(": unknown extra flag bits also present"));
3324 get_osabi_name (unsigned int osabi
)
3326 static char buff
[32];
3330 case ELFOSABI_NONE
: return "UNIX - System V";
3331 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3332 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3333 case ELFOSABI_GNU
: return "UNIX - GNU";
3334 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3335 case ELFOSABI_AIX
: return "UNIX - AIX";
3336 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3337 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3338 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3339 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3340 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3341 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3342 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3343 case ELFOSABI_AROS
: return "AROS";
3344 case ELFOSABI_FENIXOS
: return "FenixOS";
3347 switch (elf_header
.e_machine
)
3352 case ELFOSABI_ARM
: return "ARM";
3363 case ELFOSABI_STANDALONE
: return _("Standalone App");
3372 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3373 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3382 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3388 get_aarch64_segment_type (unsigned long type
)
3392 case PT_AARCH64_ARCHEXT
:
3393 return "AARCH64_ARCHEXT";
3402 get_arm_segment_type (unsigned long type
)
3416 get_mips_segment_type (unsigned long type
)
3420 case PT_MIPS_REGINFO
:
3422 case PT_MIPS_RTPROC
:
3424 case PT_MIPS_OPTIONS
:
3426 case PT_MIPS_ABIFLAGS
:
3436 get_parisc_segment_type (unsigned long type
)
3440 case PT_HP_TLS
: return "HP_TLS";
3441 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3442 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3443 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3444 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3445 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3446 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3447 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3448 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3449 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3450 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3451 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3452 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3453 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3454 case PT_HP_STACK
: return "HP_STACK";
3455 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3456 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3457 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3458 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3467 get_ia64_segment_type (unsigned long type
)
3471 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3472 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3473 case PT_HP_TLS
: return "HP_TLS";
3474 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3475 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3476 case PT_IA_64_HP_STACK
: return "HP_STACK";
3485 get_tic6x_segment_type (unsigned long type
)
3489 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3498 get_segment_type (unsigned long p_type
)
3500 static char buff
[32];
3504 case PT_NULL
: return "NULL";
3505 case PT_LOAD
: return "LOAD";
3506 case PT_DYNAMIC
: return "DYNAMIC";
3507 case PT_INTERP
: return "INTERP";
3508 case PT_NOTE
: return "NOTE";
3509 case PT_SHLIB
: return "SHLIB";
3510 case PT_PHDR
: return "PHDR";
3511 case PT_TLS
: return "TLS";
3513 case PT_GNU_EH_FRAME
:
3514 return "GNU_EH_FRAME";
3515 case PT_GNU_STACK
: return "GNU_STACK";
3516 case PT_GNU_RELRO
: return "GNU_RELRO";
3519 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3521 const char * result
;
3523 switch (elf_header
.e_machine
)
3526 result
= get_aarch64_segment_type (p_type
);
3529 result
= get_arm_segment_type (p_type
);
3532 case EM_MIPS_RS3_LE
:
3533 result
= get_mips_segment_type (p_type
);
3536 result
= get_parisc_segment_type (p_type
);
3539 result
= get_ia64_segment_type (p_type
);
3542 result
= get_tic6x_segment_type (p_type
);
3552 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3554 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3556 const char * result
;
3558 switch (elf_header
.e_machine
)
3561 result
= get_parisc_segment_type (p_type
);
3564 result
= get_ia64_segment_type (p_type
);
3574 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3577 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3584 get_mips_section_type_name (unsigned int sh_type
)
3588 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3589 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3590 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3591 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3592 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3593 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3594 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3595 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3596 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3597 case SHT_MIPS_RELD
: return "MIPS_RELD";
3598 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3599 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3600 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3601 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3602 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3603 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3604 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3605 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3606 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3607 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3608 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3609 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3610 case SHT_MIPS_LINE
: return "MIPS_LINE";
3611 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3612 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3613 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3614 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3615 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3616 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3617 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3618 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3619 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3620 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3621 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3622 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3623 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3624 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3625 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3626 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3627 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3635 get_parisc_section_type_name (unsigned int sh_type
)
3639 case SHT_PARISC_EXT
: return "PARISC_EXT";
3640 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3641 case SHT_PARISC_DOC
: return "PARISC_DOC";
3642 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3643 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3644 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3645 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3653 get_ia64_section_type_name (unsigned int sh_type
)
3655 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3656 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3657 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3661 case SHT_IA_64_EXT
: return "IA_64_EXT";
3662 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3663 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3664 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3665 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3666 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3667 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3668 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3669 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3670 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3678 get_x86_64_section_type_name (unsigned int sh_type
)
3682 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3690 get_aarch64_section_type_name (unsigned int sh_type
)
3694 case SHT_AARCH64_ATTRIBUTES
:
3695 return "AARCH64_ATTRIBUTES";
3703 get_arm_section_type_name (unsigned int sh_type
)
3707 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3708 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3709 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3710 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3711 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3719 get_tic6x_section_type_name (unsigned int sh_type
)
3723 case SHT_C6000_UNWIND
:
3724 return "C6000_UNWIND";
3725 case SHT_C6000_PREEMPTMAP
:
3726 return "C6000_PREEMPTMAP";
3727 case SHT_C6000_ATTRIBUTES
:
3728 return "C6000_ATTRIBUTES";
3733 case SHT_TI_HANDLER
:
3734 return "TI_HANDLER";
3735 case SHT_TI_INITINFO
:
3736 return "TI_INITINFO";
3737 case SHT_TI_PHATTRS
:
3738 return "TI_PHATTRS";
3746 get_msp430x_section_type_name (unsigned int sh_type
)
3750 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3751 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3752 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3753 default: return NULL
;
3758 get_v850_section_type_name (unsigned int sh_type
)
3762 case SHT_V850_SCOMMON
: return "V850 Small Common";
3763 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3764 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3765 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3766 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3767 default: return NULL
;
3772 get_section_type_name (unsigned int sh_type
)
3774 static char buff
[32];
3778 case SHT_NULL
: return "NULL";
3779 case SHT_PROGBITS
: return "PROGBITS";
3780 case SHT_SYMTAB
: return "SYMTAB";
3781 case SHT_STRTAB
: return "STRTAB";
3782 case SHT_RELA
: return "RELA";
3783 case SHT_HASH
: return "HASH";
3784 case SHT_DYNAMIC
: return "DYNAMIC";
3785 case SHT_NOTE
: return "NOTE";
3786 case SHT_NOBITS
: return "NOBITS";
3787 case SHT_REL
: return "REL";
3788 case SHT_SHLIB
: return "SHLIB";
3789 case SHT_DYNSYM
: return "DYNSYM";
3790 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3791 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3792 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3793 case SHT_GNU_HASH
: return "GNU_HASH";
3794 case SHT_GROUP
: return "GROUP";
3795 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3796 case SHT_GNU_verdef
: return "VERDEF";
3797 case SHT_GNU_verneed
: return "VERNEED";
3798 case SHT_GNU_versym
: return "VERSYM";
3799 case 0x6ffffff0: return "VERSYM";
3800 case 0x6ffffffc: return "VERDEF";
3801 case 0x7ffffffd: return "AUXILIARY";
3802 case 0x7fffffff: return "FILTER";
3803 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3806 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3808 const char * result
;
3810 switch (elf_header
.e_machine
)
3813 case EM_MIPS_RS3_LE
:
3814 result
= get_mips_section_type_name (sh_type
);
3817 result
= get_parisc_section_type_name (sh_type
);
3820 result
= get_ia64_section_type_name (sh_type
);
3825 result
= get_x86_64_section_type_name (sh_type
);
3828 result
= get_aarch64_section_type_name (sh_type
);
3831 result
= get_arm_section_type_name (sh_type
);
3834 result
= get_tic6x_section_type_name (sh_type
);
3837 result
= get_msp430x_section_type_name (sh_type
);
3841 case EM_CYGNUS_V850
:
3842 result
= get_v850_section_type_name (sh_type
);
3852 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3854 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3856 const char * result
;
3858 switch (elf_header
.e_machine
)
3861 result
= get_ia64_section_type_name (sh_type
);
3871 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3873 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3875 switch (elf_header
.e_machine
)
3879 case EM_CYGNUS_V850
:
3880 return get_v850_section_type_name (sh_type
);
3885 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3888 /* This message is probably going to be displayed in a 15
3889 character wide field, so put the hex value first. */
3890 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3896 #define OPTION_DEBUG_DUMP 512
3897 #define OPTION_DYN_SYMS 513
3898 #define OPTION_DWARF_DEPTH 514
3899 #define OPTION_DWARF_START 515
3900 #define OPTION_DWARF_CHECK 516
3902 static struct option options
[] =
3904 {"all", no_argument
, 0, 'a'},
3905 {"file-header", no_argument
, 0, 'h'},
3906 {"program-headers", no_argument
, 0, 'l'},
3907 {"headers", no_argument
, 0, 'e'},
3908 {"histogram", no_argument
, 0, 'I'},
3909 {"segments", no_argument
, 0, 'l'},
3910 {"sections", no_argument
, 0, 'S'},
3911 {"section-headers", no_argument
, 0, 'S'},
3912 {"section-groups", no_argument
, 0, 'g'},
3913 {"section-details", no_argument
, 0, 't'},
3914 {"full-section-name",no_argument
, 0, 'N'},
3915 {"symbols", no_argument
, 0, 's'},
3916 {"syms", no_argument
, 0, 's'},
3917 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3918 {"relocs", no_argument
, 0, 'r'},
3919 {"notes", no_argument
, 0, 'n'},
3920 {"dynamic", no_argument
, 0, 'd'},
3921 {"arch-specific", no_argument
, 0, 'A'},
3922 {"version-info", no_argument
, 0, 'V'},
3923 {"use-dynamic", no_argument
, 0, 'D'},
3924 {"unwind", no_argument
, 0, 'u'},
3925 {"archive-index", no_argument
, 0, 'c'},
3926 {"hex-dump", required_argument
, 0, 'x'},
3927 {"relocated-dump", required_argument
, 0, 'R'},
3928 {"string-dump", required_argument
, 0, 'p'},
3929 #ifdef SUPPORT_DISASSEMBLY
3930 {"instruction-dump", required_argument
, 0, 'i'},
3932 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3934 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3935 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3936 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3938 {"version", no_argument
, 0, 'v'},
3939 {"wide", no_argument
, 0, 'W'},
3940 {"help", no_argument
, 0, 'H'},
3941 {0, no_argument
, 0, 0}
3945 usage (FILE * stream
)
3947 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3948 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3949 fprintf (stream
, _(" Options are:\n\
3950 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3951 -h --file-header Display the ELF file header\n\
3952 -l --program-headers Display the program headers\n\
3953 --segments An alias for --program-headers\n\
3954 -S --section-headers Display the sections' header\n\
3955 --sections An alias for --section-headers\n\
3956 -g --section-groups Display the section groups\n\
3957 -t --section-details Display the section details\n\
3958 -e --headers Equivalent to: -h -l -S\n\
3959 -s --syms Display the symbol table\n\
3960 --symbols An alias for --syms\n\
3961 --dyn-syms Display the dynamic symbol table\n\
3962 -n --notes Display the core notes (if present)\n\
3963 -r --relocs Display the relocations (if present)\n\
3964 -u --unwind Display the unwind info (if present)\n\
3965 -d --dynamic Display the dynamic section (if present)\n\
3966 -V --version-info Display the version sections (if present)\n\
3967 -A --arch-specific Display architecture specific information (if any)\n\
3968 -c --archive-index Display the symbol/file index in an archive\n\
3969 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3970 -x --hex-dump=<number|name>\n\
3971 Dump the contents of section <number|name> as bytes\n\
3972 -p --string-dump=<number|name>\n\
3973 Dump the contents of section <number|name> as strings\n\
3974 -R --relocated-dump=<number|name>\n\
3975 Dump the contents of section <number|name> as relocated bytes\n\
3976 -w[lLiaprmfFsoRt] or\n\
3977 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3978 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3979 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3981 Display the contents of DWARF2 debug sections\n"));
3982 fprintf (stream
, _("\
3983 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3984 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3986 #ifdef SUPPORT_DISASSEMBLY
3987 fprintf (stream
, _("\
3988 -i --instruction-dump=<number|name>\n\
3989 Disassemble the contents of section <number|name>\n"));
3991 fprintf (stream
, _("\
3992 -I --histogram Display histogram of bucket list lengths\n\
3993 -W --wide Allow output width to exceed 80 characters\n\
3994 @<file> Read options from <file>\n\
3995 -H --help Display this information\n\
3996 -v --version Display the version number of readelf\n"));
3998 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3999 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4001 exit (stream
== stdout
? 0 : 1);
4004 /* Record the fact that the user wants the contents of section number
4005 SECTION to be displayed using the method(s) encoded as flags bits
4006 in TYPE. Note, TYPE can be zero if we are creating the array for
4010 request_dump_bynumber (unsigned int section
, dump_type type
)
4012 if (section
>= num_dump_sects
)
4014 dump_type
* new_dump_sects
;
4016 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4017 sizeof (* dump_sects
));
4019 if (new_dump_sects
== NULL
)
4020 error (_("Out of memory allocating dump request table.\n"));
4023 /* Copy current flag settings. */
4024 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4028 dump_sects
= new_dump_sects
;
4029 num_dump_sects
= section
+ 1;
4034 dump_sects
[section
] |= type
;
4039 /* Request a dump by section name. */
4042 request_dump_byname (const char * section
, dump_type type
)
4044 struct dump_list_entry
* new_request
;
4046 new_request
= (struct dump_list_entry
*)
4047 malloc (sizeof (struct dump_list_entry
));
4049 error (_("Out of memory allocating dump request table.\n"));
4051 new_request
->name
= strdup (section
);
4052 if (!new_request
->name
)
4053 error (_("Out of memory allocating dump request table.\n"));
4055 new_request
->type
= type
;
4057 new_request
->next
= dump_sects_byname
;
4058 dump_sects_byname
= new_request
;
4062 request_dump (dump_type type
)
4068 section
= strtoul (optarg
, & cp
, 0);
4070 if (! *cp
&& section
>= 0)
4071 request_dump_bynumber (section
, type
);
4073 request_dump_byname (optarg
, type
);
4078 parse_args (int argc
, char ** argv
)
4085 while ((c
= getopt_long
4086 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
4104 do_section_groups
++;
4112 do_section_groups
++;
4117 do_section_details
++;
4161 request_dump (HEX_DUMP
);
4164 request_dump (STRING_DUMP
);
4167 request_dump (RELOC_DUMP
);
4174 dwarf_select_sections_all ();
4179 dwarf_select_sections_by_letters (optarg
);
4182 case OPTION_DEBUG_DUMP
:
4189 dwarf_select_sections_by_names (optarg
);
4192 case OPTION_DWARF_DEPTH
:
4196 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4199 case OPTION_DWARF_START
:
4203 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4206 case OPTION_DWARF_CHECK
:
4209 case OPTION_DYN_SYMS
:
4212 #ifdef SUPPORT_DISASSEMBLY
4214 request_dump (DISASS_DUMP
);
4218 print_version (program_name
);
4227 /* xgettext:c-format */
4228 error (_("Invalid option '-%c'\n"), c
);
4235 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4236 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4237 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4238 && !do_section_groups
&& !do_archive_index
4243 warn (_("Nothing to do.\n"));
4249 get_elf_class (unsigned int elf_class
)
4251 static char buff
[32];
4255 case ELFCLASSNONE
: return _("none");
4256 case ELFCLASS32
: return "ELF32";
4257 case ELFCLASS64
: return "ELF64";
4259 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4265 get_data_encoding (unsigned int encoding
)
4267 static char buff
[32];
4271 case ELFDATANONE
: return _("none");
4272 case ELFDATA2LSB
: return _("2's complement, little endian");
4273 case ELFDATA2MSB
: return _("2's complement, big endian");
4275 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4280 /* Decode the data held in 'elf_header'. */
4283 process_file_header (void)
4285 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4286 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4287 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4288 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4291 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4295 init_dwarf_regnames (elf_header
.e_machine
);
4301 printf (_("ELF Header:\n"));
4302 printf (_(" Magic: "));
4303 for (i
= 0; i
< EI_NIDENT
; i
++)
4304 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4306 printf (_(" Class: %s\n"),
4307 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4308 printf (_(" Data: %s\n"),
4309 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4310 printf (_(" Version: %d %s\n"),
4311 elf_header
.e_ident
[EI_VERSION
],
4312 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4314 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4315 ? _("<unknown: %lx>")
4317 printf (_(" OS/ABI: %s\n"),
4318 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4319 printf (_(" ABI Version: %d\n"),
4320 elf_header
.e_ident
[EI_ABIVERSION
]);
4321 printf (_(" Type: %s\n"),
4322 get_file_type (elf_header
.e_type
));
4323 printf (_(" Machine: %s\n"),
4324 get_machine_name (elf_header
.e_machine
));
4325 printf (_(" Version: 0x%lx\n"),
4326 (unsigned long) elf_header
.e_version
);
4328 printf (_(" Entry point address: "));
4329 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4330 printf (_("\n Start of program headers: "));
4331 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4332 printf (_(" (bytes into file)\n Start of section headers: "));
4333 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4334 printf (_(" (bytes into file)\n"));
4336 printf (_(" Flags: 0x%lx%s\n"),
4337 (unsigned long) elf_header
.e_flags
,
4338 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4339 printf (_(" Size of this header: %ld (bytes)\n"),
4340 (long) elf_header
.e_ehsize
);
4341 printf (_(" Size of program headers: %ld (bytes)\n"),
4342 (long) elf_header
.e_phentsize
);
4343 printf (_(" Number of program headers: %ld"),
4344 (long) elf_header
.e_phnum
);
4345 if (section_headers
!= NULL
4346 && elf_header
.e_phnum
== PN_XNUM
4347 && section_headers
[0].sh_info
!= 0)
4348 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4349 putc ('\n', stdout
);
4350 printf (_(" Size of section headers: %ld (bytes)\n"),
4351 (long) elf_header
.e_shentsize
);
4352 printf (_(" Number of section headers: %ld"),
4353 (long) elf_header
.e_shnum
);
4354 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4355 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4356 putc ('\n', stdout
);
4357 printf (_(" Section header string table index: %ld"),
4358 (long) elf_header
.e_shstrndx
);
4359 if (section_headers
!= NULL
4360 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4361 printf (" (%u)", section_headers
[0].sh_link
);
4362 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4363 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4364 printf (_(" <corrupt: out of range>"));
4365 putc ('\n', stdout
);
4368 if (section_headers
!= NULL
)
4370 if (elf_header
.e_phnum
== PN_XNUM
4371 && section_headers
[0].sh_info
!= 0)
4372 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4373 if (elf_header
.e_shnum
== SHN_UNDEF
)
4374 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4375 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4376 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4377 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4378 elf_header
.e_shstrndx
= SHN_UNDEF
;
4379 free (section_headers
);
4380 section_headers
= NULL
;
4387 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4389 Elf32_External_Phdr
* phdrs
;
4390 Elf32_External_Phdr
* external
;
4391 Elf_Internal_Phdr
* internal
;
4393 unsigned int size
= elf_header
.e_phentsize
;
4394 unsigned int num
= elf_header
.e_phnum
;
4396 /* PR binutils/17531: Cope with unexpected section header sizes. */
4397 if (size
== 0 || num
== 0)
4399 if (size
< sizeof * phdrs
)
4401 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4404 if (size
> sizeof * phdrs
)
4405 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4407 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4408 size
, num
, _("program headers"));
4412 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4413 i
< elf_header
.e_phnum
;
4414 i
++, internal
++, external
++)
4416 internal
->p_type
= BYTE_GET (external
->p_type
);
4417 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4418 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4419 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4420 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4421 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4422 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4423 internal
->p_align
= BYTE_GET (external
->p_align
);
4431 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4433 Elf64_External_Phdr
* phdrs
;
4434 Elf64_External_Phdr
* external
;
4435 Elf_Internal_Phdr
* internal
;
4437 unsigned int size
= elf_header
.e_phentsize
;
4438 unsigned int num
= elf_header
.e_phnum
;
4440 /* PR binutils/17531: Cope with unexpected section header sizes. */
4441 if (size
== 0 || num
== 0)
4443 if (size
< sizeof * phdrs
)
4445 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4448 if (size
> sizeof * phdrs
)
4449 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4451 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4452 size
, num
, _("program headers"));
4456 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4457 i
< elf_header
.e_phnum
;
4458 i
++, internal
++, external
++)
4460 internal
->p_type
= BYTE_GET (external
->p_type
);
4461 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4462 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4463 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4464 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4465 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4466 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4467 internal
->p_align
= BYTE_GET (external
->p_align
);
4474 /* Returns 1 if the program headers were read into `program_headers'. */
4477 get_program_headers (FILE * file
)
4479 Elf_Internal_Phdr
* phdrs
;
4481 /* Check cache of prior read. */
4482 if (program_headers
!= NULL
)
4485 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4486 sizeof (Elf_Internal_Phdr
));
4490 error (_("Out of memory reading %u program headers\n"),
4491 elf_header
.e_phnum
);
4496 ? get_32bit_program_headers (file
, phdrs
)
4497 : get_64bit_program_headers (file
, phdrs
))
4499 program_headers
= phdrs
;
4507 /* Returns 1 if the program headers were loaded. */
4510 process_program_headers (FILE * file
)
4512 Elf_Internal_Phdr
* segment
;
4515 if (elf_header
.e_phnum
== 0)
4517 /* PR binutils/12467. */
4518 if (elf_header
.e_phoff
!= 0)
4519 warn (_("possibly corrupt ELF header - it has a non-zero program"
4520 " header offset, but no program headers\n"));
4521 else if (do_segments
)
4522 printf (_("\nThere are no program headers in this file.\n"));
4526 if (do_segments
&& !do_header
)
4528 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4529 printf (_("Entry point "));
4530 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4531 printf (_("\nThere are %d program headers, starting at offset "),
4532 elf_header
.e_phnum
);
4533 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4537 if (! get_program_headers (file
))
4542 if (elf_header
.e_phnum
> 1)
4543 printf (_("\nProgram Headers:\n"));
4545 printf (_("\nProgram Headers:\n"));
4549 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4552 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4556 (_(" Type Offset VirtAddr PhysAddr\n"));
4558 (_(" FileSiz MemSiz Flags Align\n"));
4565 for (i
= 0, segment
= program_headers
;
4566 i
< elf_header
.e_phnum
;
4571 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4575 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4576 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4577 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4578 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4579 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4581 (segment
->p_flags
& PF_R
? 'R' : ' '),
4582 (segment
->p_flags
& PF_W
? 'W' : ' '),
4583 (segment
->p_flags
& PF_X
? 'E' : ' '));
4584 printf ("%#lx", (unsigned long) segment
->p_align
);
4588 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4589 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4592 print_vma (segment
->p_offset
, FULL_HEX
);
4596 print_vma (segment
->p_vaddr
, FULL_HEX
);
4598 print_vma (segment
->p_paddr
, FULL_HEX
);
4601 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4602 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4605 print_vma (segment
->p_filesz
, FULL_HEX
);
4609 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4610 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4613 print_vma (segment
->p_memsz
, FULL_HEX
);
4617 (segment
->p_flags
& PF_R
? 'R' : ' '),
4618 (segment
->p_flags
& PF_W
? 'W' : ' '),
4619 (segment
->p_flags
& PF_X
? 'E' : ' '));
4621 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4622 printf ("%#lx", (unsigned long) segment
->p_align
);
4625 print_vma (segment
->p_align
, PREFIX_HEX
);
4630 print_vma (segment
->p_offset
, FULL_HEX
);
4632 print_vma (segment
->p_vaddr
, FULL_HEX
);
4634 print_vma (segment
->p_paddr
, FULL_HEX
);
4636 print_vma (segment
->p_filesz
, FULL_HEX
);
4638 print_vma (segment
->p_memsz
, FULL_HEX
);
4640 (segment
->p_flags
& PF_R
? 'R' : ' '),
4641 (segment
->p_flags
& PF_W
? 'W' : ' '),
4642 (segment
->p_flags
& PF_X
? 'E' : ' '));
4643 print_vma (segment
->p_align
, HEX
);
4648 putc ('\n', stdout
);
4650 switch (segment
->p_type
)
4654 error (_("more than one dynamic segment\n"));
4656 /* By default, assume that the .dynamic section is the first
4657 section in the DYNAMIC segment. */
4658 dynamic_addr
= segment
->p_offset
;
4659 dynamic_size
= segment
->p_filesz
;
4660 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4661 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4663 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4664 dynamic_addr
= dynamic_size
= 0;
4667 /* Try to locate the .dynamic section. If there is
4668 a section header table, we can easily locate it. */
4669 if (section_headers
!= NULL
)
4671 Elf_Internal_Shdr
* sec
;
4673 sec
= find_section (".dynamic");
4674 if (sec
== NULL
|| sec
->sh_size
== 0)
4676 /* A corresponding .dynamic section is expected, but on
4677 IA-64/OpenVMS it is OK for it to be missing. */
4678 if (!is_ia64_vms ())
4679 error (_("no .dynamic section in the dynamic segment\n"));
4683 if (sec
->sh_type
== SHT_NOBITS
)
4689 dynamic_addr
= sec
->sh_offset
;
4690 dynamic_size
= sec
->sh_size
;
4692 if (dynamic_addr
< segment
->p_offset
4693 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4694 warn (_("the .dynamic section is not contained"
4695 " within the dynamic segment\n"));
4696 else if (dynamic_addr
> segment
->p_offset
)
4697 warn (_("the .dynamic section is not the first section"
4698 " in the dynamic segment.\n"));
4703 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4705 error (_("Unable to find program interpreter name\n"));
4709 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4711 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4712 error (_("Internal error: failed to create format string to display program interpreter\n"));
4714 program_interpreter
[0] = 0;
4715 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4716 error (_("Unable to read program interpreter name\n"));
4719 printf (_(" [Requesting program interpreter: %s]\n"),
4720 program_interpreter
);
4726 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4728 printf (_("\n Section to Segment mapping:\n"));
4729 printf (_(" Segment Sections...\n"));
4731 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4734 Elf_Internal_Shdr
* section
;
4736 segment
= program_headers
+ i
;
4737 section
= section_headers
+ 1;
4739 printf (" %2.2d ", i
);
4741 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4743 if (!ELF_TBSS_SPECIAL (section
, segment
)
4744 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4745 printf ("%s ", printable_section_name (section
));
4756 /* Find the file offset corresponding to VMA by using the program headers. */
4759 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4761 Elf_Internal_Phdr
* seg
;
4763 if (! get_program_headers (file
))
4765 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4769 for (seg
= program_headers
;
4770 seg
< program_headers
+ elf_header
.e_phnum
;
4773 if (seg
->p_type
!= PT_LOAD
)
4776 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4777 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4778 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4781 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4782 (unsigned long) vma
);
4787 /* Allocate memory and load the sections headers into the global pointer
4788 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4789 generate any error messages if the load fails. */
4792 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4794 Elf32_External_Shdr
* shdrs
;
4795 Elf_Internal_Shdr
* internal
;
4797 unsigned int size
= elf_header
.e_shentsize
;
4798 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4800 /* PR binutils/17531: Cope with unexpected section header sizes. */
4801 if (size
== 0 || num
== 0)
4803 if (size
< sizeof * shdrs
)
4806 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4809 if (!probe
&& size
> sizeof * shdrs
)
4810 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4812 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4814 probe
? NULL
: _("section headers"));
4818 if (section_headers
!= NULL
)
4819 free (section_headers
);
4820 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4821 sizeof (Elf_Internal_Shdr
));
4822 if (section_headers
== NULL
)
4825 error (_("Out of memory reading %u section headers\n"), num
);
4829 for (i
= 0, internal
= section_headers
;
4833 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4834 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4835 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4836 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4837 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4838 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4839 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4840 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4841 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4842 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4850 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4852 Elf64_External_Shdr
* shdrs
;
4853 Elf_Internal_Shdr
* internal
;
4855 unsigned int size
= elf_header
.e_shentsize
;
4856 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4858 /* PR binutils/17531: Cope with unexpected section header sizes. */
4859 if (size
== 0 || num
== 0)
4861 if (size
< sizeof * shdrs
)
4864 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4867 if (! probe
&& size
> sizeof * shdrs
)
4868 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4870 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4872 probe
? NULL
: _("section headers"));
4876 if (section_headers
!= NULL
)
4877 free (section_headers
);
4878 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4879 sizeof (Elf_Internal_Shdr
));
4880 if (section_headers
== NULL
)
4883 error (_("Out of memory reading %u section headers\n"), num
);
4887 for (i
= 0, internal
= section_headers
;
4891 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4892 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4893 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4894 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4895 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4896 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4897 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4898 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4899 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4900 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4907 static Elf_Internal_Sym
*
4908 get_32bit_elf_symbols (FILE * file
,
4909 Elf_Internal_Shdr
* section
,
4910 unsigned long * num_syms_return
)
4912 unsigned long number
= 0;
4913 Elf32_External_Sym
* esyms
= NULL
;
4914 Elf_External_Sym_Shndx
* shndx
= NULL
;
4915 Elf_Internal_Sym
* isyms
= NULL
;
4916 Elf_Internal_Sym
* psym
;
4919 if (section
->sh_size
== 0)
4921 if (num_syms_return
!= NULL
)
4922 * num_syms_return
= 0;
4926 /* Run some sanity checks first. */
4927 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4929 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4930 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4934 if (section
->sh_size
> current_file_size
)
4936 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4937 printable_section_name (section
), (unsigned long) section
->sh_size
);
4941 number
= section
->sh_size
/ section
->sh_entsize
;
4943 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4945 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4946 (unsigned long) section
->sh_size
,
4947 printable_section_name (section
),
4948 (unsigned long) section
->sh_entsize
);
4952 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4953 section
->sh_size
, _("symbols"));
4958 if (symtab_shndx_hdr
!= NULL
4959 && (symtab_shndx_hdr
->sh_link
4960 == (unsigned long) (section
- section_headers
)))
4962 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4963 symtab_shndx_hdr
->sh_offset
,
4964 1, symtab_shndx_hdr
->sh_size
,
4965 _("symbol table section indicies"));
4968 /* PR17531: file: heap-buffer-overflow */
4969 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
4971 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4972 printable_section_name (symtab_shndx_hdr
),
4973 (unsigned long) symtab_shndx_hdr
->sh_size
,
4974 (unsigned long) section
->sh_size
);
4979 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4983 error (_("Out of memory reading %lu symbols\n"),
4984 (unsigned long) number
);
4988 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4990 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4991 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4992 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4993 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4994 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4996 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4997 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4998 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4999 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5000 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5009 if (num_syms_return
!= NULL
)
5010 * num_syms_return
= isyms
== NULL
? 0 : number
;
5015 static Elf_Internal_Sym
*
5016 get_64bit_elf_symbols (FILE * file
,
5017 Elf_Internal_Shdr
* section
,
5018 unsigned long * num_syms_return
)
5020 unsigned long number
= 0;
5021 Elf64_External_Sym
* esyms
= NULL
;
5022 Elf_External_Sym_Shndx
* shndx
= NULL
;
5023 Elf_Internal_Sym
* isyms
= NULL
;
5024 Elf_Internal_Sym
* psym
;
5027 if (section
->sh_size
== 0)
5029 if (num_syms_return
!= NULL
)
5030 * num_syms_return
= 0;
5034 /* Run some sanity checks first. */
5035 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5037 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5038 printable_section_name (section
),
5039 (unsigned long) section
->sh_entsize
);
5043 if (section
->sh_size
> current_file_size
)
5045 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5046 printable_section_name (section
),
5047 (unsigned long) section
->sh_size
);
5051 number
= section
->sh_size
/ section
->sh_entsize
;
5053 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5055 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5056 (unsigned long) section
->sh_size
,
5057 printable_section_name (section
),
5058 (unsigned long) section
->sh_entsize
);
5062 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5063 section
->sh_size
, _("symbols"));
5067 if (symtab_shndx_hdr
!= NULL
5068 && (symtab_shndx_hdr
->sh_link
5069 == (unsigned long) (section
- section_headers
)))
5071 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5072 symtab_shndx_hdr
->sh_offset
,
5073 1, symtab_shndx_hdr
->sh_size
,
5074 _("symbol table section indicies"));
5077 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5079 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5080 printable_section_name (symtab_shndx_hdr
),
5081 (unsigned long) symtab_shndx_hdr
->sh_size
,
5082 (unsigned long) section
->sh_size
);
5087 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5091 error (_("Out of memory reading %lu symbols\n"),
5092 (unsigned long) number
);
5096 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5098 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5099 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5100 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5101 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5103 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5105 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5106 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5107 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5109 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5110 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5119 if (num_syms_return
!= NULL
)
5120 * num_syms_return
= isyms
== NULL
? 0 : number
;
5126 get_elf_section_flags (bfd_vma sh_flags
)
5128 static char buff
[1024];
5130 int field_size
= is_32bit_elf
? 8 : 16;
5132 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5133 bfd_vma os_flags
= 0;
5134 bfd_vma proc_flags
= 0;
5135 bfd_vma unknown_flags
= 0;
5143 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5144 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5145 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5146 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5147 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5148 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5149 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5150 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5151 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5152 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5153 /* IA-64 specific. */
5154 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5155 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5156 /* IA-64 OpenVMS specific. */
5157 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5158 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5159 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5160 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5161 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5162 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5164 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5165 /* SPARC specific. */
5166 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5169 if (do_section_details
)
5171 sprintf (buff
, "[%*.*lx]: ",
5172 field_size
, field_size
, (unsigned long) sh_flags
);
5173 p
+= field_size
+ 4;
5180 flag
= sh_flags
& - sh_flags
;
5183 if (do_section_details
)
5187 case SHF_WRITE
: sindex
= 0; break;
5188 case SHF_ALLOC
: sindex
= 1; break;
5189 case SHF_EXECINSTR
: sindex
= 2; break;
5190 case SHF_MERGE
: sindex
= 3; break;
5191 case SHF_STRINGS
: sindex
= 4; break;
5192 case SHF_INFO_LINK
: sindex
= 5; break;
5193 case SHF_LINK_ORDER
: sindex
= 6; break;
5194 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5195 case SHF_GROUP
: sindex
= 8; break;
5196 case SHF_TLS
: sindex
= 9; break;
5197 case SHF_EXCLUDE
: sindex
= 18; break;
5201 switch (elf_header
.e_machine
)
5204 if (flag
== SHF_IA_64_SHORT
)
5206 else if (flag
== SHF_IA_64_NORECOV
)
5209 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5212 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5213 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5214 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5215 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5216 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5217 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5228 case EM_OLD_SPARCV9
:
5229 case EM_SPARC32PLUS
:
5232 if (flag
== SHF_ORDERED
)
5242 if (p
!= buff
+ field_size
+ 4)
5244 if (size
< (10 + 2))
5246 warn (_("Internal error: not enough buffer room for section flag info"));
5247 return _("<unknown>");
5254 size
-= flags
[sindex
].len
;
5255 p
= stpcpy (p
, flags
[sindex
].str
);
5257 else if (flag
& SHF_MASKOS
)
5259 else if (flag
& SHF_MASKPROC
)
5262 unknown_flags
|= flag
;
5268 case SHF_WRITE
: *p
= 'W'; break;
5269 case SHF_ALLOC
: *p
= 'A'; break;
5270 case SHF_EXECINSTR
: *p
= 'X'; break;
5271 case SHF_MERGE
: *p
= 'M'; break;
5272 case SHF_STRINGS
: *p
= 'S'; break;
5273 case SHF_INFO_LINK
: *p
= 'I'; break;
5274 case SHF_LINK_ORDER
: *p
= 'L'; break;
5275 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5276 case SHF_GROUP
: *p
= 'G'; break;
5277 case SHF_TLS
: *p
= 'T'; break;
5278 case SHF_EXCLUDE
: *p
= 'E'; break;
5281 if ((elf_header
.e_machine
== EM_X86_64
5282 || elf_header
.e_machine
== EM_L1OM
5283 || elf_header
.e_machine
== EM_K1OM
)
5284 && flag
== SHF_X86_64_LARGE
)
5286 else if (flag
& SHF_MASKOS
)
5289 sh_flags
&= ~ SHF_MASKOS
;
5291 else if (flag
& SHF_MASKPROC
)
5294 sh_flags
&= ~ SHF_MASKPROC
;
5304 if (do_section_details
)
5308 size
-= 5 + field_size
;
5309 if (p
!= buff
+ field_size
+ 4)
5313 warn (_("Internal error: not enough buffer room for section flag info"));
5314 return _("<unknown>");
5320 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5321 (unsigned long) os_flags
);
5322 p
+= 5 + field_size
;
5326 size
-= 7 + field_size
;
5327 if (p
!= buff
+ field_size
+ 4)
5331 warn (_("Internal error: not enough buffer room for section flag info"));
5332 return _("<unknown>");
5338 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5339 (unsigned long) proc_flags
);
5340 p
+= 7 + field_size
;
5344 size
-= 10 + field_size
;
5345 if (p
!= buff
+ field_size
+ 4)
5349 warn (_("Internal error: not enough buffer room for section flag info"));
5350 return _("<unknown>");
5356 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5357 (unsigned long) unknown_flags
);
5358 p
+= 10 + field_size
;
5367 process_section_headers (FILE * file
)
5369 Elf_Internal_Shdr
* section
;
5372 section_headers
= NULL
;
5374 if (elf_header
.e_shnum
== 0)
5376 /* PR binutils/12467. */
5377 if (elf_header
.e_shoff
!= 0)
5378 warn (_("possibly corrupt ELF file header - it has a non-zero"
5379 " section header offset, but no section headers\n"));
5380 else if (do_sections
)
5381 printf (_("\nThere are no sections in this file.\n"));
5386 if (do_sections
&& !do_header
)
5387 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5388 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5392 if (! get_32bit_section_headers (file
, FALSE
))
5395 else if (! get_64bit_section_headers (file
, FALSE
))
5398 /* Read in the string table, so that we have names to display. */
5399 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5400 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5402 section
= section_headers
+ elf_header
.e_shstrndx
;
5404 if (section
->sh_size
!= 0)
5406 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5407 1, section
->sh_size
,
5410 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5414 /* Scan the sections for the dynamic symbol table
5415 and dynamic string table and debug sections. */
5416 dynamic_symbols
= NULL
;
5417 dynamic_strings
= NULL
;
5418 dynamic_syminfo
= NULL
;
5419 symtab_shndx_hdr
= NULL
;
5421 eh_addr_size
= is_32bit_elf
? 4 : 8;
5422 switch (elf_header
.e_machine
)
5425 case EM_MIPS_RS3_LE
:
5426 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5427 FDE addresses. However, the ABI also has a semi-official ILP32
5428 variant for which the normal FDE address size rules apply.
5430 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5431 section, where XX is the size of longs in bits. Unfortunately,
5432 earlier compilers provided no way of distinguishing ILP32 objects
5433 from LP64 objects, so if there's any doubt, we should assume that
5434 the official LP64 form is being used. */
5435 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5436 && find_section (".gcc_compiled_long32") == NULL
)
5442 switch (elf_header
.e_flags
& EF_H8_MACH
)
5444 case E_H8_MACH_H8300
:
5445 case E_H8_MACH_H8300HN
:
5446 case E_H8_MACH_H8300SN
:
5447 case E_H8_MACH_H8300SXN
:
5450 case E_H8_MACH_H8300H
:
5451 case E_H8_MACH_H8300S
:
5452 case E_H8_MACH_H8300SX
:
5460 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5462 case EF_M32C_CPU_M16C
:
5469 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5472 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5473 if (section->sh_entsize != expected_entsize) \
5476 sprintf_vma (buf, section->sh_entsize); \
5477 /* Note: coded this way so that there is a single string for \
5479 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5480 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5481 (unsigned) expected_entsize); \
5482 section->sh_entsize = expected_entsize; \
5487 #define CHECK_ENTSIZE(section, i, type) \
5488 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5489 sizeof (Elf64_External_##type))
5491 for (i
= 0, section
= section_headers
;
5492 i
< elf_header
.e_shnum
;
5495 char * name
= SECTION_NAME (section
);
5497 if (section
->sh_type
== SHT_DYNSYM
)
5499 if (dynamic_symbols
!= NULL
)
5501 error (_("File contains multiple dynamic symbol tables\n"));
5505 CHECK_ENTSIZE (section
, i
, Sym
);
5506 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5508 else if (section
->sh_type
== SHT_STRTAB
5509 && streq (name
, ".dynstr"))
5511 if (dynamic_strings
!= NULL
)
5513 error (_("File contains multiple dynamic string tables\n"));
5517 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5518 1, section
->sh_size
,
5519 _("dynamic strings"));
5520 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5522 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5524 if (symtab_shndx_hdr
!= NULL
)
5526 error (_("File contains multiple symtab shndx tables\n"));
5529 symtab_shndx_hdr
= section
;
5531 else if (section
->sh_type
== SHT_SYMTAB
)
5532 CHECK_ENTSIZE (section
, i
, Sym
);
5533 else if (section
->sh_type
== SHT_GROUP
)
5534 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5535 else if (section
->sh_type
== SHT_REL
)
5536 CHECK_ENTSIZE (section
, i
, Rel
);
5537 else if (section
->sh_type
== SHT_RELA
)
5538 CHECK_ENTSIZE (section
, i
, Rela
);
5539 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5540 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5541 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5542 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5543 || do_debug_addr
|| do_debug_cu_index
)
5544 && (const_strneq (name
, ".debug_")
5545 || const_strneq (name
, ".zdebug_")))
5548 name
+= sizeof (".zdebug_") - 1;
5550 name
+= sizeof (".debug_") - 1;
5553 || (do_debug_info
&& const_strneq (name
, "info"))
5554 || (do_debug_info
&& const_strneq (name
, "types"))
5555 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5556 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5557 || (do_debug_lines
&& const_strneq (name
, "line."))
5558 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5559 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5560 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5561 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5562 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5563 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5564 || (do_debug_frames
&& const_strneq (name
, "frame"))
5565 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5566 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5567 || (do_debug_str
&& const_strneq (name
, "str"))
5568 || (do_debug_loc
&& const_strneq (name
, "loc"))
5569 || (do_debug_addr
&& const_strneq (name
, "addr"))
5570 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5571 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5573 request_dump_bynumber (i
, DEBUG_DUMP
);
5575 /* Linkonce section to be combined with .debug_info at link time. */
5576 else if ((do_debugging
|| do_debug_info
)
5577 && const_strneq (name
, ".gnu.linkonce.wi."))
5578 request_dump_bynumber (i
, DEBUG_DUMP
);
5579 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5580 request_dump_bynumber (i
, DEBUG_DUMP
);
5581 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5582 request_dump_bynumber (i
, DEBUG_DUMP
);
5583 /* Trace sections for Itanium VMS. */
5584 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5585 || do_trace_aranges
)
5586 && const_strneq (name
, ".trace_"))
5588 name
+= sizeof (".trace_") - 1;
5591 || (do_trace_info
&& streq (name
, "info"))
5592 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5593 || (do_trace_aranges
&& streq (name
, "aranges"))
5595 request_dump_bynumber (i
, DEBUG_DUMP
);
5602 if (elf_header
.e_shnum
> 1)
5603 printf (_("\nSection Headers:\n"));
5605 printf (_("\nSection Header:\n"));
5609 if (do_section_details
)
5611 printf (_(" [Nr] Name\n"));
5612 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5616 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5620 if (do_section_details
)
5622 printf (_(" [Nr] Name\n"));
5623 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5627 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5631 if (do_section_details
)
5633 printf (_(" [Nr] Name\n"));
5634 printf (_(" Type Address Offset Link\n"));
5635 printf (_(" Size EntSize Info Align\n"));
5639 printf (_(" [Nr] Name Type Address Offset\n"));
5640 printf (_(" Size EntSize Flags Link Info Align\n"));
5644 if (do_section_details
)
5645 printf (_(" Flags\n"));
5647 for (i
= 0, section
= section_headers
;
5648 i
< elf_header
.e_shnum
;
5651 printf (" [%2u] ", i
);
5652 if (do_section_details
)
5653 printf ("%s\n ", printable_section_name (section
));
5655 print_symbol (-17, SECTION_NAME (section
));
5657 printf (do_wide
? " %-15s " : " %-15.15s ",
5658 get_section_type_name (section
->sh_type
));
5662 const char * link_too_big
= NULL
;
5664 print_vma (section
->sh_addr
, LONG_HEX
);
5666 printf ( " %6.6lx %6.6lx %2.2lx",
5667 (unsigned long) section
->sh_offset
,
5668 (unsigned long) section
->sh_size
,
5669 (unsigned long) section
->sh_entsize
);
5671 if (do_section_details
)
5672 fputs (" ", stdout
);
5674 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5676 if (section
->sh_link
>= elf_header
.e_shnum
)
5679 /* The sh_link value is out of range. Normally this indicates
5680 an error but it can have special values in Solaris binaries. */
5681 switch (elf_header
.e_machine
)
5688 case EM_OLD_SPARCV9
:
5689 case EM_SPARC32PLUS
:
5692 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5693 link_too_big
= "BEFORE";
5694 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5695 link_too_big
= "AFTER";
5702 if (do_section_details
)
5704 if (link_too_big
!= NULL
&& * link_too_big
)
5705 printf ("<%s> ", link_too_big
);
5707 printf ("%2u ", section
->sh_link
);
5708 printf ("%3u %2lu\n", section
->sh_info
,
5709 (unsigned long) section
->sh_addralign
);
5712 printf ("%2u %3u %2lu\n",
5715 (unsigned long) section
->sh_addralign
);
5717 if (link_too_big
&& ! * link_too_big
)
5718 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5719 i
, section
->sh_link
);
5723 print_vma (section
->sh_addr
, LONG_HEX
);
5725 if ((long) section
->sh_offset
== section
->sh_offset
)
5726 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5730 print_vma (section
->sh_offset
, LONG_HEX
);
5733 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5734 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5738 print_vma (section
->sh_size
, LONG_HEX
);
5741 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5742 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5746 print_vma (section
->sh_entsize
, LONG_HEX
);
5749 if (do_section_details
)
5750 fputs (" ", stdout
);
5752 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5754 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5756 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5757 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5760 print_vma (section
->sh_addralign
, DEC
);
5764 else if (do_section_details
)
5766 printf (" %-15.15s ",
5767 get_section_type_name (section
->sh_type
));
5768 print_vma (section
->sh_addr
, LONG_HEX
);
5769 if ((long) section
->sh_offset
== section
->sh_offset
)
5770 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5774 print_vma (section
->sh_offset
, LONG_HEX
);
5776 printf (" %u\n ", section
->sh_link
);
5777 print_vma (section
->sh_size
, LONG_HEX
);
5779 print_vma (section
->sh_entsize
, LONG_HEX
);
5781 printf (" %-16u %lu\n",
5783 (unsigned long) section
->sh_addralign
);
5788 print_vma (section
->sh_addr
, LONG_HEX
);
5789 if ((long) section
->sh_offset
== section
->sh_offset
)
5790 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5794 print_vma (section
->sh_offset
, LONG_HEX
);
5797 print_vma (section
->sh_size
, LONG_HEX
);
5799 print_vma (section
->sh_entsize
, LONG_HEX
);
5801 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5803 printf (" %2u %3u %lu\n",
5806 (unsigned long) section
->sh_addralign
);
5809 if (do_section_details
)
5810 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5813 if (!do_section_details
)
5815 if (elf_header
.e_machine
== EM_X86_64
5816 || elf_header
.e_machine
== EM_L1OM
5817 || elf_header
.e_machine
== EM_K1OM
)
5818 printf (_("Key to Flags:\n\
5819 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5820 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5821 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5823 printf (_("Key to Flags:\n\
5824 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5825 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5826 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5833 get_group_flags (unsigned int flags
)
5835 static char buff
[32];
5845 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5852 process_section_groups (FILE * file
)
5854 Elf_Internal_Shdr
* section
;
5856 struct group
* group
;
5857 Elf_Internal_Shdr
* symtab_sec
;
5858 Elf_Internal_Shdr
* strtab_sec
;
5859 Elf_Internal_Sym
* symtab
;
5860 unsigned long num_syms
;
5864 /* Don't process section groups unless needed. */
5865 if (!do_unwind
&& !do_section_groups
)
5868 if (elf_header
.e_shnum
== 0)
5870 if (do_section_groups
)
5871 printf (_("\nThere are no sections to group in this file.\n"));
5876 if (section_headers
== NULL
)
5878 error (_("Section headers are not available!\n"));
5879 /* PR 13622: This can happen with a corrupt ELF header. */
5883 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5884 sizeof (struct group
*));
5886 if (section_headers_groups
== NULL
)
5888 error (_("Out of memory reading %u section group headers\n"),
5889 elf_header
.e_shnum
);
5893 /* Scan the sections for the group section. */
5895 for (i
= 0, section
= section_headers
;
5896 i
< elf_header
.e_shnum
;
5898 if (section
->sh_type
== SHT_GROUP
)
5901 if (group_count
== 0)
5903 if (do_section_groups
)
5904 printf (_("\nThere are no section groups in this file.\n"));
5909 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5911 if (section_groups
== NULL
)
5913 error (_("Out of memory reading %lu groups\n"),
5914 (unsigned long) group_count
);
5924 for (i
= 0, section
= section_headers
, group
= section_groups
;
5925 i
< elf_header
.e_shnum
;
5928 if (section
->sh_type
== SHT_GROUP
)
5930 const char * name
= printable_section_name (section
);
5931 const char * group_name
;
5932 unsigned char * start
;
5933 unsigned char * indices
;
5934 unsigned int entry
, j
, size
;
5935 Elf_Internal_Shdr
* sec
;
5936 Elf_Internal_Sym
* sym
;
5938 /* Get the symbol table. */
5939 if (section
->sh_link
>= elf_header
.e_shnum
5940 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5943 error (_("Bad sh_link in group section `%s'\n"), name
);
5947 if (symtab_sec
!= sec
)
5952 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5957 error (_("Corrupt header in group section `%s'\n"), name
);
5961 if (section
->sh_info
>= num_syms
)
5963 error (_("Bad sh_info in group section `%s'\n"), name
);
5967 sym
= symtab
+ section
->sh_info
;
5969 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5971 if (sym
->st_shndx
== 0
5972 || sym
->st_shndx
>= elf_header
.e_shnum
)
5974 error (_("Bad sh_info in group section `%s'\n"), name
);
5978 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5987 /* Get the string table. */
5988 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5997 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6003 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6004 1, strtab_sec
->sh_size
,
6006 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6008 group_name
= sym
->st_name
< strtab_size
6009 ? strtab
+ sym
->st_name
: _("<corrupt>");
6012 /* PR 17531: file: loop. */
6013 if (section
->sh_entsize
> section
->sh_size
)
6015 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6016 printable_section_name (section
),
6017 (unsigned long) section
->sh_entsize
,
6018 (unsigned long) section
->sh_size
);
6022 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6023 1, section
->sh_size
,
6029 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6030 entry
= byte_get (indices
, 4);
6033 if (do_section_groups
)
6035 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6036 get_group_flags (entry
), i
, name
, group_name
, size
);
6038 printf (_(" [Index] Name\n"));
6041 group
->group_index
= i
;
6043 for (j
= 0; j
< size
; j
++)
6045 struct group_list
* g
;
6047 entry
= byte_get (indices
, 4);
6050 if (entry
>= elf_header
.e_shnum
)
6052 static unsigned num_group_errors
= 0;
6054 if (num_group_errors
++ < 10)
6056 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6057 entry
, i
, elf_header
.e_shnum
- 1);
6058 if (num_group_errors
== 10)
6059 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6064 if (section_headers_groups
[entry
] != NULL
)
6068 static unsigned num_errs
= 0;
6070 if (num_errs
++ < 10)
6072 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6074 section_headers_groups
[entry
]->group_index
);
6076 warn (_("Further error messages about already contained group sections suppressed\n"));
6082 /* Intel C/C++ compiler may put section 0 in a
6083 section group. We just warn it the first time
6084 and ignore it afterwards. */
6085 static int warned
= 0;
6088 error (_("section 0 in group section [%5u]\n"),
6089 section_headers_groups
[entry
]->group_index
);
6095 section_headers_groups
[entry
] = group
;
6097 if (do_section_groups
)
6099 sec
= section_headers
+ entry
;
6100 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6103 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6104 g
->section_index
= entry
;
6105 g
->next
= group
->root
;
6123 /* Data used to display dynamic fixups. */
6125 struct ia64_vms_dynfixup
6127 bfd_vma needed_ident
; /* Library ident number. */
6128 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6129 bfd_vma fixup_needed
; /* Index of the library. */
6130 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6131 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6134 /* Data used to display dynamic relocations. */
6136 struct ia64_vms_dynimgrela
6138 bfd_vma img_rela_cnt
; /* Number of relocations. */
6139 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6142 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6146 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6147 const char *strtab
, unsigned int strtab_sz
)
6149 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6151 const char *lib_name
;
6153 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6154 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6155 _("dynamic section image fixups"));
6159 if (fixup
->needed
< strtab_sz
)
6160 lib_name
= strtab
+ fixup
->needed
;
6163 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6164 (unsigned long) fixup
->needed
);
6167 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6168 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6170 (_("Seg Offset Type SymVec DataType\n"));
6172 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6177 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6178 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6179 type
= BYTE_GET (imfs
[i
].type
);
6180 rtype
= elf_ia64_reloc_type (type
);
6182 printf (" 0x%08x ", type
);
6184 printf (" %-32s ", rtype
);
6185 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6186 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6192 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6195 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6197 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6200 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6201 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6202 _("dynamic section image relocations"));
6206 printf (_("\nImage relocs\n"));
6208 (_("Seg Offset Type Addend Seg Sym Off\n"));
6210 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6215 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6216 printf ("%08" BFD_VMA_FMT
"x ",
6217 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6218 type
= BYTE_GET (imrs
[i
].type
);
6219 rtype
= elf_ia64_reloc_type (type
);
6221 printf ("0x%08x ", type
);
6223 printf ("%-31s ", rtype
);
6224 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6225 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6226 printf ("%08" BFD_VMA_FMT
"x\n",
6227 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6233 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6236 process_ia64_vms_dynamic_relocs (FILE *file
)
6238 struct ia64_vms_dynfixup fixup
;
6239 struct ia64_vms_dynimgrela imgrela
;
6240 Elf_Internal_Dyn
*entry
;
6242 bfd_vma strtab_off
= 0;
6243 bfd_vma strtab_sz
= 0;
6244 char *strtab
= NULL
;
6246 memset (&fixup
, 0, sizeof (fixup
));
6247 memset (&imgrela
, 0, sizeof (imgrela
));
6249 /* Note: the order of the entries is specified by the OpenVMS specs. */
6250 for (entry
= dynamic_section
;
6251 entry
< dynamic_section
+ dynamic_nent
;
6254 switch (entry
->d_tag
)
6256 case DT_IA_64_VMS_STRTAB_OFFSET
:
6257 strtab_off
= entry
->d_un
.d_val
;
6260 strtab_sz
= entry
->d_un
.d_val
;
6262 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6263 1, strtab_sz
, _("dynamic string section"));
6266 case DT_IA_64_VMS_NEEDED_IDENT
:
6267 fixup
.needed_ident
= entry
->d_un
.d_val
;
6270 fixup
.needed
= entry
->d_un
.d_val
;
6272 case DT_IA_64_VMS_FIXUP_NEEDED
:
6273 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6275 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6276 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6278 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6279 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6281 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6284 case DT_IA_64_VMS_IMG_RELA_CNT
:
6285 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6287 case DT_IA_64_VMS_IMG_RELA_OFF
:
6288 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6290 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6310 } dynamic_relocations
[] =
6312 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6313 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6314 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6317 /* Process the reloc section. */
6320 process_relocs (FILE * file
)
6322 unsigned long rel_size
;
6323 unsigned long rel_offset
;
6329 if (do_using_dynamic
)
6333 int has_dynamic_reloc
;
6336 has_dynamic_reloc
= 0;
6338 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6340 is_rela
= dynamic_relocations
[i
].rela
;
6341 name
= dynamic_relocations
[i
].name
;
6342 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6343 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6345 has_dynamic_reloc
|= rel_size
;
6347 if (is_rela
== UNKNOWN
)
6349 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6350 switch (dynamic_info
[DT_PLTREL
])
6364 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6365 name
, rel_offset
, rel_size
);
6367 dump_relocations (file
,
6368 offset_from_vma (file
, rel_offset
, rel_size
),
6370 dynamic_symbols
, num_dynamic_syms
,
6371 dynamic_strings
, dynamic_strings_length
,
6377 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6379 if (! has_dynamic_reloc
)
6380 printf (_("\nThere are no dynamic relocations in this file.\n"));
6384 Elf_Internal_Shdr
* section
;
6388 for (i
= 0, section
= section_headers
;
6389 i
< elf_header
.e_shnum
;
6392 if ( section
->sh_type
!= SHT_RELA
6393 && section
->sh_type
!= SHT_REL
)
6396 rel_offset
= section
->sh_offset
;
6397 rel_size
= section
->sh_size
;
6401 Elf_Internal_Shdr
* strsec
;
6404 printf (_("\nRelocation section "));
6406 if (string_table
== NULL
)
6407 printf ("%d", section
->sh_name
);
6409 printf ("'%s'", printable_section_name (section
));
6411 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6412 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6414 is_rela
= section
->sh_type
== SHT_RELA
;
6416 if (section
->sh_link
!= 0
6417 && section
->sh_link
< elf_header
.e_shnum
)
6419 Elf_Internal_Shdr
* symsec
;
6420 Elf_Internal_Sym
* symtab
;
6421 unsigned long nsyms
;
6422 unsigned long strtablen
= 0;
6423 char * strtab
= NULL
;
6425 symsec
= section_headers
+ section
->sh_link
;
6426 if (symsec
->sh_type
!= SHT_SYMTAB
6427 && symsec
->sh_type
!= SHT_DYNSYM
)
6430 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6435 if (symsec
->sh_link
!= 0
6436 && symsec
->sh_link
< elf_header
.e_shnum
)
6438 strsec
= section_headers
+ symsec
->sh_link
;
6440 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6443 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6446 dump_relocations (file
, rel_offset
, rel_size
,
6447 symtab
, nsyms
, strtab
, strtablen
,
6449 symsec
->sh_type
== SHT_DYNSYM
);
6455 dump_relocations (file
, rel_offset
, rel_size
,
6456 NULL
, 0, NULL
, 0, is_rela
, 0);
6463 printf (_("\nThere are no relocations in this file.\n"));
6469 /* An absolute address consists of a section and an offset. If the
6470 section is NULL, the offset itself is the address, otherwise, the
6471 address equals to LOAD_ADDRESS(section) + offset. */
6475 unsigned short section
;
6479 #define ABSADDR(a) \
6481 ? section_headers [(a).section].sh_addr + (a).offset \
6484 /* Find the nearest symbol at or below ADDR. Returns the symbol
6485 name, if found, and the offset from the symbol to ADDR. */
6488 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6489 unsigned long nsyms
,
6490 const char * strtab
,
6491 unsigned long strtab_size
,
6492 struct absaddr addr
,
6493 const char ** symname
,
6496 bfd_vma dist
= 0x100000;
6497 Elf_Internal_Sym
* sym
;
6498 Elf_Internal_Sym
* beg
;
6499 Elf_Internal_Sym
* end
;
6500 Elf_Internal_Sym
* best
= NULL
;
6502 REMOVE_ARCH_BITS (addr
.offset
);
6504 end
= symtab
+ nsyms
;
6510 sym
= beg
+ (end
- beg
) / 2;
6512 value
= sym
->st_value
;
6513 REMOVE_ARCH_BITS (value
);
6515 if (sym
->st_name
!= 0
6516 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6517 && addr
.offset
>= value
6518 && addr
.offset
- value
< dist
)
6521 dist
= addr
.offset
- value
;
6526 if (addr
.offset
< value
)
6534 *symname
= (best
->st_name
>= strtab_size
6535 ? _("<corrupt>") : strtab
+ best
->st_name
);
6541 *offset
= addr
.offset
;
6545 symcmp (const void *p
, const void *q
)
6547 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6548 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6550 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6553 /* Process the unwind section. */
6555 #include "unwind-ia64.h"
6557 struct ia64_unw_table_entry
6559 struct absaddr start
;
6561 struct absaddr info
;
6564 struct ia64_unw_aux_info
6566 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6567 unsigned long table_len
; /* Length of unwind table. */
6568 unsigned char * info
; /* Unwind info. */
6569 unsigned long info_size
; /* Size of unwind info. */
6570 bfd_vma info_addr
; /* Starting address of unwind info. */
6571 bfd_vma seg_base
; /* Starting address of segment. */
6572 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6573 unsigned long nsyms
; /* Number of symbols. */
6574 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6575 unsigned long nfuns
; /* Number of entries in funtab. */
6576 char * strtab
; /* The string table. */
6577 unsigned long strtab_size
; /* Size of string table. */
6581 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6583 struct ia64_unw_table_entry
* tp
;
6584 unsigned long j
, nfuns
;
6587 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6588 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6589 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6590 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6592 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6594 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6598 const unsigned char * dp
;
6599 const unsigned char * head
;
6600 const unsigned char * end
;
6601 const char * procname
;
6603 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6604 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6606 fputs ("\n<", stdout
);
6610 fputs (procname
, stdout
);
6613 printf ("+%lx", (unsigned long) offset
);
6616 fputs (">: [", stdout
);
6617 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6618 fputc ('-', stdout
);
6619 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6620 printf ("], info at +0x%lx\n",
6621 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6623 /* PR 17531: file: 86232b32. */
6624 if (aux
->info
== NULL
)
6627 /* PR 17531: file: 0997b4d1. */
6628 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6630 warn (_("Invalid offset %lx in table entry %ld\n"),
6631 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6635 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6636 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6638 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6639 (unsigned) UNW_VER (stamp
),
6640 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6641 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6642 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6643 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6645 if (UNW_VER (stamp
) != 1)
6647 printf (_("\tUnknown version.\n"));
6652 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6653 /* PR 17531: file: 16ceda89. */
6654 if (end
> aux
->info
+ aux
->info_size
)
6655 end
= aux
->info
+ aux
->info_size
;
6656 for (dp
= head
+ 8; dp
< end
;)
6657 dp
= unw_decode (dp
, in_body
, & in_body
);
6664 slurp_ia64_unwind_table (FILE * file
,
6665 struct ia64_unw_aux_info
* aux
,
6666 Elf_Internal_Shdr
* sec
)
6668 unsigned long size
, nrelas
, i
;
6669 Elf_Internal_Phdr
* seg
;
6670 struct ia64_unw_table_entry
* tep
;
6671 Elf_Internal_Shdr
* relsec
;
6672 Elf_Internal_Rela
* rela
;
6673 Elf_Internal_Rela
* rp
;
6674 unsigned char * table
;
6676 Elf_Internal_Sym
* sym
;
6677 const char * relname
;
6681 /* First, find the starting address of the segment that includes
6684 if (elf_header
.e_phnum
)
6686 if (! get_program_headers (file
))
6689 for (seg
= program_headers
;
6690 seg
< program_headers
+ elf_header
.e_phnum
;
6693 if (seg
->p_type
!= PT_LOAD
)
6696 if (sec
->sh_addr
>= seg
->p_vaddr
6697 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6699 aux
->seg_base
= seg
->p_vaddr
;
6705 /* Second, build the unwind table from the contents of the unwind section: */
6706 size
= sec
->sh_size
;
6707 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6712 aux
->table_len
= size
/ (3 * eh_addr_size
);
6713 aux
->table
= (struct ia64_unw_table_entry
*)
6714 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6717 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6719 tep
->start
.section
= SHN_UNDEF
;
6720 tep
->end
.section
= SHN_UNDEF
;
6721 tep
->info
.section
= SHN_UNDEF
;
6722 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6723 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6724 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6725 tep
->start
.offset
+= aux
->seg_base
;
6726 tep
->end
.offset
+= aux
->seg_base
;
6727 tep
->info
.offset
+= aux
->seg_base
;
6731 /* Third, apply any relocations to the unwind table: */
6732 for (relsec
= section_headers
;
6733 relsec
< section_headers
+ elf_header
.e_shnum
;
6736 if (relsec
->sh_type
!= SHT_RELA
6737 || relsec
->sh_info
>= elf_header
.e_shnum
6738 || section_headers
+ relsec
->sh_info
!= sec
)
6741 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6750 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6752 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6753 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6755 /* PR 17531: file: 9fa67536. */
6756 if (relname
== NULL
)
6758 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6762 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6764 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6768 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6770 /* PR 17531: file: 5bc8d9bf. */
6771 if (i
>= aux
->table_len
)
6773 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6777 switch (rp
->r_offset
/ eh_addr_size
% 3)
6780 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6781 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6784 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6785 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6788 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6789 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6803 ia64_process_unwind (FILE * file
)
6805 Elf_Internal_Shdr
* sec
;
6806 Elf_Internal_Shdr
* unwsec
= NULL
;
6807 Elf_Internal_Shdr
* strsec
;
6808 unsigned long i
, unwcount
= 0, unwstart
= 0;
6809 struct ia64_unw_aux_info aux
;
6811 memset (& aux
, 0, sizeof (aux
));
6813 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6815 if (sec
->sh_type
== SHT_SYMTAB
6816 && sec
->sh_link
< elf_header
.e_shnum
)
6818 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6820 strsec
= section_headers
+ sec
->sh_link
;
6821 if (aux
.strtab
!= NULL
)
6823 error (_("Multiple auxillary string tables encountered\n"));
6826 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6829 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6831 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6836 printf (_("\nThere are no unwind sections in this file.\n"));
6838 while (unwcount
-- > 0)
6843 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6844 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6845 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6850 /* We have already counted the number of SHT_IA64_UNWIND
6851 sections so the loop above should never fail. */
6852 assert (unwsec
!= NULL
);
6855 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6857 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6859 /* We need to find which section group it is in. */
6860 struct group_list
* g
;
6862 if (section_headers_groups
== NULL
6863 || section_headers_groups
[i
] == NULL
)
6864 i
= elf_header
.e_shnum
;
6867 g
= section_headers_groups
[i
]->root
;
6869 for (; g
!= NULL
; g
= g
->next
)
6871 sec
= section_headers
+ g
->section_index
;
6873 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6878 i
= elf_header
.e_shnum
;
6881 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6883 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6884 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6885 suffix
= SECTION_NAME (unwsec
) + len
;
6886 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6888 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6889 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6894 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6895 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6896 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6897 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6899 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6900 suffix
= SECTION_NAME (unwsec
) + len
;
6901 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6903 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6904 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6908 if (i
== elf_header
.e_shnum
)
6910 printf (_("\nCould not find unwind info section for "));
6912 if (string_table
== NULL
)
6913 printf ("%d", unwsec
->sh_name
);
6915 printf ("'%s'", printable_section_name (unwsec
));
6919 aux
.info_addr
= sec
->sh_addr
;
6920 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6923 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6925 printf (_("\nUnwind section "));
6927 if (string_table
== NULL
)
6928 printf ("%d", unwsec
->sh_name
);
6930 printf ("'%s'", printable_section_name (unwsec
));
6932 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6933 (unsigned long) unwsec
->sh_offset
,
6934 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6936 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
6937 && aux
.table_len
> 0)
6938 dump_ia64_unwind (& aux
);
6941 free ((char *) aux
.table
);
6943 free ((char *) aux
.info
);
6952 free ((char *) aux
.strtab
);
6955 struct hppa_unw_table_entry
6957 struct absaddr start
;
6959 unsigned int Cannot_unwind
:1; /* 0 */
6960 unsigned int Millicode
:1; /* 1 */
6961 unsigned int Millicode_save_sr0
:1; /* 2 */
6962 unsigned int Region_description
:2; /* 3..4 */
6963 unsigned int reserved1
:1; /* 5 */
6964 unsigned int Entry_SR
:1; /* 6 */
6965 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6966 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6967 unsigned int Args_stored
:1; /* 16 */
6968 unsigned int Variable_Frame
:1; /* 17 */
6969 unsigned int Separate_Package_Body
:1; /* 18 */
6970 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6971 unsigned int Stack_Overflow_Check
:1; /* 20 */
6972 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
6973 unsigned int Ada_Region
:1; /* 22 */
6974 unsigned int cxx_info
:1; /* 23 */
6975 unsigned int cxx_try_catch
:1; /* 24 */
6976 unsigned int sched_entry_seq
:1; /* 25 */
6977 unsigned int reserved2
:1; /* 26 */
6978 unsigned int Save_SP
:1; /* 27 */
6979 unsigned int Save_RP
:1; /* 28 */
6980 unsigned int Save_MRP_in_frame
:1; /* 29 */
6981 unsigned int extn_ptr_defined
:1; /* 30 */
6982 unsigned int Cleanup_defined
:1; /* 31 */
6984 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6985 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6986 unsigned int Large_frame
:1; /* 2 */
6987 unsigned int Pseudo_SP_Set
:1; /* 3 */
6988 unsigned int reserved4
:1; /* 4 */
6989 unsigned int Total_frame_size
:27; /* 5..31 */
6992 struct hppa_unw_aux_info
6994 struct hppa_unw_table_entry
* table
; /* Unwind table. */
6995 unsigned long table_len
; /* Length of unwind table. */
6996 bfd_vma seg_base
; /* Starting address of segment. */
6997 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6998 unsigned long nsyms
; /* Number of symbols. */
6999 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7000 unsigned long nfuns
; /* Number of entries in funtab. */
7001 char * strtab
; /* The string table. */
7002 unsigned long strtab_size
; /* Size of string table. */
7006 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7008 struct hppa_unw_table_entry
* tp
;
7009 unsigned long j
, nfuns
;
7011 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7012 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7013 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7014 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7016 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7018 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7021 const char * procname
;
7023 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7024 aux
->strtab_size
, tp
->start
, &procname
,
7027 fputs ("\n<", stdout
);
7031 fputs (procname
, stdout
);
7034 printf ("+%lx", (unsigned long) offset
);
7037 fputs (">: [", stdout
);
7038 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7039 fputc ('-', stdout
);
7040 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7043 #define PF(_m) if (tp->_m) printf (#_m " ");
7044 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7047 PF(Millicode_save_sr0
);
7048 /* PV(Region_description); */
7054 PF(Separate_Package_Body
);
7055 PF(Frame_Extension_Millicode
);
7056 PF(Stack_Overflow_Check
);
7057 PF(Two_Instruction_SP_Increment
);
7061 PF(sched_entry_seq
);
7064 PF(Save_MRP_in_frame
);
7065 PF(extn_ptr_defined
);
7066 PF(Cleanup_defined
);
7067 PF(MPE_XL_interrupt_marker
);
7068 PF(HP_UX_interrupt_marker
);
7071 PV(Total_frame_size
);
7082 slurp_hppa_unwind_table (FILE * file
,
7083 struct hppa_unw_aux_info
* aux
,
7084 Elf_Internal_Shdr
* sec
)
7086 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7087 Elf_Internal_Phdr
* seg
;
7088 struct hppa_unw_table_entry
* tep
;
7089 Elf_Internal_Shdr
* relsec
;
7090 Elf_Internal_Rela
* rela
;
7091 Elf_Internal_Rela
* rp
;
7092 unsigned char * table
;
7094 Elf_Internal_Sym
* sym
;
7095 const char * relname
;
7097 /* First, find the starting address of the segment that includes
7100 if (elf_header
.e_phnum
)
7102 if (! get_program_headers (file
))
7105 for (seg
= program_headers
;
7106 seg
< program_headers
+ elf_header
.e_phnum
;
7109 if (seg
->p_type
!= PT_LOAD
)
7112 if (sec
->sh_addr
>= seg
->p_vaddr
7113 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7115 aux
->seg_base
= seg
->p_vaddr
;
7121 /* Second, build the unwind table from the contents of the unwind
7123 size
= sec
->sh_size
;
7124 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7130 nentries
= size
/ unw_ent_size
;
7131 size
= unw_ent_size
* nentries
;
7133 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7134 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7136 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7138 unsigned int tmp1
, tmp2
;
7140 tep
->start
.section
= SHN_UNDEF
;
7141 tep
->end
.section
= SHN_UNDEF
;
7143 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7144 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7145 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7146 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7148 tep
->start
.offset
+= aux
->seg_base
;
7149 tep
->end
.offset
+= aux
->seg_base
;
7151 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7152 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7153 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7154 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7155 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7156 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7157 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7158 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7159 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7160 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7161 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7162 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7163 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7164 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7165 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7166 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7167 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7168 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7169 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7170 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7171 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7172 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7173 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7174 tep
->Cleanup_defined
= tmp1
& 0x1;
7176 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7177 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7178 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7179 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7180 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7181 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7185 /* Third, apply any relocations to the unwind table. */
7186 for (relsec
= section_headers
;
7187 relsec
< section_headers
+ elf_header
.e_shnum
;
7190 if (relsec
->sh_type
!= SHT_RELA
7191 || relsec
->sh_info
>= elf_header
.e_shnum
7192 || section_headers
+ relsec
->sh_info
!= sec
)
7195 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7199 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7201 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7202 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7204 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7205 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7207 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7211 i
= rp
->r_offset
/ unw_ent_size
;
7213 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7216 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7217 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7220 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7221 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7231 aux
->table_len
= nentries
;
7237 hppa_process_unwind (FILE * file
)
7239 struct hppa_unw_aux_info aux
;
7240 Elf_Internal_Shdr
* unwsec
= NULL
;
7241 Elf_Internal_Shdr
* strsec
;
7242 Elf_Internal_Shdr
* sec
;
7245 if (string_table
== NULL
)
7248 memset (& aux
, 0, sizeof (aux
));
7250 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7252 if (sec
->sh_type
== SHT_SYMTAB
7253 && sec
->sh_link
< elf_header
.e_shnum
)
7255 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7257 strsec
= section_headers
+ sec
->sh_link
;
7258 if (aux
.strtab
!= NULL
)
7260 error (_("Multiple auxillary string tables encountered\n"));
7263 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7266 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7268 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7273 printf (_("\nThere are no unwind sections in this file.\n"));
7275 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7277 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7279 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7280 printable_section_name (sec
),
7281 (unsigned long) sec
->sh_offset
,
7282 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7284 slurp_hppa_unwind_table (file
, &aux
, sec
);
7285 if (aux
.table_len
> 0)
7286 dump_hppa_unwind (&aux
);
7289 free ((char *) aux
.table
);
7297 free ((char *) aux
.strtab
);
7302 unsigned char * data
; /* The unwind data. */
7303 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7304 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7305 unsigned long nrelas
; /* The number of relocations. */
7306 unsigned int rel_type
; /* REL or RELA ? */
7307 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7310 struct arm_unw_aux_info
7312 FILE * file
; /* The file containing the unwind sections. */
7313 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7314 unsigned long nsyms
; /* Number of symbols. */
7315 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7316 unsigned long nfuns
; /* Number of these symbols. */
7317 char * strtab
; /* The file's string table. */
7318 unsigned long strtab_size
; /* Size of string table. */
7322 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7323 bfd_vma fn
, struct absaddr addr
)
7325 const char *procname
;
7328 if (addr
.section
== SHN_UNDEF
)
7331 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7332 aux
->strtab_size
, addr
, &procname
,
7335 print_vma (fn
, PREFIX_HEX
);
7339 fputs (" <", stdout
);
7340 fputs (procname
, stdout
);
7343 printf ("+0x%lx", (unsigned long) sym_offset
);
7344 fputc ('>', stdout
);
7351 arm_free_section (struct arm_section
*arm_sec
)
7353 if (arm_sec
->data
!= NULL
)
7354 free (arm_sec
->data
);
7356 if (arm_sec
->rela
!= NULL
)
7357 free (arm_sec
->rela
);
7360 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7361 cached section and install SEC instead.
7362 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7363 and return its valued in * WORDP, relocating if necessary.
7364 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7365 relocation's offset in ADDR.
7366 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7367 into the string table of the symbol associated with the reloc. If no
7368 reloc was applied store -1 there.
7369 5) Return TRUE upon success, FALSE otherwise. */
7372 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7373 struct arm_section
* arm_sec
,
7374 Elf_Internal_Shdr
* sec
,
7375 bfd_vma word_offset
,
7376 unsigned int * wordp
,
7377 struct absaddr
* addr
,
7380 Elf_Internal_Rela
*rp
;
7381 Elf_Internal_Sym
*sym
;
7382 const char * relname
;
7384 bfd_boolean wrapped
;
7386 if (sec
== NULL
|| arm_sec
== NULL
)
7389 addr
->section
= SHN_UNDEF
;
7392 if (sym_name
!= NULL
)
7393 *sym_name
= (bfd_vma
) -1;
7395 /* If necessary, update the section cache. */
7396 if (sec
!= arm_sec
->sec
)
7398 Elf_Internal_Shdr
*relsec
;
7400 arm_free_section (arm_sec
);
7403 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7404 sec
->sh_size
, _("unwind data"));
7405 arm_sec
->rela
= NULL
;
7406 arm_sec
->nrelas
= 0;
7408 for (relsec
= section_headers
;
7409 relsec
< section_headers
+ elf_header
.e_shnum
;
7412 if (relsec
->sh_info
>= elf_header
.e_shnum
7413 || section_headers
+ relsec
->sh_info
!= sec
7414 /* PR 15745: Check the section type as well. */
7415 || (relsec
->sh_type
!= SHT_REL
7416 && relsec
->sh_type
!= SHT_RELA
))
7419 arm_sec
->rel_type
= relsec
->sh_type
;
7420 if (relsec
->sh_type
== SHT_REL
)
7422 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7424 & arm_sec
->rela
, & arm_sec
->nrelas
))
7427 else /* relsec->sh_type == SHT_RELA */
7429 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7431 & arm_sec
->rela
, & arm_sec
->nrelas
))
7437 arm_sec
->next_rela
= arm_sec
->rela
;
7440 /* If there is no unwind data we can do nothing. */
7441 if (arm_sec
->data
== NULL
)
7444 /* If the offset is invalid then fail. */
7445 if (word_offset
> sec
->sh_size
- 4)
7448 /* Get the word at the required offset. */
7449 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7451 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7452 if (arm_sec
->rela
== NULL
)
7458 /* Look through the relocs to find the one that applies to the provided offset. */
7460 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7462 bfd_vma prelval
, offset
;
7464 if (rp
->r_offset
> word_offset
&& !wrapped
)
7469 if (rp
->r_offset
> word_offset
)
7472 if (rp
->r_offset
& 3)
7474 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7475 (unsigned long) rp
->r_offset
);
7479 if (rp
->r_offset
< word_offset
)
7482 /* PR 17531: file: 027-161405-0.004 */
7483 if (aux
->symtab
== NULL
)
7486 if (arm_sec
->rel_type
== SHT_REL
)
7488 offset
= word
& 0x7fffffff;
7489 if (offset
& 0x40000000)
7490 offset
|= ~ (bfd_vma
) 0x7fffffff;
7492 else if (arm_sec
->rel_type
== SHT_RELA
)
7493 offset
= rp
->r_addend
;
7496 error (_("Unknown section relocation type %d encountered\n"),
7501 /* PR 17531 file: 027-1241568-0.004. */
7502 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7504 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7505 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7509 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7510 offset
+= sym
->st_value
;
7511 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7513 /* Check that we are processing the expected reloc type. */
7514 if (elf_header
.e_machine
== EM_ARM
)
7516 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7517 if (relname
== NULL
)
7519 warn (_("Skipping unknown ARM relocation type: %d\n"),
7520 (int) ELF32_R_TYPE (rp
->r_info
));
7524 if (streq (relname
, "R_ARM_NONE"))
7527 if (! streq (relname
, "R_ARM_PREL31"))
7529 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7533 else if (elf_header
.e_machine
== EM_TI_C6000
)
7535 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7536 if (relname
== NULL
)
7538 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7539 (int) ELF32_R_TYPE (rp
->r_info
));
7543 if (streq (relname
, "R_C6000_NONE"))
7546 if (! streq (relname
, "R_C6000_PREL31"))
7548 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7556 /* This function currently only supports ARM and TI unwinders. */
7557 warn (_("Only TI and ARM unwinders are currently supported\n"));
7561 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7562 addr
->section
= sym
->st_shndx
;
7563 addr
->offset
= offset
;
7566 * sym_name
= sym
->st_name
;
7571 arm_sec
->next_rela
= rp
;
7576 static const char *tic6x_unwind_regnames
[16] =
7578 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7579 "A14", "A13", "A12", "A11", "A10",
7580 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7584 decode_tic6x_unwind_regmask (unsigned int mask
)
7588 for (i
= 12; mask
; mask
>>= 1, i
--)
7592 fputs (tic6x_unwind_regnames
[i
], stdout
);
7594 fputs (", ", stdout
);
7600 if (remaining == 0 && more_words) \
7603 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7604 data_offset, & word, & addr, NULL)) \
7610 #define GET_OP(OP) \
7615 (OP) = word >> 24; \
7620 printf (_("[Truncated opcode]\n")); \
7623 printf ("0x%02x ", OP)
7626 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7628 unsigned int remaining
,
7629 unsigned int more_words
,
7630 bfd_vma data_offset
,
7631 Elf_Internal_Shdr
* data_sec
,
7632 struct arm_section
* data_arm_sec
)
7634 struct absaddr addr
;
7636 /* Decode the unwinding instructions. */
7639 unsigned int op
, op2
;
7648 printf (" 0x%02x ", op
);
7650 if ((op
& 0xc0) == 0x00)
7652 int offset
= ((op
& 0x3f) << 2) + 4;
7654 printf (" vsp = vsp + %d", offset
);
7656 else if ((op
& 0xc0) == 0x40)
7658 int offset
= ((op
& 0x3f) << 2) + 4;
7660 printf (" vsp = vsp - %d", offset
);
7662 else if ((op
& 0xf0) == 0x80)
7665 if (op
== 0x80 && op2
== 0)
7666 printf (_("Refuse to unwind"));
7669 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7674 for (i
= 0; i
< 12; i
++)
7675 if (mask
& (1 << i
))
7681 printf ("r%d", 4 + i
);
7686 else if ((op
& 0xf0) == 0x90)
7688 if (op
== 0x9d || op
== 0x9f)
7689 printf (_(" [Reserved]"));
7691 printf (" vsp = r%d", op
& 0x0f);
7693 else if ((op
& 0xf0) == 0xa0)
7695 int end
= 4 + (op
& 0x07);
7700 for (i
= 4; i
<= end
; i
++)
7716 else if (op
== 0xb0)
7717 printf (_(" finish"));
7718 else if (op
== 0xb1)
7721 if (op2
== 0 || (op2
& 0xf0) != 0)
7722 printf (_("[Spare]"));
7725 unsigned int mask
= op2
& 0x0f;
7730 for (i
= 0; i
< 12; i
++)
7731 if (mask
& (1 << i
))
7742 else if (op
== 0xb2)
7744 unsigned char buf
[9];
7745 unsigned int i
, len
;
7746 unsigned long offset
;
7748 for (i
= 0; i
< sizeof (buf
); i
++)
7751 if ((buf
[i
] & 0x80) == 0)
7754 if (i
== sizeof (buf
))
7755 printf (_("corrupt change to vsp"));
7758 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7759 assert (len
== i
+ 1);
7760 offset
= offset
* 4 + 0x204;
7761 printf ("vsp = vsp + %ld", offset
);
7764 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7766 unsigned int first
, last
;
7773 printf ("pop {D%d", first
);
7775 printf ("-D%d", first
+ last
);
7778 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7780 unsigned int count
= op
& 0x07;
7784 printf ("-D%d", 8 + count
);
7787 else if (op
>= 0xc0 && op
<= 0xc5)
7789 unsigned int count
= op
& 0x07;
7791 printf (" pop {wR10");
7793 printf ("-wR%d", 10 + count
);
7796 else if (op
== 0xc6)
7798 unsigned int first
, last
;
7803 printf ("pop {wR%d", first
);
7805 printf ("-wR%d", first
+ last
);
7808 else if (op
== 0xc7)
7811 if (op2
== 0 || (op2
& 0xf0) != 0)
7812 printf (_("[Spare]"));
7815 unsigned int mask
= op2
& 0x0f;
7820 for (i
= 0; i
< 4; i
++)
7821 if (mask
& (1 << i
))
7827 printf ("wCGR%d", i
);
7833 printf (_(" [unsupported opcode]"));
7839 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7841 unsigned int remaining
,
7842 unsigned int more_words
,
7843 bfd_vma data_offset
,
7844 Elf_Internal_Shdr
* data_sec
,
7845 struct arm_section
* data_arm_sec
)
7847 struct absaddr addr
;
7849 /* Decode the unwinding instructions. */
7852 unsigned int op
, op2
;
7861 printf (" 0x%02x ", op
);
7863 if ((op
& 0xc0) == 0x00)
7865 int offset
= ((op
& 0x3f) << 3) + 8;
7866 printf (" sp = sp + %d", offset
);
7868 else if ((op
& 0xc0) == 0x80)
7871 if (op
== 0x80 && op2
== 0)
7872 printf (_("Refuse to unwind"));
7875 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7877 printf ("pop compact {");
7881 decode_tic6x_unwind_regmask (mask
);
7885 else if ((op
& 0xf0) == 0xc0)
7893 unsigned int offset
;
7897 /* Scan entire instruction first so that GET_OP output is not
7898 interleaved with disassembly. */
7900 for (i
= 0; nregs
< (op
& 0xf); i
++)
7906 regpos
[nregs
].offset
= i
* 2;
7907 regpos
[nregs
].reg
= reg
;
7914 regpos
[nregs
].offset
= i
* 2 + 1;
7915 regpos
[nregs
].reg
= reg
;
7920 printf (_("pop frame {"));
7922 for (i
= i
* 2; i
> 0; i
--)
7924 if (regpos
[reg
].offset
== i
- 1)
7926 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7933 fputs (name
, stdout
);
7940 else if (op
== 0xd0)
7941 printf (" MOV FP, SP");
7942 else if (op
== 0xd1)
7943 printf (" __c6xabi_pop_rts");
7944 else if (op
== 0xd2)
7946 unsigned char buf
[9];
7947 unsigned int i
, len
;
7948 unsigned long offset
;
7950 for (i
= 0; i
< sizeof (buf
); i
++)
7953 if ((buf
[i
] & 0x80) == 0)
7956 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7957 if (i
== sizeof (buf
))
7959 printf ("<corrupt sp adjust>\n");
7960 warn (_("Corrupt stack pointer adjustment detected\n"));
7964 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7965 assert (len
== i
+ 1);
7966 offset
= offset
* 8 + 0x408;
7967 printf (_("sp = sp + %ld"), offset
);
7969 else if ((op
& 0xf0) == 0xe0)
7971 if ((op
& 0x0f) == 7)
7974 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7978 printf (_(" [unsupported opcode]"));
7985 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7989 offset
= word
& 0x7fffffff;
7990 if (offset
& 0x40000000)
7991 offset
|= ~ (bfd_vma
) 0x7fffffff;
7993 if (elf_header
.e_machine
== EM_TI_C6000
)
7996 return offset
+ where
;
8000 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8002 unsigned int remaining
,
8003 bfd_vma data_offset
,
8004 Elf_Internal_Shdr
* data_sec
,
8005 struct arm_section
* data_arm_sec
)
8008 unsigned int more_words
= 0;
8009 struct absaddr addr
;
8010 bfd_vma sym_name
= (bfd_vma
) -1;
8014 /* Fetch the first word.
8015 Note - when decoding an object file the address extracted
8016 here will always be 0. So we also pass in the sym_name
8017 parameter so that we can find the symbol associated with
8018 the personality routine. */
8019 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8020 & word
, & addr
, & sym_name
))
8026 if ((word
& 0x80000000) == 0)
8028 /* Expand prel31 for personality routine. */
8030 const char *procname
;
8032 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8033 printf (_(" Personality routine: "));
8035 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8036 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8038 procname
= aux
->strtab
+ sym_name
;
8039 print_vma (fn
, PREFIX_HEX
);
8042 fputs (" <", stdout
);
8043 fputs (procname
, stdout
);
8044 fputc ('>', stdout
);
8048 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8049 fputc ('\n', stdout
);
8051 /* The GCC personality routines use the standard compact
8052 encoding, starting with one byte giving the number of
8054 if (procname
!= NULL
8055 && (const_strneq (procname
, "__gcc_personality_v0")
8056 || const_strneq (procname
, "__gxx_personality_v0")
8057 || const_strneq (procname
, "__gcj_personality_v0")
8058 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8065 printf (_(" [Truncated data]\n"));
8068 more_words
= word
>> 24;
8078 /* ARM EHABI Section 6.3:
8080 An exception-handling table entry for the compact model looks like:
8084 1 0 index Data for personalityRoutine[index] */
8086 if (elf_header
.e_machine
== EM_ARM
8087 && (word
& 0x70000000))
8088 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8090 per_index
= (word
>> 24) & 0x7f;
8091 printf (_(" Compact model index: %d\n"), per_index
);
8098 else if (per_index
< 3)
8100 more_words
= (word
>> 16) & 0xff;
8106 switch (elf_header
.e_machine
)
8111 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8112 data_offset
, data_sec
, data_arm_sec
);
8116 warn (_("Unknown ARM compact model index encountered\n"));
8117 printf (_(" [reserved]\n"));
8124 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8125 data_offset
, data_sec
, data_arm_sec
);
8127 else if (per_index
< 5)
8129 if (((word
>> 17) & 0x7f) == 0x7f)
8130 printf (_(" Restore stack from frame pointer\n"));
8132 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8133 printf (_(" Registers restored: "));
8135 printf (" (compact) ");
8136 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8138 printf (_(" Return register: %s\n"),
8139 tic6x_unwind_regnames
[word
& 0xf]);
8142 printf (_(" [reserved (%d)]\n"), per_index
);
8146 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8147 elf_header
.e_machine
);
8150 /* Decode the descriptors. Not implemented. */
8154 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8156 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8157 unsigned int i
, exidx_len
;
8158 unsigned long j
, nfuns
;
8160 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8161 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8162 exidx_len
= exidx_sec
->sh_size
/ 8;
8164 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8165 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8166 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8167 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8169 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8171 for (i
= 0; i
< exidx_len
; i
++)
8173 unsigned int exidx_fn
, exidx_entry
;
8174 struct absaddr fn_addr
, entry_addr
;
8177 fputc ('\n', stdout
);
8179 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8180 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8181 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8182 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8185 arm_free_section (& exidx_arm_sec
);
8186 arm_free_section (& extab_arm_sec
);
8190 /* ARM EHABI, Section 5:
8191 An index table entry consists of 2 words.
8192 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8193 if (exidx_fn
& 0x80000000)
8194 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8196 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8198 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8199 fputs (": ", stdout
);
8201 if (exidx_entry
== 1)
8203 print_vma (exidx_entry
, PREFIX_HEX
);
8204 fputs (" [cantunwind]\n", stdout
);
8206 else if (exidx_entry
& 0x80000000)
8208 print_vma (exidx_entry
, PREFIX_HEX
);
8209 fputc ('\n', stdout
);
8210 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8214 bfd_vma table
, table_offset
= 0;
8215 Elf_Internal_Shdr
*table_sec
;
8217 fputs ("@", stdout
);
8218 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8219 print_vma (table
, PREFIX_HEX
);
8222 /* Locate the matching .ARM.extab. */
8223 if (entry_addr
.section
!= SHN_UNDEF
8224 && entry_addr
.section
< elf_header
.e_shnum
)
8226 table_sec
= section_headers
+ entry_addr
.section
;
8227 table_offset
= entry_addr
.offset
;
8231 table_sec
= find_section_by_address (table
);
8232 if (table_sec
!= NULL
)
8233 table_offset
= table
- table_sec
->sh_addr
;
8235 if (table_sec
== NULL
)
8237 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8238 (unsigned long) table
);
8241 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8249 arm_free_section (&exidx_arm_sec
);
8250 arm_free_section (&extab_arm_sec
);
8253 /* Used for both ARM and C6X unwinding tables. */
8256 arm_process_unwind (FILE *file
)
8258 struct arm_unw_aux_info aux
;
8259 Elf_Internal_Shdr
*unwsec
= NULL
;
8260 Elf_Internal_Shdr
*strsec
;
8261 Elf_Internal_Shdr
*sec
;
8263 unsigned int sec_type
;
8265 switch (elf_header
.e_machine
)
8268 sec_type
= SHT_ARM_EXIDX
;
8272 sec_type
= SHT_C6000_UNWIND
;
8276 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8277 elf_header
.e_machine
);
8281 if (string_table
== NULL
)
8284 memset (& aux
, 0, sizeof (aux
));
8287 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8289 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8291 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8293 strsec
= section_headers
+ sec
->sh_link
;
8295 /* PR binutils/17531 file: 011-12666-0.004. */
8296 if (aux
.strtab
!= NULL
)
8298 error (_("Multiple string tables found in file.\n"));
8301 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8302 1, strsec
->sh_size
, _("string table"));
8303 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8305 else if (sec
->sh_type
== sec_type
)
8310 printf (_("\nThere are no unwind sections in this file.\n"));
8312 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8314 if (sec
->sh_type
== sec_type
)
8316 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8317 printable_section_name (sec
),
8318 (unsigned long) sec
->sh_offset
,
8319 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8321 dump_arm_unwind (&aux
, sec
);
8328 free ((char *) aux
.strtab
);
8332 process_unwind (FILE * file
)
8334 struct unwind_handler
8337 void (* handler
)(FILE *);
8340 { EM_ARM
, arm_process_unwind
},
8341 { EM_IA_64
, ia64_process_unwind
},
8342 { EM_PARISC
, hppa_process_unwind
},
8343 { EM_TI_C6000
, arm_process_unwind
},
8351 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8352 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8354 handlers
[i
].handler (file
);
8358 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8359 get_machine_name (elf_header
.e_machine
));
8363 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8365 switch (entry
->d_tag
)
8368 if (entry
->d_un
.d_val
== 0)
8372 static const char * opts
[] =
8374 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8375 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8376 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8377 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8383 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8384 if (entry
->d_un
.d_val
& (1 << cnt
))
8386 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8392 case DT_MIPS_IVERSION
:
8393 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8394 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8398 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8399 /* Note: coded this way so that there is a single string for translation. */
8400 printf (_("<corrupt: %s>"), buf
);
8404 case DT_MIPS_TIME_STAMP
:
8408 time_t atime
= entry
->d_un
.d_val
;
8410 tmp
= gmtime (&atime
);
8411 /* PR 17531: file: 6accc532. */
8413 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8415 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8416 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8417 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8418 printf (_("Time Stamp: %s"), timebuf
);
8422 case DT_MIPS_RLD_VERSION
:
8423 case DT_MIPS_LOCAL_GOTNO
:
8424 case DT_MIPS_CONFLICTNO
:
8425 case DT_MIPS_LIBLISTNO
:
8426 case DT_MIPS_SYMTABNO
:
8427 case DT_MIPS_UNREFEXTNO
:
8428 case DT_MIPS_HIPAGENO
:
8429 case DT_MIPS_DELTA_CLASS_NO
:
8430 case DT_MIPS_DELTA_INSTANCE_NO
:
8431 case DT_MIPS_DELTA_RELOC_NO
:
8432 case DT_MIPS_DELTA_SYM_NO
:
8433 case DT_MIPS_DELTA_CLASSSYM_NO
:
8434 case DT_MIPS_COMPACT_SIZE
:
8435 print_vma (entry
->d_un
.d_ptr
, DEC
);
8439 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8445 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8447 switch (entry
->d_tag
)
8449 case DT_HP_DLD_FLAGS
:
8458 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8459 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8460 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8461 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8462 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8463 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8464 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8465 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8466 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8467 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8468 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8469 { DT_HP_GST
, "HP_GST" },
8470 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8471 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8472 { DT_HP_NODELETE
, "HP_NODELETE" },
8473 { DT_HP_GROUP
, "HP_GROUP" },
8474 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8478 bfd_vma val
= entry
->d_un
.d_val
;
8480 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8481 if (val
& flags
[cnt
].bit
)
8485 fputs (flags
[cnt
].str
, stdout
);
8487 val
^= flags
[cnt
].bit
;
8490 if (val
!= 0 || first
)
8494 print_vma (val
, HEX
);
8500 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8508 /* VMS vs Unix time offset and factor. */
8510 #define VMS_EPOCH_OFFSET 35067168000000000LL
8511 #define VMS_GRANULARITY_FACTOR 10000000
8513 /* Display a VMS time in a human readable format. */
8516 print_vms_time (bfd_int64_t vmstime
)
8521 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8522 tm
= gmtime (&unxtime
);
8523 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8524 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8525 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8530 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8532 switch (entry
->d_tag
)
8534 case DT_IA_64_PLT_RESERVE
:
8535 /* First 3 slots reserved. */
8536 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8538 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8541 case DT_IA_64_VMS_LINKTIME
:
8543 print_vms_time (entry
->d_un
.d_val
);
8547 case DT_IA_64_VMS_LNKFLAGS
:
8548 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8549 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8550 printf (" CALL_DEBUG");
8551 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8552 printf (" NOP0BUFS");
8553 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8554 printf (" P0IMAGE");
8555 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8556 printf (" MKTHREADS");
8557 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8558 printf (" UPCALLS");
8559 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8561 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8562 printf (" INITIALIZE");
8563 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8565 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8566 printf (" EXE_INIT");
8567 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8568 printf (" TBK_IN_IMG");
8569 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8570 printf (" DBG_IN_IMG");
8571 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8572 printf (" TBK_IN_DSF");
8573 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8574 printf (" DBG_IN_DSF");
8575 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8576 printf (" SIGNATURES");
8577 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8578 printf (" REL_SEG_OFF");
8582 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8589 get_32bit_dynamic_section (FILE * file
)
8591 Elf32_External_Dyn
* edyn
;
8592 Elf32_External_Dyn
* ext
;
8593 Elf_Internal_Dyn
* entry
;
8595 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8596 dynamic_size
, _("dynamic section"));
8600 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8601 might not have the luxury of section headers. Look for the DT_NULL
8602 terminator to determine the number of entries. */
8603 for (ext
= edyn
, dynamic_nent
= 0;
8604 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8608 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8612 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8614 if (dynamic_section
== NULL
)
8616 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8617 (unsigned long) dynamic_nent
);
8622 for (ext
= edyn
, entry
= dynamic_section
;
8623 entry
< dynamic_section
+ dynamic_nent
;
8626 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8627 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8636 get_64bit_dynamic_section (FILE * file
)
8638 Elf64_External_Dyn
* edyn
;
8639 Elf64_External_Dyn
* ext
;
8640 Elf_Internal_Dyn
* entry
;
8642 /* Read in the data. */
8643 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8644 dynamic_size
, _("dynamic section"));
8648 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8649 might not have the luxury of section headers. Look for the DT_NULL
8650 terminator to determine the number of entries. */
8651 for (ext
= edyn
, dynamic_nent
= 0;
8652 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8653 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8657 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8661 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8663 if (dynamic_section
== NULL
)
8665 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8666 (unsigned long) dynamic_nent
);
8671 /* Convert from external to internal formats. */
8672 for (ext
= edyn
, entry
= dynamic_section
;
8673 entry
< dynamic_section
+ dynamic_nent
;
8676 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8677 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8686 print_dynamic_flags (bfd_vma flags
)
8694 flag
= flags
& - flags
;
8704 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8705 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8706 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8707 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8708 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8709 default: fputs (_("unknown"), stdout
); break;
8715 /* Parse and display the contents of the dynamic section. */
8718 process_dynamic_section (FILE * file
)
8720 Elf_Internal_Dyn
* entry
;
8722 if (dynamic_size
== 0)
8725 printf (_("\nThere is no dynamic section in this file.\n"));
8732 if (! get_32bit_dynamic_section (file
))
8735 else if (! get_64bit_dynamic_section (file
))
8738 /* Find the appropriate symbol table. */
8739 if (dynamic_symbols
== NULL
)
8741 for (entry
= dynamic_section
;
8742 entry
< dynamic_section
+ dynamic_nent
;
8745 Elf_Internal_Shdr section
;
8747 if (entry
->d_tag
!= DT_SYMTAB
)
8750 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8752 /* Since we do not know how big the symbol table is,
8753 we default to reading in the entire file (!) and
8754 processing that. This is overkill, I know, but it
8756 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8758 if (archive_file_offset
!= 0)
8759 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8762 if (fseek (file
, 0, SEEK_END
))
8763 error (_("Unable to seek to end of file!\n"));
8765 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8769 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8771 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8772 section
.sh_name
= string_table_length
;
8774 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8775 if (num_dynamic_syms
< 1)
8777 error (_("Unable to determine the number of symbols to load\n"));
8783 /* Similarly find a string table. */
8784 if (dynamic_strings
== NULL
)
8786 for (entry
= dynamic_section
;
8787 entry
< dynamic_section
+ dynamic_nent
;
8790 unsigned long offset
;
8793 if (entry
->d_tag
!= DT_STRTAB
)
8796 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8798 /* Since we do not know how big the string table is,
8799 we default to reading in the entire file (!) and
8800 processing that. This is overkill, I know, but it
8803 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8805 if (archive_file_offset
!= 0)
8806 str_tab_len
= archive_file_size
- offset
;
8809 if (fseek (file
, 0, SEEK_END
))
8810 error (_("Unable to seek to end of file\n"));
8811 str_tab_len
= ftell (file
) - offset
;
8814 if (str_tab_len
< 1)
8817 (_("Unable to determine the length of the dynamic string table\n"));
8821 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8823 _("dynamic string table"));
8824 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8829 /* And find the syminfo section if available. */
8830 if (dynamic_syminfo
== NULL
)
8832 unsigned long syminsz
= 0;
8834 for (entry
= dynamic_section
;
8835 entry
< dynamic_section
+ dynamic_nent
;
8838 if (entry
->d_tag
== DT_SYMINENT
)
8840 /* Note: these braces are necessary to avoid a syntax
8841 error from the SunOS4 C compiler. */
8842 /* PR binutils/17531: A corrupt file can trigger this test.
8843 So do not use an assert, instead generate an error message. */
8844 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8845 error (_("Bad value (%d) for SYMINENT entry\n"),
8846 (int) entry
->d_un
.d_val
);
8848 else if (entry
->d_tag
== DT_SYMINSZ
)
8849 syminsz
= entry
->d_un
.d_val
;
8850 else if (entry
->d_tag
== DT_SYMINFO
)
8851 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8855 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8857 Elf_External_Syminfo
* extsyminfo
;
8858 Elf_External_Syminfo
* extsym
;
8859 Elf_Internal_Syminfo
* syminfo
;
8861 /* There is a syminfo section. Read the data. */
8862 extsyminfo
= (Elf_External_Syminfo
*)
8863 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8864 _("symbol information"));
8868 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8869 if (dynamic_syminfo
== NULL
)
8871 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8872 (unsigned long) syminsz
);
8876 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8877 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8878 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8879 ++syminfo
, ++extsym
)
8881 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8882 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8889 if (do_dynamic
&& dynamic_addr
)
8890 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8891 dynamic_addr
, (unsigned long) dynamic_nent
);
8893 printf (_(" Tag Type Name/Value\n"));
8895 for (entry
= dynamic_section
;
8896 entry
< dynamic_section
+ dynamic_nent
;
8904 print_vma (entry
->d_tag
, FULL_HEX
);
8905 dtype
= get_dynamic_type (entry
->d_tag
);
8906 printf (" (%s)%*s", dtype
,
8907 ((is_32bit_elf
? 27 : 19)
8908 - (int) strlen (dtype
)),
8912 switch (entry
->d_tag
)
8916 print_dynamic_flags (entry
->d_un
.d_val
);
8926 switch (entry
->d_tag
)
8929 printf (_("Auxiliary library"));
8933 printf (_("Filter library"));
8937 printf (_("Configuration file"));
8941 printf (_("Dependency audit library"));
8945 printf (_("Audit library"));
8949 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8950 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8954 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8963 printf (_("Flags:"));
8965 if (entry
->d_un
.d_val
== 0)
8966 printf (_(" None\n"));
8969 unsigned long int val
= entry
->d_un
.d_val
;
8971 if (val
& DTF_1_PARINIT
)
8973 printf (" PARINIT");
8974 val
^= DTF_1_PARINIT
;
8976 if (val
& DTF_1_CONFEXP
)
8978 printf (" CONFEXP");
8979 val
^= DTF_1_CONFEXP
;
8982 printf (" %lx", val
);
8991 printf (_("Flags:"));
8993 if (entry
->d_un
.d_val
== 0)
8994 printf (_(" None\n"));
8997 unsigned long int val
= entry
->d_un
.d_val
;
8999 if (val
& DF_P1_LAZYLOAD
)
9001 printf (" LAZYLOAD");
9002 val
^= DF_P1_LAZYLOAD
;
9004 if (val
& DF_P1_GROUPPERM
)
9006 printf (" GROUPPERM");
9007 val
^= DF_P1_GROUPPERM
;
9010 printf (" %lx", val
);
9019 printf (_("Flags:"));
9020 if (entry
->d_un
.d_val
== 0)
9021 printf (_(" None\n"));
9024 unsigned long int val
= entry
->d_un
.d_val
;
9031 if (val
& DF_1_GLOBAL
)
9036 if (val
& DF_1_GROUP
)
9041 if (val
& DF_1_NODELETE
)
9043 printf (" NODELETE");
9044 val
^= DF_1_NODELETE
;
9046 if (val
& DF_1_LOADFLTR
)
9048 printf (" LOADFLTR");
9049 val
^= DF_1_LOADFLTR
;
9051 if (val
& DF_1_INITFIRST
)
9053 printf (" INITFIRST");
9054 val
^= DF_1_INITFIRST
;
9056 if (val
& DF_1_NOOPEN
)
9061 if (val
& DF_1_ORIGIN
)
9066 if (val
& DF_1_DIRECT
)
9071 if (val
& DF_1_TRANS
)
9076 if (val
& DF_1_INTERPOSE
)
9078 printf (" INTERPOSE");
9079 val
^= DF_1_INTERPOSE
;
9081 if (val
& DF_1_NODEFLIB
)
9083 printf (" NODEFLIB");
9084 val
^= DF_1_NODEFLIB
;
9086 if (val
& DF_1_NODUMP
)
9091 if (val
& DF_1_CONFALT
)
9093 printf (" CONFALT");
9094 val
^= DF_1_CONFALT
;
9096 if (val
& DF_1_ENDFILTEE
)
9098 printf (" ENDFILTEE");
9099 val
^= DF_1_ENDFILTEE
;
9101 if (val
& DF_1_DISPRELDNE
)
9103 printf (" DISPRELDNE");
9104 val
^= DF_1_DISPRELDNE
;
9106 if (val
& DF_1_DISPRELPND
)
9108 printf (" DISPRELPND");
9109 val
^= DF_1_DISPRELPND
;
9111 if (val
& DF_1_NODIRECT
)
9113 printf (" NODIRECT");
9114 val
^= DF_1_NODIRECT
;
9116 if (val
& DF_1_IGNMULDEF
)
9118 printf (" IGNMULDEF");
9119 val
^= DF_1_IGNMULDEF
;
9121 if (val
& DF_1_NOKSYMS
)
9123 printf (" NOKSYMS");
9124 val
^= DF_1_NOKSYMS
;
9126 if (val
& DF_1_NOHDR
)
9131 if (val
& DF_1_EDITED
)
9136 if (val
& DF_1_NORELOC
)
9138 printf (" NORELOC");
9139 val
^= DF_1_NORELOC
;
9141 if (val
& DF_1_SYMINTPOSE
)
9143 printf (" SYMINTPOSE");
9144 val
^= DF_1_SYMINTPOSE
;
9146 if (val
& DF_1_GLOBAUDIT
)
9148 printf (" GLOBAUDIT");
9149 val
^= DF_1_GLOBAUDIT
;
9151 if (val
& DF_1_SINGLETON
)
9153 printf (" SINGLETON");
9154 val
^= DF_1_SINGLETON
;
9157 printf (" %lx", val
);
9164 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9166 puts (get_dynamic_type (entry
->d_un
.d_val
));
9186 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9192 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9193 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9199 switch (entry
->d_tag
)
9202 printf (_("Shared library: [%s]"), name
);
9204 if (streq (name
, program_interpreter
))
9205 printf (_(" program interpreter"));
9209 printf (_("Library soname: [%s]"), name
);
9213 printf (_("Library rpath: [%s]"), name
);
9217 printf (_("Library runpath: [%s]"), name
);
9221 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9226 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9239 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9243 case DT_INIT_ARRAYSZ
:
9244 case DT_FINI_ARRAYSZ
:
9245 case DT_GNU_CONFLICTSZ
:
9246 case DT_GNU_LIBLISTSZ
:
9249 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9250 printf (_(" (bytes)\n"));
9260 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9273 if (entry
->d_tag
== DT_USED
9274 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9276 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9280 printf (_("Not needed object: [%s]\n"), name
);
9285 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9291 /* The value of this entry is ignored. */
9296 case DT_GNU_PRELINKED
:
9300 time_t atime
= entry
->d_un
.d_val
;
9302 tmp
= gmtime (&atime
);
9303 /* PR 17533 file: 041-1244816-0.004. */
9305 printf (_("<corrupt time val: %lx"),
9306 (unsigned long) atime
);
9308 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9309 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9310 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9316 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9319 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9325 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9326 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9331 switch (elf_header
.e_machine
)
9334 case EM_MIPS_RS3_LE
:
9335 dynamic_section_mips_val (entry
);
9338 dynamic_section_parisc_val (entry
);
9341 dynamic_section_ia64_val (entry
);
9344 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9356 get_ver_flags (unsigned int flags
)
9358 static char buff
[32];
9365 if (flags
& VER_FLG_BASE
)
9366 strcat (buff
, "BASE ");
9368 if (flags
& VER_FLG_WEAK
)
9370 if (flags
& VER_FLG_BASE
)
9371 strcat (buff
, "| ");
9373 strcat (buff
, "WEAK ");
9376 if (flags
& VER_FLG_INFO
)
9378 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9379 strcat (buff
, "| ");
9381 strcat (buff
, "INFO ");
9384 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9385 strcat (buff
, _("| <unknown>"));
9390 /* Display the contents of the version sections. */
9393 process_version_sections (FILE * file
)
9395 Elf_Internal_Shdr
* section
;
9402 for (i
= 0, section
= section_headers
;
9403 i
< elf_header
.e_shnum
;
9406 switch (section
->sh_type
)
9408 case SHT_GNU_verdef
:
9410 Elf_External_Verdef
* edefs
;
9417 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9418 printable_section_name (section
),
9421 printf (_(" Addr: 0x"));
9422 printf_vma (section
->sh_addr
);
9423 printf (_(" Offset: %#08lx Link: %u (%s)"),
9424 (unsigned long) section
->sh_offset
, section
->sh_link
,
9425 printable_section_name_from_index (section
->sh_link
));
9427 edefs
= (Elf_External_Verdef
*)
9428 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9429 _("version definition section"));
9432 endbuf
= (char *) edefs
+ section
->sh_size
;
9434 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9437 Elf_External_Verdef
* edef
;
9438 Elf_Internal_Verdef ent
;
9439 Elf_External_Verdaux
* eaux
;
9440 Elf_Internal_Verdaux aux
;
9444 /* Check for very large indicies. */
9445 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9448 vstart
= ((char *) edefs
) + idx
;
9449 if (vstart
+ sizeof (*edef
) > endbuf
)
9452 edef
= (Elf_External_Verdef
*) vstart
;
9454 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9455 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9456 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9457 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9458 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9459 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9460 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9462 printf (_(" %#06x: Rev: %d Flags: %s"),
9463 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9465 printf (_(" Index: %d Cnt: %d "),
9466 ent
.vd_ndx
, ent
.vd_cnt
);
9468 /* Check for overflow. */
9469 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9472 vstart
+= ent
.vd_aux
;
9474 eaux
= (Elf_External_Verdaux
*) vstart
;
9476 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9477 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9479 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9480 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9482 printf (_("Name index: %ld\n"), aux
.vda_name
);
9484 isum
= idx
+ ent
.vd_aux
;
9486 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9488 /* Check for overflow. */
9489 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9492 isum
+= aux
.vda_next
;
9493 vstart
+= aux
.vda_next
;
9495 eaux
= (Elf_External_Verdaux
*) vstart
;
9496 if (vstart
+ sizeof (*eaux
) > endbuf
)
9499 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9500 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9502 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9503 printf (_(" %#06x: Parent %d: %s\n"),
9504 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9506 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9507 isum
, j
, aux
.vda_name
);
9511 printf (_(" Version def aux past end of section\n"));
9513 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9514 if (idx
+ ent
.vd_next
<= idx
)
9520 if (cnt
< section
->sh_info
)
9521 printf (_(" Version definition past end of section\n"));
9527 case SHT_GNU_verneed
:
9529 Elf_External_Verneed
* eneed
;
9536 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9537 printable_section_name (section
), section
->sh_info
);
9539 printf (_(" Addr: 0x"));
9540 printf_vma (section
->sh_addr
);
9541 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9542 (unsigned long) section
->sh_offset
, section
->sh_link
,
9543 printable_section_name_from_index (section
->sh_link
));
9545 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9546 section
->sh_offset
, 1,
9548 _("Version Needs section"));
9551 endbuf
= (char *) eneed
+ section
->sh_size
;
9553 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9555 Elf_External_Verneed
* entry
;
9556 Elf_Internal_Verneed ent
;
9561 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9564 vstart
= ((char *) eneed
) + idx
;
9565 if (vstart
+ sizeof (*entry
) > endbuf
)
9568 entry
= (Elf_External_Verneed
*) vstart
;
9570 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9571 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9572 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9573 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9574 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9576 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9578 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9579 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9581 printf (_(" File: %lx"), ent
.vn_file
);
9583 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9585 /* Check for overflow. */
9586 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9588 vstart
+= ent
.vn_aux
;
9590 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9592 Elf_External_Vernaux
* eaux
;
9593 Elf_Internal_Vernaux aux
;
9595 if (vstart
+ sizeof (*eaux
) > endbuf
)
9597 eaux
= (Elf_External_Vernaux
*) vstart
;
9599 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9600 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9601 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9602 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9603 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9605 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9606 printf (_(" %#06x: Name: %s"),
9607 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9609 printf (_(" %#06x: Name index: %lx"),
9610 isum
, aux
.vna_name
);
9612 printf (_(" Flags: %s Version: %d\n"),
9613 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9615 /* Check for overflow. */
9616 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9617 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9619 warn (_("Invalid vna_next field of %lx\n"),
9624 isum
+= aux
.vna_next
;
9625 vstart
+= aux
.vna_next
;
9629 warn (_("Missing Version Needs auxillary information\n"));
9631 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9633 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9634 cnt
= section
->sh_info
;
9640 if (cnt
< section
->sh_info
)
9641 warn (_("Missing Version Needs information\n"));
9647 case SHT_GNU_versym
:
9649 Elf_Internal_Shdr
* link_section
;
9652 unsigned char * edata
;
9653 unsigned short * data
;
9655 Elf_Internal_Sym
* symbols
;
9656 Elf_Internal_Shdr
* string_sec
;
9657 unsigned long num_syms
;
9660 if (section
->sh_link
>= elf_header
.e_shnum
)
9663 link_section
= section_headers
+ section
->sh_link
;
9664 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9666 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9671 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9672 if (symbols
== NULL
)
9675 string_sec
= section_headers
+ link_section
->sh_link
;
9677 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9678 string_sec
->sh_size
,
9679 _("version string table"));
9686 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9687 printable_section_name (section
), (unsigned long) total
);
9689 printf (_(" Addr: "));
9690 printf_vma (section
->sh_addr
);
9691 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9692 (unsigned long) section
->sh_offset
, section
->sh_link
,
9693 printable_section_name (link_section
));
9695 off
= offset_from_vma (file
,
9696 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9697 total
* sizeof (short));
9698 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9700 _("version symbol data"));
9708 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9710 for (cnt
= total
; cnt
--;)
9711 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9716 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9719 int check_def
, check_need
;
9722 printf (" %03x:", cnt
);
9724 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9725 switch (data
[cnt
+ j
])
9728 fputs (_(" 0 (*local*) "), stdout
);
9732 fputs (_(" 1 (*global*) "), stdout
);
9736 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9737 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9739 /* If this index value is greater than the size of the symbols
9740 array, break to avoid an out-of-bounds read. */
9741 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9743 warn (_("invalid index into symbol array\n"));
9749 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9750 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9753 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9760 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9762 Elf_Internal_Verneed ivn
;
9763 unsigned long offset
;
9765 offset
= offset_from_vma
9766 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9767 sizeof (Elf_External_Verneed
));
9771 Elf_Internal_Vernaux ivna
;
9772 Elf_External_Verneed evn
;
9773 Elf_External_Vernaux evna
;
9774 unsigned long a_off
;
9776 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9777 _("version need")) == NULL
)
9780 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9781 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9783 a_off
= offset
+ ivn
.vn_aux
;
9787 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9788 1, _("version need aux (2)")) == NULL
)
9795 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9796 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9799 a_off
+= ivna
.vna_next
;
9801 while (ivna
.vna_other
!= data
[cnt
+ j
]
9802 && ivna
.vna_next
!= 0);
9804 if (ivna
.vna_other
== data
[cnt
+ j
])
9806 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9808 if (ivna
.vna_name
>= string_sec
->sh_size
)
9809 name
= _("*invalid*");
9811 name
= strtab
+ ivna
.vna_name
;
9812 nn
+= printf ("(%s%-*s",
9814 12 - (int) strlen (name
),
9820 offset
+= ivn
.vn_next
;
9822 while (ivn
.vn_next
);
9825 if (check_def
&& data
[cnt
+ j
] != 0x8001
9826 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9828 Elf_Internal_Verdef ivd
;
9829 Elf_External_Verdef evd
;
9830 unsigned long offset
;
9832 offset
= offset_from_vma
9833 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9838 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9839 _("version def")) == NULL
)
9842 /* PR 17531: file: 046-1082287-0.004. */
9843 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9848 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9849 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9852 offset
+= ivd
.vd_next
;
9854 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9855 && ivd
.vd_next
!= 0);
9857 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9859 Elf_External_Verdaux evda
;
9860 Elf_Internal_Verdaux ivda
;
9862 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9864 if (get_data (&evda
, file
,
9865 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9867 _("version def aux")) == NULL
)
9870 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9872 if (ivda
.vda_name
>= string_sec
->sh_size
)
9873 name
= _("*invalid*");
9875 name
= strtab
+ ivda
.vda_name
;
9876 nn
+= printf ("(%s%-*s",
9878 12 - (int) strlen (name
),
9884 printf ("%*c", 18 - nn
, ' ');
9902 printf (_("\nNo version information found in this file.\n"));
9908 get_symbol_binding (unsigned int binding
)
9910 static char buff
[32];
9914 case STB_LOCAL
: return "LOCAL";
9915 case STB_GLOBAL
: return "GLOBAL";
9916 case STB_WEAK
: return "WEAK";
9918 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9919 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9921 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9923 if (binding
== STB_GNU_UNIQUE
9924 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9925 /* GNU is still using the default value 0. */
9926 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9928 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9931 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9937 get_symbol_type (unsigned int type
)
9939 static char buff
[32];
9943 case STT_NOTYPE
: return "NOTYPE";
9944 case STT_OBJECT
: return "OBJECT";
9945 case STT_FUNC
: return "FUNC";
9946 case STT_SECTION
: return "SECTION";
9947 case STT_FILE
: return "FILE";
9948 case STT_COMMON
: return "COMMON";
9949 case STT_TLS
: return "TLS";
9950 case STT_RELC
: return "RELC";
9951 case STT_SRELC
: return "SRELC";
9953 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9955 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9956 return "THUMB_FUNC";
9958 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9961 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9962 return "PARISC_MILLI";
9964 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9966 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9968 if (elf_header
.e_machine
== EM_PARISC
)
9970 if (type
== STT_HP_OPAQUE
)
9972 if (type
== STT_HP_STUB
)
9976 if (type
== STT_GNU_IFUNC
9977 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9978 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9979 /* GNU is still using the default value 0. */
9980 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9983 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9986 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9992 get_symbol_visibility (unsigned int visibility
)
9996 case STV_DEFAULT
: return "DEFAULT";
9997 case STV_INTERNAL
: return "INTERNAL";
9998 case STV_HIDDEN
: return "HIDDEN";
9999 case STV_PROTECTED
: return "PROTECTED";
10001 error (_("Unrecognized visibility value: %u"), visibility
);
10002 return _("<unknown>");
10006 static const char *
10007 get_mips_symbol_other (unsigned int other
)
10017 case STO_MICROMIPS
:
10018 return "MICROMIPS";
10019 case STO_MICROMIPS
| STO_MIPS_PIC
:
10020 return "MICROMIPS, MIPS PIC";
10028 static const char *
10029 get_ia64_symbol_other (unsigned int other
)
10031 if (is_ia64_vms ())
10033 static char res
[32];
10037 /* Function types is for images and .STB files only. */
10038 switch (elf_header
.e_type
)
10042 switch (VMS_ST_FUNC_TYPE (other
))
10044 case VMS_SFT_CODE_ADDR
:
10045 strcat (res
, " CA");
10047 case VMS_SFT_SYMV_IDX
:
10048 strcat (res
, " VEC");
10051 strcat (res
, " FD");
10053 case VMS_SFT_RESERVE
:
10054 strcat (res
, " RSV");
10057 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10058 VMS_ST_FUNC_TYPE (other
));
10059 strcat (res
, " <unknown>");
10066 switch (VMS_ST_LINKAGE (other
))
10068 case VMS_STL_IGNORE
:
10069 strcat (res
, " IGN");
10071 case VMS_STL_RESERVE
:
10072 strcat (res
, " RSV");
10075 strcat (res
, " STD");
10078 strcat (res
, " LNK");
10081 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10082 VMS_ST_LINKAGE (other
));
10083 strcat (res
, " <unknown>");
10095 static const char *
10096 get_ppc64_symbol_other (unsigned int other
)
10098 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10100 static char buf
[32];
10101 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10102 PPC64_LOCAL_ENTRY_OFFSET (other
));
10108 static const char *
10109 get_symbol_other (unsigned int other
)
10111 const char * result
= NULL
;
10112 static char buff
[32];
10117 switch (elf_header
.e_machine
)
10120 result
= get_mips_symbol_other (other
);
10123 result
= get_ia64_symbol_other (other
);
10126 result
= get_ppc64_symbol_other (other
);
10135 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10139 static const char *
10140 get_symbol_index_type (unsigned int type
)
10142 static char buff
[32];
10146 case SHN_UNDEF
: return "UND";
10147 case SHN_ABS
: return "ABS";
10148 case SHN_COMMON
: return "COM";
10150 if (type
== SHN_IA_64_ANSI_COMMON
10151 && elf_header
.e_machine
== EM_IA_64
10152 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10154 else if ((elf_header
.e_machine
== EM_X86_64
10155 || elf_header
.e_machine
== EM_L1OM
10156 || elf_header
.e_machine
== EM_K1OM
)
10157 && type
== SHN_X86_64_LCOMMON
)
10158 return "LARGE_COM";
10159 else if ((type
== SHN_MIPS_SCOMMON
10160 && elf_header
.e_machine
== EM_MIPS
)
10161 || (type
== SHN_TIC6X_SCOMMON
10162 && elf_header
.e_machine
== EM_TI_C6000
))
10164 else if (type
== SHN_MIPS_SUNDEFINED
10165 && elf_header
.e_machine
== EM_MIPS
)
10167 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10168 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10169 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10170 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10171 else if (type
>= SHN_LORESERVE
)
10172 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10173 else if (type
>= elf_header
.e_shnum
)
10174 sprintf (buff
, _("bad section index[%3d]"), type
);
10176 sprintf (buff
, "%3d", type
);
10184 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10186 unsigned char * e_data
;
10189 /* If the size_t type is smaller than the bfd_size_type, eg because
10190 you are building a 32-bit tool on a 64-bit host, then make sure
10191 that when (number) is cast to (size_t) no information is lost. */
10192 if (sizeof (size_t) < sizeof (bfd_size_type
)
10193 && (bfd_size_type
) ((size_t) number
) != number
)
10195 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10196 (unsigned long long) number
, ent_size
);
10200 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10201 attempting to allocate memory when the read is bound to fail. */
10202 if (ent_size
* number
> current_file_size
)
10204 error (_("Invalid number of dynamic entries: %llu\n"),
10205 (unsigned long long) number
);
10209 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10210 if (e_data
== NULL
)
10212 error (_("Out of memory reading %llu dynamic entries\n"),
10213 (unsigned long long) number
);
10217 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10219 error (_("Unable to read in %llu bytes of dynamic data\n"),
10220 (unsigned long long) (number
* ent_size
));
10225 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10226 if (i_data
== NULL
)
10228 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10229 (unsigned long long) number
);
10235 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10243 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10245 Elf_Internal_Sym
* psym
;
10248 n
= print_vma (si
, DEC_5
);
10250 fputs (&" "[n
], stdout
);
10251 printf (" %3lu: ", hn
);
10253 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10255 printf (_("<No info available for dynamic symbol number %lu>\n"),
10256 (unsigned long) si
);
10260 psym
= dynamic_symbols
+ si
;
10261 print_vma (psym
->st_value
, LONG_HEX
);
10263 print_vma (psym
->st_size
, DEC_5
);
10265 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10266 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10267 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10268 /* Check to see if any other bits in the st_other field are set.
10269 Note - displaying this information disrupts the layout of the
10270 table being generated, but for the moment this case is very
10272 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10273 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10274 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10275 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10276 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10278 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10282 static const char *
10283 get_symbol_version_string (FILE *file
, int is_dynsym
,
10284 const char *strtab
,
10285 unsigned long int strtab_size
,
10286 unsigned int si
, Elf_Internal_Sym
*psym
,
10287 enum versioned_symbol_info
*sym_info
,
10288 unsigned short *vna_other
)
10290 const char *version_string
= NULL
;
10293 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10295 unsigned char data
[2];
10296 unsigned short vers_data
;
10297 unsigned long offset
;
10301 offset
= offset_from_vma
10302 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10303 sizeof data
+ si
* sizeof (vers_data
));
10305 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10306 sizeof (data
), 1, _("version data")) == NULL
)
10309 vers_data
= byte_get (data
, 2);
10311 is_nobits
= (section_headers
!= NULL
10312 && psym
->st_shndx
< elf_header
.e_shnum
10313 && section_headers
[psym
->st_shndx
].sh_type
10316 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10318 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10320 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10321 && (is_nobits
|| ! check_def
))
10323 Elf_External_Verneed evn
;
10324 Elf_Internal_Verneed ivn
;
10325 Elf_Internal_Vernaux ivna
;
10327 /* We must test both. */
10328 offset
= offset_from_vma
10329 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10334 unsigned long vna_off
;
10336 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10337 _("version need")) == NULL
)
10340 ivna
.vna_other
= 0;
10345 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10346 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10348 vna_off
= offset
+ ivn
.vn_aux
;
10352 Elf_External_Vernaux evna
;
10354 if (get_data (&evna
, file
, vna_off
,
10356 _("version need aux (3)")) == NULL
)
10359 ivna
.vna_other
= 0;
10364 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10365 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10366 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10369 vna_off
+= ivna
.vna_next
;
10371 while (ivna
.vna_other
!= vers_data
10372 && ivna
.vna_next
!= 0);
10374 if (ivna
.vna_other
== vers_data
)
10377 offset
+= ivn
.vn_next
;
10379 while (ivn
.vn_next
!= 0);
10381 if (ivna
.vna_other
== vers_data
)
10383 *sym_info
= symbol_undefined
;
10384 *vna_other
= ivna
.vna_other
;
10385 version_string
= (ivna
.vna_name
< strtab_size
10386 ? strtab
+ ivna
.vna_name
10390 else if (! is_nobits
)
10391 error (_("bad dynamic symbol\n"));
10398 if (vers_data
!= 0x8001
10399 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10401 Elf_Internal_Verdef ivd
;
10402 Elf_Internal_Verdaux ivda
;
10403 Elf_External_Verdaux evda
;
10406 off
= offset_from_vma
10408 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10409 sizeof (Elf_External_Verdef
));
10413 Elf_External_Verdef evd
;
10415 if (get_data (&evd
, file
, off
, sizeof (evd
),
10416 1, _("version def")) == NULL
)
10424 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10425 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10426 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10429 off
+= ivd
.vd_next
;
10431 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10432 && ivd
.vd_next
!= 0);
10434 off
-= ivd
.vd_next
;
10437 if (get_data (&evda
, file
, off
, sizeof (evda
),
10438 1, _("version def aux")) == NULL
)
10439 return version_string
;
10441 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10443 if (psym
->st_name
!= ivda
.vda_name
)
10445 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10446 ? symbol_hidden
: symbol_public
);
10447 version_string
= (ivda
.vda_name
< strtab_size
10448 ? strtab
+ ivda
.vda_name
10455 return version_string
;
10458 /* Dump the symbol table. */
10460 process_symbol_table (FILE * file
)
10462 Elf_Internal_Shdr
* section
;
10463 bfd_size_type nbuckets
= 0;
10464 bfd_size_type nchains
= 0;
10465 bfd_vma
* buckets
= NULL
;
10466 bfd_vma
* chains
= NULL
;
10467 bfd_vma ngnubuckets
= 0;
10468 bfd_vma
* gnubuckets
= NULL
;
10469 bfd_vma
* gnuchains
= NULL
;
10470 bfd_vma gnusymidx
= 0;
10471 bfd_size_type ngnuchains
= 0;
10473 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10476 if (dynamic_info
[DT_HASH
]
10478 || (do_using_dynamic
10480 && dynamic_strings
!= NULL
)))
10482 unsigned char nb
[8];
10483 unsigned char nc
[8];
10484 unsigned int hash_ent_size
= 4;
10486 if ((elf_header
.e_machine
== EM_ALPHA
10487 || elf_header
.e_machine
== EM_S390
10488 || elf_header
.e_machine
== EM_S390_OLD
)
10489 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10493 (archive_file_offset
10494 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10495 sizeof nb
+ sizeof nc
)),
10498 error (_("Unable to seek to start of dynamic information\n"));
10502 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10504 error (_("Failed to read in number of buckets\n"));
10508 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10510 error (_("Failed to read in number of chains\n"));
10514 nbuckets
= byte_get (nb
, hash_ent_size
);
10515 nchains
= byte_get (nc
, hash_ent_size
);
10517 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10518 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10521 if (buckets
== NULL
|| chains
== NULL
)
10523 if (do_using_dynamic
)
10534 if (dynamic_info_DT_GNU_HASH
10536 || (do_using_dynamic
10538 && dynamic_strings
!= NULL
)))
10540 unsigned char nb
[16];
10541 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10542 bfd_vma buckets_vma
;
10545 (archive_file_offset
10546 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10550 error (_("Unable to seek to start of dynamic information\n"));
10554 if (fread (nb
, 16, 1, file
) != 1)
10556 error (_("Failed to read in number of buckets\n"));
10560 ngnubuckets
= byte_get (nb
, 4);
10561 gnusymidx
= byte_get (nb
+ 4, 4);
10562 bitmaskwords
= byte_get (nb
+ 8, 4);
10563 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10565 buckets_vma
+= bitmaskwords
* 4;
10567 buckets_vma
+= bitmaskwords
* 8;
10570 (archive_file_offset
10571 + offset_from_vma (file
, buckets_vma
, 4)),
10574 error (_("Unable to seek to start of dynamic information\n"));
10578 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10580 if (gnubuckets
== NULL
)
10583 for (i
= 0; i
< ngnubuckets
; i
++)
10584 if (gnubuckets
[i
] != 0)
10586 if (gnubuckets
[i
] < gnusymidx
)
10589 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10590 maxchain
= gnubuckets
[i
];
10593 if (maxchain
== 0xffffffff)
10596 maxchain
-= gnusymidx
;
10599 (archive_file_offset
10600 + offset_from_vma (file
, buckets_vma
10601 + 4 * (ngnubuckets
+ maxchain
), 4)),
10604 error (_("Unable to seek to start of dynamic information\n"));
10610 if (fread (nb
, 4, 1, file
) != 1)
10612 error (_("Failed to determine last chain length\n"));
10616 if (maxchain
+ 1 == 0)
10621 while ((byte_get (nb
, 4) & 1) == 0);
10624 (archive_file_offset
10625 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10628 error (_("Unable to seek to start of dynamic information\n"));
10632 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10633 ngnuchains
= maxchain
;
10636 if (gnuchains
== NULL
)
10641 if (do_using_dynamic
)
10646 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10648 && do_using_dynamic
10649 && dynamic_strings
!= NULL
10650 && dynamic_symbols
!= NULL
)
10654 if (dynamic_info
[DT_HASH
])
10658 printf (_("\nSymbol table for image:\n"));
10660 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10662 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10664 for (hn
= 0; hn
< nbuckets
; hn
++)
10669 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10670 print_dynamic_symbol (si
, hn
);
10674 if (dynamic_info_DT_GNU_HASH
)
10676 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10678 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10680 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10682 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10683 if (gnubuckets
[hn
] != 0)
10685 bfd_vma si
= gnubuckets
[hn
];
10686 bfd_vma off
= si
- gnusymidx
;
10690 print_dynamic_symbol (si
, hn
);
10693 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10697 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10698 && section_headers
!= NULL
)
10702 for (i
= 0, section
= section_headers
;
10703 i
< elf_header
.e_shnum
;
10707 char * strtab
= NULL
;
10708 unsigned long int strtab_size
= 0;
10709 Elf_Internal_Sym
* symtab
;
10710 Elf_Internal_Sym
* psym
;
10711 unsigned long num_syms
;
10713 if ((section
->sh_type
!= SHT_SYMTAB
10714 && section
->sh_type
!= SHT_DYNSYM
)
10716 && section
->sh_type
== SHT_SYMTAB
))
10719 if (section
->sh_entsize
== 0)
10721 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10722 printable_section_name (section
));
10726 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10727 printable_section_name (section
),
10728 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10731 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10733 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10735 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10736 if (symtab
== NULL
)
10739 if (section
->sh_link
== elf_header
.e_shstrndx
)
10741 strtab
= string_table
;
10742 strtab_size
= string_table_length
;
10744 else if (section
->sh_link
< elf_header
.e_shnum
)
10746 Elf_Internal_Shdr
* string_sec
;
10748 string_sec
= section_headers
+ section
->sh_link
;
10750 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10751 1, string_sec
->sh_size
,
10752 _("string table"));
10753 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10756 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10758 const char *version_string
;
10759 enum versioned_symbol_info sym_info
;
10760 unsigned short vna_other
;
10762 printf ("%6d: ", si
);
10763 print_vma (psym
->st_value
, LONG_HEX
);
10765 print_vma (psym
->st_size
, DEC_5
);
10766 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10767 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10768 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10769 /* Check to see if any other bits in the st_other field are set.
10770 Note - displaying this information disrupts the layout of the
10771 table being generated, but for the moment this case is very rare. */
10772 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10773 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10774 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10775 print_symbol (25, psym
->st_name
< strtab_size
10776 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10779 = get_symbol_version_string (file
,
10780 section
->sh_type
== SHT_DYNSYM
,
10781 strtab
, strtab_size
, si
,
10782 psym
, &sym_info
, &vna_other
);
10783 if (version_string
)
10785 if (sym_info
== symbol_undefined
)
10786 printf ("@%s (%d)", version_string
, vna_other
);
10788 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10796 if (strtab
!= string_table
)
10802 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10804 if (do_histogram
&& buckets
!= NULL
)
10806 unsigned long * lengths
;
10807 unsigned long * counts
;
10810 unsigned long maxlength
= 0;
10811 unsigned long nzero_counts
= 0;
10812 unsigned long nsyms
= 0;
10813 unsigned long chained
;
10815 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10816 (unsigned long) nbuckets
);
10818 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10819 if (lengths
== NULL
)
10821 error (_("Out of memory allocating space for histogram buckets\n"));
10825 printf (_(" Length Number %% of total Coverage\n"));
10826 for (hn
= 0; hn
< nbuckets
; ++hn
)
10828 for (si
= buckets
[hn
], chained
= 0;
10829 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
10830 si
= chains
[si
], ++chained
)
10833 if (maxlength
< ++lengths
[hn
])
10837 /* PR binutils/17531: A corrupt binary could contain broken
10838 histogram data. Do not go into an infinite loop trying
10840 if (chained
> nchains
)
10842 error (_("histogram chain is corrupt\n"));
10847 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10848 if (counts
== NULL
)
10851 error (_("Out of memory allocating space for histogram counts\n"));
10855 for (hn
= 0; hn
< nbuckets
; ++hn
)
10856 ++counts
[lengths
[hn
]];
10861 printf (" 0 %-10lu (%5.1f%%)\n",
10862 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10863 for (i
= 1; i
<= maxlength
; ++i
)
10865 nzero_counts
+= counts
[i
] * i
;
10866 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10867 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10868 (nzero_counts
* 100.0) / nsyms
);
10876 if (buckets
!= NULL
)
10882 if (do_histogram
&& gnubuckets
!= NULL
)
10884 unsigned long * lengths
;
10885 unsigned long * counts
;
10887 unsigned long maxlength
= 0;
10888 unsigned long nzero_counts
= 0;
10889 unsigned long nsyms
= 0;
10891 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10892 (unsigned long) ngnubuckets
);
10894 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10895 if (lengths
== NULL
)
10897 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10901 printf (_(" Length Number %% of total Coverage\n"));
10903 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10904 if (gnubuckets
[hn
] != 0)
10906 bfd_vma off
, length
= 1;
10908 for (off
= gnubuckets
[hn
] - gnusymidx
;
10909 /* PR 17531 file: 010-77222-0.004. */
10910 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10913 lengths
[hn
] = length
;
10914 if (length
> maxlength
)
10915 maxlength
= length
;
10919 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10920 if (counts
== NULL
)
10923 error (_("Out of memory allocating space for gnu histogram counts\n"));
10927 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10928 ++counts
[lengths
[hn
]];
10930 if (ngnubuckets
> 0)
10933 printf (" 0 %-10lu (%5.1f%%)\n",
10934 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10935 for (j
= 1; j
<= maxlength
; ++j
)
10937 nzero_counts
+= counts
[j
] * j
;
10938 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10939 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10940 (nzero_counts
* 100.0) / nsyms
);
10954 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10958 if (dynamic_syminfo
== NULL
10960 /* No syminfo, this is ok. */
10963 /* There better should be a dynamic symbol section. */
10964 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10968 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10969 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10971 printf (_(" Num: Name BoundTo Flags\n"));
10972 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10974 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10976 printf ("%4d: ", i
);
10977 if (i
>= num_dynamic_syms
)
10978 printf (_("<corrupt index>"));
10979 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10980 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10982 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10985 switch (dynamic_syminfo
[i
].si_boundto
)
10987 case SYMINFO_BT_SELF
:
10988 fputs ("SELF ", stdout
);
10990 case SYMINFO_BT_PARENT
:
10991 fputs ("PARENT ", stdout
);
10994 if (dynamic_syminfo
[i
].si_boundto
> 0
10995 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10996 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10998 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11002 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11006 if (flags
& SYMINFO_FLG_DIRECT
)
11007 printf (" DIRECT");
11008 if (flags
& SYMINFO_FLG_PASSTHRU
)
11009 printf (" PASSTHRU");
11010 if (flags
& SYMINFO_FLG_COPY
)
11012 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11013 printf (" LAZYLOAD");
11021 /* Check to see if the given reloc needs to be handled in a target specific
11022 manner. If so then process the reloc and return TRUE otherwise return
11026 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11027 unsigned char * start
,
11028 Elf_Internal_Sym
* symtab
)
11030 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11032 switch (elf_header
.e_machine
)
11035 case EM_MSP430_OLD
:
11037 static Elf_Internal_Sym
* saved_sym
= NULL
;
11039 switch (reloc_type
)
11041 case 10: /* R_MSP430_SYM_DIFF */
11042 if (uses_msp430x_relocs ())
11044 case 21: /* R_MSP430X_SYM_DIFF */
11045 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11048 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11049 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11050 goto handle_sym_diff
;
11052 case 5: /* R_MSP430_16_BYTE */
11053 case 9: /* R_MSP430_8 */
11054 if (uses_msp430x_relocs ())
11056 goto handle_sym_diff
;
11058 case 2: /* R_MSP430_ABS16 */
11059 case 15: /* R_MSP430X_ABS16 */
11060 if (! uses_msp430x_relocs ())
11062 goto handle_sym_diff
;
11065 if (saved_sym
!= NULL
)
11069 value
= reloc
->r_addend
11070 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11071 - saved_sym
->st_value
);
11073 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11081 if (saved_sym
!= NULL
)
11082 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11089 case EM_CYGNUS_MN10300
:
11091 static Elf_Internal_Sym
* saved_sym
= NULL
;
11093 switch (reloc_type
)
11095 case 34: /* R_MN10300_ALIGN */
11097 case 33: /* R_MN10300_SYM_DIFF */
11098 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11100 case 1: /* R_MN10300_32 */
11101 case 2: /* R_MN10300_16 */
11102 if (saved_sym
!= NULL
)
11106 value
= reloc
->r_addend
11107 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11108 - saved_sym
->st_value
);
11110 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11117 if (saved_sym
!= NULL
)
11118 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11128 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11129 DWARF debug sections. This is a target specific test. Note - we do not
11130 go through the whole including-target-headers-multiple-times route, (as
11131 we have already done with <elf/h8.h>) because this would become very
11132 messy and even then this function would have to contain target specific
11133 information (the names of the relocs instead of their numeric values).
11134 FIXME: This is not the correct way to solve this problem. The proper way
11135 is to have target specific reloc sizing and typing functions created by
11136 the reloc-macros.h header, in the same way that it already creates the
11137 reloc naming functions. */
11140 is_32bit_abs_reloc (unsigned int reloc_type
)
11142 switch (elf_header
.e_machine
)
11146 return reloc_type
== 1; /* R_386_32. */
11148 return reloc_type
== 1; /* R_68K_32. */
11150 return reloc_type
== 1; /* R_860_32. */
11152 return reloc_type
== 2; /* R_960_32. */
11154 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11156 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11158 return reloc_type
== 1; /* R_ARC_32. */
11160 return reloc_type
== 2; /* R_ARM_ABS32 */
11163 return reloc_type
== 1;
11164 case EM_ADAPTEVA_EPIPHANY
:
11165 return reloc_type
== 3;
11167 return reloc_type
== 0x12; /* R_byte4_data. */
11169 return reloc_type
== 3; /* R_CRIS_32. */
11171 return reloc_type
== 3; /* R_CR16_NUM32. */
11173 return reloc_type
== 15; /* R_CRX_NUM32. */
11174 case EM_CYGNUS_FRV
:
11175 return reloc_type
== 1;
11176 case EM_CYGNUS_D10V
:
11178 return reloc_type
== 6; /* R_D10V_32. */
11179 case EM_CYGNUS_D30V
:
11181 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11183 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11184 case EM_CYGNUS_FR30
:
11186 return reloc_type
== 3; /* R_FR30_32. */
11188 return reloc_type
== 1; /* R_FT32_32. */
11192 return reloc_type
== 1; /* R_H8_DIR32. */
11194 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
11197 return reloc_type
== 2; /* R_IP2K_32. */
11199 return reloc_type
== 2; /* R_IQ2000_32. */
11200 case EM_LATTICEMICO32
:
11201 return reloc_type
== 3; /* R_LM32_32. */
11204 return reloc_type
== 3; /* R_M32C_32. */
11206 return reloc_type
== 34; /* R_M32R_32_RELA. */
11208 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11209 case EM_CYGNUS_MEP
:
11210 return reloc_type
== 4; /* R_MEP_32. */
11212 return reloc_type
== 2; /* R_METAG_ADDR32. */
11213 case EM_MICROBLAZE
:
11214 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11216 return reloc_type
== 2; /* R_MIPS_32. */
11218 return reloc_type
== 4; /* R_MMIX_32. */
11219 case EM_CYGNUS_MN10200
:
11221 return reloc_type
== 1; /* R_MN10200_32. */
11222 case EM_CYGNUS_MN10300
:
11224 return reloc_type
== 1; /* R_MN10300_32. */
11226 return reloc_type
== 1; /* R_MOXIE_32. */
11227 case EM_MSP430_OLD
:
11229 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11231 return reloc_type
== 2; /* R_MT_32. */
11233 return reloc_type
== 20; /* R_NDS32_RELA. */
11234 case EM_ALTERA_NIOS2
:
11235 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11237 return reloc_type
== 1; /* R_NIOS_32. */
11239 return reloc_type
== 1; /* R_OR1K_32. */
11241 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11242 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11245 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11247 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11249 return reloc_type
== 1; /* R_PPC_ADDR32. */
11251 return reloc_type
== 1; /* R_RL78_DIR32. */
11253 return reloc_type
== 1; /* R_RX_DIR32. */
11255 return reloc_type
== 1; /* R_I370_ADDR31. */
11258 return reloc_type
== 4; /* R_S390_32. */
11260 return reloc_type
== 8; /* R_SCORE_ABS32. */
11262 return reloc_type
== 1; /* R_SH_DIR32. */
11263 case EM_SPARC32PLUS
:
11266 return reloc_type
== 3 /* R_SPARC_32. */
11267 || reloc_type
== 23; /* R_SPARC_UA32. */
11269 return reloc_type
== 6; /* R_SPU_ADDR32 */
11271 return reloc_type
== 1; /* R_C6000_ABS32. */
11273 return reloc_type
== 2; /* R_TILEGX_32. */
11275 return reloc_type
== 1; /* R_TILEPRO_32. */
11276 case EM_CYGNUS_V850
:
11278 return reloc_type
== 6; /* R_V850_ABS32. */
11280 return reloc_type
== 0x33; /* R_V810_WORD. */
11282 return reloc_type
== 1; /* R_VAX_32. */
11284 return reloc_type
== 3; /* R_VISIUM_32. */
11288 return reloc_type
== 10; /* R_X86_64_32. */
11291 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11293 return reloc_type
== 4; /* R_XGATE_32. */
11295 return reloc_type
== 1; /* R_XSTROMY16_32. */
11296 case EM_XTENSA_OLD
:
11298 return reloc_type
== 1; /* R_XTENSA_32. */
11301 static unsigned int prev_warn
= 0;
11303 /* Avoid repeating the same warning multiple times. */
11304 if (prev_warn
!= elf_header
.e_machine
)
11305 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11306 elf_header
.e_machine
);
11307 prev_warn
= elf_header
.e_machine
;
11313 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11314 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11317 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11319 switch (elf_header
.e_machine
)
11323 return reloc_type
== 2; /* R_386_PC32. */
11325 return reloc_type
== 4; /* R_68K_PC32. */
11327 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11328 case EM_ADAPTEVA_EPIPHANY
:
11329 return reloc_type
== 6;
11331 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11333 return reloc_type
== 3; /* R_ARM_REL32 */
11334 case EM_MICROBLAZE
:
11335 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11337 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11339 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11341 return reloc_type
== 26; /* R_PPC_REL32. */
11343 return reloc_type
== 26; /* R_PPC64_REL32. */
11346 return reloc_type
== 5; /* R_390_PC32. */
11348 return reloc_type
== 2; /* R_SH_REL32. */
11349 case EM_SPARC32PLUS
:
11352 return reloc_type
== 6; /* R_SPARC_DISP32. */
11354 return reloc_type
== 13; /* R_SPU_REL32. */
11356 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11358 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11360 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11364 return reloc_type
== 2; /* R_X86_64_PC32. */
11365 case EM_XTENSA_OLD
:
11367 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11369 /* Do not abort or issue an error message here. Not all targets use
11370 pc-relative 32-bit relocs in their DWARF debug information and we
11371 have already tested for target coverage in is_32bit_abs_reloc. A
11372 more helpful warning message will be generated by apply_relocations
11373 anyway, so just return. */
11378 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11379 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11382 is_64bit_abs_reloc (unsigned int reloc_type
)
11384 switch (elf_header
.e_machine
)
11387 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11389 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11391 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11393 return reloc_type
== 80; /* R_PARISC_DIR64. */
11395 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11396 case EM_SPARC32PLUS
:
11399 return reloc_type
== 54; /* R_SPARC_UA64. */
11403 return reloc_type
== 1; /* R_X86_64_64. */
11406 return reloc_type
== 22; /* R_S390_64. */
11408 return reloc_type
== 1; /* R_TILEGX_64. */
11410 return reloc_type
== 18; /* R_MIPS_64. */
11416 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11417 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11420 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11422 switch (elf_header
.e_machine
)
11425 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11427 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11429 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11431 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11433 return reloc_type
== 44; /* R_PPC64_REL64. */
11434 case EM_SPARC32PLUS
:
11437 return reloc_type
== 46; /* R_SPARC_DISP64. */
11441 return reloc_type
== 24; /* R_X86_64_PC64. */
11444 return reloc_type
== 23; /* R_S390_PC64. */
11446 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11452 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11453 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11456 is_24bit_abs_reloc (unsigned int reloc_type
)
11458 switch (elf_header
.e_machine
)
11460 case EM_CYGNUS_MN10200
:
11462 return reloc_type
== 4; /* R_MN10200_24. */
11468 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11469 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11472 is_16bit_abs_reloc (unsigned int reloc_type
)
11474 switch (elf_header
.e_machine
)
11478 return reloc_type
== 4; /* R_AVR_16. */
11479 case EM_ADAPTEVA_EPIPHANY
:
11480 return reloc_type
== 5;
11481 case EM_CYGNUS_D10V
:
11483 return reloc_type
== 3; /* R_D10V_16. */
11487 return reloc_type
== R_H8_DIR16
;
11490 return reloc_type
== 1; /* R_IP2K_16. */
11493 return reloc_type
== 1; /* R_M32C_16 */
11495 if (uses_msp430x_relocs ())
11496 return reloc_type
== 2; /* R_MSP430_ABS16. */
11497 case EM_MSP430_OLD
:
11498 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11500 return reloc_type
== 19; /* R_NDS32_RELA. */
11501 case EM_ALTERA_NIOS2
:
11502 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11504 return reloc_type
== 9; /* R_NIOS_16. */
11506 return reloc_type
== 2; /* R_OR1K_16. */
11508 return reloc_type
== 2; /* R_C6000_ABS16. */
11511 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11512 case EM_CYGNUS_MN10200
:
11514 return reloc_type
== 2; /* R_MN10200_16. */
11515 case EM_CYGNUS_MN10300
:
11517 return reloc_type
== 2; /* R_MN10300_16. */
11519 return reloc_type
== 2; /* R_VISIUM_16. */
11521 return reloc_type
== 3; /* R_XGATE_16. */
11527 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11528 relocation entries (possibly formerly used for SHT_GROUP sections). */
11531 is_none_reloc (unsigned int reloc_type
)
11533 switch (elf_header
.e_machine
)
11535 case EM_68K
: /* R_68K_NONE. */
11536 case EM_386
: /* R_386_NONE. */
11537 case EM_SPARC32PLUS
:
11539 case EM_SPARC
: /* R_SPARC_NONE. */
11540 case EM_MIPS
: /* R_MIPS_NONE. */
11541 case EM_PARISC
: /* R_PARISC_NONE. */
11542 case EM_ALPHA
: /* R_ALPHA_NONE. */
11543 case EM_ADAPTEVA_EPIPHANY
:
11544 case EM_PPC
: /* R_PPC_NONE. */
11545 case EM_PPC64
: /* R_PPC64_NONE. */
11546 case EM_ARM
: /* R_ARM_NONE. */
11547 case EM_IA_64
: /* R_IA64_NONE. */
11548 case EM_SH
: /* R_SH_NONE. */
11550 case EM_S390
: /* R_390_NONE. */
11551 case EM_CRIS
: /* R_CRIS_NONE. */
11552 case EM_X86_64
: /* R_X86_64_NONE. */
11553 case EM_L1OM
: /* R_X86_64_NONE. */
11554 case EM_K1OM
: /* R_X86_64_NONE. */
11555 case EM_MN10300
: /* R_MN10300_NONE. */
11556 case EM_FT32
: /* R_FT32_NONE. */
11557 case EM_MOXIE
: /* R_MOXIE_NONE. */
11558 case EM_M32R
: /* R_M32R_NONE. */
11559 case EM_TI_C6000
:/* R_C6000_NONE. */
11560 case EM_TILEGX
: /* R_TILEGX_NONE. */
11561 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11563 case EM_C166
: /* R_XC16X_NONE. */
11564 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11565 case EM_NIOS32
: /* R_NIOS_NONE. */
11566 case EM_OR1K
: /* R_OR1K_NONE. */
11567 return reloc_type
== 0;
11569 return reloc_type
== 0 || reloc_type
== 256;
11571 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11572 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11573 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11574 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11575 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11576 case EM_XTENSA_OLD
:
11578 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11579 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11580 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11581 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11583 return reloc_type
== 3; /* R_METAG_NONE. */
11588 /* Apply relocations to a section.
11589 Note: So far support has been added only for those relocations
11590 which can be found in debug sections.
11591 FIXME: Add support for more relocations ? */
11594 apply_relocations (void * file
,
11595 Elf_Internal_Shdr
* section
,
11596 unsigned char * start
)
11598 Elf_Internal_Shdr
* relsec
;
11599 unsigned char * end
= start
+ section
->sh_size
;
11601 if (elf_header
.e_type
!= ET_REL
)
11604 /* Find the reloc section associated with the section. */
11605 for (relsec
= section_headers
;
11606 relsec
< section_headers
+ elf_header
.e_shnum
;
11609 bfd_boolean is_rela
;
11610 unsigned long num_relocs
;
11611 Elf_Internal_Rela
* relocs
;
11612 Elf_Internal_Rela
* rp
;
11613 Elf_Internal_Shdr
* symsec
;
11614 Elf_Internal_Sym
* symtab
;
11615 unsigned long num_syms
;
11616 Elf_Internal_Sym
* sym
;
11618 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11619 || relsec
->sh_info
>= elf_header
.e_shnum
11620 || section_headers
+ relsec
->sh_info
!= section
11621 || relsec
->sh_size
== 0
11622 || relsec
->sh_link
>= elf_header
.e_shnum
)
11625 is_rela
= relsec
->sh_type
== SHT_RELA
;
11629 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11630 relsec
->sh_size
, & relocs
, & num_relocs
))
11635 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11636 relsec
->sh_size
, & relocs
, & num_relocs
))
11640 /* SH uses RELA but uses in place value instead of the addend field. */
11641 if (elf_header
.e_machine
== EM_SH
)
11644 symsec
= section_headers
+ relsec
->sh_link
;
11645 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11647 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11650 unsigned int reloc_type
;
11651 unsigned int reloc_size
;
11652 unsigned char * rloc
;
11653 unsigned long sym_index
;
11655 reloc_type
= get_reloc_type (rp
->r_info
);
11657 if (target_specific_reloc_handling (rp
, start
, symtab
))
11659 else if (is_none_reloc (reloc_type
))
11661 else if (is_32bit_abs_reloc (reloc_type
)
11662 || is_32bit_pcrel_reloc (reloc_type
))
11664 else if (is_64bit_abs_reloc (reloc_type
)
11665 || is_64bit_pcrel_reloc (reloc_type
))
11667 else if (is_24bit_abs_reloc (reloc_type
))
11669 else if (is_16bit_abs_reloc (reloc_type
))
11673 static unsigned int prev_reloc
= 0;
11674 if (reloc_type
!= prev_reloc
)
11675 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11676 reloc_type
, printable_section_name (section
));
11677 prev_reloc
= reloc_type
;
11681 rloc
= start
+ rp
->r_offset
;
11682 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11684 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11685 (unsigned long) rp
->r_offset
,
11686 printable_section_name (section
));
11690 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11691 if (sym_index
>= num_syms
)
11693 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11694 sym_index
, printable_section_name (section
));
11697 sym
= symtab
+ sym_index
;
11699 /* If the reloc has a symbol associated with it,
11700 make sure that it is of an appropriate type.
11702 Relocations against symbols without type can happen.
11703 Gcc -feliminate-dwarf2-dups may generate symbols
11704 without type for debug info.
11706 Icc generates relocations against function symbols
11707 instead of local labels.
11709 Relocations against object symbols can happen, eg when
11710 referencing a global array. For an example of this see
11711 the _clz.o binary in libgcc.a. */
11713 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11715 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11716 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11717 (long int)(rp
- relocs
),
11718 printable_section_name (relsec
));
11724 addend
+= rp
->r_addend
;
11725 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11726 partial_inplace. */
11728 || (elf_header
.e_machine
== EM_XTENSA
11729 && reloc_type
== 1)
11730 || ((elf_header
.e_machine
== EM_PJ
11731 || elf_header
.e_machine
== EM_PJ_OLD
)
11732 && reloc_type
== 1)
11733 || ((elf_header
.e_machine
== EM_D30V
11734 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11735 && reloc_type
== 12))
11736 addend
+= byte_get (rloc
, reloc_size
);
11738 if (is_32bit_pcrel_reloc (reloc_type
)
11739 || is_64bit_pcrel_reloc (reloc_type
))
11741 /* On HPPA, all pc-relative relocations are biased by 8. */
11742 if (elf_header
.e_machine
== EM_PARISC
)
11744 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11748 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11757 #ifdef SUPPORT_DISASSEMBLY
11759 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11761 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11763 /* FIXME: XXX -- to be done --- XXX */
11769 /* Reads in the contents of SECTION from FILE, returning a pointer
11770 to a malloc'ed buffer or NULL if something went wrong. */
11773 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11775 bfd_size_type num_bytes
;
11777 num_bytes
= section
->sh_size
;
11779 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11781 printf (_("\nSection '%s' has no data to dump.\n"),
11782 printable_section_name (section
));
11786 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11787 _("section contents"));
11792 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11794 Elf_Internal_Shdr
* relsec
;
11795 bfd_size_type num_bytes
;
11799 bfd_boolean some_strings_shown
;
11801 start
= get_section_contents (section
, file
);
11805 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11807 /* If the section being dumped has relocations against it the user might
11808 be expecting these relocations to have been applied. Check for this
11809 case and issue a warning message in order to avoid confusion.
11810 FIXME: Maybe we ought to have an option that dumps a section with
11811 relocs applied ? */
11812 for (relsec
= section_headers
;
11813 relsec
< section_headers
+ elf_header
.e_shnum
;
11816 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11817 || relsec
->sh_info
>= elf_header
.e_shnum
11818 || section_headers
+ relsec
->sh_info
!= section
11819 || relsec
->sh_size
== 0
11820 || relsec
->sh_link
>= elf_header
.e_shnum
)
11823 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11827 num_bytes
= section
->sh_size
;
11829 end
= start
+ num_bytes
;
11830 some_strings_shown
= FALSE
;
11834 while (!ISPRINT (* data
))
11835 if (++ data
>= end
)
11840 size_t maxlen
= end
- data
;
11843 /* PR 11128: Use two separate invocations in order to work
11844 around bugs in the Solaris 8 implementation of printf. */
11845 printf (" [%6tx] ", data
- start
);
11847 printf (" [%6Ix] ", (size_t) (data
- start
));
11851 print_symbol ((int) maxlen
, data
);
11853 data
+= strnlen (data
, maxlen
);
11857 printf (_("<corrupt>\n"));
11860 some_strings_shown
= TRUE
;
11864 if (! some_strings_shown
)
11865 printf (_(" No strings found in this section."));
11873 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11875 bfd_boolean relocate
)
11877 Elf_Internal_Shdr
* relsec
;
11878 bfd_size_type bytes
;
11880 unsigned char * data
;
11881 unsigned char * start
;
11883 start
= (unsigned char *) get_section_contents (section
, file
);
11887 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11891 apply_relocations (file
, section
, start
);
11895 /* If the section being dumped has relocations against it the user might
11896 be expecting these relocations to have been applied. Check for this
11897 case and issue a warning message in order to avoid confusion.
11898 FIXME: Maybe we ought to have an option that dumps a section with
11899 relocs applied ? */
11900 for (relsec
= section_headers
;
11901 relsec
< section_headers
+ elf_header
.e_shnum
;
11904 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11905 || relsec
->sh_info
>= elf_header
.e_shnum
11906 || section_headers
+ relsec
->sh_info
!= section
11907 || relsec
->sh_size
== 0
11908 || relsec
->sh_link
>= elf_header
.e_shnum
)
11911 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11916 addr
= section
->sh_addr
;
11917 bytes
= section
->sh_size
;
11926 lbytes
= (bytes
> 16 ? 16 : bytes
);
11928 printf (" 0x%8.8lx ", (unsigned long) addr
);
11930 for (j
= 0; j
< 16; j
++)
11933 printf ("%2.2x", data
[j
]);
11941 for (j
= 0; j
< lbytes
; j
++)
11944 if (k
>= ' ' && k
< 0x7f)
11962 /* Uncompresses a section that was compressed using zlib, in place. */
11965 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11966 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11968 #ifndef HAVE_ZLIB_H
11971 dwarf_size_type compressed_size
= *size
;
11972 unsigned char * compressed_buffer
= *buffer
;
11973 dwarf_size_type uncompressed_size
;
11974 unsigned char * uncompressed_buffer
;
11977 dwarf_size_type header_size
= 12;
11979 /* Read the zlib header. In this case, it should be "ZLIB" followed
11980 by the uncompressed section size, 8 bytes in big-endian order. */
11981 if (compressed_size
< header_size
11982 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11985 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11986 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11987 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11988 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11989 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11990 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11991 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11992 uncompressed_size
+= compressed_buffer
[11];
11994 /* It is possible the section consists of several compressed
11995 buffers concatenated together, so we uncompress in a loop. */
11996 strm
.zalloc
= NULL
;
11998 strm
.opaque
= NULL
;
11999 strm
.avail_in
= compressed_size
- header_size
;
12000 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
12001 strm
.avail_out
= uncompressed_size
;
12002 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12004 rc
= inflateInit (& strm
);
12005 while (strm
.avail_in
> 0)
12009 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12010 + (uncompressed_size
- strm
.avail_out
));
12011 rc
= inflate (&strm
, Z_FINISH
);
12012 if (rc
!= Z_STREAM_END
)
12014 rc
= inflateReset (& strm
);
12016 rc
= inflateEnd (& strm
);
12018 || strm
.avail_out
!= 0)
12021 free (compressed_buffer
);
12022 *buffer
= uncompressed_buffer
;
12023 *size
= uncompressed_size
;
12027 free (uncompressed_buffer
);
12028 /* Indicate decompression failure. */
12031 #endif /* HAVE_ZLIB_H */
12035 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12036 Elf_Internal_Shdr
* sec
, void * file
)
12038 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12041 /* If it is already loaded, do nothing. */
12042 if (section
->start
!= NULL
)
12045 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12046 section
->address
= sec
->sh_addr
;
12047 section
->user_data
= NULL
;
12048 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12050 sec
->sh_size
, buf
);
12051 if (section
->start
== NULL
)
12055 section
->size
= sec
->sh_size
;
12056 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
12057 sec
->sh_size
= section
->size
;
12060 if (section
->start
== NULL
)
12063 if (debug_displays
[debug
].relocate
)
12064 apply_relocations ((FILE *) file
, sec
, section
->start
);
12069 /* If this is not NULL, load_debug_section will only look for sections
12070 within the list of sections given here. */
12071 unsigned int *section_subset
= NULL
;
12074 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12076 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12077 Elf_Internal_Shdr
* sec
;
12079 /* Locate the debug section. */
12080 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12082 section
->name
= section
->uncompressed_name
;
12085 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12087 section
->name
= section
->compressed_name
;
12092 /* If we're loading from a subset of sections, and we've loaded
12093 a section matching this name before, it's likely that it's a
12095 if (section_subset
!= NULL
)
12096 free_debug_section (debug
);
12098 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12102 free_debug_section (enum dwarf_section_display_enum debug
)
12104 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12106 if (section
->start
== NULL
)
12109 free ((char *) section
->start
);
12110 section
->start
= NULL
;
12111 section
->address
= 0;
12116 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12118 char * name
= SECTION_NAME (section
);
12119 const char * print_name
= printable_section_name (section
);
12120 bfd_size_type length
;
12124 length
= section
->sh_size
;
12127 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12130 if (section
->sh_type
== SHT_NOBITS
)
12132 /* There is no point in dumping the contents of a debugging section
12133 which has the NOBITS type - the bits in the file will be random.
12134 This can happen when a file containing a .eh_frame section is
12135 stripped with the --only-keep-debug command line option. */
12136 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12141 if (const_strneq (name
, ".gnu.linkonce.wi."))
12142 name
= ".debug_info";
12144 /* See if we know how to display the contents of this section. */
12145 for (i
= 0; i
< max
; i
++)
12146 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12147 || (i
== line
&& const_strneq (name
, ".debug_line."))
12148 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12150 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12151 int secondary
= (section
!= find_section (name
));
12154 free_debug_section ((enum dwarf_section_display_enum
) i
);
12156 if (i
== line
&& const_strneq (name
, ".debug_line."))
12158 else if (streq (sec
->uncompressed_name
, name
))
12159 sec
->name
= sec
->uncompressed_name
;
12161 sec
->name
= sec
->compressed_name
;
12162 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12165 /* If this debug section is part of a CU/TU set in a .dwp file,
12166 restrict load_debug_section to the sections in that set. */
12167 section_subset
= find_cu_tu_set (file
, shndx
);
12169 result
&= debug_displays
[i
].display (sec
, file
);
12171 section_subset
= NULL
;
12173 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12174 free_debug_section ((enum dwarf_section_display_enum
) i
);
12182 printf (_("Unrecognized debug section: %s\n"), print_name
);
12189 /* Set DUMP_SECTS for all sections where dumps were requested
12190 based on section name. */
12193 initialise_dumps_byname (void)
12195 struct dump_list_entry
* cur
;
12197 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12202 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12203 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12205 request_dump_bynumber (i
, cur
->type
);
12210 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12216 process_section_contents (FILE * file
)
12218 Elf_Internal_Shdr
* section
;
12224 initialise_dumps_byname ();
12226 for (i
= 0, section
= section_headers
;
12227 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12230 #ifdef SUPPORT_DISASSEMBLY
12231 if (dump_sects
[i
] & DISASS_DUMP
)
12232 disassemble_section (section
, file
);
12234 if (dump_sects
[i
] & HEX_DUMP
)
12235 dump_section_as_bytes (section
, file
, FALSE
);
12237 if (dump_sects
[i
] & RELOC_DUMP
)
12238 dump_section_as_bytes (section
, file
, TRUE
);
12240 if (dump_sects
[i
] & STRING_DUMP
)
12241 dump_section_as_strings (section
, file
);
12243 if (dump_sects
[i
] & DEBUG_DUMP
)
12244 display_debug_section (i
, section
, file
);
12247 /* Check to see if the user requested a
12248 dump of a section that does not exist. */
12249 while (i
++ < num_dump_sects
)
12251 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12255 process_mips_fpe_exception (int mask
)
12260 if (mask
& OEX_FPU_INEX
)
12261 fputs ("INEX", stdout
), first
= 0;
12262 if (mask
& OEX_FPU_UFLO
)
12263 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12264 if (mask
& OEX_FPU_OFLO
)
12265 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12266 if (mask
& OEX_FPU_DIV0
)
12267 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12268 if (mask
& OEX_FPU_INVAL
)
12269 printf ("%sINVAL", first
? "" : "|");
12272 fputs ("0", stdout
);
12275 /* Display's the value of TAG at location P. If TAG is
12276 greater than 0 it is assumed to be an unknown tag, and
12277 a message is printed to this effect. Otherwise it is
12278 assumed that a message has already been printed.
12280 If the bottom bit of TAG is set it assumed to have a
12281 string value, otherwise it is assumed to have an integer
12284 Returns an updated P pointing to the first unread byte
12285 beyond the end of TAG's value.
12287 Reads at or beyond END will not be made. */
12289 static unsigned char *
12290 display_tag_value (int tag
,
12292 const unsigned char * const end
)
12297 printf (" Tag_unknown_%d: ", tag
);
12301 warn (_("<corrupt tag>\n"));
12305 /* PR 17531 file: 027-19978-0.004. */
12306 size_t maxlen
= (end
- p
) - 1;
12311 print_symbol ((int) maxlen
, (const char *) p
);
12312 p
+= strnlen ((char *) p
, maxlen
) + 1;
12316 printf (_("<corrupt string tag>"));
12317 p
= (unsigned char *) end
;
12325 val
= read_uleb128 (p
, &len
, end
);
12327 printf ("%ld (0x%lx)\n", val
, val
);
12334 /* ARM EABI attributes section. */
12339 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12341 const char ** table
;
12342 } arm_attr_public_tag
;
12344 static const char * arm_attr_tag_CPU_arch
[] =
12345 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12346 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12347 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12348 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12349 {"No", "Thumb-1", "Thumb-2"};
12350 static const char * arm_attr_tag_FP_arch
[] =
12351 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12352 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12353 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12354 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12355 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12356 static const char * arm_attr_tag_PCS_config
[] =
12357 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12358 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12359 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12360 {"V6", "SB", "TLS", "Unused"};
12361 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12362 {"Absolute", "PC-relative", "SB-relative", "None"};
12363 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12364 {"Absolute", "PC-relative", "None"};
12365 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12366 {"None", "direct", "GOT-indirect"};
12367 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12368 {"None", "??? 1", "2", "??? 3", "4"};
12369 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12370 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12371 {"Unused", "Needed", "Sign only"};
12372 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12373 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12374 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12375 {"Unused", "Finite", "RTABI", "IEEE 754"};
12376 static const char * arm_attr_tag_ABI_enum_size
[] =
12377 {"Unused", "small", "int", "forced to int"};
12378 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12379 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12380 static const char * arm_attr_tag_ABI_VFP_args
[] =
12381 {"AAPCS", "VFP registers", "custom", "compatible"};
12382 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12383 {"AAPCS", "WMMX registers", "custom"};
12384 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12385 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12386 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12387 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12388 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12389 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12390 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12391 static const char * arm_attr_tag_FP_HP_extension
[] =
12392 {"Not Allowed", "Allowed"};
12393 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12394 {"None", "IEEE 754", "Alternative Format"};
12395 static const char * arm_attr_tag_MPextension_use
[] =
12396 {"Not Allowed", "Allowed"};
12397 static const char * arm_attr_tag_DIV_use
[] =
12398 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12399 "Allowed in v7-A with integer division extension"};
12400 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12401 static const char * arm_attr_tag_Virtualization_use
[] =
12402 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12403 "TrustZone and Virtualization Extensions"};
12404 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12405 {"Not Allowed", "Allowed"};
12407 #define LOOKUP(id, name) \
12408 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12409 static arm_attr_public_tag arm_attr_public_tags
[] =
12411 {4, "CPU_raw_name", 1, NULL
},
12412 {5, "CPU_name", 1, NULL
},
12413 LOOKUP(6, CPU_arch
),
12414 {7, "CPU_arch_profile", 0, NULL
},
12415 LOOKUP(8, ARM_ISA_use
),
12416 LOOKUP(9, THUMB_ISA_use
),
12417 LOOKUP(10, FP_arch
),
12418 LOOKUP(11, WMMX_arch
),
12419 LOOKUP(12, Advanced_SIMD_arch
),
12420 LOOKUP(13, PCS_config
),
12421 LOOKUP(14, ABI_PCS_R9_use
),
12422 LOOKUP(15, ABI_PCS_RW_data
),
12423 LOOKUP(16, ABI_PCS_RO_data
),
12424 LOOKUP(17, ABI_PCS_GOT_use
),
12425 LOOKUP(18, ABI_PCS_wchar_t
),
12426 LOOKUP(19, ABI_FP_rounding
),
12427 LOOKUP(20, ABI_FP_denormal
),
12428 LOOKUP(21, ABI_FP_exceptions
),
12429 LOOKUP(22, ABI_FP_user_exceptions
),
12430 LOOKUP(23, ABI_FP_number_model
),
12431 {24, "ABI_align_needed", 0, NULL
},
12432 {25, "ABI_align_preserved", 0, NULL
},
12433 LOOKUP(26, ABI_enum_size
),
12434 LOOKUP(27, ABI_HardFP_use
),
12435 LOOKUP(28, ABI_VFP_args
),
12436 LOOKUP(29, ABI_WMMX_args
),
12437 LOOKUP(30, ABI_optimization_goals
),
12438 LOOKUP(31, ABI_FP_optimization_goals
),
12439 {32, "compatibility", 0, NULL
},
12440 LOOKUP(34, CPU_unaligned_access
),
12441 LOOKUP(36, FP_HP_extension
),
12442 LOOKUP(38, ABI_FP_16bit_format
),
12443 LOOKUP(42, MPextension_use
),
12444 LOOKUP(44, DIV_use
),
12445 {64, "nodefaults", 0, NULL
},
12446 {65, "also_compatible_with", 0, NULL
},
12447 LOOKUP(66, T2EE_use
),
12448 {67, "conformance", 1, NULL
},
12449 LOOKUP(68, Virtualization_use
),
12450 LOOKUP(70, MPextension_use_legacy
)
12454 static unsigned char *
12455 display_arm_attribute (unsigned char * p
,
12456 const unsigned char * const end
)
12461 arm_attr_public_tag
* attr
;
12465 tag
= read_uleb128 (p
, &len
, end
);
12468 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12470 if (arm_attr_public_tags
[i
].tag
== tag
)
12472 attr
= &arm_attr_public_tags
[i
];
12479 printf (" Tag_%s: ", attr
->name
);
12480 switch (attr
->type
)
12485 case 7: /* Tag_CPU_arch_profile. */
12486 val
= read_uleb128 (p
, &len
, end
);
12490 case 0: printf (_("None\n")); break;
12491 case 'A': printf (_("Application\n")); break;
12492 case 'R': printf (_("Realtime\n")); break;
12493 case 'M': printf (_("Microcontroller\n")); break;
12494 case 'S': printf (_("Application or Realtime\n")); break;
12495 default: printf ("??? (%d)\n", val
); break;
12499 case 24: /* Tag_align_needed. */
12500 val
= read_uleb128 (p
, &len
, end
);
12504 case 0: printf (_("None\n")); break;
12505 case 1: printf (_("8-byte\n")); break;
12506 case 2: printf (_("4-byte\n")); break;
12507 case 3: printf ("??? 3\n"); break;
12510 printf (_("8-byte and up to %d-byte extended\n"),
12513 printf ("??? (%d)\n", val
);
12518 case 25: /* Tag_align_preserved. */
12519 val
= read_uleb128 (p
, &len
, end
);
12523 case 0: printf (_("None\n")); break;
12524 case 1: printf (_("8-byte, except leaf SP\n")); break;
12525 case 2: printf (_("8-byte\n")); break;
12526 case 3: printf ("??? 3\n"); break;
12529 printf (_("8-byte and up to %d-byte extended\n"),
12532 printf ("??? (%d)\n", val
);
12537 case 32: /* Tag_compatibility. */
12539 val
= read_uleb128 (p
, &len
, end
);
12541 printf (_("flag = %d, vendor = "), val
);
12544 size_t maxlen
= (end
- p
) - 1;
12546 print_symbol ((int) maxlen
, (const char *) p
);
12547 p
+= strnlen ((char *) p
, maxlen
) + 1;
12551 printf (_("<corrupt>"));
12552 p
= (unsigned char *) end
;
12558 case 64: /* Tag_nodefaults. */
12559 /* PR 17531: file: 001-505008-0.01. */
12562 printf (_("True\n"));
12565 case 65: /* Tag_also_compatible_with. */
12566 val
= read_uleb128 (p
, &len
, end
);
12568 if (val
== 6 /* Tag_CPU_arch. */)
12570 val
= read_uleb128 (p
, &len
, end
);
12572 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12573 printf ("??? (%d)\n", val
);
12575 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12579 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12584 printf (_("<unknown: %d>\n"), tag
);
12590 return display_tag_value (-1, p
, end
);
12592 return display_tag_value (0, p
, end
);
12595 assert (attr
->type
& 0x80);
12596 val
= read_uleb128 (p
, &len
, end
);
12598 type
= attr
->type
& 0x7f;
12600 printf ("??? (%d)\n", val
);
12602 printf ("%s\n", attr
->table
[val
]);
12607 return display_tag_value (tag
, p
, end
);
12610 static unsigned char *
12611 display_gnu_attribute (unsigned char * p
,
12612 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12613 const unsigned char * const end
)
12619 tag
= read_uleb128 (p
, &len
, end
);
12622 /* Tag_compatibility is the only generic GNU attribute defined at
12626 val
= read_uleb128 (p
, &len
, end
);
12629 printf (_("flag = %d, vendor = "), val
);
12632 printf (_("<corrupt>\n"));
12633 warn (_("corrupt vendor attribute\n"));
12639 size_t maxlen
= (end
- p
) - 1;
12641 print_symbol ((int) maxlen
, (const char *) p
);
12642 p
+= strnlen ((char *) p
, maxlen
) + 1;
12646 printf (_("<corrupt>"));
12647 p
= (unsigned char *) end
;
12654 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12655 return display_proc_gnu_attribute (p
, tag
, end
);
12657 return display_tag_value (tag
, p
, end
);
12660 static unsigned char *
12661 display_power_gnu_attribute (unsigned char * p
,
12663 const unsigned char * const end
)
12668 if (tag
== Tag_GNU_Power_ABI_FP
)
12670 val
= read_uleb128 (p
, &len
, end
);
12672 printf (" Tag_GNU_Power_ABI_FP: ");
12677 printf (_("Hard or soft float\n"));
12680 printf (_("Hard float\n"));
12683 printf (_("Soft float\n"));
12686 printf (_("Single-precision hard float\n"));
12689 printf ("??? (%d)\n", val
);
12695 if (tag
== Tag_GNU_Power_ABI_Vector
)
12697 val
= read_uleb128 (p
, &len
, end
);
12699 printf (" Tag_GNU_Power_ABI_Vector: ");
12703 printf (_("Any\n"));
12706 printf (_("Generic\n"));
12709 printf ("AltiVec\n");
12715 printf ("??? (%d)\n", val
);
12721 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12725 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12729 val
= read_uleb128 (p
, &len
, end
);
12731 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12735 printf (_("Any\n"));
12738 printf ("r3/r4\n");
12741 printf (_("Memory\n"));
12744 printf ("??? (%d)\n", val
);
12750 return display_tag_value (tag
& 1, p
, end
);
12754 display_sparc_hwcaps (int mask
)
12760 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12761 fputs ("mul32", stdout
), first
= 0;
12762 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12763 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12764 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12765 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12766 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12767 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12768 if (mask
& ELF_SPARC_HWCAP_POPC
)
12769 printf ("%spopc", first
? "" : "|"), first
= 0;
12770 if (mask
& ELF_SPARC_HWCAP_VIS
)
12771 printf ("%svis", first
? "" : "|"), first
= 0;
12772 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12773 printf ("%svis2", first
? "" : "|"), first
= 0;
12774 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12775 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12776 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12777 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12778 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12779 printf ("%svis3", first
? "" : "|"), first
= 0;
12780 if (mask
& ELF_SPARC_HWCAP_HPC
)
12781 printf ("%shpc", first
? "" : "|"), first
= 0;
12782 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12783 printf ("%srandom", first
? "" : "|"), first
= 0;
12784 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12785 printf ("%strans", first
? "" : "|"), first
= 0;
12786 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12787 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12788 if (mask
& ELF_SPARC_HWCAP_IMA
)
12789 printf ("%sima", first
? "" : "|"), first
= 0;
12790 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12791 printf ("%scspare", first
? "" : "|"), first
= 0;
12794 fputc ('0', stdout
);
12795 fputc ('\n', stdout
);
12799 display_sparc_hwcaps2 (int mask
)
12805 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12806 fputs ("fjathplus", stdout
), first
= 0;
12807 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12808 printf ("%svis3b", first
? "" : "|"), first
= 0;
12809 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12810 printf ("%sadp", first
? "" : "|"), first
= 0;
12811 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12812 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12813 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12814 printf ("%smwait", first
? "" : "|"), first
= 0;
12815 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12816 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12817 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12818 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12819 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12820 printf ("%snsec", first
? "" : "|"), first
= 0;
12821 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12822 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12823 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12824 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12825 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12826 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12829 fputc ('0', stdout
);
12830 fputc ('\n', stdout
);
12833 static unsigned char *
12834 display_sparc_gnu_attribute (unsigned char * p
,
12836 const unsigned char * const end
)
12841 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12843 val
= read_uleb128 (p
, &len
, end
);
12845 printf (" Tag_GNU_Sparc_HWCAPS: ");
12846 display_sparc_hwcaps (val
);
12849 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12851 val
= read_uleb128 (p
, &len
, end
);
12853 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12854 display_sparc_hwcaps2 (val
);
12858 return display_tag_value (tag
, p
, end
);
12862 print_mips_fp_abi_value (int val
)
12866 case Val_GNU_MIPS_ABI_FP_ANY
:
12867 printf (_("Hard or soft float\n"));
12869 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12870 printf (_("Hard float (double precision)\n"));
12872 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12873 printf (_("Hard float (single precision)\n"));
12875 case Val_GNU_MIPS_ABI_FP_SOFT
:
12876 printf (_("Soft float\n"));
12878 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12879 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12881 case Val_GNU_MIPS_ABI_FP_XX
:
12882 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12884 case Val_GNU_MIPS_ABI_FP_64
:
12885 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12887 case Val_GNU_MIPS_ABI_FP_64A
:
12888 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12891 printf ("??? (%d)\n", val
);
12896 static unsigned char *
12897 display_mips_gnu_attribute (unsigned char * p
,
12899 const unsigned char * const end
)
12901 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12906 val
= read_uleb128 (p
, &len
, end
);
12908 printf (" Tag_GNU_MIPS_ABI_FP: ");
12910 print_mips_fp_abi_value (val
);
12915 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12920 val
= read_uleb128 (p
, &len
, end
);
12922 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12926 case Val_GNU_MIPS_ABI_MSA_ANY
:
12927 printf (_("Any MSA or not\n"));
12929 case Val_GNU_MIPS_ABI_MSA_128
:
12930 printf (_("128-bit MSA\n"));
12933 printf ("??? (%d)\n", val
);
12939 return display_tag_value (tag
& 1, p
, end
);
12942 static unsigned char *
12943 display_tic6x_attribute (unsigned char * p
,
12944 const unsigned char * const end
)
12950 tag
= read_uleb128 (p
, &len
, end
);
12956 val
= read_uleb128 (p
, &len
, end
);
12958 printf (" Tag_ISA: ");
12962 case C6XABI_Tag_ISA_none
:
12963 printf (_("None\n"));
12965 case C6XABI_Tag_ISA_C62X
:
12968 case C6XABI_Tag_ISA_C67X
:
12971 case C6XABI_Tag_ISA_C67XP
:
12972 printf ("C67x+\n");
12974 case C6XABI_Tag_ISA_C64X
:
12977 case C6XABI_Tag_ISA_C64XP
:
12978 printf ("C64x+\n");
12980 case C6XABI_Tag_ISA_C674X
:
12981 printf ("C674x\n");
12984 printf ("??? (%d)\n", val
);
12989 case Tag_ABI_wchar_t
:
12990 val
= read_uleb128 (p
, &len
, end
);
12992 printf (" Tag_ABI_wchar_t: ");
12996 printf (_("Not used\n"));
12999 printf (_("2 bytes\n"));
13002 printf (_("4 bytes\n"));
13005 printf ("??? (%d)\n", val
);
13010 case Tag_ABI_stack_align_needed
:
13011 val
= read_uleb128 (p
, &len
, end
);
13013 printf (" Tag_ABI_stack_align_needed: ");
13017 printf (_("8-byte\n"));
13020 printf (_("16-byte\n"));
13023 printf ("??? (%d)\n", val
);
13028 case Tag_ABI_stack_align_preserved
:
13029 val
= read_uleb128 (p
, &len
, end
);
13031 printf (" Tag_ABI_stack_align_preserved: ");
13035 printf (_("8-byte\n"));
13038 printf (_("16-byte\n"));
13041 printf ("??? (%d)\n", val
);
13047 val
= read_uleb128 (p
, &len
, end
);
13049 printf (" Tag_ABI_DSBT: ");
13053 printf (_("DSBT addressing not used\n"));
13056 printf (_("DSBT addressing used\n"));
13059 printf ("??? (%d)\n", val
);
13065 val
= read_uleb128 (p
, &len
, end
);
13067 printf (" Tag_ABI_PID: ");
13071 printf (_("Data addressing position-dependent\n"));
13074 printf (_("Data addressing position-independent, GOT near DP\n"));
13077 printf (_("Data addressing position-independent, GOT far from DP\n"));
13080 printf ("??? (%d)\n", val
);
13086 val
= read_uleb128 (p
, &len
, end
);
13088 printf (" Tag_ABI_PIC: ");
13092 printf (_("Code addressing position-dependent\n"));
13095 printf (_("Code addressing position-independent\n"));
13098 printf ("??? (%d)\n", val
);
13103 case Tag_ABI_array_object_alignment
:
13104 val
= read_uleb128 (p
, &len
, end
);
13106 printf (" Tag_ABI_array_object_alignment: ");
13110 printf (_("8-byte\n"));
13113 printf (_("4-byte\n"));
13116 printf (_("16-byte\n"));
13119 printf ("??? (%d)\n", val
);
13124 case Tag_ABI_array_object_align_expected
:
13125 val
= read_uleb128 (p
, &len
, end
);
13127 printf (" Tag_ABI_array_object_align_expected: ");
13131 printf (_("8-byte\n"));
13134 printf (_("4-byte\n"));
13137 printf (_("16-byte\n"));
13140 printf ("??? (%d)\n", val
);
13145 case Tag_ABI_compatibility
:
13147 val
= read_uleb128 (p
, &len
, end
);
13149 printf (" Tag_ABI_compatibility: ");
13150 printf (_("flag = %d, vendor = "), val
);
13153 size_t maxlen
= (end
- p
) - 1;
13155 print_symbol ((int) maxlen
, (const char *) p
);
13156 p
+= strnlen ((char *) p
, maxlen
) + 1;
13160 printf (_("<corrupt>"));
13161 p
= (unsigned char *) end
;
13167 case Tag_ABI_conformance
:
13169 printf (" Tag_ABI_conformance: \"");
13172 size_t maxlen
= (end
- p
) - 1;
13174 print_symbol ((int) maxlen
, (const char *) p
);
13175 p
+= strnlen ((char *) p
, maxlen
) + 1;
13179 printf (_("<corrupt>"));
13180 p
= (unsigned char *) end
;
13187 return display_tag_value (tag
, p
, end
);
13191 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13193 unsigned long addr
= 0;
13194 size_t bytes
= end
- p
;
13201 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13203 printf (" 0x%8.8lx ", addr
);
13205 for (j
= 0; j
< 16; j
++)
13208 printf ("%2.2x", p
[j
]);
13216 for (j
= 0; j
< lbytes
; j
++)
13219 if (k
>= ' ' && k
< 0x7f)
13235 static unsigned char *
13236 display_msp430x_attribute (unsigned char * p
,
13237 const unsigned char * const end
)
13243 tag
= read_uleb128 (p
, & len
, end
);
13248 case OFBA_MSPABI_Tag_ISA
:
13249 val
= read_uleb128 (p
, &len
, end
);
13251 printf (" Tag_ISA: ");
13254 case 0: printf (_("None\n")); break;
13255 case 1: printf (_("MSP430\n")); break;
13256 case 2: printf (_("MSP430X\n")); break;
13257 default: printf ("??? (%d)\n", val
); break;
13261 case OFBA_MSPABI_Tag_Code_Model
:
13262 val
= read_uleb128 (p
, &len
, end
);
13264 printf (" Tag_Code_Model: ");
13267 case 0: printf (_("None\n")); break;
13268 case 1: printf (_("Small\n")); break;
13269 case 2: printf (_("Large\n")); break;
13270 default: printf ("??? (%d)\n", val
); break;
13274 case OFBA_MSPABI_Tag_Data_Model
:
13275 val
= read_uleb128 (p
, &len
, end
);
13277 printf (" Tag_Data_Model: ");
13280 case 0: printf (_("None\n")); break;
13281 case 1: printf (_("Small\n")); break;
13282 case 2: printf (_("Large\n")); break;
13283 case 3: printf (_("Restricted Large\n")); break;
13284 default: printf ("??? (%d)\n", val
); break;
13289 printf (_(" <unknown tag %d>: "), tag
);
13296 size_t maxlen
= (end
- p
) - 1;
13298 print_symbol ((int) maxlen
, (const char *) p
);
13299 p
+= strnlen ((char *) p
, maxlen
) + 1;
13303 printf (_("<corrupt>"));
13304 p
= (unsigned char *) end
;
13310 val
= read_uleb128 (p
, &len
, end
);
13312 printf ("%d (0x%x)\n", val
, val
);
13322 process_attributes (FILE * file
,
13323 const char * public_name
,
13324 unsigned int proc_type
,
13325 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13326 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13328 Elf_Internal_Shdr
* sect
;
13331 /* Find the section header so that we get the size. */
13332 for (i
= 0, sect
= section_headers
;
13333 i
< elf_header
.e_shnum
;
13336 unsigned char * contents
;
13339 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13342 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13343 sect
->sh_size
, _("attributes"));
13344 if (contents
== NULL
)
13350 bfd_vma section_len
;
13352 section_len
= sect
->sh_size
- 1;
13355 while (section_len
> 0)
13358 unsigned int namelen
;
13359 bfd_boolean public_section
;
13360 bfd_boolean gnu_section
;
13362 if (section_len
<= 4)
13364 error (_("Tag section ends prematurely\n"));
13367 attr_len
= byte_get (p
, 4);
13370 if (attr_len
> section_len
)
13372 error (_("Bad attribute length (%u > %u)\n"),
13373 (unsigned) attr_len
, (unsigned) section_len
);
13374 attr_len
= section_len
;
13376 /* PR 17531: file: 001-101425-0.004 */
13377 else if (attr_len
< 5)
13379 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13383 section_len
-= attr_len
;
13386 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13387 if (namelen
== 0 || namelen
>= attr_len
)
13389 error (_("Corrupt attribute section name\n"));
13393 printf (_("Attribute Section: "));
13394 print_symbol (INT_MAX
, (const char *) p
);
13397 if (public_name
&& streq ((char *) p
, public_name
))
13398 public_section
= TRUE
;
13400 public_section
= FALSE
;
13402 if (streq ((char *) p
, "gnu"))
13403 gnu_section
= TRUE
;
13405 gnu_section
= FALSE
;
13408 attr_len
-= namelen
;
13410 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13415 unsigned char * end
;
13417 /* PR binutils/17531: Safe handling of corrupt files. */
13420 error (_("Unused bytes at end of section\n"));
13426 size
= byte_get (p
, 4);
13427 if (size
> attr_len
)
13429 error (_("Bad subsection length (%u > %u)\n"),
13430 (unsigned) size
, (unsigned) attr_len
);
13433 /* PR binutils/17531: Safe handling of corrupt files. */
13436 error (_("Bad subsection length (%u < 6)\n"),
13443 end
= p
+ size
- 1;
13444 assert (end
<= contents
+ sect
->sh_size
);
13450 printf (_("File Attributes\n"));
13453 printf (_("Section Attributes:"));
13456 printf (_("Symbol Attributes:"));
13462 val
= read_uleb128 (p
, &j
, end
);
13466 printf (" %d", val
);
13471 printf (_("Unknown tag: %d\n"), tag
);
13472 public_section
= FALSE
;
13476 if (public_section
&& display_pub_attribute
!= NULL
)
13479 p
= display_pub_attribute (p
, end
);
13482 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13485 p
= display_gnu_attribute (p
,
13486 display_proc_gnu_attribute
,
13492 printf (_(" Unknown attribute:\n"));
13493 display_raw_attribute (p
, end
);
13502 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13510 process_arm_specific (FILE * file
)
13512 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13513 display_arm_attribute
, NULL
);
13517 process_power_specific (FILE * file
)
13519 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13520 display_power_gnu_attribute
);
13524 process_sparc_specific (FILE * file
)
13526 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13527 display_sparc_gnu_attribute
);
13531 process_tic6x_specific (FILE * file
)
13533 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13534 display_tic6x_attribute
, NULL
);
13538 process_msp430x_specific (FILE * file
)
13540 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13541 display_msp430x_attribute
, NULL
);
13544 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13545 Print the Address, Access and Initial fields of an entry at VMA ADDR
13546 and return the VMA of the next entry, or -1 if there was a problem.
13547 Does not read from DATA_END or beyond. */
13550 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13551 unsigned char * data_end
)
13554 print_vma (addr
, LONG_HEX
);
13556 if (addr
< pltgot
+ 0xfff0)
13557 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13559 printf ("%10s", "");
13562 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13566 unsigned char * from
= data
+ addr
- pltgot
;
13568 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
13570 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13571 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
13572 return (bfd_vma
) -1;
13576 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13577 print_vma (entry
, LONG_HEX
);
13580 return addr
+ (is_32bit_elf
? 4 : 8);
13583 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13584 PLTGOT. Print the Address and Initial fields of an entry at VMA
13585 ADDR and return the VMA of the next entry. */
13588 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13591 print_vma (addr
, LONG_HEX
);
13594 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13599 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13600 print_vma (entry
, LONG_HEX
);
13602 return addr
+ (is_32bit_elf
? 4 : 8);
13606 print_mips_ases (unsigned int mask
)
13608 if (mask
& AFL_ASE_DSP
)
13609 fputs ("\n\tDSP ASE", stdout
);
13610 if (mask
& AFL_ASE_DSPR2
)
13611 fputs ("\n\tDSP R2 ASE", stdout
);
13612 if (mask
& AFL_ASE_EVA
)
13613 fputs ("\n\tEnhanced VA Scheme", stdout
);
13614 if (mask
& AFL_ASE_MCU
)
13615 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13616 if (mask
& AFL_ASE_MDMX
)
13617 fputs ("\n\tMDMX ASE", stdout
);
13618 if (mask
& AFL_ASE_MIPS3D
)
13619 fputs ("\n\tMIPS-3D ASE", stdout
);
13620 if (mask
& AFL_ASE_MT
)
13621 fputs ("\n\tMT ASE", stdout
);
13622 if (mask
& AFL_ASE_SMARTMIPS
)
13623 fputs ("\n\tSmartMIPS ASE", stdout
);
13624 if (mask
& AFL_ASE_VIRT
)
13625 fputs ("\n\tVZ ASE", stdout
);
13626 if (mask
& AFL_ASE_MSA
)
13627 fputs ("\n\tMSA ASE", stdout
);
13628 if (mask
& AFL_ASE_MIPS16
)
13629 fputs ("\n\tMIPS16 ASE", stdout
);
13630 if (mask
& AFL_ASE_MICROMIPS
)
13631 fputs ("\n\tMICROMIPS ASE", stdout
);
13632 if (mask
& AFL_ASE_XPA
)
13633 fputs ("\n\tXPA ASE", stdout
);
13635 fprintf (stdout
, "\n\t%s", _("None"));
13636 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13637 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13641 print_mips_isa_ext (unsigned int isa_ext
)
13646 fputs (_("None"), stdout
);
13649 fputs ("RMI XLR", stdout
);
13651 case AFL_EXT_OCTEON3
:
13652 fputs ("Cavium Networks Octeon3", stdout
);
13654 case AFL_EXT_OCTEON2
:
13655 fputs ("Cavium Networks Octeon2", stdout
);
13657 case AFL_EXT_OCTEONP
:
13658 fputs ("Cavium Networks OcteonP", stdout
);
13660 case AFL_EXT_LOONGSON_3A
:
13661 fputs ("Loongson 3A", stdout
);
13663 case AFL_EXT_OCTEON
:
13664 fputs ("Cavium Networks Octeon", stdout
);
13667 fputs ("Toshiba R5900", stdout
);
13670 fputs ("MIPS R4650", stdout
);
13673 fputs ("LSI R4010", stdout
);
13676 fputs ("NEC VR4100", stdout
);
13679 fputs ("Toshiba R3900", stdout
);
13681 case AFL_EXT_10000
:
13682 fputs ("MIPS R10000", stdout
);
13685 fputs ("Broadcom SB-1", stdout
);
13688 fputs ("NEC VR4111/VR4181", stdout
);
13691 fputs ("NEC VR4120", stdout
);
13694 fputs ("NEC VR5400", stdout
);
13697 fputs ("NEC VR5500", stdout
);
13699 case AFL_EXT_LOONGSON_2E
:
13700 fputs ("ST Microelectronics Loongson 2E", stdout
);
13702 case AFL_EXT_LOONGSON_2F
:
13703 fputs ("ST Microelectronics Loongson 2F", stdout
);
13706 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13711 get_mips_reg_size (int reg_size
)
13713 return (reg_size
== AFL_REG_NONE
) ? 0
13714 : (reg_size
== AFL_REG_32
) ? 32
13715 : (reg_size
== AFL_REG_64
) ? 64
13716 : (reg_size
== AFL_REG_128
) ? 128
13721 process_mips_specific (FILE * file
)
13723 Elf_Internal_Dyn
* entry
;
13724 Elf_Internal_Shdr
*sect
= NULL
;
13725 size_t liblist_offset
= 0;
13726 size_t liblistno
= 0;
13727 size_t conflictsno
= 0;
13728 size_t options_offset
= 0;
13729 size_t conflicts_offset
= 0;
13730 size_t pltrelsz
= 0;
13732 bfd_vma pltgot
= 0;
13733 bfd_vma mips_pltgot
= 0;
13734 bfd_vma jmprel
= 0;
13735 bfd_vma local_gotno
= 0;
13736 bfd_vma gotsym
= 0;
13737 bfd_vma symtabno
= 0;
13739 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13740 display_mips_gnu_attribute
);
13742 sect
= find_section (".MIPS.abiflags");
13746 Elf_External_ABIFlags_v0
*abiflags_ext
;
13747 Elf_Internal_ABIFlags_v0 abiflags_in
;
13749 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13750 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13753 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13754 sect
->sh_size
, _("MIPS ABI Flags section"));
13757 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13758 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13759 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13760 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13761 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13762 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13763 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13764 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13765 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13766 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13767 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13769 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13770 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13771 if (abiflags_in
.isa_rev
> 1)
13772 printf ("r%d", abiflags_in
.isa_rev
);
13773 printf ("\nGPR size: %d",
13774 get_mips_reg_size (abiflags_in
.gpr_size
));
13775 printf ("\nCPR1 size: %d",
13776 get_mips_reg_size (abiflags_in
.cpr1_size
));
13777 printf ("\nCPR2 size: %d",
13778 get_mips_reg_size (abiflags_in
.cpr2_size
));
13779 fputs ("\nFP ABI: ", stdout
);
13780 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13781 fputs ("ISA Extension: ", stdout
);
13782 print_mips_isa_ext (abiflags_in
.isa_ext
);
13783 fputs ("\nASEs:", stdout
);
13784 print_mips_ases (abiflags_in
.ases
);
13785 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13786 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13787 fputc ('\n', stdout
);
13788 free (abiflags_ext
);
13793 /* We have a lot of special sections. Thanks SGI! */
13794 if (dynamic_section
== NULL
)
13795 /* No information available. */
13798 for (entry
= dynamic_section
;
13799 /* PR 17531 file: 012-50589-0.004. */
13800 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
13802 switch (entry
->d_tag
)
13804 case DT_MIPS_LIBLIST
:
13806 = offset_from_vma (file
, entry
->d_un
.d_val
,
13807 liblistno
* sizeof (Elf32_External_Lib
));
13809 case DT_MIPS_LIBLISTNO
:
13810 liblistno
= entry
->d_un
.d_val
;
13812 case DT_MIPS_OPTIONS
:
13813 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13815 case DT_MIPS_CONFLICT
:
13817 = offset_from_vma (file
, entry
->d_un
.d_val
,
13818 conflictsno
* sizeof (Elf32_External_Conflict
));
13820 case DT_MIPS_CONFLICTNO
:
13821 conflictsno
= entry
->d_un
.d_val
;
13824 pltgot
= entry
->d_un
.d_ptr
;
13826 case DT_MIPS_LOCAL_GOTNO
:
13827 local_gotno
= entry
->d_un
.d_val
;
13829 case DT_MIPS_GOTSYM
:
13830 gotsym
= entry
->d_un
.d_val
;
13832 case DT_MIPS_SYMTABNO
:
13833 symtabno
= entry
->d_un
.d_val
;
13835 case DT_MIPS_PLTGOT
:
13836 mips_pltgot
= entry
->d_un
.d_ptr
;
13839 pltrel
= entry
->d_un
.d_val
;
13842 pltrelsz
= entry
->d_un
.d_val
;
13845 jmprel
= entry
->d_un
.d_ptr
;
13851 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13853 Elf32_External_Lib
* elib
;
13856 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13858 sizeof (Elf32_External_Lib
),
13859 _("liblist section data"));
13862 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13863 (unsigned long) liblistno
);
13864 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13867 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13874 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13875 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13876 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13877 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13878 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13880 tmp
= gmtime (&atime
);
13881 snprintf (timebuf
, sizeof (timebuf
),
13882 "%04u-%02u-%02uT%02u:%02u:%02u",
13883 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13884 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13886 printf ("%3lu: ", (unsigned long) cnt
);
13887 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13888 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13890 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13891 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13892 liblist
.l_version
);
13894 if (liblist
.l_flags
== 0)
13898 static const struct
13905 { " EXACT_MATCH", LL_EXACT_MATCH
},
13906 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13907 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13908 { " EXPORTS", LL_EXPORTS
},
13909 { " DELAY_LOAD", LL_DELAY_LOAD
},
13910 { " DELTA", LL_DELTA
}
13912 int flags
= liblist
.l_flags
;
13915 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13916 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13918 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13919 flags
^= l_flags_vals
[fcnt
].bit
;
13922 printf (" %#x", (unsigned int) flags
);
13932 if (options_offset
!= 0)
13934 Elf_External_Options
* eopt
;
13935 Elf_Internal_Options
* iopt
;
13936 Elf_Internal_Options
* option
;
13939 sect
= section_headers
;
13941 /* Find the section header so that we get the size. */
13942 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
13943 /* PR 17533 file: 012-277276-0.004. */
13946 error (_("No MIPS_OPTIONS header found\n"));
13950 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13951 sect
->sh_size
, _("options"));
13954 iopt
= (Elf_Internal_Options
*)
13955 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13958 error (_("Out of memory allocatinf space for MIPS options\n"));
13965 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
13967 Elf_External_Options
* eoption
;
13969 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13971 option
->kind
= BYTE_GET (eoption
->kind
);
13972 option
->size
= BYTE_GET (eoption
->size
);
13973 option
->section
= BYTE_GET (eoption
->section
);
13974 option
->info
= BYTE_GET (eoption
->info
);
13976 /* PR 17531: file: ffa0fa3b. */
13977 if (option
->size
< sizeof (* eopt
)
13978 || offset
+ option
->size
> sect
->sh_size
)
13980 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
13983 offset
+= option
->size
;
13989 printf (_("\nSection '%s' contains %d entries:\n"),
13990 printable_section_name (sect
), cnt
);
13999 switch (option
->kind
)
14002 /* This shouldn't happen. */
14003 printf (" NULL %d %lx", option
->section
, option
->info
);
14006 printf (" REGINFO ");
14007 if (elf_header
.e_machine
== EM_MIPS
)
14010 Elf32_External_RegInfo
* ereg
;
14011 Elf32_RegInfo reginfo
;
14013 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14014 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14015 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14016 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14017 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14018 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14019 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14021 printf ("GPR %08lx GP 0x%lx\n",
14022 reginfo
.ri_gprmask
,
14023 (unsigned long) reginfo
.ri_gp_value
);
14024 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14025 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14026 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14031 Elf64_External_RegInfo
* ereg
;
14032 Elf64_Internal_RegInfo reginfo
;
14034 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14035 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14036 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14037 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14038 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14039 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14040 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14042 printf ("GPR %08lx GP 0x",
14043 reginfo
.ri_gprmask
);
14044 printf_vma (reginfo
.ri_gp_value
);
14047 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14048 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14049 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14053 case ODK_EXCEPTIONS
:
14054 fputs (" EXCEPTIONS fpe_min(", stdout
);
14055 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14056 fputs (") fpe_max(", stdout
);
14057 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14058 fputs (")", stdout
);
14060 if (option
->info
& OEX_PAGE0
)
14061 fputs (" PAGE0", stdout
);
14062 if (option
->info
& OEX_SMM
)
14063 fputs (" SMM", stdout
);
14064 if (option
->info
& OEX_FPDBUG
)
14065 fputs (" FPDBUG", stdout
);
14066 if (option
->info
& OEX_DISMISS
)
14067 fputs (" DISMISS", stdout
);
14070 fputs (" PAD ", stdout
);
14071 if (option
->info
& OPAD_PREFIX
)
14072 fputs (" PREFIX", stdout
);
14073 if (option
->info
& OPAD_POSTFIX
)
14074 fputs (" POSTFIX", stdout
);
14075 if (option
->info
& OPAD_SYMBOL
)
14076 fputs (" SYMBOL", stdout
);
14079 fputs (" HWPATCH ", stdout
);
14080 if (option
->info
& OHW_R4KEOP
)
14081 fputs (" R4KEOP", stdout
);
14082 if (option
->info
& OHW_R8KPFETCH
)
14083 fputs (" R8KPFETCH", stdout
);
14084 if (option
->info
& OHW_R5KEOP
)
14085 fputs (" R5KEOP", stdout
);
14086 if (option
->info
& OHW_R5KCVTL
)
14087 fputs (" R5KCVTL", stdout
);
14090 fputs (" FILL ", stdout
);
14091 /* XXX Print content of info word? */
14094 fputs (" TAGS ", stdout
);
14095 /* XXX Print content of info word? */
14098 fputs (" HWAND ", stdout
);
14099 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14100 fputs (" R4KEOP_CHECKED", stdout
);
14101 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14102 fputs (" R4KEOP_CLEAN", stdout
);
14105 fputs (" HWOR ", stdout
);
14106 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14107 fputs (" R4KEOP_CHECKED", stdout
);
14108 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14109 fputs (" R4KEOP_CLEAN", stdout
);
14112 printf (" GP_GROUP %#06lx self-contained %#06lx",
14113 option
->info
& OGP_GROUP
,
14114 (option
->info
& OGP_SELF
) >> 16);
14117 printf (" IDENT %#06lx self-contained %#06lx",
14118 option
->info
& OGP_GROUP
,
14119 (option
->info
& OGP_SELF
) >> 16);
14122 /* This shouldn't happen. */
14123 printf (" %3d ??? %d %lx",
14124 option
->kind
, option
->section
, option
->info
);
14128 len
= sizeof (* eopt
);
14129 while (len
< option
->size
)
14131 char datum
= * ((char *) eopt
+ offset
+ len
);
14133 if (ISPRINT (datum
))
14134 printf ("%c", datum
);
14136 printf ("\\%03o", datum
);
14139 fputs ("\n", stdout
);
14141 offset
+= option
->size
;
14149 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14151 Elf32_Conflict
* iconf
;
14154 if (dynamic_symbols
== NULL
)
14156 error (_("conflict list found without a dynamic symbol table\n"));
14160 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14163 error (_("Out of memory allocating space for dynamic conflicts\n"));
14169 Elf32_External_Conflict
* econf32
;
14171 econf32
= (Elf32_External_Conflict
*)
14172 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14173 sizeof (* econf32
), _("conflict"));
14177 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14178 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14184 Elf64_External_Conflict
* econf64
;
14186 econf64
= (Elf64_External_Conflict
*)
14187 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14188 sizeof (* econf64
), _("conflict"));
14192 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14193 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14198 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14199 (unsigned long) conflictsno
);
14200 puts (_(" Num: Index Value Name"));
14202 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14204 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14206 if (iconf
[cnt
] >= num_dynamic_syms
)
14207 printf (_("<corrupt symbol index>"));
14210 Elf_Internal_Sym
* psym
;
14212 psym
= & dynamic_symbols
[iconf
[cnt
]];
14213 print_vma (psym
->st_value
, FULL_HEX
);
14215 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14216 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14218 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14226 if (pltgot
!= 0 && local_gotno
!= 0)
14228 bfd_vma ent
, local_end
, global_end
;
14230 unsigned char * data
;
14231 unsigned char * data_end
;
14235 addr_size
= (is_32bit_elf
? 4 : 8);
14236 local_end
= pltgot
+ local_gotno
* addr_size
;
14238 /* PR binutils/17533 file: 012-111227-0.004 */
14239 if (symtabno
< gotsym
)
14241 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14242 (unsigned long) gotsym
, (unsigned long) symtabno
);
14246 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14247 /* PR 17531: file: 54c91a34. */
14248 if (global_end
< local_end
)
14250 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14254 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14255 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14256 global_end
- pltgot
, 1,
14257 _("Global Offset Table data"));
14260 data_end
= data
+ (global_end
- pltgot
);
14262 printf (_("\nPrimary GOT:\n"));
14263 printf (_(" Canonical gp value: "));
14264 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14267 printf (_(" Reserved entries:\n"));
14268 printf (_(" %*s %10s %*s Purpose\n"),
14269 addr_size
* 2, _("Address"), _("Access"),
14270 addr_size
* 2, _("Initial"));
14271 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14272 printf (_(" Lazy resolver\n"));
14273 if (ent
== (bfd_vma
) -1)
14274 goto got_print_fail
;
14276 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14277 >> (addr_size
* 8 - 1)) != 0)
14279 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14280 printf (_(" Module pointer (GNU extension)\n"));
14281 if (ent
== (bfd_vma
) -1)
14282 goto got_print_fail
;
14286 if (ent
< local_end
)
14288 printf (_(" Local entries:\n"));
14289 printf (" %*s %10s %*s\n",
14290 addr_size
* 2, _("Address"), _("Access"),
14291 addr_size
* 2, _("Initial"));
14292 while (ent
< local_end
)
14294 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14296 if (ent
== (bfd_vma
) -1)
14297 goto got_print_fail
;
14302 if (gotsym
< symtabno
)
14306 printf (_(" Global entries:\n"));
14307 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14308 addr_size
* 2, _("Address"),
14310 addr_size
* 2, _("Initial"),
14311 addr_size
* 2, _("Sym.Val."),
14313 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14314 _("Ndx"), _("Name"));
14316 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14318 for (i
= gotsym
; i
< symtabno
; i
++)
14320 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14323 if (dynamic_symbols
== NULL
)
14324 printf (_("<no dynamic symbols>"));
14325 else if (i
< num_dynamic_syms
)
14327 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14329 print_vma (psym
->st_value
, LONG_HEX
);
14330 printf (" %-7s %3s ",
14331 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14332 get_symbol_index_type (psym
->st_shndx
));
14334 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14335 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14337 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14340 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14341 (unsigned long) i
);
14344 if (ent
== (bfd_vma
) -1)
14355 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14358 size_t offset
, rel_offset
;
14359 unsigned long count
, i
;
14360 unsigned char * data
;
14361 int addr_size
, sym_width
;
14362 Elf_Internal_Rela
* rels
;
14364 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14365 if (pltrel
== DT_RELA
)
14367 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14372 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14377 addr_size
= (is_32bit_elf
? 4 : 8);
14378 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14380 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14381 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14382 1, _("Procedure Linkage Table data"));
14386 printf ("\nPLT GOT:\n\n");
14387 printf (_(" Reserved entries:\n"));
14388 printf (_(" %*s %*s Purpose\n"),
14389 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14390 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14391 printf (_(" PLT lazy resolver\n"));
14392 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14393 printf (_(" Module pointer\n"));
14396 printf (_(" Entries:\n"));
14397 printf (" %*s %*s %*s %-7s %3s %s\n",
14398 addr_size
* 2, _("Address"),
14399 addr_size
* 2, _("Initial"),
14400 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14401 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14402 for (i
= 0; i
< count
; i
++)
14404 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14406 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14409 if (idx
>= num_dynamic_syms
)
14410 printf (_("<corrupt symbol index: %lu>"), idx
);
14413 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14415 print_vma (psym
->st_value
, LONG_HEX
);
14416 printf (" %-7s %3s ",
14417 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14418 get_symbol_index_type (psym
->st_shndx
));
14419 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14420 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14422 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14437 process_nds32_specific (FILE * file
)
14439 Elf_Internal_Shdr
*sect
= NULL
;
14441 sect
= find_section (".nds32_e_flags");
14444 unsigned int *flag
;
14446 printf ("\nNDS32 elf flags section:\n");
14447 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14448 sect
->sh_size
, _("NDS32 elf flags section"));
14450 switch ((*flag
) & 0x3)
14453 printf ("(VEC_SIZE):\tNo entry.\n");
14456 printf ("(VEC_SIZE):\t4 bytes\n");
14459 printf ("(VEC_SIZE):\t16 bytes\n");
14462 printf ("(VEC_SIZE):\treserved\n");
14471 process_gnu_liblist (FILE * file
)
14473 Elf_Internal_Shdr
* section
;
14474 Elf_Internal_Shdr
* string_sec
;
14475 Elf32_External_Lib
* elib
;
14477 size_t strtab_size
;
14484 for (i
= 0, section
= section_headers
;
14485 i
< elf_header
.e_shnum
;
14488 switch (section
->sh_type
)
14490 case SHT_GNU_LIBLIST
:
14491 if (section
->sh_link
>= elf_header
.e_shnum
)
14494 elib
= (Elf32_External_Lib
*)
14495 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14496 _("liblist section data"));
14500 string_sec
= section_headers
+ section
->sh_link
;
14502 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14503 string_sec
->sh_size
,
14504 _("liblist string table"));
14506 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14512 strtab_size
= string_sec
->sh_size
;
14514 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14515 printable_section_name (section
),
14516 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14518 puts (_(" Library Time Stamp Checksum Version Flags"));
14520 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14528 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14529 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14530 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14531 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14532 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14534 tmp
= gmtime (&atime
);
14535 snprintf (timebuf
, sizeof (timebuf
),
14536 "%04u-%02u-%02uT%02u:%02u:%02u",
14537 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14538 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14540 printf ("%3lu: ", (unsigned long) cnt
);
14542 printf ("%-20s", liblist
.l_name
< strtab_size
14543 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14545 printf ("%-20.20s", liblist
.l_name
< strtab_size
14546 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14547 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14548 liblist
.l_version
, liblist
.l_flags
);
14559 static const char *
14560 get_note_type (unsigned e_type
)
14562 static char buff
[64];
14564 if (elf_header
.e_type
== ET_CORE
)
14568 return _("NT_AUXV (auxiliary vector)");
14570 return _("NT_PRSTATUS (prstatus structure)");
14572 return _("NT_FPREGSET (floating point registers)");
14574 return _("NT_PRPSINFO (prpsinfo structure)");
14575 case NT_TASKSTRUCT
:
14576 return _("NT_TASKSTRUCT (task structure)");
14578 return _("NT_PRXFPREG (user_xfpregs structure)");
14580 return _("NT_PPC_VMX (ppc Altivec registers)");
14582 return _("NT_PPC_VSX (ppc VSX registers)");
14584 return _("NT_386_TLS (x86 TLS information)");
14585 case NT_386_IOPERM
:
14586 return _("NT_386_IOPERM (x86 I/O permissions)");
14587 case NT_X86_XSTATE
:
14588 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14589 case NT_S390_HIGH_GPRS
:
14590 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14591 case NT_S390_TIMER
:
14592 return _("NT_S390_TIMER (s390 timer register)");
14593 case NT_S390_TODCMP
:
14594 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14595 case NT_S390_TODPREG
:
14596 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14598 return _("NT_S390_CTRS (s390 control registers)");
14599 case NT_S390_PREFIX
:
14600 return _("NT_S390_PREFIX (s390 prefix register)");
14601 case NT_S390_LAST_BREAK
:
14602 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14603 case NT_S390_SYSTEM_CALL
:
14604 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14606 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14607 case NT_S390_VXRS_LOW
:
14608 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14609 case NT_S390_VXRS_HIGH
:
14610 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14612 return _("NT_ARM_VFP (arm VFP registers)");
14614 return _("NT_ARM_TLS (AArch TLS registers)");
14615 case NT_ARM_HW_BREAK
:
14616 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14617 case NT_ARM_HW_WATCH
:
14618 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14620 return _("NT_PSTATUS (pstatus structure)");
14622 return _("NT_FPREGS (floating point registers)");
14624 return _("NT_PSINFO (psinfo structure)");
14626 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14628 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14629 case NT_WIN32PSTATUS
:
14630 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14632 return _("NT_SIGINFO (siginfo_t data)");
14634 return _("NT_FILE (mapped files)");
14642 return _("NT_VERSION (version)");
14644 return _("NT_ARCH (architecture)");
14649 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14654 print_core_note (Elf_Internal_Note
*pnote
)
14656 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14657 bfd_vma count
, page_size
;
14658 unsigned char *descdata
, *filenames
, *descend
;
14660 if (pnote
->type
!= NT_FILE
)
14666 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14667 /* Still "successful". */
14672 if (pnote
->descsz
< 2 * addr_size
)
14674 printf (_(" Malformed note - too short for header\n"));
14678 descdata
= (unsigned char *) pnote
->descdata
;
14679 descend
= descdata
+ pnote
->descsz
;
14681 if (descdata
[pnote
->descsz
- 1] != '\0')
14683 printf (_(" Malformed note - does not end with \\0\n"));
14687 count
= byte_get (descdata
, addr_size
);
14688 descdata
+= addr_size
;
14690 page_size
= byte_get (descdata
, addr_size
);
14691 descdata
+= addr_size
;
14693 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
14695 printf (_(" Malformed note - too short for supplied file count\n"));
14699 printf (_(" Page size: "));
14700 print_vma (page_size
, DEC
);
14703 printf (_(" %*s%*s%*s\n"),
14704 (int) (2 + 2 * addr_size
), _("Start"),
14705 (int) (4 + 2 * addr_size
), _("End"),
14706 (int) (4 + 2 * addr_size
), _("Page Offset"));
14707 filenames
= descdata
+ count
* 3 * addr_size
;
14708 while (--count
> 0)
14710 bfd_vma start
, end
, file_ofs
;
14712 if (filenames
== descend
)
14714 printf (_(" Malformed note - filenames end too early\n"));
14718 start
= byte_get (descdata
, addr_size
);
14719 descdata
+= addr_size
;
14720 end
= byte_get (descdata
, addr_size
);
14721 descdata
+= addr_size
;
14722 file_ofs
= byte_get (descdata
, addr_size
);
14723 descdata
+= addr_size
;
14726 print_vma (start
, FULL_HEX
);
14728 print_vma (end
, FULL_HEX
);
14730 print_vma (file_ofs
, FULL_HEX
);
14731 printf ("\n %s\n", filenames
);
14733 filenames
+= 1 + strlen ((char *) filenames
);
14739 static const char *
14740 get_gnu_elf_note_type (unsigned e_type
)
14742 static char buff
[64];
14746 case NT_GNU_ABI_TAG
:
14747 return _("NT_GNU_ABI_TAG (ABI version tag)");
14749 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14750 case NT_GNU_BUILD_ID
:
14751 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14752 case NT_GNU_GOLD_VERSION
:
14753 return _("NT_GNU_GOLD_VERSION (gold version)");
14758 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14763 print_gnu_note (Elf_Internal_Note
*pnote
)
14765 switch (pnote
->type
)
14767 case NT_GNU_BUILD_ID
:
14771 printf (_(" Build ID: "));
14772 for (i
= 0; i
< pnote
->descsz
; ++i
)
14773 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14778 case NT_GNU_ABI_TAG
:
14780 unsigned long os
, major
, minor
, subminor
;
14781 const char *osname
;
14783 /* PR 17531: file: 030-599401-0.004. */
14784 if (pnote
->descsz
< 16)
14786 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14790 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14791 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14792 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14793 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14797 case GNU_ABI_TAG_LINUX
:
14800 case GNU_ABI_TAG_HURD
:
14803 case GNU_ABI_TAG_SOLARIS
:
14804 osname
= "Solaris";
14806 case GNU_ABI_TAG_FREEBSD
:
14807 osname
= "FreeBSD";
14809 case GNU_ABI_TAG_NETBSD
:
14813 osname
= "Unknown";
14817 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14818 major
, minor
, subminor
);
14822 case NT_GNU_GOLD_VERSION
:
14826 printf (_(" Version: "));
14827 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14828 printf ("%c", pnote
->descdata
[i
]);
14837 static const char *
14838 get_v850_elf_note_type (enum v850_notes n_type
)
14840 static char buff
[64];
14844 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
14845 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
14846 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
14847 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
14848 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
14849 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
14851 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
14857 print_v850_note (Elf_Internal_Note
* pnote
)
14861 if (pnote
->descsz
!= 4)
14863 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
14867 printf (_("not set\n"));
14871 switch (pnote
->type
)
14873 case V850_NOTE_ALIGNMENT
:
14876 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
14877 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
14881 case V850_NOTE_DATA_SIZE
:
14884 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
14885 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
14889 case V850_NOTE_FPU_INFO
:
14892 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
14893 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
14897 case V850_NOTE_MMU_INFO
:
14898 case V850_NOTE_CACHE_INFO
:
14899 case V850_NOTE_SIMD_INFO
:
14900 if (val
== EF_RH850_SIMD
)
14902 printf (_("yes\n"));
14908 /* An 'unknown note type' message will already have been displayed. */
14912 printf (_("unknown value: %x\n"), val
);
14916 static const char *
14917 get_netbsd_elfcore_note_type (unsigned e_type
)
14919 static char buff
[64];
14921 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14923 /* NetBSD core "procinfo" structure. */
14924 return _("NetBSD procinfo structure");
14927 /* As of Jan 2002 there are no other machine-independent notes
14928 defined for NetBSD core files. If the note type is less
14929 than the start of the machine-dependent note types, we don't
14932 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14934 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14938 switch (elf_header
.e_machine
)
14940 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14941 and PT_GETFPREGS == mach+2. */
14946 case EM_SPARC32PLUS
:
14950 case NT_NETBSDCORE_FIRSTMACH
+ 0:
14951 return _("PT_GETREGS (reg structure)");
14952 case NT_NETBSDCORE_FIRSTMACH
+ 2:
14953 return _("PT_GETFPREGS (fpreg structure)");
14959 /* On all other arch's, PT_GETREGS == mach+1 and
14960 PT_GETFPREGS == mach+3. */
14964 case NT_NETBSDCORE_FIRSTMACH
+ 1:
14965 return _("PT_GETREGS (reg structure)");
14966 case NT_NETBSDCORE_FIRSTMACH
+ 3:
14967 return _("PT_GETFPREGS (fpreg structure)");
14973 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
14974 e_type
- NT_NETBSDCORE_FIRSTMACH
);
14978 static const char *
14979 get_stapsdt_note_type (unsigned e_type
)
14981 static char buff
[64];
14986 return _("NT_STAPSDT (SystemTap probe descriptors)");
14992 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14997 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14999 int addr_size
= is_32bit_elf
? 4 : 8;
15000 char *data
= pnote
->descdata
;
15001 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15002 bfd_vma pc
, base_addr
, semaphore
;
15003 char *provider
, *probe
, *arg_fmt
;
15005 pc
= byte_get ((unsigned char *) data
, addr_size
);
15007 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15009 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15013 data
+= strlen (data
) + 1;
15015 data
+= strlen (data
) + 1;
15017 data
+= strlen (data
) + 1;
15019 printf (_(" Provider: %s\n"), provider
);
15020 printf (_(" Name: %s\n"), probe
);
15021 printf (_(" Location: "));
15022 print_vma (pc
, FULL_HEX
);
15023 printf (_(", Base: "));
15024 print_vma (base_addr
, FULL_HEX
);
15025 printf (_(", Semaphore: "));
15026 print_vma (semaphore
, FULL_HEX
);
15028 printf (_(" Arguments: %s\n"), arg_fmt
);
15030 return data
== data_end
;
15033 static const char *
15034 get_ia64_vms_note_type (unsigned e_type
)
15036 static char buff
[64];
15041 return _("NT_VMS_MHD (module header)");
15043 return _("NT_VMS_LNM (language name)");
15045 return _("NT_VMS_SRC (source files)");
15047 return "NT_VMS_TITLE";
15049 return _("NT_VMS_EIDC (consistency check)");
15050 case NT_VMS_FPMODE
:
15051 return _("NT_VMS_FPMODE (FP mode)");
15052 case NT_VMS_LINKTIME
:
15053 return "NT_VMS_LINKTIME";
15054 case NT_VMS_IMGNAM
:
15055 return _("NT_VMS_IMGNAM (image name)");
15057 return _("NT_VMS_IMGID (image id)");
15058 case NT_VMS_LINKID
:
15059 return _("NT_VMS_LINKID (link id)");
15060 case NT_VMS_IMGBID
:
15061 return _("NT_VMS_IMGBID (build id)");
15062 case NT_VMS_GSTNAM
:
15063 return _("NT_VMS_GSTNAM (sym table name)");
15064 case NT_VMS_ORIG_DYN
:
15065 return "NT_VMS_ORIG_DYN";
15066 case NT_VMS_PATCHTIME
:
15067 return "NT_VMS_PATCHTIME";
15069 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15075 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15077 switch (pnote
->type
)
15080 if (pnote
->descsz
> 36)
15082 size_t l
= strlen (pnote
->descdata
+ 34);
15083 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15084 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15085 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15086 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15089 printf (_(" Invalid size\n"));
15092 printf (_(" Language: %s\n"), pnote
->descdata
);
15095 case NT_VMS_FPMODE
:
15096 printf (_(" Floating Point mode: "));
15097 printf ("0x%016" BFD_VMA_FMT
"x\n",
15098 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15100 case NT_VMS_LINKTIME
:
15101 printf (_(" Link time: "));
15103 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15106 case NT_VMS_PATCHTIME
:
15107 printf (_(" Patch time: "));
15109 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15112 case NT_VMS_ORIG_DYN
:
15113 printf (_(" Major id: %u, minor id: %u\n"),
15114 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15115 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15116 printf (_(" Last modified : "));
15118 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15119 printf (_("\n Link flags : "));
15120 printf ("0x%016" BFD_VMA_FMT
"x\n",
15121 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15122 printf (_(" Header flags: 0x%08x\n"),
15123 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15124 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15127 case NT_VMS_IMGNAM
:
15128 printf (_(" Image name: %s\n"), pnote
->descdata
);
15130 case NT_VMS_GSTNAM
:
15131 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15134 printf (_(" Image id: %s\n"), pnote
->descdata
);
15136 case NT_VMS_LINKID
:
15137 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15145 /* Note that by the ELF standard, the name field is already null byte
15146 terminated, and namesz includes the terminating null byte.
15147 I.E. the value of namesz for the name "FSF" is 4.
15149 If the value of namesz is zero, there is no name present. */
15151 process_note (Elf_Internal_Note
* pnote
)
15153 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15156 if (pnote
->namesz
== 0)
15157 /* If there is no note name, then use the default set of
15158 note type strings. */
15159 nt
= get_note_type (pnote
->type
);
15161 else if (const_strneq (pnote
->namedata
, "GNU"))
15162 /* GNU-specific object file notes. */
15163 nt
= get_gnu_elf_note_type (pnote
->type
);
15165 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15166 /* NetBSD-specific core file notes. */
15167 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15169 else if (strneq (pnote
->namedata
, "SPU/", 4))
15171 /* SPU-specific core file notes. */
15172 nt
= pnote
->namedata
+ 4;
15176 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15177 /* VMS/ia64-specific file notes. */
15178 nt
= get_ia64_vms_note_type (pnote
->type
);
15180 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15181 nt
= get_stapsdt_note_type (pnote
->type
);
15184 /* Don't recognize this note name; just use the default set of
15185 note type strings. */
15186 nt
= get_note_type (pnote
->type
);
15188 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15190 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15191 return print_ia64_vms_note (pnote
);
15192 else if (const_strneq (pnote
->namedata
, "GNU"))
15193 return print_gnu_note (pnote
);
15194 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15195 return print_stapsdt_note (pnote
);
15196 else if (const_strneq (pnote
->namedata
, "CORE"))
15197 return print_core_note (pnote
);
15204 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15206 Elf_External_Note
* pnotes
;
15207 Elf_External_Note
* external
;
15213 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15215 if (pnotes
== NULL
)
15220 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15221 (unsigned long) offset
, (unsigned long) length
);
15222 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15224 while ((char *) external
< (char *) pnotes
+ length
)
15226 Elf_Internal_Note inote
;
15229 char * temp
= NULL
;
15230 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
15232 if (!is_ia64_vms ())
15234 /* PR binutils/15191
15235 Make sure that there is enough data to read. */
15236 min_notesz
= offsetof (Elf_External_Note
, name
);
15237 if (data_remaining
< min_notesz
)
15239 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15240 (int) data_remaining
);
15243 inote
.type
= BYTE_GET (external
->type
);
15244 inote
.namesz
= BYTE_GET (external
->namesz
);
15245 inote
.namedata
= external
->name
;
15246 inote
.descsz
= BYTE_GET (external
->descsz
);
15247 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15248 /* PR 17531: file: 3443835e. */
15249 if (inote
.descdata
< (char *) pnotes
)
15251 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15252 inote
.descdata
= inote
.namedata
;
15255 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15256 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15260 Elf64_External_VMS_Note
*vms_external
;
15262 /* PR binutils/15191
15263 Make sure that there is enough data to read. */
15264 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15265 if (data_remaining
< min_notesz
)
15267 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15268 (int) data_remaining
);
15272 vms_external
= (Elf64_External_VMS_Note
*) external
;
15273 inote
.type
= BYTE_GET (vms_external
->type
);
15274 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15275 inote
.namedata
= vms_external
->name
;
15276 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15277 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15278 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15279 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15282 if (inote
.descdata
< (char *) external
+ min_notesz
15283 || next
< (char *) external
+ min_notesz
15284 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15285 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15286 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15287 || data_remaining
< (size_t)(next
- (char *) external
))
15289 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15290 (unsigned long) ((char *) external
- (char *) pnotes
));
15291 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15292 inote
.type
, inote
.namesz
, inote
.descsz
);
15296 external
= (Elf_External_Note
*) next
;
15298 /* Verify that name is null terminated. It appears that at least
15299 one version of Linux (RedHat 6.0) generates corefiles that don't
15300 comply with the ELF spec by failing to include the null byte in
15302 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15304 temp
= (char *) malloc (inote
.namesz
+ 1);
15307 error (_("Out of memory allocating space for inote name\n"));
15312 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15313 temp
[inote
.namesz
] = 0;
15315 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15316 inote
.namedata
= temp
;
15319 res
&= process_note (& inote
);
15334 process_corefile_note_segments (FILE * file
)
15336 Elf_Internal_Phdr
* segment
;
15340 if (! get_program_headers (file
))
15343 for (i
= 0, segment
= program_headers
;
15344 i
< elf_header
.e_phnum
;
15347 if (segment
->p_type
== PT_NOTE
)
15348 res
&= process_corefile_note_segment (file
,
15349 (bfd_vma
) segment
->p_offset
,
15350 (bfd_vma
) segment
->p_filesz
);
15357 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15359 Elf_External_Note
* pnotes
;
15360 Elf_External_Note
* external
;
15366 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15368 if (pnotes
== NULL
)
15373 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15374 (unsigned long) offset
, (unsigned long) length
);
15376 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
15378 Elf_External_Note
* next
;
15379 Elf_Internal_Note inote
;
15381 inote
.type
= BYTE_GET (external
->type
);
15382 inote
.namesz
= BYTE_GET (external
->namesz
);
15383 inote
.namedata
= external
->name
;
15384 inote
.descsz
= BYTE_GET (external
->descsz
);
15385 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15386 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15388 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15390 if ( ((char *) next
> ((char *) pnotes
) + length
)
15391 || ((char *) next
< (char *) pnotes
))
15393 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15394 (unsigned long) ((char *) external
- (char *) pnotes
));
15395 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15396 inote
.type
, inote
.namesz
, inote
.descsz
);
15402 /* Prevent out-of-bounds indexing. */
15403 if ( inote
.namedata
+ inote
.namesz
> (char *) pnotes
+ length
15404 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15406 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15407 (unsigned long) ((char *) external
- (char *) pnotes
));
15408 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15409 inote
.type
, inote
.namesz
, inote
.descsz
);
15413 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15415 if (! print_v850_note (& inote
))
15418 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15419 inote
.namesz
, inote
.descsz
);
15429 process_note_sections (FILE * file
)
15431 Elf_Internal_Shdr
* section
;
15436 for (i
= 0, section
= section_headers
;
15437 i
< elf_header
.e_shnum
&& section
!= NULL
;
15440 if (section
->sh_type
== SHT_NOTE
)
15442 res
&= process_corefile_note_segment (file
,
15443 (bfd_vma
) section
->sh_offset
,
15444 (bfd_vma
) section
->sh_size
);
15448 if (( elf_header
.e_machine
== EM_V800
15449 || elf_header
.e_machine
== EM_V850
15450 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15451 && section
->sh_type
== SHT_RENESAS_INFO
)
15453 res
&= process_v850_notes (file
,
15454 (bfd_vma
) section
->sh_offset
,
15455 (bfd_vma
) section
->sh_size
);
15461 /* Try processing NOTE segments instead. */
15462 return process_corefile_note_segments (file
);
15468 process_notes (FILE * file
)
15470 /* If we have not been asked to display the notes then do nothing. */
15474 if (elf_header
.e_type
!= ET_CORE
)
15475 return process_note_sections (file
);
15477 /* No program headers means no NOTE segment. */
15478 if (elf_header
.e_phnum
> 0)
15479 return process_corefile_note_segments (file
);
15481 printf (_("No note segments present in the core file.\n"));
15486 process_arch_specific (FILE * file
)
15491 switch (elf_header
.e_machine
)
15494 return process_arm_specific (file
);
15496 case EM_MIPS_RS3_LE
:
15497 return process_mips_specific (file
);
15500 return process_nds32_specific (file
);
15503 return process_power_specific (file
);
15506 case EM_SPARC32PLUS
:
15508 return process_sparc_specific (file
);
15511 return process_tic6x_specific (file
);
15514 return process_msp430x_specific (file
);
15522 get_file_header (FILE * file
)
15524 /* Read in the identity array. */
15525 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15528 /* Determine how to read the rest of the header. */
15529 switch (elf_header
.e_ident
[EI_DATA
])
15531 default: /* fall through */
15532 case ELFDATANONE
: /* fall through */
15534 byte_get
= byte_get_little_endian
;
15535 byte_put
= byte_put_little_endian
;
15538 byte_get
= byte_get_big_endian
;
15539 byte_put
= byte_put_big_endian
;
15543 /* For now we only support 32 bit and 64 bit ELF files. */
15544 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15546 /* Read in the rest of the header. */
15549 Elf32_External_Ehdr ehdr32
;
15551 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15554 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15555 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15556 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15557 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15558 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15559 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15560 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15561 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15562 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15563 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15564 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15565 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15566 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15570 Elf64_External_Ehdr ehdr64
;
15572 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15573 we will not be able to cope with the 64bit data found in
15574 64 ELF files. Detect this now and abort before we start
15575 overwriting things. */
15576 if (sizeof (bfd_vma
) < 8)
15578 error (_("This instance of readelf has been built without support for a\n\
15579 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15583 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15586 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15587 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15588 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15589 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15590 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15591 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15592 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15593 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15594 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15595 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15596 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15597 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15598 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15601 if (elf_header
.e_shoff
)
15603 /* There may be some extensions in the first section header. Don't
15604 bomb if we can't read it. */
15606 get_32bit_section_headers (file
, TRUE
);
15608 get_64bit_section_headers (file
, TRUE
);
15614 /* Process one ELF object file according to the command line options.
15615 This file may actually be stored in an archive. The file is
15616 positioned at the start of the ELF object. */
15619 process_object (char * file_name
, FILE * file
)
15623 if (! get_file_header (file
))
15625 error (_("%s: Failed to read file header\n"), file_name
);
15629 /* Initialise per file variables. */
15630 for (i
= ARRAY_SIZE (version_info
); i
--;)
15631 version_info
[i
] = 0;
15633 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15634 dynamic_info
[i
] = 0;
15635 dynamic_info_DT_GNU_HASH
= 0;
15637 /* Process the file. */
15639 printf (_("\nFile: %s\n"), file_name
);
15641 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15642 Note we do this even if cmdline_dump_sects is empty because we
15643 must make sure that the dump_sets array is zeroed out before each
15644 object file is processed. */
15645 if (num_dump_sects
> num_cmdline_dump_sects
)
15646 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15648 if (num_cmdline_dump_sects
> 0)
15650 if (num_dump_sects
== 0)
15651 /* A sneaky way of allocating the dump_sects array. */
15652 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15654 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15655 memcpy (dump_sects
, cmdline_dump_sects
,
15656 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15659 if (! process_file_header ())
15662 if (! process_section_headers (file
))
15664 /* Without loaded section headers we cannot process lots of
15666 do_unwind
= do_version
= do_dump
= do_arch
= 0;
15668 if (! do_using_dynamic
)
15669 do_syms
= do_dyn_syms
= do_reloc
= 0;
15672 if (! process_section_groups (file
))
15674 /* Without loaded section groups we cannot process unwind. */
15678 if (process_program_headers (file
))
15679 process_dynamic_section (file
);
15681 process_relocs (file
);
15683 process_unwind (file
);
15685 process_symbol_table (file
);
15687 process_syminfo (file
);
15689 process_version_sections (file
);
15691 process_section_contents (file
);
15693 process_notes (file
);
15695 process_gnu_liblist (file
);
15697 process_arch_specific (file
);
15699 if (program_headers
)
15701 free (program_headers
);
15702 program_headers
= NULL
;
15705 if (section_headers
)
15707 free (section_headers
);
15708 section_headers
= NULL
;
15713 free (string_table
);
15714 string_table
= NULL
;
15715 string_table_length
= 0;
15718 if (dynamic_strings
)
15720 free (dynamic_strings
);
15721 dynamic_strings
= NULL
;
15722 dynamic_strings_length
= 0;
15725 if (dynamic_symbols
)
15727 free (dynamic_symbols
);
15728 dynamic_symbols
= NULL
;
15729 num_dynamic_syms
= 0;
15732 if (dynamic_syminfo
)
15734 free (dynamic_syminfo
);
15735 dynamic_syminfo
= NULL
;
15738 if (dynamic_section
)
15740 free (dynamic_section
);
15741 dynamic_section
= NULL
;
15744 if (section_headers_groups
)
15746 free (section_headers_groups
);
15747 section_headers_groups
= NULL
;
15750 if (section_groups
)
15752 struct group_list
* g
;
15753 struct group_list
* next
;
15755 for (i
= 0; i
< group_count
; i
++)
15757 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
15764 free (section_groups
);
15765 section_groups
= NULL
;
15768 free_debug_memory ();
15773 /* Process an ELF archive.
15774 On entry the file is positioned just after the ARMAG string. */
15777 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
15779 struct archive_info arch
;
15780 struct archive_info nested_arch
;
15786 /* The ARCH structure is used to hold information about this archive. */
15787 arch
.file_name
= NULL
;
15789 arch
.index_array
= NULL
;
15790 arch
.sym_table
= NULL
;
15791 arch
.longnames
= NULL
;
15793 /* The NESTED_ARCH structure is used as a single-item cache of information
15794 about a nested archive (when members of a thin archive reside within
15795 another regular archive file). */
15796 nested_arch
.file_name
= NULL
;
15797 nested_arch
.file
= NULL
;
15798 nested_arch
.index_array
= NULL
;
15799 nested_arch
.sym_table
= NULL
;
15800 nested_arch
.longnames
= NULL
;
15802 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
15808 if (do_archive_index
)
15810 if (arch
.sym_table
== NULL
)
15811 error (_("%s: unable to dump the index as none was found\n"), file_name
);
15814 unsigned long i
, l
;
15815 unsigned long current_pos
;
15817 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15818 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
15819 current_pos
= ftell (file
);
15821 for (i
= l
= 0; i
< arch
.index_num
; i
++)
15823 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
15825 char * member_name
;
15827 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
15829 if (member_name
!= NULL
)
15831 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
15833 if (qualified_name
!= NULL
)
15835 printf (_("Contents of binary %s at offset "), qualified_name
);
15836 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
15838 free (qualified_name
);
15843 if (l
>= arch
.sym_size
)
15845 error (_("%s: end of the symbol table reached before the end of the index\n"),
15849 /* PR 17531: file: 0b6630b2. */
15850 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
15851 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
15854 if (arch
.uses_64bit_indicies
)
15859 if (l
< arch
.sym_size
)
15860 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15861 file_name
, arch
.sym_size
- l
);
15863 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
15865 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
15871 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
15872 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
15873 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
15874 && !do_section_groups
&& !do_dyn_syms
)
15876 ret
= 0; /* Archive index only. */
15887 char * qualified_name
;
15889 /* Read the next archive header. */
15890 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
15892 error (_("%s: failed to seek to next archive header\n"), file_name
);
15895 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
15896 if (got
!= sizeof arch
.arhdr
)
15900 error (_("%s: failed to read archive header\n"), file_name
);
15904 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
15906 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
15911 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
15913 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
15914 if (archive_file_size
& 01)
15915 ++archive_file_size
;
15917 name
= get_archive_member_name (&arch
, &nested_arch
);
15920 error (_("%s: bad archive file name\n"), file_name
);
15924 namelen
= strlen (name
);
15926 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15927 if (qualified_name
== NULL
)
15929 error (_("%s: bad archive file name\n"), file_name
);
15934 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
15936 /* This is a proxy for an external member of a thin archive. */
15937 FILE * member_file
;
15938 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
15939 if (member_file_name
== NULL
)
15945 member_file
= fopen (member_file_name
, "rb");
15946 if (member_file
== NULL
)
15948 error (_("Input file '%s' is not readable.\n"), member_file_name
);
15949 free (member_file_name
);
15954 archive_file_offset
= arch
.nested_member_origin
;
15956 ret
|= process_object (qualified_name
, member_file
);
15958 fclose (member_file
);
15959 free (member_file_name
);
15961 else if (is_thin_archive
)
15963 /* PR 15140: Allow for corrupt thin archives. */
15964 if (nested_arch
.file
== NULL
)
15966 error (_("%s: contains corrupt thin archive: %s\n"),
15972 /* This is a proxy for a member of a nested archive. */
15973 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
15975 /* The nested archive file will have been opened and setup by
15976 get_archive_member_name. */
15977 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
15979 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
15984 ret
|= process_object (qualified_name
, nested_arch
.file
);
15988 archive_file_offset
= arch
.next_arhdr_offset
;
15989 arch
.next_arhdr_offset
+= archive_file_size
;
15991 ret
|= process_object (qualified_name
, file
);
15994 if (dump_sects
!= NULL
)
15998 num_dump_sects
= 0;
16001 free (qualified_name
);
16005 if (nested_arch
.file
!= NULL
)
16006 fclose (nested_arch
.file
);
16007 release_archive (&nested_arch
);
16008 release_archive (&arch
);
16014 process_file (char * file_name
)
16017 struct stat statbuf
;
16018 char armag
[SARMAG
];
16021 if (stat (file_name
, &statbuf
) < 0)
16023 if (errno
== ENOENT
)
16024 error (_("'%s': No such file\n"), file_name
);
16026 error (_("Could not locate '%s'. System error message: %s\n"),
16027 file_name
, strerror (errno
));
16031 if (! S_ISREG (statbuf
.st_mode
))
16033 error (_("'%s' is not an ordinary file\n"), file_name
);
16037 file
= fopen (file_name
, "rb");
16040 error (_("Input file '%s' is not readable.\n"), file_name
);
16044 if (fread (armag
, SARMAG
, 1, file
) != 1)
16046 error (_("%s: Failed to read file's magic number\n"), file_name
);
16051 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16053 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16054 ret
= process_archive (file_name
, file
, FALSE
);
16055 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16056 ret
= process_archive (file_name
, file
, TRUE
);
16059 if (do_archive_index
)
16060 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16064 archive_file_size
= archive_file_offset
= 0;
16065 ret
= process_object (file_name
, file
);
16070 current_file_size
= 0;
16074 #ifdef SUPPORT_DISASSEMBLY
16075 /* Needed by the i386 disassembler. For extra credit, someone could
16076 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16080 print_address (unsigned int addr
, FILE * outfile
)
16082 fprintf (outfile
,"0x%8.8x", addr
);
16085 /* Needed by the i386 disassembler. */
16087 db_task_printsym (unsigned int addr
)
16089 print_address (addr
, stderr
);
16094 main (int argc
, char ** argv
)
16098 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16099 setlocale (LC_MESSAGES
, "");
16101 #if defined (HAVE_SETLOCALE)
16102 setlocale (LC_CTYPE
, "");
16104 bindtextdomain (PACKAGE
, LOCALEDIR
);
16105 textdomain (PACKAGE
);
16107 expandargv (&argc
, &argv
);
16109 parse_args (argc
, argv
);
16111 if (num_dump_sects
> 0)
16113 /* Make a copy of the dump_sects array. */
16114 cmdline_dump_sects
= (dump_type
*)
16115 malloc (num_dump_sects
* sizeof (* dump_sects
));
16116 if (cmdline_dump_sects
== NULL
)
16117 error (_("Out of memory allocating dump request table.\n"));
16120 memcpy (cmdline_dump_sects
, dump_sects
,
16121 num_dump_sects
* sizeof (* dump_sects
));
16122 num_cmdline_dump_sects
= num_dump_sects
;
16126 if (optind
< (argc
- 1))
16130 while (optind
< argc
)
16131 err
|= process_file (argv
[optind
++]);
16133 if (dump_sects
!= NULL
)
16135 if (cmdline_dump_sects
!= NULL
)
16136 free (cmdline_dump_sects
);