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 /* Now handle EABI specific flags. */
2287 strcat (buf
, ", <unrecognized EABI>");
2292 case EF_ARM_EABI_VER1
:
2293 strcat (buf
, ", Version1 EABI");
2298 /* Process flags one bit at a time. */
2299 flag
= e_flags
& - e_flags
;
2304 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2305 strcat (buf
, ", sorted symbol tables");
2315 case EF_ARM_EABI_VER2
:
2316 strcat (buf
, ", Version2 EABI");
2321 /* Process flags one bit at a time. */
2322 flag
= e_flags
& - e_flags
;
2327 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2328 strcat (buf
, ", sorted symbol tables");
2331 case EF_ARM_DYNSYMSUSESEGIDX
:
2332 strcat (buf
, ", dynamic symbols use segment index");
2335 case EF_ARM_MAPSYMSFIRST
:
2336 strcat (buf
, ", mapping symbols precede others");
2346 case EF_ARM_EABI_VER3
:
2347 strcat (buf
, ", Version3 EABI");
2350 case EF_ARM_EABI_VER4
:
2351 strcat (buf
, ", Version4 EABI");
2356 /* Process flags one bit at a time. */
2357 flag
= e_flags
& - e_flags
;
2363 strcat (buf
, ", BE8");
2367 strcat (buf
, ", LE8");
2378 case EF_ARM_EABI_VER5
:
2379 strcat (buf
, ", Version5 EABI");
2384 /* Process flags one bit at a time. */
2385 flag
= e_flags
& - e_flags
;
2391 strcat (buf
, ", BE8");
2395 strcat (buf
, ", LE8");
2398 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2399 strcat (buf
, ", soft-float ABI");
2402 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2403 strcat (buf
, ", hard-float ABI");
2413 case EF_ARM_EABI_UNKNOWN
:
2414 strcat (buf
, ", GNU EABI");
2419 /* Process flags one bit at a time. */
2420 flag
= e_flags
& - e_flags
;
2425 case EF_ARM_INTERWORK
:
2426 strcat (buf
, ", interworking enabled");
2429 case EF_ARM_APCS_26
:
2430 strcat (buf
, ", uses APCS/26");
2433 case EF_ARM_APCS_FLOAT
:
2434 strcat (buf
, ", uses APCS/float");
2438 strcat (buf
, ", position independent");
2442 strcat (buf
, ", 8 bit structure alignment");
2445 case EF_ARM_NEW_ABI
:
2446 strcat (buf
, ", uses new ABI");
2449 case EF_ARM_OLD_ABI
:
2450 strcat (buf
, ", uses old ABI");
2453 case EF_ARM_SOFT_FLOAT
:
2454 strcat (buf
, ", software FP");
2457 case EF_ARM_VFP_FLOAT
:
2458 strcat (buf
, ", VFP");
2461 case EF_ARM_MAVERICK_FLOAT
:
2462 strcat (buf
, ", Maverick FP");
2473 strcat (buf
,_(", <unknown>"));
2477 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2479 --size
; /* Leave space for null terminator. */
2481 switch (e_flags
& EF_AVR_MACH
)
2483 case E_AVR_MACH_AVR1
:
2484 strncat (buf
, ", avr:1", size
);
2486 case E_AVR_MACH_AVR2
:
2487 strncat (buf
, ", avr:2", size
);
2489 case E_AVR_MACH_AVR25
:
2490 strncat (buf
, ", avr:25", size
);
2492 case E_AVR_MACH_AVR3
:
2493 strncat (buf
, ", avr:3", size
);
2495 case E_AVR_MACH_AVR31
:
2496 strncat (buf
, ", avr:31", size
);
2498 case E_AVR_MACH_AVR35
:
2499 strncat (buf
, ", avr:35", size
);
2501 case E_AVR_MACH_AVR4
:
2502 strncat (buf
, ", avr:4", size
);
2504 case E_AVR_MACH_AVR5
:
2505 strncat (buf
, ", avr:5", size
);
2507 case E_AVR_MACH_AVR51
:
2508 strncat (buf
, ", avr:51", size
);
2510 case E_AVR_MACH_AVR6
:
2511 strncat (buf
, ", avr:6", size
);
2513 case E_AVR_MACH_AVRTINY
:
2514 strncat (buf
, ", avr:100", size
);
2516 case E_AVR_MACH_XMEGA1
:
2517 strncat (buf
, ", avr:101", size
);
2519 case E_AVR_MACH_XMEGA2
:
2520 strncat (buf
, ", avr:102", size
);
2522 case E_AVR_MACH_XMEGA3
:
2523 strncat (buf
, ", avr:103", size
);
2525 case E_AVR_MACH_XMEGA4
:
2526 strncat (buf
, ", avr:104", size
);
2528 case E_AVR_MACH_XMEGA5
:
2529 strncat (buf
, ", avr:105", size
);
2531 case E_AVR_MACH_XMEGA6
:
2532 strncat (buf
, ", avr:106", size
);
2534 case E_AVR_MACH_XMEGA7
:
2535 strncat (buf
, ", avr:107", size
);
2538 strncat (buf
, ", avr:<unknown>", size
);
2542 size
-= strlen (buf
);
2543 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2544 strncat (buf
, ", link-relax", size
);
2548 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2557 static const char *ABI_STRINGS
[] =
2559 "ABI v0", /* use r5 as return register; only used in N1213HC */
2560 "ABI v1", /* use r0 as return register */
2561 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2562 "ABI v2fp", /* for FPU */
2566 static const char *VER_STRINGS
[] =
2568 "Andes ELF V1.3 or older",
2572 static const char *ARCH_STRINGS
[] =
2581 abi
= EF_NDS_ABI
& e_flags
;
2582 arch
= EF_NDS_ARCH
& e_flags
;
2583 config
= EF_NDS_INST
& e_flags
;
2584 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2586 memset (buf
, 0, size
);
2593 case E_NDS_ABI_V2FP
:
2594 case E_NDS_ABI_AABI
:
2595 case E_NDS_ABI_V2FP_PLUS
:
2596 /* In case there are holes in the array. */
2597 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2601 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2607 case E_NDS32_ELF_VER_1_2
:
2608 case E_NDS32_ELF_VER_1_3
:
2609 case E_NDS32_ELF_VER_1_4
:
2610 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2614 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2618 if (E_NDS_ABI_V0
== abi
)
2620 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2621 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2622 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2623 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2629 case E_NDS_ARCH_STAR_V1_0
:
2630 case E_NDS_ARCH_STAR_V2_0
:
2631 case E_NDS_ARCH_STAR_V3_0
:
2632 case E_NDS_ARCH_STAR_V3_M
:
2633 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2637 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2638 /* ARCH version determines how the e_flags are interpreted.
2639 If it is unknown, we cannot proceed. */
2643 /* Newer ABI; Now handle architecture specific flags. */
2644 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2646 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2647 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2649 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2650 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2652 if (config
& E_NDS32_HAS_DIV_INST
)
2653 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2655 if (config
& E_NDS32_HAS_16BIT_INST
)
2656 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2660 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2662 if (version
<= E_NDS32_ELF_VER_1_3
)
2663 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2665 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2668 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2669 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2671 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2672 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2674 if (config
& E_NDS32_HAS_16BIT_INST
)
2676 if (version
<= E_NDS32_ELF_VER_1_3
)
2677 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2679 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2683 if (config
& E_NDS32_HAS_EXT_INST
)
2684 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2686 if (config
& E_NDS32_HAS_EXT2_INST
)
2687 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2689 if (config
& E_NDS32_HAS_FPU_INST
)
2692 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2695 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2698 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2701 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2704 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2709 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2711 case E_NDS32_FPU_REG_8SP_4DP
:
2712 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2714 case E_NDS32_FPU_REG_16SP_8DP
:
2715 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2717 case E_NDS32_FPU_REG_32SP_16DP
:
2718 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2720 case E_NDS32_FPU_REG_32SP_32DP
:
2721 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2726 if (config
& E_NDS32_HAS_AUDIO_INST
)
2727 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2729 if (config
& E_NDS32_HAS_STRING_INST
)
2730 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2732 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2733 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2735 if (config
& E_NDS32_HAS_VIDEO_INST
)
2737 if (version
<= E_NDS32_ELF_VER_1_3
)
2738 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2740 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2743 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2744 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2746 if (config
& E_NDS32_HAS_L2C_INST
)
2747 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2751 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2753 static char buf
[1024];
2765 decode_ARM_machine_flags (e_flags
, buf
);
2769 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2773 if (e_flags
& EF_BFIN_PIC
)
2774 strcat (buf
, ", PIC");
2776 if (e_flags
& EF_BFIN_FDPIC
)
2777 strcat (buf
, ", FDPIC");
2779 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2780 strcat (buf
, ", code in L1");
2782 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2783 strcat (buf
, ", data in L1");
2788 switch (e_flags
& EF_FRV_CPU_MASK
)
2790 case EF_FRV_CPU_GENERIC
:
2794 strcat (buf
, ", fr???");
2797 case EF_FRV_CPU_FR300
:
2798 strcat (buf
, ", fr300");
2801 case EF_FRV_CPU_FR400
:
2802 strcat (buf
, ", fr400");
2804 case EF_FRV_CPU_FR405
:
2805 strcat (buf
, ", fr405");
2808 case EF_FRV_CPU_FR450
:
2809 strcat (buf
, ", fr450");
2812 case EF_FRV_CPU_FR500
:
2813 strcat (buf
, ", fr500");
2815 case EF_FRV_CPU_FR550
:
2816 strcat (buf
, ", fr550");
2819 case EF_FRV_CPU_SIMPLE
:
2820 strcat (buf
, ", simple");
2822 case EF_FRV_CPU_TOMCAT
:
2823 strcat (buf
, ", tomcat");
2829 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2830 strcat (buf
, ", m68000");
2831 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2832 strcat (buf
, ", cpu32");
2833 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2834 strcat (buf
, ", fido_a");
2837 char const * isa
= _("unknown");
2838 char const * mac
= _("unknown mac");
2839 char const * additional
= NULL
;
2841 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2843 case EF_M68K_CF_ISA_A_NODIV
:
2845 additional
= ", nodiv";
2847 case EF_M68K_CF_ISA_A
:
2850 case EF_M68K_CF_ISA_A_PLUS
:
2853 case EF_M68K_CF_ISA_B_NOUSP
:
2855 additional
= ", nousp";
2857 case EF_M68K_CF_ISA_B
:
2860 case EF_M68K_CF_ISA_C
:
2863 case EF_M68K_CF_ISA_C_NODIV
:
2865 additional
= ", nodiv";
2868 strcat (buf
, ", cf, isa ");
2871 strcat (buf
, additional
);
2872 if (e_flags
& EF_M68K_CF_FLOAT
)
2873 strcat (buf
, ", float");
2874 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2879 case EF_M68K_CF_MAC
:
2882 case EF_M68K_CF_EMAC
:
2885 case EF_M68K_CF_EMAC_B
:
2898 if (e_flags
& EF_PPC_EMB
)
2899 strcat (buf
, ", emb");
2901 if (e_flags
& EF_PPC_RELOCATABLE
)
2902 strcat (buf
, _(", relocatable"));
2904 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2905 strcat (buf
, _(", relocatable-lib"));
2909 if (e_flags
& EF_PPC64_ABI
)
2911 char abi
[] = ", abiv0";
2913 abi
[6] += e_flags
& EF_PPC64_ABI
;
2919 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2920 strcat (buf
, ", RH850 ABI");
2922 if (e_flags
& EF_V800_850E3
)
2923 strcat (buf
, ", V3 architecture");
2925 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2926 strcat (buf
, ", FPU not used");
2928 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2929 strcat (buf
, ", regmode: COMMON");
2931 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2932 strcat (buf
, ", r4 not used");
2934 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2935 strcat (buf
, ", r30 not used");
2937 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2938 strcat (buf
, ", r5 not used");
2940 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2941 strcat (buf
, ", r2 not used");
2943 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2945 switch (e_flags
& - e_flags
)
2947 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2948 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2949 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2950 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2951 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2952 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2953 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2954 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2955 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2956 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2957 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2958 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2965 case EM_CYGNUS_V850
:
2966 switch (e_flags
& EF_V850_ARCH
)
2968 case E_V850E3V5_ARCH
:
2969 strcat (buf
, ", v850e3v5");
2971 case E_V850E2V3_ARCH
:
2972 strcat (buf
, ", v850e2v3");
2975 strcat (buf
, ", v850e2");
2978 strcat (buf
, ", v850e1");
2981 strcat (buf
, ", v850e");
2984 strcat (buf
, ", v850");
2987 strcat (buf
, _(", unknown v850 architecture variant"));
2993 case EM_CYGNUS_M32R
:
2994 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2995 strcat (buf
, ", m32r");
2999 case EM_MIPS_RS3_LE
:
3000 if (e_flags
& EF_MIPS_NOREORDER
)
3001 strcat (buf
, ", noreorder");
3003 if (e_flags
& EF_MIPS_PIC
)
3004 strcat (buf
, ", pic");
3006 if (e_flags
& EF_MIPS_CPIC
)
3007 strcat (buf
, ", cpic");
3009 if (e_flags
& EF_MIPS_UCODE
)
3010 strcat (buf
, ", ugen_reserved");
3012 if (e_flags
& EF_MIPS_ABI2
)
3013 strcat (buf
, ", abi2");
3015 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3016 strcat (buf
, ", odk first");
3018 if (e_flags
& EF_MIPS_32BITMODE
)
3019 strcat (buf
, ", 32bitmode");
3021 if (e_flags
& EF_MIPS_NAN2008
)
3022 strcat (buf
, ", nan2008");
3024 if (e_flags
& EF_MIPS_FP64
)
3025 strcat (buf
, ", fp64");
3027 switch ((e_flags
& EF_MIPS_MACH
))
3029 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3030 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3031 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3032 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3033 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3034 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3035 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3036 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3037 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3038 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3039 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3040 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3041 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3042 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3043 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3044 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3045 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3047 /* We simply ignore the field in this case to avoid confusion:
3048 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3051 default: strcat (buf
, _(", unknown CPU")); break;
3054 switch ((e_flags
& EF_MIPS_ABI
))
3056 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3057 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3058 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3059 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3061 /* We simply ignore the field in this case to avoid confusion:
3062 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3063 This means it is likely to be an o32 file, but not for
3066 default: strcat (buf
, _(", unknown ABI")); break;
3069 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3070 strcat (buf
, ", mdmx");
3072 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3073 strcat (buf
, ", mips16");
3075 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3076 strcat (buf
, ", micromips");
3078 switch ((e_flags
& EF_MIPS_ARCH
))
3080 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3081 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3082 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3083 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3084 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3085 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3086 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3087 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3088 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3089 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3090 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3091 default: strcat (buf
, _(", unknown ISA")); break;
3096 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3100 switch ((e_flags
& EF_SH_MACH_MASK
))
3102 case EF_SH1
: strcat (buf
, ", sh1"); break;
3103 case EF_SH2
: strcat (buf
, ", sh2"); break;
3104 case EF_SH3
: strcat (buf
, ", sh3"); break;
3105 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3106 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3107 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3108 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3109 case EF_SH4
: strcat (buf
, ", sh4"); break;
3110 case EF_SH5
: strcat (buf
, ", sh5"); break;
3111 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3112 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3113 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3114 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3115 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3116 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3117 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3118 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3119 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3120 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3121 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3122 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3123 default: strcat (buf
, _(", unknown ISA")); break;
3126 if (e_flags
& EF_SH_PIC
)
3127 strcat (buf
, ", pic");
3129 if (e_flags
& EF_SH_FDPIC
)
3130 strcat (buf
, ", fdpic");
3134 if (e_flags
& EF_OR1K_NODELAY
)
3135 strcat (buf
, ", no delay");
3139 if (e_flags
& EF_SPARC_32PLUS
)
3140 strcat (buf
, ", v8+");
3142 if (e_flags
& EF_SPARC_SUN_US1
)
3143 strcat (buf
, ", ultrasparcI");
3145 if (e_flags
& EF_SPARC_SUN_US3
)
3146 strcat (buf
, ", ultrasparcIII");
3148 if (e_flags
& EF_SPARC_HAL_R1
)
3149 strcat (buf
, ", halr1");
3151 if (e_flags
& EF_SPARC_LEDATA
)
3152 strcat (buf
, ", ledata");
3154 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3155 strcat (buf
, ", tso");
3157 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3158 strcat (buf
, ", pso");
3160 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3161 strcat (buf
, ", rmo");
3165 switch (e_flags
& EF_PARISC_ARCH
)
3167 case EFA_PARISC_1_0
:
3168 strcpy (buf
, ", PA-RISC 1.0");
3170 case EFA_PARISC_1_1
:
3171 strcpy (buf
, ", PA-RISC 1.1");
3173 case EFA_PARISC_2_0
:
3174 strcpy (buf
, ", PA-RISC 2.0");
3179 if (e_flags
& EF_PARISC_TRAPNIL
)
3180 strcat (buf
, ", trapnil");
3181 if (e_flags
& EF_PARISC_EXT
)
3182 strcat (buf
, ", ext");
3183 if (e_flags
& EF_PARISC_LSB
)
3184 strcat (buf
, ", lsb");
3185 if (e_flags
& EF_PARISC_WIDE
)
3186 strcat (buf
, ", wide");
3187 if (e_flags
& EF_PARISC_NO_KABP
)
3188 strcat (buf
, ", no kabp");
3189 if (e_flags
& EF_PARISC_LAZYSWAP
)
3190 strcat (buf
, ", lazyswap");
3195 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3196 strcat (buf
, ", new calling convention");
3198 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3199 strcat (buf
, ", gnu calling convention");
3203 if ((e_flags
& EF_IA_64_ABI64
))
3204 strcat (buf
, ", 64-bit");
3206 strcat (buf
, ", 32-bit");
3207 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3208 strcat (buf
, ", reduced fp model");
3209 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3210 strcat (buf
, ", no function descriptors, constant gp");
3211 else if ((e_flags
& EF_IA_64_CONS_GP
))
3212 strcat (buf
, ", constant gp");
3213 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3214 strcat (buf
, ", absolute");
3215 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3217 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3218 strcat (buf
, ", vms_linkages");
3219 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3221 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3223 case EF_IA_64_VMS_COMCOD_WARNING
:
3224 strcat (buf
, ", warning");
3226 case EF_IA_64_VMS_COMCOD_ERROR
:
3227 strcat (buf
, ", error");
3229 case EF_IA_64_VMS_COMCOD_ABORT
:
3230 strcat (buf
, ", abort");
3233 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3234 e_flags
& EF_IA_64_VMS_COMCOD
);
3235 strcat (buf
, ", <unknown>");
3241 if ((e_flags
& EF_VAX_NONPIC
))
3242 strcat (buf
, ", non-PIC");
3243 if ((e_flags
& EF_VAX_DFLOAT
))
3244 strcat (buf
, ", D-Float");
3245 if ((e_flags
& EF_VAX_GFLOAT
))
3246 strcat (buf
, ", G-Float");
3250 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3251 strcat (buf
, ", mcm");
3252 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3253 strcat (buf
, ", mcm24");
3254 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3255 strcat (buf
, ", gr6");
3259 if (e_flags
& E_FLAG_RL78_G10
)
3260 strcat (buf
, ", G10");
3261 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3262 strcat (buf
, ", 64-bit doubles");
3266 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3267 strcat (buf
, ", 64-bit doubles");
3268 if (e_flags
& E_FLAG_RX_DSP
)
3269 strcat (buf
, ", dsp");
3270 if (e_flags
& E_FLAG_RX_PID
)
3271 strcat (buf
, ", pid");
3272 if (e_flags
& E_FLAG_RX_ABI
)
3273 strcat (buf
, ", RX ABI");
3277 if (e_flags
& EF_S390_HIGH_GPRS
)
3278 strcat (buf
, ", highgprs");
3282 if ((e_flags
& EF_C6000_REL
))
3283 strcat (buf
, ", relocatable module");
3287 strcat (buf
, _(": architecture variant: "));
3288 switch (e_flags
& EF_MSP430_MACH
)
3290 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3291 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3292 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3293 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3294 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3295 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3296 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3297 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3298 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3299 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3300 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3301 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3302 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3303 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3304 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3306 strcat (buf
, _(": unknown")); break;
3309 if (e_flags
& ~ EF_MSP430_MACH
)
3310 strcat (buf
, _(": unknown extra flag bits also present"));
3318 get_osabi_name (unsigned int osabi
)
3320 static char buff
[32];
3324 case ELFOSABI_NONE
: return "UNIX - System V";
3325 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3326 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3327 case ELFOSABI_GNU
: return "UNIX - GNU";
3328 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3329 case ELFOSABI_AIX
: return "UNIX - AIX";
3330 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3331 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3332 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3333 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3334 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3335 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3336 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3337 case ELFOSABI_AROS
: return "AROS";
3338 case ELFOSABI_FENIXOS
: return "FenixOS";
3341 switch (elf_header
.e_machine
)
3346 case ELFOSABI_ARM
: return "ARM";
3357 case ELFOSABI_STANDALONE
: return _("Standalone App");
3366 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3367 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3376 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3382 get_aarch64_segment_type (unsigned long type
)
3386 case PT_AARCH64_ARCHEXT
:
3387 return "AARCH64_ARCHEXT";
3396 get_arm_segment_type (unsigned long type
)
3410 get_mips_segment_type (unsigned long type
)
3414 case PT_MIPS_REGINFO
:
3416 case PT_MIPS_RTPROC
:
3418 case PT_MIPS_OPTIONS
:
3420 case PT_MIPS_ABIFLAGS
:
3430 get_parisc_segment_type (unsigned long type
)
3434 case PT_HP_TLS
: return "HP_TLS";
3435 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3436 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3437 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3438 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3439 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3440 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3441 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3442 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3443 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3444 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3445 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3446 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3447 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3448 case PT_HP_STACK
: return "HP_STACK";
3449 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3450 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3451 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3452 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3461 get_ia64_segment_type (unsigned long type
)
3465 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3466 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3467 case PT_HP_TLS
: return "HP_TLS";
3468 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3469 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3470 case PT_IA_64_HP_STACK
: return "HP_STACK";
3479 get_tic6x_segment_type (unsigned long type
)
3483 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3492 get_segment_type (unsigned long p_type
)
3494 static char buff
[32];
3498 case PT_NULL
: return "NULL";
3499 case PT_LOAD
: return "LOAD";
3500 case PT_DYNAMIC
: return "DYNAMIC";
3501 case PT_INTERP
: return "INTERP";
3502 case PT_NOTE
: return "NOTE";
3503 case PT_SHLIB
: return "SHLIB";
3504 case PT_PHDR
: return "PHDR";
3505 case PT_TLS
: return "TLS";
3507 case PT_GNU_EH_FRAME
:
3508 return "GNU_EH_FRAME";
3509 case PT_GNU_STACK
: return "GNU_STACK";
3510 case PT_GNU_RELRO
: return "GNU_RELRO";
3513 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3515 const char * result
;
3517 switch (elf_header
.e_machine
)
3520 result
= get_aarch64_segment_type (p_type
);
3523 result
= get_arm_segment_type (p_type
);
3526 case EM_MIPS_RS3_LE
:
3527 result
= get_mips_segment_type (p_type
);
3530 result
= get_parisc_segment_type (p_type
);
3533 result
= get_ia64_segment_type (p_type
);
3536 result
= get_tic6x_segment_type (p_type
);
3546 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3548 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3550 const char * result
;
3552 switch (elf_header
.e_machine
)
3555 result
= get_parisc_segment_type (p_type
);
3558 result
= get_ia64_segment_type (p_type
);
3568 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3571 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3578 get_mips_section_type_name (unsigned int sh_type
)
3582 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3583 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3584 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3585 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3586 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3587 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3588 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3589 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3590 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3591 case SHT_MIPS_RELD
: return "MIPS_RELD";
3592 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3593 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3594 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3595 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3596 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3597 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3598 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3599 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3600 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3601 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3602 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3603 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3604 case SHT_MIPS_LINE
: return "MIPS_LINE";
3605 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3606 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3607 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3608 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3609 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3610 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3611 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3612 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3613 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3614 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3615 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3616 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3617 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3618 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3619 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3620 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3621 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3629 get_parisc_section_type_name (unsigned int sh_type
)
3633 case SHT_PARISC_EXT
: return "PARISC_EXT";
3634 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3635 case SHT_PARISC_DOC
: return "PARISC_DOC";
3636 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3637 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3638 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3639 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3647 get_ia64_section_type_name (unsigned int sh_type
)
3649 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3650 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3651 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3655 case SHT_IA_64_EXT
: return "IA_64_EXT";
3656 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3657 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3658 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3659 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3660 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3661 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3662 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3663 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3664 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3672 get_x86_64_section_type_name (unsigned int sh_type
)
3676 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3684 get_aarch64_section_type_name (unsigned int sh_type
)
3688 case SHT_AARCH64_ATTRIBUTES
:
3689 return "AARCH64_ATTRIBUTES";
3697 get_arm_section_type_name (unsigned int sh_type
)
3701 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3702 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3703 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3704 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3705 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3713 get_tic6x_section_type_name (unsigned int sh_type
)
3717 case SHT_C6000_UNWIND
:
3718 return "C6000_UNWIND";
3719 case SHT_C6000_PREEMPTMAP
:
3720 return "C6000_PREEMPTMAP";
3721 case SHT_C6000_ATTRIBUTES
:
3722 return "C6000_ATTRIBUTES";
3727 case SHT_TI_HANDLER
:
3728 return "TI_HANDLER";
3729 case SHT_TI_INITINFO
:
3730 return "TI_INITINFO";
3731 case SHT_TI_PHATTRS
:
3732 return "TI_PHATTRS";
3740 get_msp430x_section_type_name (unsigned int sh_type
)
3744 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3745 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3746 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3747 default: return NULL
;
3752 get_v850_section_type_name (unsigned int sh_type
)
3756 case SHT_V850_SCOMMON
: return "V850 Small Common";
3757 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3758 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3759 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3760 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3761 default: return NULL
;
3766 get_section_type_name (unsigned int sh_type
)
3768 static char buff
[32];
3772 case SHT_NULL
: return "NULL";
3773 case SHT_PROGBITS
: return "PROGBITS";
3774 case SHT_SYMTAB
: return "SYMTAB";
3775 case SHT_STRTAB
: return "STRTAB";
3776 case SHT_RELA
: return "RELA";
3777 case SHT_HASH
: return "HASH";
3778 case SHT_DYNAMIC
: return "DYNAMIC";
3779 case SHT_NOTE
: return "NOTE";
3780 case SHT_NOBITS
: return "NOBITS";
3781 case SHT_REL
: return "REL";
3782 case SHT_SHLIB
: return "SHLIB";
3783 case SHT_DYNSYM
: return "DYNSYM";
3784 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3785 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3786 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3787 case SHT_GNU_HASH
: return "GNU_HASH";
3788 case SHT_GROUP
: return "GROUP";
3789 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3790 case SHT_GNU_verdef
: return "VERDEF";
3791 case SHT_GNU_verneed
: return "VERNEED";
3792 case SHT_GNU_versym
: return "VERSYM";
3793 case 0x6ffffff0: return "VERSYM";
3794 case 0x6ffffffc: return "VERDEF";
3795 case 0x7ffffffd: return "AUXILIARY";
3796 case 0x7fffffff: return "FILTER";
3797 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3800 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3802 const char * result
;
3804 switch (elf_header
.e_machine
)
3807 case EM_MIPS_RS3_LE
:
3808 result
= get_mips_section_type_name (sh_type
);
3811 result
= get_parisc_section_type_name (sh_type
);
3814 result
= get_ia64_section_type_name (sh_type
);
3819 result
= get_x86_64_section_type_name (sh_type
);
3822 result
= get_aarch64_section_type_name (sh_type
);
3825 result
= get_arm_section_type_name (sh_type
);
3828 result
= get_tic6x_section_type_name (sh_type
);
3831 result
= get_msp430x_section_type_name (sh_type
);
3835 case EM_CYGNUS_V850
:
3836 result
= get_v850_section_type_name (sh_type
);
3846 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3848 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3850 const char * result
;
3852 switch (elf_header
.e_machine
)
3855 result
= get_ia64_section_type_name (sh_type
);
3865 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3867 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3869 switch (elf_header
.e_machine
)
3873 case EM_CYGNUS_V850
:
3874 return get_v850_section_type_name (sh_type
);
3879 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3882 /* This message is probably going to be displayed in a 15
3883 character wide field, so put the hex value first. */
3884 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3890 #define OPTION_DEBUG_DUMP 512
3891 #define OPTION_DYN_SYMS 513
3892 #define OPTION_DWARF_DEPTH 514
3893 #define OPTION_DWARF_START 515
3894 #define OPTION_DWARF_CHECK 516
3896 static struct option options
[] =
3898 {"all", no_argument
, 0, 'a'},
3899 {"file-header", no_argument
, 0, 'h'},
3900 {"program-headers", no_argument
, 0, 'l'},
3901 {"headers", no_argument
, 0, 'e'},
3902 {"histogram", no_argument
, 0, 'I'},
3903 {"segments", no_argument
, 0, 'l'},
3904 {"sections", no_argument
, 0, 'S'},
3905 {"section-headers", no_argument
, 0, 'S'},
3906 {"section-groups", no_argument
, 0, 'g'},
3907 {"section-details", no_argument
, 0, 't'},
3908 {"full-section-name",no_argument
, 0, 'N'},
3909 {"symbols", no_argument
, 0, 's'},
3910 {"syms", no_argument
, 0, 's'},
3911 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3912 {"relocs", no_argument
, 0, 'r'},
3913 {"notes", no_argument
, 0, 'n'},
3914 {"dynamic", no_argument
, 0, 'd'},
3915 {"arch-specific", no_argument
, 0, 'A'},
3916 {"version-info", no_argument
, 0, 'V'},
3917 {"use-dynamic", no_argument
, 0, 'D'},
3918 {"unwind", no_argument
, 0, 'u'},
3919 {"archive-index", no_argument
, 0, 'c'},
3920 {"hex-dump", required_argument
, 0, 'x'},
3921 {"relocated-dump", required_argument
, 0, 'R'},
3922 {"string-dump", required_argument
, 0, 'p'},
3923 #ifdef SUPPORT_DISASSEMBLY
3924 {"instruction-dump", required_argument
, 0, 'i'},
3926 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3928 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3929 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3930 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3932 {"version", no_argument
, 0, 'v'},
3933 {"wide", no_argument
, 0, 'W'},
3934 {"help", no_argument
, 0, 'H'},
3935 {0, no_argument
, 0, 0}
3939 usage (FILE * stream
)
3941 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3942 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3943 fprintf (stream
, _(" Options are:\n\
3944 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3945 -h --file-header Display the ELF file header\n\
3946 -l --program-headers Display the program headers\n\
3947 --segments An alias for --program-headers\n\
3948 -S --section-headers Display the sections' header\n\
3949 --sections An alias for --section-headers\n\
3950 -g --section-groups Display the section groups\n\
3951 -t --section-details Display the section details\n\
3952 -e --headers Equivalent to: -h -l -S\n\
3953 -s --syms Display the symbol table\n\
3954 --symbols An alias for --syms\n\
3955 --dyn-syms Display the dynamic symbol table\n\
3956 -n --notes Display the core notes (if present)\n\
3957 -r --relocs Display the relocations (if present)\n\
3958 -u --unwind Display the unwind info (if present)\n\
3959 -d --dynamic Display the dynamic section (if present)\n\
3960 -V --version-info Display the version sections (if present)\n\
3961 -A --arch-specific Display architecture specific information (if any)\n\
3962 -c --archive-index Display the symbol/file index in an archive\n\
3963 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3964 -x --hex-dump=<number|name>\n\
3965 Dump the contents of section <number|name> as bytes\n\
3966 -p --string-dump=<number|name>\n\
3967 Dump the contents of section <number|name> as strings\n\
3968 -R --relocated-dump=<number|name>\n\
3969 Dump the contents of section <number|name> as relocated bytes\n\
3970 -w[lLiaprmfFsoRt] or\n\
3971 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3972 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3973 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3975 Display the contents of DWARF2 debug sections\n"));
3976 fprintf (stream
, _("\
3977 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3978 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3980 #ifdef SUPPORT_DISASSEMBLY
3981 fprintf (stream
, _("\
3982 -i --instruction-dump=<number|name>\n\
3983 Disassemble the contents of section <number|name>\n"));
3985 fprintf (stream
, _("\
3986 -I --histogram Display histogram of bucket list lengths\n\
3987 -W --wide Allow output width to exceed 80 characters\n\
3988 @<file> Read options from <file>\n\
3989 -H --help Display this information\n\
3990 -v --version Display the version number of readelf\n"));
3992 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3993 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3995 exit (stream
== stdout
? 0 : 1);
3998 /* Record the fact that the user wants the contents of section number
3999 SECTION to be displayed using the method(s) encoded as flags bits
4000 in TYPE. Note, TYPE can be zero if we are creating the array for
4004 request_dump_bynumber (unsigned int section
, dump_type type
)
4006 if (section
>= num_dump_sects
)
4008 dump_type
* new_dump_sects
;
4010 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4011 sizeof (* dump_sects
));
4013 if (new_dump_sects
== NULL
)
4014 error (_("Out of memory allocating dump request table.\n"));
4017 /* Copy current flag settings. */
4018 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4022 dump_sects
= new_dump_sects
;
4023 num_dump_sects
= section
+ 1;
4028 dump_sects
[section
] |= type
;
4033 /* Request a dump by section name. */
4036 request_dump_byname (const char * section
, dump_type type
)
4038 struct dump_list_entry
* new_request
;
4040 new_request
= (struct dump_list_entry
*)
4041 malloc (sizeof (struct dump_list_entry
));
4043 error (_("Out of memory allocating dump request table.\n"));
4045 new_request
->name
= strdup (section
);
4046 if (!new_request
->name
)
4047 error (_("Out of memory allocating dump request table.\n"));
4049 new_request
->type
= type
;
4051 new_request
->next
= dump_sects_byname
;
4052 dump_sects_byname
= new_request
;
4056 request_dump (dump_type type
)
4062 section
= strtoul (optarg
, & cp
, 0);
4064 if (! *cp
&& section
>= 0)
4065 request_dump_bynumber (section
, type
);
4067 request_dump_byname (optarg
, type
);
4072 parse_args (int argc
, char ** argv
)
4079 while ((c
= getopt_long
4080 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
4098 do_section_groups
++;
4106 do_section_groups
++;
4111 do_section_details
++;
4155 request_dump (HEX_DUMP
);
4158 request_dump (STRING_DUMP
);
4161 request_dump (RELOC_DUMP
);
4168 dwarf_select_sections_all ();
4173 dwarf_select_sections_by_letters (optarg
);
4176 case OPTION_DEBUG_DUMP
:
4183 dwarf_select_sections_by_names (optarg
);
4186 case OPTION_DWARF_DEPTH
:
4190 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4193 case OPTION_DWARF_START
:
4197 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4200 case OPTION_DWARF_CHECK
:
4203 case OPTION_DYN_SYMS
:
4206 #ifdef SUPPORT_DISASSEMBLY
4208 request_dump (DISASS_DUMP
);
4212 print_version (program_name
);
4221 /* xgettext:c-format */
4222 error (_("Invalid option '-%c'\n"), c
);
4229 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4230 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4231 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4232 && !do_section_groups
&& !do_archive_index
4238 get_elf_class (unsigned int elf_class
)
4240 static char buff
[32];
4244 case ELFCLASSNONE
: return _("none");
4245 case ELFCLASS32
: return "ELF32";
4246 case ELFCLASS64
: return "ELF64";
4248 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4254 get_data_encoding (unsigned int encoding
)
4256 static char buff
[32];
4260 case ELFDATANONE
: return _("none");
4261 case ELFDATA2LSB
: return _("2's complement, little endian");
4262 case ELFDATA2MSB
: return _("2's complement, big endian");
4264 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4269 /* Decode the data held in 'elf_header'. */
4272 process_file_header (void)
4274 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4275 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4276 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4277 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4280 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4284 init_dwarf_regnames (elf_header
.e_machine
);
4290 printf (_("ELF Header:\n"));
4291 printf (_(" Magic: "));
4292 for (i
= 0; i
< EI_NIDENT
; i
++)
4293 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4295 printf (_(" Class: %s\n"),
4296 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4297 printf (_(" Data: %s\n"),
4298 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4299 printf (_(" Version: %d %s\n"),
4300 elf_header
.e_ident
[EI_VERSION
],
4301 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4303 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4304 ? _("<unknown: %lx>")
4306 printf (_(" OS/ABI: %s\n"),
4307 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4308 printf (_(" ABI Version: %d\n"),
4309 elf_header
.e_ident
[EI_ABIVERSION
]);
4310 printf (_(" Type: %s\n"),
4311 get_file_type (elf_header
.e_type
));
4312 printf (_(" Machine: %s\n"),
4313 get_machine_name (elf_header
.e_machine
));
4314 printf (_(" Version: 0x%lx\n"),
4315 (unsigned long) elf_header
.e_version
);
4317 printf (_(" Entry point address: "));
4318 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4319 printf (_("\n Start of program headers: "));
4320 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4321 printf (_(" (bytes into file)\n Start of section headers: "));
4322 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4323 printf (_(" (bytes into file)\n"));
4325 printf (_(" Flags: 0x%lx%s\n"),
4326 (unsigned long) elf_header
.e_flags
,
4327 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4328 printf (_(" Size of this header: %ld (bytes)\n"),
4329 (long) elf_header
.e_ehsize
);
4330 printf (_(" Size of program headers: %ld (bytes)\n"),
4331 (long) elf_header
.e_phentsize
);
4332 printf (_(" Number of program headers: %ld"),
4333 (long) elf_header
.e_phnum
);
4334 if (section_headers
!= NULL
4335 && elf_header
.e_phnum
== PN_XNUM
4336 && section_headers
[0].sh_info
!= 0)
4337 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4338 putc ('\n', stdout
);
4339 printf (_(" Size of section headers: %ld (bytes)\n"),
4340 (long) elf_header
.e_shentsize
);
4341 printf (_(" Number of section headers: %ld"),
4342 (long) elf_header
.e_shnum
);
4343 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4344 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4345 putc ('\n', stdout
);
4346 printf (_(" Section header string table index: %ld"),
4347 (long) elf_header
.e_shstrndx
);
4348 if (section_headers
!= NULL
4349 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4350 printf (" (%u)", section_headers
[0].sh_link
);
4351 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4352 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4353 printf (_(" <corrupt: out of range>"));
4354 putc ('\n', stdout
);
4357 if (section_headers
!= NULL
)
4359 if (elf_header
.e_phnum
== PN_XNUM
4360 && section_headers
[0].sh_info
!= 0)
4361 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4362 if (elf_header
.e_shnum
== SHN_UNDEF
)
4363 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4364 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4365 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4366 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4367 elf_header
.e_shstrndx
= SHN_UNDEF
;
4368 free (section_headers
);
4369 section_headers
= NULL
;
4376 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4378 Elf32_External_Phdr
* phdrs
;
4379 Elf32_External_Phdr
* external
;
4380 Elf_Internal_Phdr
* internal
;
4382 unsigned int size
= elf_header
.e_phentsize
;
4383 unsigned int num
= elf_header
.e_phnum
;
4385 /* PR binutils/17531: Cope with unexpected section header sizes. */
4386 if (size
== 0 || num
== 0)
4388 if (size
< sizeof * phdrs
)
4390 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4393 if (size
> sizeof * phdrs
)
4394 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4396 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4397 size
, num
, _("program headers"));
4401 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4402 i
< elf_header
.e_phnum
;
4403 i
++, internal
++, external
++)
4405 internal
->p_type
= BYTE_GET (external
->p_type
);
4406 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4407 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4408 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4409 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4410 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4411 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4412 internal
->p_align
= BYTE_GET (external
->p_align
);
4420 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4422 Elf64_External_Phdr
* phdrs
;
4423 Elf64_External_Phdr
* external
;
4424 Elf_Internal_Phdr
* internal
;
4426 unsigned int size
= elf_header
.e_phentsize
;
4427 unsigned int num
= elf_header
.e_phnum
;
4429 /* PR binutils/17531: Cope with unexpected section header sizes. */
4430 if (size
== 0 || num
== 0)
4432 if (size
< sizeof * phdrs
)
4434 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4437 if (size
> sizeof * phdrs
)
4438 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4440 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4441 size
, num
, _("program headers"));
4445 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4446 i
< elf_header
.e_phnum
;
4447 i
++, internal
++, external
++)
4449 internal
->p_type
= BYTE_GET (external
->p_type
);
4450 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4451 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4452 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4453 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4454 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4455 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4456 internal
->p_align
= BYTE_GET (external
->p_align
);
4463 /* Returns 1 if the program headers were read into `program_headers'. */
4466 get_program_headers (FILE * file
)
4468 Elf_Internal_Phdr
* phdrs
;
4470 /* Check cache of prior read. */
4471 if (program_headers
!= NULL
)
4474 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4475 sizeof (Elf_Internal_Phdr
));
4479 error (_("Out of memory reading %u program headers\n"),
4480 elf_header
.e_phnum
);
4485 ? get_32bit_program_headers (file
, phdrs
)
4486 : get_64bit_program_headers (file
, phdrs
))
4488 program_headers
= phdrs
;
4496 /* Returns 1 if the program headers were loaded. */
4499 process_program_headers (FILE * file
)
4501 Elf_Internal_Phdr
* segment
;
4504 if (elf_header
.e_phnum
== 0)
4506 /* PR binutils/12467. */
4507 if (elf_header
.e_phoff
!= 0)
4508 warn (_("possibly corrupt ELF header - it has a non-zero program"
4509 " header offset, but no program headers\n"));
4510 else if (do_segments
)
4511 printf (_("\nThere are no program headers in this file.\n"));
4515 if (do_segments
&& !do_header
)
4517 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4518 printf (_("Entry point "));
4519 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4520 printf (_("\nThere are %d program headers, starting at offset "),
4521 elf_header
.e_phnum
);
4522 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4526 if (! get_program_headers (file
))
4531 if (elf_header
.e_phnum
> 1)
4532 printf (_("\nProgram Headers:\n"));
4534 printf (_("\nProgram Headers:\n"));
4538 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4541 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4545 (_(" Type Offset VirtAddr PhysAddr\n"));
4547 (_(" FileSiz MemSiz Flags Align\n"));
4554 for (i
= 0, segment
= program_headers
;
4555 i
< elf_header
.e_phnum
;
4560 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4564 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4565 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4566 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4567 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4568 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4570 (segment
->p_flags
& PF_R
? 'R' : ' '),
4571 (segment
->p_flags
& PF_W
? 'W' : ' '),
4572 (segment
->p_flags
& PF_X
? 'E' : ' '));
4573 printf ("%#lx", (unsigned long) segment
->p_align
);
4577 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4578 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4581 print_vma (segment
->p_offset
, FULL_HEX
);
4585 print_vma (segment
->p_vaddr
, FULL_HEX
);
4587 print_vma (segment
->p_paddr
, FULL_HEX
);
4590 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4591 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4594 print_vma (segment
->p_filesz
, FULL_HEX
);
4598 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4599 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4602 print_vma (segment
->p_memsz
, FULL_HEX
);
4606 (segment
->p_flags
& PF_R
? 'R' : ' '),
4607 (segment
->p_flags
& PF_W
? 'W' : ' '),
4608 (segment
->p_flags
& PF_X
? 'E' : ' '));
4610 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4611 printf ("%#lx", (unsigned long) segment
->p_align
);
4614 print_vma (segment
->p_align
, PREFIX_HEX
);
4619 print_vma (segment
->p_offset
, FULL_HEX
);
4621 print_vma (segment
->p_vaddr
, FULL_HEX
);
4623 print_vma (segment
->p_paddr
, FULL_HEX
);
4625 print_vma (segment
->p_filesz
, FULL_HEX
);
4627 print_vma (segment
->p_memsz
, FULL_HEX
);
4629 (segment
->p_flags
& PF_R
? 'R' : ' '),
4630 (segment
->p_flags
& PF_W
? 'W' : ' '),
4631 (segment
->p_flags
& PF_X
? 'E' : ' '));
4632 print_vma (segment
->p_align
, HEX
);
4637 putc ('\n', stdout
);
4639 switch (segment
->p_type
)
4643 error (_("more than one dynamic segment\n"));
4645 /* By default, assume that the .dynamic section is the first
4646 section in the DYNAMIC segment. */
4647 dynamic_addr
= segment
->p_offset
;
4648 dynamic_size
= segment
->p_filesz
;
4649 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4650 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4652 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4653 dynamic_addr
= dynamic_size
= 0;
4656 /* Try to locate the .dynamic section. If there is
4657 a section header table, we can easily locate it. */
4658 if (section_headers
!= NULL
)
4660 Elf_Internal_Shdr
* sec
;
4662 sec
= find_section (".dynamic");
4663 if (sec
== NULL
|| sec
->sh_size
== 0)
4665 /* A corresponding .dynamic section is expected, but on
4666 IA-64/OpenVMS it is OK for it to be missing. */
4667 if (!is_ia64_vms ())
4668 error (_("no .dynamic section in the dynamic segment\n"));
4672 if (sec
->sh_type
== SHT_NOBITS
)
4678 dynamic_addr
= sec
->sh_offset
;
4679 dynamic_size
= sec
->sh_size
;
4681 if (dynamic_addr
< segment
->p_offset
4682 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4683 warn (_("the .dynamic section is not contained"
4684 " within the dynamic segment\n"));
4685 else if (dynamic_addr
> segment
->p_offset
)
4686 warn (_("the .dynamic section is not the first section"
4687 " in the dynamic segment.\n"));
4692 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4694 error (_("Unable to find program interpreter name\n"));
4698 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4700 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4701 error (_("Internal error: failed to create format string to display program interpreter\n"));
4703 program_interpreter
[0] = 0;
4704 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4705 error (_("Unable to read program interpreter name\n"));
4708 printf (_(" [Requesting program interpreter: %s]\n"),
4709 program_interpreter
);
4715 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4717 printf (_("\n Section to Segment mapping:\n"));
4718 printf (_(" Segment Sections...\n"));
4720 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4723 Elf_Internal_Shdr
* section
;
4725 segment
= program_headers
+ i
;
4726 section
= section_headers
+ 1;
4728 printf (" %2.2d ", i
);
4730 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4732 if (!ELF_TBSS_SPECIAL (section
, segment
)
4733 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4734 printf ("%s ", printable_section_name (section
));
4745 /* Find the file offset corresponding to VMA by using the program headers. */
4748 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4750 Elf_Internal_Phdr
* seg
;
4752 if (! get_program_headers (file
))
4754 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4758 for (seg
= program_headers
;
4759 seg
< program_headers
+ elf_header
.e_phnum
;
4762 if (seg
->p_type
!= PT_LOAD
)
4765 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4766 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4767 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4770 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4771 (unsigned long) vma
);
4776 /* Allocate memory and load the sections headers into the global pointer
4777 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4778 generate any error messages if the load fails. */
4781 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4783 Elf32_External_Shdr
* shdrs
;
4784 Elf_Internal_Shdr
* internal
;
4786 unsigned int size
= elf_header
.e_shentsize
;
4787 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4789 /* PR binutils/17531: Cope with unexpected section header sizes. */
4790 if (size
== 0 || num
== 0)
4792 if (size
< sizeof * shdrs
)
4795 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4798 if (!probe
&& size
> sizeof * shdrs
)
4799 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4801 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4803 probe
? NULL
: _("section headers"));
4807 if (section_headers
!= NULL
)
4808 free (section_headers
);
4809 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4810 sizeof (Elf_Internal_Shdr
));
4811 if (section_headers
== NULL
)
4814 error (_("Out of memory reading %u section headers\n"), num
);
4818 for (i
= 0, internal
= section_headers
;
4822 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4823 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4824 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4825 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4826 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4827 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4828 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4829 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4830 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4831 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4839 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4841 Elf64_External_Shdr
* shdrs
;
4842 Elf_Internal_Shdr
* internal
;
4844 unsigned int size
= elf_header
.e_shentsize
;
4845 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4847 /* PR binutils/17531: Cope with unexpected section header sizes. */
4848 if (size
== 0 || num
== 0)
4850 if (size
< sizeof * shdrs
)
4853 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4856 if (! probe
&& size
> sizeof * shdrs
)
4857 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4859 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4861 probe
? NULL
: _("section headers"));
4865 if (section_headers
!= NULL
)
4866 free (section_headers
);
4867 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4868 sizeof (Elf_Internal_Shdr
));
4869 if (section_headers
== NULL
)
4872 error (_("Out of memory reading %u section headers\n"), num
);
4876 for (i
= 0, internal
= section_headers
;
4880 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4881 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4882 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4883 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4884 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4885 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4886 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4887 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4888 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4889 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4896 static Elf_Internal_Sym
*
4897 get_32bit_elf_symbols (FILE * file
,
4898 Elf_Internal_Shdr
* section
,
4899 unsigned long * num_syms_return
)
4901 unsigned long number
= 0;
4902 Elf32_External_Sym
* esyms
= NULL
;
4903 Elf_External_Sym_Shndx
* shndx
= NULL
;
4904 Elf_Internal_Sym
* isyms
= NULL
;
4905 Elf_Internal_Sym
* psym
;
4908 if (section
->sh_size
== 0)
4910 if (num_syms_return
!= NULL
)
4911 * num_syms_return
= 0;
4915 /* Run some sanity checks first. */
4916 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4918 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4919 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4923 if (section
->sh_size
> current_file_size
)
4925 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4926 printable_section_name (section
), (unsigned long) section
->sh_size
);
4930 number
= section
->sh_size
/ section
->sh_entsize
;
4932 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4934 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4935 (unsigned long) section
->sh_size
,
4936 printable_section_name (section
),
4937 (unsigned long) section
->sh_entsize
);
4941 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4942 section
->sh_size
, _("symbols"));
4947 if (symtab_shndx_hdr
!= NULL
4948 && (symtab_shndx_hdr
->sh_link
4949 == (unsigned long) (section
- section_headers
)))
4951 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4952 symtab_shndx_hdr
->sh_offset
,
4953 1, symtab_shndx_hdr
->sh_size
,
4954 _("symbol table section indicies"));
4957 /* PR17531: file: heap-buffer-overflow */
4958 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
4960 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4961 printable_section_name (symtab_shndx_hdr
),
4962 (unsigned long) symtab_shndx_hdr
->sh_size
,
4963 (unsigned long) section
->sh_size
);
4968 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4972 error (_("Out of memory reading %lu symbols\n"),
4973 (unsigned long) number
);
4977 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4979 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4980 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4981 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4982 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4983 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4985 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4986 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4987 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4988 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4989 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4998 if (num_syms_return
!= NULL
)
4999 * num_syms_return
= isyms
== NULL
? 0 : number
;
5004 static Elf_Internal_Sym
*
5005 get_64bit_elf_symbols (FILE * file
,
5006 Elf_Internal_Shdr
* section
,
5007 unsigned long * num_syms_return
)
5009 unsigned long number
= 0;
5010 Elf64_External_Sym
* esyms
= NULL
;
5011 Elf_External_Sym_Shndx
* shndx
= NULL
;
5012 Elf_Internal_Sym
* isyms
= NULL
;
5013 Elf_Internal_Sym
* psym
;
5016 if (section
->sh_size
== 0)
5018 if (num_syms_return
!= NULL
)
5019 * num_syms_return
= 0;
5023 /* Run some sanity checks first. */
5024 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5026 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5027 printable_section_name (section
),
5028 (unsigned long) section
->sh_entsize
);
5032 if (section
->sh_size
> current_file_size
)
5034 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5035 printable_section_name (section
),
5036 (unsigned long) section
->sh_size
);
5040 number
= section
->sh_size
/ section
->sh_entsize
;
5042 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5044 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5045 (unsigned long) section
->sh_size
,
5046 printable_section_name (section
),
5047 (unsigned long) section
->sh_entsize
);
5051 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5052 section
->sh_size
, _("symbols"));
5056 if (symtab_shndx_hdr
!= NULL
5057 && (symtab_shndx_hdr
->sh_link
5058 == (unsigned long) (section
- section_headers
)))
5060 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5061 symtab_shndx_hdr
->sh_offset
,
5062 1, symtab_shndx_hdr
->sh_size
,
5063 _("symbol table section indicies"));
5066 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5068 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5069 printable_section_name (symtab_shndx_hdr
),
5070 (unsigned long) symtab_shndx_hdr
->sh_size
,
5071 (unsigned long) section
->sh_size
);
5076 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5080 error (_("Out of memory reading %lu symbols\n"),
5081 (unsigned long) number
);
5085 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5087 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5088 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5089 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5090 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5092 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5094 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5095 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5096 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5098 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5099 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5108 if (num_syms_return
!= NULL
)
5109 * num_syms_return
= isyms
== NULL
? 0 : number
;
5115 get_elf_section_flags (bfd_vma sh_flags
)
5117 static char buff
[1024];
5119 int field_size
= is_32bit_elf
? 8 : 16;
5121 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5122 bfd_vma os_flags
= 0;
5123 bfd_vma proc_flags
= 0;
5124 bfd_vma unknown_flags
= 0;
5132 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5133 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5134 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5135 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5136 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5137 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5138 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5139 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5140 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5141 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5142 /* IA-64 specific. */
5143 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5144 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5145 /* IA-64 OpenVMS specific. */
5146 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5147 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5148 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5149 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5150 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5151 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5153 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5154 /* SPARC specific. */
5155 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5158 if (do_section_details
)
5160 sprintf (buff
, "[%*.*lx]: ",
5161 field_size
, field_size
, (unsigned long) sh_flags
);
5162 p
+= field_size
+ 4;
5169 flag
= sh_flags
& - sh_flags
;
5172 if (do_section_details
)
5176 case SHF_WRITE
: sindex
= 0; break;
5177 case SHF_ALLOC
: sindex
= 1; break;
5178 case SHF_EXECINSTR
: sindex
= 2; break;
5179 case SHF_MERGE
: sindex
= 3; break;
5180 case SHF_STRINGS
: sindex
= 4; break;
5181 case SHF_INFO_LINK
: sindex
= 5; break;
5182 case SHF_LINK_ORDER
: sindex
= 6; break;
5183 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5184 case SHF_GROUP
: sindex
= 8; break;
5185 case SHF_TLS
: sindex
= 9; break;
5186 case SHF_EXCLUDE
: sindex
= 18; break;
5190 switch (elf_header
.e_machine
)
5193 if (flag
== SHF_IA_64_SHORT
)
5195 else if (flag
== SHF_IA_64_NORECOV
)
5198 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5201 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5202 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5203 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5204 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5205 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5206 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5217 case EM_OLD_SPARCV9
:
5218 case EM_SPARC32PLUS
:
5221 if (flag
== SHF_ORDERED
)
5231 if (p
!= buff
+ field_size
+ 4)
5233 if (size
< (10 + 2))
5235 warn (_("Internal error: not enough buffer room for section flag info"));
5236 return _("<unknown>");
5243 size
-= flags
[sindex
].len
;
5244 p
= stpcpy (p
, flags
[sindex
].str
);
5246 else if (flag
& SHF_MASKOS
)
5248 else if (flag
& SHF_MASKPROC
)
5251 unknown_flags
|= flag
;
5257 case SHF_WRITE
: *p
= 'W'; break;
5258 case SHF_ALLOC
: *p
= 'A'; break;
5259 case SHF_EXECINSTR
: *p
= 'X'; break;
5260 case SHF_MERGE
: *p
= 'M'; break;
5261 case SHF_STRINGS
: *p
= 'S'; break;
5262 case SHF_INFO_LINK
: *p
= 'I'; break;
5263 case SHF_LINK_ORDER
: *p
= 'L'; break;
5264 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5265 case SHF_GROUP
: *p
= 'G'; break;
5266 case SHF_TLS
: *p
= 'T'; break;
5267 case SHF_EXCLUDE
: *p
= 'E'; break;
5270 if ((elf_header
.e_machine
== EM_X86_64
5271 || elf_header
.e_machine
== EM_L1OM
5272 || elf_header
.e_machine
== EM_K1OM
)
5273 && flag
== SHF_X86_64_LARGE
)
5275 else if (flag
& SHF_MASKOS
)
5278 sh_flags
&= ~ SHF_MASKOS
;
5280 else if (flag
& SHF_MASKPROC
)
5283 sh_flags
&= ~ SHF_MASKPROC
;
5293 if (do_section_details
)
5297 size
-= 5 + field_size
;
5298 if (p
!= buff
+ field_size
+ 4)
5302 warn (_("Internal error: not enough buffer room for section flag info"));
5303 return _("<unknown>");
5309 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5310 (unsigned long) os_flags
);
5311 p
+= 5 + field_size
;
5315 size
-= 7 + field_size
;
5316 if (p
!= buff
+ field_size
+ 4)
5320 warn (_("Internal error: not enough buffer room for section flag info"));
5321 return _("<unknown>");
5327 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5328 (unsigned long) proc_flags
);
5329 p
+= 7 + field_size
;
5333 size
-= 10 + field_size
;
5334 if (p
!= buff
+ field_size
+ 4)
5338 warn (_("Internal error: not enough buffer room for section flag info"));
5339 return _("<unknown>");
5345 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5346 (unsigned long) unknown_flags
);
5347 p
+= 10 + field_size
;
5356 process_section_headers (FILE * file
)
5358 Elf_Internal_Shdr
* section
;
5361 section_headers
= NULL
;
5363 if (elf_header
.e_shnum
== 0)
5365 /* PR binutils/12467. */
5366 if (elf_header
.e_shoff
!= 0)
5367 warn (_("possibly corrupt ELF file header - it has a non-zero"
5368 " section header offset, but no section headers\n"));
5369 else if (do_sections
)
5370 printf (_("\nThere are no sections in this file.\n"));
5375 if (do_sections
&& !do_header
)
5376 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5377 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5381 if (! get_32bit_section_headers (file
, FALSE
))
5384 else if (! get_64bit_section_headers (file
, FALSE
))
5387 /* Read in the string table, so that we have names to display. */
5388 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5389 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5391 section
= section_headers
+ elf_header
.e_shstrndx
;
5393 if (section
->sh_size
!= 0)
5395 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5396 1, section
->sh_size
,
5399 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5403 /* Scan the sections for the dynamic symbol table
5404 and dynamic string table and debug sections. */
5405 dynamic_symbols
= NULL
;
5406 dynamic_strings
= NULL
;
5407 dynamic_syminfo
= NULL
;
5408 symtab_shndx_hdr
= NULL
;
5410 eh_addr_size
= is_32bit_elf
? 4 : 8;
5411 switch (elf_header
.e_machine
)
5414 case EM_MIPS_RS3_LE
:
5415 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5416 FDE addresses. However, the ABI also has a semi-official ILP32
5417 variant for which the normal FDE address size rules apply.
5419 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5420 section, where XX is the size of longs in bits. Unfortunately,
5421 earlier compilers provided no way of distinguishing ILP32 objects
5422 from LP64 objects, so if there's any doubt, we should assume that
5423 the official LP64 form is being used. */
5424 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5425 && find_section (".gcc_compiled_long32") == NULL
)
5431 switch (elf_header
.e_flags
& EF_H8_MACH
)
5433 case E_H8_MACH_H8300
:
5434 case E_H8_MACH_H8300HN
:
5435 case E_H8_MACH_H8300SN
:
5436 case E_H8_MACH_H8300SXN
:
5439 case E_H8_MACH_H8300H
:
5440 case E_H8_MACH_H8300S
:
5441 case E_H8_MACH_H8300SX
:
5449 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5451 case EF_M32C_CPU_M16C
:
5458 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5461 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5462 if (section->sh_entsize != expected_entsize) \
5465 sprintf_vma (buf, section->sh_entsize); \
5466 /* Note: coded this way so that there is a single string for \
5468 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5469 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5470 (unsigned) expected_entsize); \
5471 section->sh_entsize = expected_entsize; \
5476 #define CHECK_ENTSIZE(section, i, type) \
5477 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5478 sizeof (Elf64_External_##type))
5480 for (i
= 0, section
= section_headers
;
5481 i
< elf_header
.e_shnum
;
5484 char * name
= SECTION_NAME (section
);
5486 if (section
->sh_type
== SHT_DYNSYM
)
5488 if (dynamic_symbols
!= NULL
)
5490 error (_("File contains multiple dynamic symbol tables\n"));
5494 CHECK_ENTSIZE (section
, i
, Sym
);
5495 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5497 else if (section
->sh_type
== SHT_STRTAB
5498 && streq (name
, ".dynstr"))
5500 if (dynamic_strings
!= NULL
)
5502 error (_("File contains multiple dynamic string tables\n"));
5506 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5507 1, section
->sh_size
,
5508 _("dynamic strings"));
5509 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5511 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5513 if (symtab_shndx_hdr
!= NULL
)
5515 error (_("File contains multiple symtab shndx tables\n"));
5518 symtab_shndx_hdr
= section
;
5520 else if (section
->sh_type
== SHT_SYMTAB
)
5521 CHECK_ENTSIZE (section
, i
, Sym
);
5522 else if (section
->sh_type
== SHT_GROUP
)
5523 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5524 else if (section
->sh_type
== SHT_REL
)
5525 CHECK_ENTSIZE (section
, i
, Rel
);
5526 else if (section
->sh_type
== SHT_RELA
)
5527 CHECK_ENTSIZE (section
, i
, Rela
);
5528 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5529 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5530 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5531 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5532 || do_debug_addr
|| do_debug_cu_index
)
5533 && (const_strneq (name
, ".debug_")
5534 || const_strneq (name
, ".zdebug_")))
5537 name
+= sizeof (".zdebug_") - 1;
5539 name
+= sizeof (".debug_") - 1;
5542 || (do_debug_info
&& const_strneq (name
, "info"))
5543 || (do_debug_info
&& const_strneq (name
, "types"))
5544 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5545 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5546 || (do_debug_lines
&& const_strneq (name
, "line."))
5547 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5548 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5549 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5550 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5551 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5552 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5553 || (do_debug_frames
&& const_strneq (name
, "frame"))
5554 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5555 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5556 || (do_debug_str
&& const_strneq (name
, "str"))
5557 || (do_debug_loc
&& const_strneq (name
, "loc"))
5558 || (do_debug_addr
&& const_strneq (name
, "addr"))
5559 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5560 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5562 request_dump_bynumber (i
, DEBUG_DUMP
);
5564 /* Linkonce section to be combined with .debug_info at link time. */
5565 else if ((do_debugging
|| do_debug_info
)
5566 && const_strneq (name
, ".gnu.linkonce.wi."))
5567 request_dump_bynumber (i
, DEBUG_DUMP
);
5568 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5569 request_dump_bynumber (i
, DEBUG_DUMP
);
5570 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5571 request_dump_bynumber (i
, DEBUG_DUMP
);
5572 /* Trace sections for Itanium VMS. */
5573 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5574 || do_trace_aranges
)
5575 && const_strneq (name
, ".trace_"))
5577 name
+= sizeof (".trace_") - 1;
5580 || (do_trace_info
&& streq (name
, "info"))
5581 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5582 || (do_trace_aranges
&& streq (name
, "aranges"))
5584 request_dump_bynumber (i
, DEBUG_DUMP
);
5591 if (elf_header
.e_shnum
> 1)
5592 printf (_("\nSection Headers:\n"));
5594 printf (_("\nSection Header:\n"));
5598 if (do_section_details
)
5600 printf (_(" [Nr] Name\n"));
5601 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5605 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5609 if (do_section_details
)
5611 printf (_(" [Nr] Name\n"));
5612 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5616 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5620 if (do_section_details
)
5622 printf (_(" [Nr] Name\n"));
5623 printf (_(" Type Address Offset Link\n"));
5624 printf (_(" Size EntSize Info Align\n"));
5628 printf (_(" [Nr] Name Type Address Offset\n"));
5629 printf (_(" Size EntSize Flags Link Info Align\n"));
5633 if (do_section_details
)
5634 printf (_(" Flags\n"));
5636 for (i
= 0, section
= section_headers
;
5637 i
< elf_header
.e_shnum
;
5640 printf (" [%2u] ", i
);
5641 if (do_section_details
)
5642 printf ("%s\n ", printable_section_name (section
));
5644 print_symbol (-17, SECTION_NAME (section
));
5646 printf (do_wide
? " %-15s " : " %-15.15s ",
5647 get_section_type_name (section
->sh_type
));
5651 const char * link_too_big
= NULL
;
5653 print_vma (section
->sh_addr
, LONG_HEX
);
5655 printf ( " %6.6lx %6.6lx %2.2lx",
5656 (unsigned long) section
->sh_offset
,
5657 (unsigned long) section
->sh_size
,
5658 (unsigned long) section
->sh_entsize
);
5660 if (do_section_details
)
5661 fputs (" ", stdout
);
5663 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5665 if (section
->sh_link
>= elf_header
.e_shnum
)
5668 /* The sh_link value is out of range. Normally this indicates
5669 an error but it can have special values in Solaris binaries. */
5670 switch (elf_header
.e_machine
)
5677 case EM_OLD_SPARCV9
:
5678 case EM_SPARC32PLUS
:
5681 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5682 link_too_big
= "BEFORE";
5683 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5684 link_too_big
= "AFTER";
5691 if (do_section_details
)
5693 if (link_too_big
!= NULL
&& * link_too_big
)
5694 printf ("<%s> ", link_too_big
);
5696 printf ("%2u ", section
->sh_link
);
5697 printf ("%3u %2lu\n", section
->sh_info
,
5698 (unsigned long) section
->sh_addralign
);
5701 printf ("%2u %3u %2lu\n",
5704 (unsigned long) section
->sh_addralign
);
5706 if (link_too_big
&& ! * link_too_big
)
5707 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5708 i
, section
->sh_link
);
5712 print_vma (section
->sh_addr
, LONG_HEX
);
5714 if ((long) section
->sh_offset
== section
->sh_offset
)
5715 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5719 print_vma (section
->sh_offset
, LONG_HEX
);
5722 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5723 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5727 print_vma (section
->sh_size
, LONG_HEX
);
5730 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5731 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5735 print_vma (section
->sh_entsize
, LONG_HEX
);
5738 if (do_section_details
)
5739 fputs (" ", stdout
);
5741 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5743 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5745 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5746 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5749 print_vma (section
->sh_addralign
, DEC
);
5753 else if (do_section_details
)
5755 printf (" %-15.15s ",
5756 get_section_type_name (section
->sh_type
));
5757 print_vma (section
->sh_addr
, LONG_HEX
);
5758 if ((long) section
->sh_offset
== section
->sh_offset
)
5759 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5763 print_vma (section
->sh_offset
, LONG_HEX
);
5765 printf (" %u\n ", section
->sh_link
);
5766 print_vma (section
->sh_size
, LONG_HEX
);
5768 print_vma (section
->sh_entsize
, LONG_HEX
);
5770 printf (" %-16u %lu\n",
5772 (unsigned long) section
->sh_addralign
);
5777 print_vma (section
->sh_addr
, LONG_HEX
);
5778 if ((long) section
->sh_offset
== section
->sh_offset
)
5779 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5783 print_vma (section
->sh_offset
, LONG_HEX
);
5786 print_vma (section
->sh_size
, LONG_HEX
);
5788 print_vma (section
->sh_entsize
, LONG_HEX
);
5790 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5792 printf (" %2u %3u %lu\n",
5795 (unsigned long) section
->sh_addralign
);
5798 if (do_section_details
)
5799 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5802 if (!do_section_details
)
5804 if (elf_header
.e_machine
== EM_X86_64
5805 || elf_header
.e_machine
== EM_L1OM
5806 || elf_header
.e_machine
== EM_K1OM
)
5807 printf (_("Key to Flags:\n\
5808 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5809 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5810 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5812 printf (_("Key to Flags:\n\
5813 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5814 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5815 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5822 get_group_flags (unsigned int flags
)
5824 static char buff
[32];
5834 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5841 process_section_groups (FILE * file
)
5843 Elf_Internal_Shdr
* section
;
5845 struct group
* group
;
5846 Elf_Internal_Shdr
* symtab_sec
;
5847 Elf_Internal_Shdr
* strtab_sec
;
5848 Elf_Internal_Sym
* symtab
;
5849 unsigned long num_syms
;
5853 /* Don't process section groups unless needed. */
5854 if (!do_unwind
&& !do_section_groups
)
5857 if (elf_header
.e_shnum
== 0)
5859 if (do_section_groups
)
5860 printf (_("\nThere are no sections to group in this file.\n"));
5865 if (section_headers
== NULL
)
5867 error (_("Section headers are not available!\n"));
5868 /* PR 13622: This can happen with a corrupt ELF header. */
5872 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5873 sizeof (struct group
*));
5875 if (section_headers_groups
== NULL
)
5877 error (_("Out of memory reading %u section group headers\n"),
5878 elf_header
.e_shnum
);
5882 /* Scan the sections for the group section. */
5884 for (i
= 0, section
= section_headers
;
5885 i
< elf_header
.e_shnum
;
5887 if (section
->sh_type
== SHT_GROUP
)
5890 if (group_count
== 0)
5892 if (do_section_groups
)
5893 printf (_("\nThere are no section groups in this file.\n"));
5898 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5900 if (section_groups
== NULL
)
5902 error (_("Out of memory reading %lu groups\n"),
5903 (unsigned long) group_count
);
5913 for (i
= 0, section
= section_headers
, group
= section_groups
;
5914 i
< elf_header
.e_shnum
;
5917 if (section
->sh_type
== SHT_GROUP
)
5919 const char * name
= printable_section_name (section
);
5920 const char * group_name
;
5921 unsigned char * start
;
5922 unsigned char * indices
;
5923 unsigned int entry
, j
, size
;
5924 Elf_Internal_Shdr
* sec
;
5925 Elf_Internal_Sym
* sym
;
5927 /* Get the symbol table. */
5928 if (section
->sh_link
>= elf_header
.e_shnum
5929 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5932 error (_("Bad sh_link in group section `%s'\n"), name
);
5936 if (symtab_sec
!= sec
)
5941 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5946 error (_("Corrupt header in group section `%s'\n"), name
);
5950 if (section
->sh_info
>= num_syms
)
5952 error (_("Bad sh_info in group section `%s'\n"), name
);
5956 sym
= symtab
+ section
->sh_info
;
5958 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5960 if (sym
->st_shndx
== 0
5961 || sym
->st_shndx
>= elf_header
.e_shnum
)
5963 error (_("Bad sh_info in group section `%s'\n"), name
);
5967 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5976 /* Get the string table. */
5977 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5986 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5992 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5993 1, strtab_sec
->sh_size
,
5995 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5997 group_name
= sym
->st_name
< strtab_size
5998 ? strtab
+ sym
->st_name
: _("<corrupt>");
6001 /* PR 17531: file: loop. */
6002 if (section
->sh_entsize
> section
->sh_size
)
6004 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6005 printable_section_name (section
),
6006 (unsigned long) section
->sh_entsize
,
6007 (unsigned long) section
->sh_size
);
6011 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6012 1, section
->sh_size
,
6018 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6019 entry
= byte_get (indices
, 4);
6022 if (do_section_groups
)
6024 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6025 get_group_flags (entry
), i
, name
, group_name
, size
);
6027 printf (_(" [Index] Name\n"));
6030 group
->group_index
= i
;
6032 for (j
= 0; j
< size
; j
++)
6034 struct group_list
* g
;
6036 entry
= byte_get (indices
, 4);
6039 if (entry
>= elf_header
.e_shnum
)
6041 static unsigned num_group_errors
= 0;
6043 if (num_group_errors
++ < 10)
6045 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6046 entry
, i
, elf_header
.e_shnum
- 1);
6047 if (num_group_errors
== 10)
6048 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6053 if (section_headers_groups
[entry
] != NULL
)
6057 static unsigned num_errs
= 0;
6059 if (num_errs
++ < 10)
6061 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6063 section_headers_groups
[entry
]->group_index
);
6065 warn (_("Further error messages about already contained group sections suppressed\n"));
6071 /* Intel C/C++ compiler may put section 0 in a
6072 section group. We just warn it the first time
6073 and ignore it afterwards. */
6074 static int warned
= 0;
6077 error (_("section 0 in group section [%5u]\n"),
6078 section_headers_groups
[entry
]->group_index
);
6084 section_headers_groups
[entry
] = group
;
6086 if (do_section_groups
)
6088 sec
= section_headers
+ entry
;
6089 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6092 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6093 g
->section_index
= entry
;
6094 g
->next
= group
->root
;
6112 /* Data used to display dynamic fixups. */
6114 struct ia64_vms_dynfixup
6116 bfd_vma needed_ident
; /* Library ident number. */
6117 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6118 bfd_vma fixup_needed
; /* Index of the library. */
6119 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6120 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6123 /* Data used to display dynamic relocations. */
6125 struct ia64_vms_dynimgrela
6127 bfd_vma img_rela_cnt
; /* Number of relocations. */
6128 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6131 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6135 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6136 const char *strtab
, unsigned int strtab_sz
)
6138 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6140 const char *lib_name
;
6142 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6143 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6144 _("dynamic section image fixups"));
6148 if (fixup
->needed
< strtab_sz
)
6149 lib_name
= strtab
+ fixup
->needed
;
6152 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6153 (unsigned long) fixup
->needed
);
6156 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6157 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6159 (_("Seg Offset Type SymVec DataType\n"));
6161 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6166 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6167 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6168 type
= BYTE_GET (imfs
[i
].type
);
6169 rtype
= elf_ia64_reloc_type (type
);
6171 printf (" 0x%08x ", type
);
6173 printf (" %-32s ", rtype
);
6174 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6175 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6181 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6184 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6186 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6189 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6190 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6191 _("dynamic section image relocations"));
6195 printf (_("\nImage relocs\n"));
6197 (_("Seg Offset Type Addend Seg Sym Off\n"));
6199 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6204 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6205 printf ("%08" BFD_VMA_FMT
"x ",
6206 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6207 type
= BYTE_GET (imrs
[i
].type
);
6208 rtype
= elf_ia64_reloc_type (type
);
6210 printf ("0x%08x ", type
);
6212 printf ("%-31s ", rtype
);
6213 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6214 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6215 printf ("%08" BFD_VMA_FMT
"x\n",
6216 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6222 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6225 process_ia64_vms_dynamic_relocs (FILE *file
)
6227 struct ia64_vms_dynfixup fixup
;
6228 struct ia64_vms_dynimgrela imgrela
;
6229 Elf_Internal_Dyn
*entry
;
6231 bfd_vma strtab_off
= 0;
6232 bfd_vma strtab_sz
= 0;
6233 char *strtab
= NULL
;
6235 memset (&fixup
, 0, sizeof (fixup
));
6236 memset (&imgrela
, 0, sizeof (imgrela
));
6238 /* Note: the order of the entries is specified by the OpenVMS specs. */
6239 for (entry
= dynamic_section
;
6240 entry
< dynamic_section
+ dynamic_nent
;
6243 switch (entry
->d_tag
)
6245 case DT_IA_64_VMS_STRTAB_OFFSET
:
6246 strtab_off
= entry
->d_un
.d_val
;
6249 strtab_sz
= entry
->d_un
.d_val
;
6251 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6252 1, strtab_sz
, _("dynamic string section"));
6255 case DT_IA_64_VMS_NEEDED_IDENT
:
6256 fixup
.needed_ident
= entry
->d_un
.d_val
;
6259 fixup
.needed
= entry
->d_un
.d_val
;
6261 case DT_IA_64_VMS_FIXUP_NEEDED
:
6262 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6264 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6265 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6267 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6268 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6270 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6273 case DT_IA_64_VMS_IMG_RELA_CNT
:
6274 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6276 case DT_IA_64_VMS_IMG_RELA_OFF
:
6277 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6279 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6299 } dynamic_relocations
[] =
6301 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6302 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6303 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6306 /* Process the reloc section. */
6309 process_relocs (FILE * file
)
6311 unsigned long rel_size
;
6312 unsigned long rel_offset
;
6318 if (do_using_dynamic
)
6322 int has_dynamic_reloc
;
6325 has_dynamic_reloc
= 0;
6327 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6329 is_rela
= dynamic_relocations
[i
].rela
;
6330 name
= dynamic_relocations
[i
].name
;
6331 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6332 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6334 has_dynamic_reloc
|= rel_size
;
6336 if (is_rela
== UNKNOWN
)
6338 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6339 switch (dynamic_info
[DT_PLTREL
])
6353 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6354 name
, rel_offset
, rel_size
);
6356 dump_relocations (file
,
6357 offset_from_vma (file
, rel_offset
, rel_size
),
6359 dynamic_symbols
, num_dynamic_syms
,
6360 dynamic_strings
, dynamic_strings_length
,
6366 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6368 if (! has_dynamic_reloc
)
6369 printf (_("\nThere are no dynamic relocations in this file.\n"));
6373 Elf_Internal_Shdr
* section
;
6377 for (i
= 0, section
= section_headers
;
6378 i
< elf_header
.e_shnum
;
6381 if ( section
->sh_type
!= SHT_RELA
6382 && section
->sh_type
!= SHT_REL
)
6385 rel_offset
= section
->sh_offset
;
6386 rel_size
= section
->sh_size
;
6390 Elf_Internal_Shdr
* strsec
;
6393 printf (_("\nRelocation section "));
6395 if (string_table
== NULL
)
6396 printf ("%d", section
->sh_name
);
6398 printf ("'%s'", printable_section_name (section
));
6400 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6401 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6403 is_rela
= section
->sh_type
== SHT_RELA
;
6405 if (section
->sh_link
!= 0
6406 && section
->sh_link
< elf_header
.e_shnum
)
6408 Elf_Internal_Shdr
* symsec
;
6409 Elf_Internal_Sym
* symtab
;
6410 unsigned long nsyms
;
6411 unsigned long strtablen
= 0;
6412 char * strtab
= NULL
;
6414 symsec
= section_headers
+ section
->sh_link
;
6415 if (symsec
->sh_type
!= SHT_SYMTAB
6416 && symsec
->sh_type
!= SHT_DYNSYM
)
6419 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6424 if (symsec
->sh_link
!= 0
6425 && symsec
->sh_link
< elf_header
.e_shnum
)
6427 strsec
= section_headers
+ symsec
->sh_link
;
6429 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6432 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6435 dump_relocations (file
, rel_offset
, rel_size
,
6436 symtab
, nsyms
, strtab
, strtablen
,
6438 symsec
->sh_type
== SHT_DYNSYM
);
6444 dump_relocations (file
, rel_offset
, rel_size
,
6445 NULL
, 0, NULL
, 0, is_rela
, 0);
6452 printf (_("\nThere are no relocations in this file.\n"));
6458 /* An absolute address consists of a section and an offset. If the
6459 section is NULL, the offset itself is the address, otherwise, the
6460 address equals to LOAD_ADDRESS(section) + offset. */
6464 unsigned short section
;
6468 #define ABSADDR(a) \
6470 ? section_headers [(a).section].sh_addr + (a).offset \
6473 /* Find the nearest symbol at or below ADDR. Returns the symbol
6474 name, if found, and the offset from the symbol to ADDR. */
6477 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6478 unsigned long nsyms
,
6479 const char * strtab
,
6480 unsigned long strtab_size
,
6481 struct absaddr addr
,
6482 const char ** symname
,
6485 bfd_vma dist
= 0x100000;
6486 Elf_Internal_Sym
* sym
;
6487 Elf_Internal_Sym
* beg
;
6488 Elf_Internal_Sym
* end
;
6489 Elf_Internal_Sym
* best
= NULL
;
6491 REMOVE_ARCH_BITS (addr
.offset
);
6493 end
= symtab
+ nsyms
;
6499 sym
= beg
+ (end
- beg
) / 2;
6501 value
= sym
->st_value
;
6502 REMOVE_ARCH_BITS (value
);
6504 if (sym
->st_name
!= 0
6505 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6506 && addr
.offset
>= value
6507 && addr
.offset
- value
< dist
)
6510 dist
= addr
.offset
- value
;
6515 if (addr
.offset
< value
)
6523 *symname
= (best
->st_name
>= strtab_size
6524 ? _("<corrupt>") : strtab
+ best
->st_name
);
6530 *offset
= addr
.offset
;
6534 symcmp (const void *p
, const void *q
)
6536 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6537 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6539 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6542 /* Process the unwind section. */
6544 #include "unwind-ia64.h"
6546 struct ia64_unw_table_entry
6548 struct absaddr start
;
6550 struct absaddr info
;
6553 struct ia64_unw_aux_info
6555 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6556 unsigned long table_len
; /* Length of unwind table. */
6557 unsigned char * info
; /* Unwind info. */
6558 unsigned long info_size
; /* Size of unwind info. */
6559 bfd_vma info_addr
; /* Starting address of unwind info. */
6560 bfd_vma seg_base
; /* Starting address of segment. */
6561 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6562 unsigned long nsyms
; /* Number of symbols. */
6563 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6564 unsigned long nfuns
; /* Number of entries in funtab. */
6565 char * strtab
; /* The string table. */
6566 unsigned long strtab_size
; /* Size of string table. */
6570 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6572 struct ia64_unw_table_entry
* tp
;
6573 unsigned long j
, nfuns
;
6576 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6577 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6578 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6579 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6581 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6583 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6587 const unsigned char * dp
;
6588 const unsigned char * head
;
6589 const unsigned char * end
;
6590 const char * procname
;
6592 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6593 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6595 fputs ("\n<", stdout
);
6599 fputs (procname
, stdout
);
6602 printf ("+%lx", (unsigned long) offset
);
6605 fputs (">: [", stdout
);
6606 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6607 fputc ('-', stdout
);
6608 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6609 printf ("], info at +0x%lx\n",
6610 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6612 /* PR 17531: file: 86232b32. */
6613 if (aux
->info
== NULL
)
6616 /* PR 17531: file: 0997b4d1. */
6617 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6619 warn (_("Invalid offset %lx in table entry %ld\n"),
6620 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6624 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6625 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6627 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6628 (unsigned) UNW_VER (stamp
),
6629 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6630 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6631 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6632 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6634 if (UNW_VER (stamp
) != 1)
6636 printf (_("\tUnknown version.\n"));
6641 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6642 /* PR 17531: file: 16ceda89. */
6643 if (end
> aux
->info
+ aux
->info_size
)
6644 end
= aux
->info
+ aux
->info_size
;
6645 for (dp
= head
+ 8; dp
< end
;)
6646 dp
= unw_decode (dp
, in_body
, & in_body
);
6653 slurp_ia64_unwind_table (FILE * file
,
6654 struct ia64_unw_aux_info
* aux
,
6655 Elf_Internal_Shdr
* sec
)
6657 unsigned long size
, nrelas
, i
;
6658 Elf_Internal_Phdr
* seg
;
6659 struct ia64_unw_table_entry
* tep
;
6660 Elf_Internal_Shdr
* relsec
;
6661 Elf_Internal_Rela
* rela
;
6662 Elf_Internal_Rela
* rp
;
6663 unsigned char * table
;
6665 Elf_Internal_Sym
* sym
;
6666 const char * relname
;
6670 /* First, find the starting address of the segment that includes
6673 if (elf_header
.e_phnum
)
6675 if (! get_program_headers (file
))
6678 for (seg
= program_headers
;
6679 seg
< program_headers
+ elf_header
.e_phnum
;
6682 if (seg
->p_type
!= PT_LOAD
)
6685 if (sec
->sh_addr
>= seg
->p_vaddr
6686 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6688 aux
->seg_base
= seg
->p_vaddr
;
6694 /* Second, build the unwind table from the contents of the unwind section: */
6695 size
= sec
->sh_size
;
6696 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6701 aux
->table_len
= size
/ (3 * eh_addr_size
);
6702 aux
->table
= (struct ia64_unw_table_entry
*)
6703 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6706 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6708 tep
->start
.section
= SHN_UNDEF
;
6709 tep
->end
.section
= SHN_UNDEF
;
6710 tep
->info
.section
= SHN_UNDEF
;
6711 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6712 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6713 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6714 tep
->start
.offset
+= aux
->seg_base
;
6715 tep
->end
.offset
+= aux
->seg_base
;
6716 tep
->info
.offset
+= aux
->seg_base
;
6720 /* Third, apply any relocations to the unwind table: */
6721 for (relsec
= section_headers
;
6722 relsec
< section_headers
+ elf_header
.e_shnum
;
6725 if (relsec
->sh_type
!= SHT_RELA
6726 || relsec
->sh_info
>= elf_header
.e_shnum
6727 || section_headers
+ relsec
->sh_info
!= sec
)
6730 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6739 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6741 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6742 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6744 /* PR 17531: file: 9fa67536. */
6745 if (relname
== NULL
)
6747 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6751 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6753 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6757 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6759 /* PR 17531: file: 5bc8d9bf. */
6760 if (i
>= aux
->table_len
)
6762 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6766 switch (rp
->r_offset
/ eh_addr_size
% 3)
6769 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6770 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6773 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6774 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6777 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6778 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6792 ia64_process_unwind (FILE * file
)
6794 Elf_Internal_Shdr
* sec
;
6795 Elf_Internal_Shdr
* unwsec
= NULL
;
6796 Elf_Internal_Shdr
* strsec
;
6797 unsigned long i
, unwcount
= 0, unwstart
= 0;
6798 struct ia64_unw_aux_info aux
;
6800 memset (& aux
, 0, sizeof (aux
));
6802 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6804 if (sec
->sh_type
== SHT_SYMTAB
6805 && sec
->sh_link
< elf_header
.e_shnum
)
6807 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6809 strsec
= section_headers
+ sec
->sh_link
;
6810 if (aux
.strtab
!= NULL
)
6812 error (_("Multiple auxillary string tables encountered\n"));
6815 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6818 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6820 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6825 printf (_("\nThere are no unwind sections in this file.\n"));
6827 while (unwcount
-- > 0)
6832 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6833 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6834 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6839 /* We have already counted the number of SHT_IA64_UNWIND
6840 sections so the loop above should never fail. */
6841 assert (unwsec
!= NULL
);
6844 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6846 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6848 /* We need to find which section group it is in. */
6849 struct group_list
* g
;
6851 if (section_headers_groups
== NULL
6852 || section_headers_groups
[i
] == NULL
)
6853 i
= elf_header
.e_shnum
;
6856 g
= section_headers_groups
[i
]->root
;
6858 for (; g
!= NULL
; g
= g
->next
)
6860 sec
= section_headers
+ g
->section_index
;
6862 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6867 i
= elf_header
.e_shnum
;
6870 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6872 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6873 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6874 suffix
= SECTION_NAME (unwsec
) + len
;
6875 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6877 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6878 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6883 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6884 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6885 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6886 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6888 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6889 suffix
= SECTION_NAME (unwsec
) + len
;
6890 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6892 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6893 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6897 if (i
== elf_header
.e_shnum
)
6899 printf (_("\nCould not find unwind info section for "));
6901 if (string_table
== NULL
)
6902 printf ("%d", unwsec
->sh_name
);
6904 printf ("'%s'", printable_section_name (unwsec
));
6908 aux
.info_addr
= sec
->sh_addr
;
6909 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6912 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6914 printf (_("\nUnwind section "));
6916 if (string_table
== NULL
)
6917 printf ("%d", unwsec
->sh_name
);
6919 printf ("'%s'", printable_section_name (unwsec
));
6921 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6922 (unsigned long) unwsec
->sh_offset
,
6923 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6925 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
6926 && aux
.table_len
> 0)
6927 dump_ia64_unwind (& aux
);
6930 free ((char *) aux
.table
);
6932 free ((char *) aux
.info
);
6941 free ((char *) aux
.strtab
);
6944 struct hppa_unw_table_entry
6946 struct absaddr start
;
6948 unsigned int Cannot_unwind
:1; /* 0 */
6949 unsigned int Millicode
:1; /* 1 */
6950 unsigned int Millicode_save_sr0
:1; /* 2 */
6951 unsigned int Region_description
:2; /* 3..4 */
6952 unsigned int reserved1
:1; /* 5 */
6953 unsigned int Entry_SR
:1; /* 6 */
6954 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6955 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6956 unsigned int Args_stored
:1; /* 16 */
6957 unsigned int Variable_Frame
:1; /* 17 */
6958 unsigned int Separate_Package_Body
:1; /* 18 */
6959 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6960 unsigned int Stack_Overflow_Check
:1; /* 20 */
6961 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
6962 unsigned int Ada_Region
:1; /* 22 */
6963 unsigned int cxx_info
:1; /* 23 */
6964 unsigned int cxx_try_catch
:1; /* 24 */
6965 unsigned int sched_entry_seq
:1; /* 25 */
6966 unsigned int reserved2
:1; /* 26 */
6967 unsigned int Save_SP
:1; /* 27 */
6968 unsigned int Save_RP
:1; /* 28 */
6969 unsigned int Save_MRP_in_frame
:1; /* 29 */
6970 unsigned int extn_ptr_defined
:1; /* 30 */
6971 unsigned int Cleanup_defined
:1; /* 31 */
6973 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6974 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6975 unsigned int Large_frame
:1; /* 2 */
6976 unsigned int Pseudo_SP_Set
:1; /* 3 */
6977 unsigned int reserved4
:1; /* 4 */
6978 unsigned int Total_frame_size
:27; /* 5..31 */
6981 struct hppa_unw_aux_info
6983 struct hppa_unw_table_entry
* table
; /* Unwind table. */
6984 unsigned long table_len
; /* Length of unwind table. */
6985 bfd_vma seg_base
; /* Starting address of segment. */
6986 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6987 unsigned long nsyms
; /* Number of symbols. */
6988 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6989 unsigned long nfuns
; /* Number of entries in funtab. */
6990 char * strtab
; /* The string table. */
6991 unsigned long strtab_size
; /* Size of string table. */
6995 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6997 struct hppa_unw_table_entry
* tp
;
6998 unsigned long j
, nfuns
;
7000 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7001 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7002 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7003 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7005 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7007 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7010 const char * procname
;
7012 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7013 aux
->strtab_size
, tp
->start
, &procname
,
7016 fputs ("\n<", stdout
);
7020 fputs (procname
, stdout
);
7023 printf ("+%lx", (unsigned long) offset
);
7026 fputs (">: [", stdout
);
7027 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7028 fputc ('-', stdout
);
7029 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7032 #define PF(_m) if (tp->_m) printf (#_m " ");
7033 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7036 PF(Millicode_save_sr0
);
7037 /* PV(Region_description); */
7043 PF(Separate_Package_Body
);
7044 PF(Frame_Extension_Millicode
);
7045 PF(Stack_Overflow_Check
);
7046 PF(Two_Instruction_SP_Increment
);
7050 PF(sched_entry_seq
);
7053 PF(Save_MRP_in_frame
);
7054 PF(extn_ptr_defined
);
7055 PF(Cleanup_defined
);
7056 PF(MPE_XL_interrupt_marker
);
7057 PF(HP_UX_interrupt_marker
);
7060 PV(Total_frame_size
);
7071 slurp_hppa_unwind_table (FILE * file
,
7072 struct hppa_unw_aux_info
* aux
,
7073 Elf_Internal_Shdr
* sec
)
7075 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7076 Elf_Internal_Phdr
* seg
;
7077 struct hppa_unw_table_entry
* tep
;
7078 Elf_Internal_Shdr
* relsec
;
7079 Elf_Internal_Rela
* rela
;
7080 Elf_Internal_Rela
* rp
;
7081 unsigned char * table
;
7083 Elf_Internal_Sym
* sym
;
7084 const char * relname
;
7086 /* First, find the starting address of the segment that includes
7089 if (elf_header
.e_phnum
)
7091 if (! get_program_headers (file
))
7094 for (seg
= program_headers
;
7095 seg
< program_headers
+ elf_header
.e_phnum
;
7098 if (seg
->p_type
!= PT_LOAD
)
7101 if (sec
->sh_addr
>= seg
->p_vaddr
7102 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7104 aux
->seg_base
= seg
->p_vaddr
;
7110 /* Second, build the unwind table from the contents of the unwind
7112 size
= sec
->sh_size
;
7113 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7119 nentries
= size
/ unw_ent_size
;
7120 size
= unw_ent_size
* nentries
;
7122 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7123 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7125 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7127 unsigned int tmp1
, tmp2
;
7129 tep
->start
.section
= SHN_UNDEF
;
7130 tep
->end
.section
= SHN_UNDEF
;
7132 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7133 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7134 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7135 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7137 tep
->start
.offset
+= aux
->seg_base
;
7138 tep
->end
.offset
+= aux
->seg_base
;
7140 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7141 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7142 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7143 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7144 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7145 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7146 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7147 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7148 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7149 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7150 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7151 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7152 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7153 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7154 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7155 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7156 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7157 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7158 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7159 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7160 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7161 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7162 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7163 tep
->Cleanup_defined
= tmp1
& 0x1;
7165 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7166 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7167 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7168 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7169 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7170 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7174 /* Third, apply any relocations to the unwind table. */
7175 for (relsec
= section_headers
;
7176 relsec
< section_headers
+ elf_header
.e_shnum
;
7179 if (relsec
->sh_type
!= SHT_RELA
7180 || relsec
->sh_info
>= elf_header
.e_shnum
7181 || section_headers
+ relsec
->sh_info
!= sec
)
7184 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7188 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7190 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7191 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7193 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7194 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7196 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7200 i
= rp
->r_offset
/ unw_ent_size
;
7202 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7205 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7206 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7209 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7210 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7220 aux
->table_len
= nentries
;
7226 hppa_process_unwind (FILE * file
)
7228 struct hppa_unw_aux_info aux
;
7229 Elf_Internal_Shdr
* unwsec
= NULL
;
7230 Elf_Internal_Shdr
* strsec
;
7231 Elf_Internal_Shdr
* sec
;
7234 if (string_table
== NULL
)
7237 memset (& aux
, 0, sizeof (aux
));
7239 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7241 if (sec
->sh_type
== SHT_SYMTAB
7242 && sec
->sh_link
< elf_header
.e_shnum
)
7244 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7246 strsec
= section_headers
+ sec
->sh_link
;
7247 if (aux
.strtab
!= NULL
)
7249 error (_("Multiple auxillary string tables encountered\n"));
7252 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7255 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7257 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7262 printf (_("\nThere are no unwind sections in this file.\n"));
7264 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7266 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7268 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7269 printable_section_name (sec
),
7270 (unsigned long) sec
->sh_offset
,
7271 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7273 slurp_hppa_unwind_table (file
, &aux
, sec
);
7274 if (aux
.table_len
> 0)
7275 dump_hppa_unwind (&aux
);
7278 free ((char *) aux
.table
);
7286 free ((char *) aux
.strtab
);
7291 unsigned char * data
; /* The unwind data. */
7292 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7293 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7294 unsigned long nrelas
; /* The number of relocations. */
7295 unsigned int rel_type
; /* REL or RELA ? */
7296 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7299 struct arm_unw_aux_info
7301 FILE * file
; /* The file containing the unwind sections. */
7302 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7303 unsigned long nsyms
; /* Number of symbols. */
7304 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7305 unsigned long nfuns
; /* Number of these symbols. */
7306 char * strtab
; /* The file's string table. */
7307 unsigned long strtab_size
; /* Size of string table. */
7311 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7312 bfd_vma fn
, struct absaddr addr
)
7314 const char *procname
;
7317 if (addr
.section
== SHN_UNDEF
)
7320 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7321 aux
->strtab_size
, addr
, &procname
,
7324 print_vma (fn
, PREFIX_HEX
);
7328 fputs (" <", stdout
);
7329 fputs (procname
, stdout
);
7332 printf ("+0x%lx", (unsigned long) sym_offset
);
7333 fputc ('>', stdout
);
7340 arm_free_section (struct arm_section
*arm_sec
)
7342 if (arm_sec
->data
!= NULL
)
7343 free (arm_sec
->data
);
7345 if (arm_sec
->rela
!= NULL
)
7346 free (arm_sec
->rela
);
7349 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7350 cached section and install SEC instead.
7351 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7352 and return its valued in * WORDP, relocating if necessary.
7353 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7354 relocation's offset in ADDR.
7355 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7356 into the string table of the symbol associated with the reloc. If no
7357 reloc was applied store -1 there.
7358 5) Return TRUE upon success, FALSE otherwise. */
7361 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7362 struct arm_section
* arm_sec
,
7363 Elf_Internal_Shdr
* sec
,
7364 bfd_vma word_offset
,
7365 unsigned int * wordp
,
7366 struct absaddr
* addr
,
7369 Elf_Internal_Rela
*rp
;
7370 Elf_Internal_Sym
*sym
;
7371 const char * relname
;
7373 bfd_boolean wrapped
;
7375 if (sec
== NULL
|| arm_sec
== NULL
)
7378 addr
->section
= SHN_UNDEF
;
7381 if (sym_name
!= NULL
)
7382 *sym_name
= (bfd_vma
) -1;
7384 /* If necessary, update the section cache. */
7385 if (sec
!= arm_sec
->sec
)
7387 Elf_Internal_Shdr
*relsec
;
7389 arm_free_section (arm_sec
);
7392 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7393 sec
->sh_size
, _("unwind data"));
7394 arm_sec
->rela
= NULL
;
7395 arm_sec
->nrelas
= 0;
7397 for (relsec
= section_headers
;
7398 relsec
< section_headers
+ elf_header
.e_shnum
;
7401 if (relsec
->sh_info
>= elf_header
.e_shnum
7402 || section_headers
+ relsec
->sh_info
!= sec
7403 /* PR 15745: Check the section type as well. */
7404 || (relsec
->sh_type
!= SHT_REL
7405 && relsec
->sh_type
!= SHT_RELA
))
7408 arm_sec
->rel_type
= relsec
->sh_type
;
7409 if (relsec
->sh_type
== SHT_REL
)
7411 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7413 & arm_sec
->rela
, & arm_sec
->nrelas
))
7416 else /* relsec->sh_type == SHT_RELA */
7418 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7420 & arm_sec
->rela
, & arm_sec
->nrelas
))
7426 arm_sec
->next_rela
= arm_sec
->rela
;
7429 /* If there is no unwind data we can do nothing. */
7430 if (arm_sec
->data
== NULL
)
7433 /* If the offset is invalid then fail. */
7434 if (word_offset
> sec
->sh_size
- 4)
7437 /* Get the word at the required offset. */
7438 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7440 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7441 if (arm_sec
->rela
== NULL
)
7447 /* Look through the relocs to find the one that applies to the provided offset. */
7449 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7451 bfd_vma prelval
, offset
;
7453 if (rp
->r_offset
> word_offset
&& !wrapped
)
7458 if (rp
->r_offset
> word_offset
)
7461 if (rp
->r_offset
& 3)
7463 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7464 (unsigned long) rp
->r_offset
);
7468 if (rp
->r_offset
< word_offset
)
7471 /* PR 17531: file: 027-161405-0.004 */
7472 if (aux
->symtab
== NULL
)
7475 if (arm_sec
->rel_type
== SHT_REL
)
7477 offset
= word
& 0x7fffffff;
7478 if (offset
& 0x40000000)
7479 offset
|= ~ (bfd_vma
) 0x7fffffff;
7481 else if (arm_sec
->rel_type
== SHT_RELA
)
7482 offset
= rp
->r_addend
;
7485 error (_("Unknown section relocation type %d encountered\n"),
7490 /* PR 17531 file: 027-1241568-0.004. */
7491 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7493 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7494 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7498 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7499 offset
+= sym
->st_value
;
7500 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7502 /* Check that we are processing the expected reloc type. */
7503 if (elf_header
.e_machine
== EM_ARM
)
7505 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7506 if (relname
== NULL
)
7508 warn (_("Skipping unknown ARM relocation type: %d\n"),
7509 (int) ELF32_R_TYPE (rp
->r_info
));
7513 if (streq (relname
, "R_ARM_NONE"))
7516 if (! streq (relname
, "R_ARM_PREL31"))
7518 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7522 else if (elf_header
.e_machine
== EM_TI_C6000
)
7524 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7525 if (relname
== NULL
)
7527 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7528 (int) ELF32_R_TYPE (rp
->r_info
));
7532 if (streq (relname
, "R_C6000_NONE"))
7535 if (! streq (relname
, "R_C6000_PREL31"))
7537 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7545 /* This function currently only supports ARM and TI unwinders. */
7546 warn (_("Only TI and ARM unwinders are currently supported\n"));
7550 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7551 addr
->section
= sym
->st_shndx
;
7552 addr
->offset
= offset
;
7555 * sym_name
= sym
->st_name
;
7560 arm_sec
->next_rela
= rp
;
7565 static const char *tic6x_unwind_regnames
[16] =
7567 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7568 "A14", "A13", "A12", "A11", "A10",
7569 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7573 decode_tic6x_unwind_regmask (unsigned int mask
)
7577 for (i
= 12; mask
; mask
>>= 1, i
--)
7581 fputs (tic6x_unwind_regnames
[i
], stdout
);
7583 fputs (", ", stdout
);
7589 if (remaining == 0 && more_words) \
7592 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7593 data_offset, & word, & addr, NULL)) \
7599 #define GET_OP(OP) \
7604 (OP) = word >> 24; \
7609 printf (_("[Truncated opcode]\n")); \
7612 printf ("0x%02x ", OP)
7615 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7617 unsigned int remaining
,
7618 unsigned int more_words
,
7619 bfd_vma data_offset
,
7620 Elf_Internal_Shdr
* data_sec
,
7621 struct arm_section
* data_arm_sec
)
7623 struct absaddr addr
;
7625 /* Decode the unwinding instructions. */
7628 unsigned int op
, op2
;
7637 printf (" 0x%02x ", op
);
7639 if ((op
& 0xc0) == 0x00)
7641 int offset
= ((op
& 0x3f) << 2) + 4;
7643 printf (" vsp = vsp + %d", offset
);
7645 else if ((op
& 0xc0) == 0x40)
7647 int offset
= ((op
& 0x3f) << 2) + 4;
7649 printf (" vsp = vsp - %d", offset
);
7651 else if ((op
& 0xf0) == 0x80)
7654 if (op
== 0x80 && op2
== 0)
7655 printf (_("Refuse to unwind"));
7658 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7663 for (i
= 0; i
< 12; i
++)
7664 if (mask
& (1 << i
))
7670 printf ("r%d", 4 + i
);
7675 else if ((op
& 0xf0) == 0x90)
7677 if (op
== 0x9d || op
== 0x9f)
7678 printf (_(" [Reserved]"));
7680 printf (" vsp = r%d", op
& 0x0f);
7682 else if ((op
& 0xf0) == 0xa0)
7684 int end
= 4 + (op
& 0x07);
7689 for (i
= 4; i
<= end
; i
++)
7705 else if (op
== 0xb0)
7706 printf (_(" finish"));
7707 else if (op
== 0xb1)
7710 if (op2
== 0 || (op2
& 0xf0) != 0)
7711 printf (_("[Spare]"));
7714 unsigned int mask
= op2
& 0x0f;
7719 for (i
= 0; i
< 12; i
++)
7720 if (mask
& (1 << i
))
7731 else if (op
== 0xb2)
7733 unsigned char buf
[9];
7734 unsigned int i
, len
;
7735 unsigned long offset
;
7737 for (i
= 0; i
< sizeof (buf
); i
++)
7740 if ((buf
[i
] & 0x80) == 0)
7743 if (i
== sizeof (buf
))
7744 printf (_("corrupt change to vsp"));
7747 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7748 assert (len
== i
+ 1);
7749 offset
= offset
* 4 + 0x204;
7750 printf ("vsp = vsp + %ld", offset
);
7753 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7755 unsigned int first
, last
;
7762 printf ("pop {D%d", first
);
7764 printf ("-D%d", first
+ last
);
7767 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7769 unsigned int count
= op
& 0x07;
7773 printf ("-D%d", 8 + count
);
7776 else if (op
>= 0xc0 && op
<= 0xc5)
7778 unsigned int count
= op
& 0x07;
7780 printf (" pop {wR10");
7782 printf ("-wR%d", 10 + count
);
7785 else if (op
== 0xc6)
7787 unsigned int first
, last
;
7792 printf ("pop {wR%d", first
);
7794 printf ("-wR%d", first
+ last
);
7797 else if (op
== 0xc7)
7800 if (op2
== 0 || (op2
& 0xf0) != 0)
7801 printf (_("[Spare]"));
7804 unsigned int mask
= op2
& 0x0f;
7809 for (i
= 0; i
< 4; i
++)
7810 if (mask
& (1 << i
))
7816 printf ("wCGR%d", i
);
7822 printf (_(" [unsupported opcode]"));
7828 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7830 unsigned int remaining
,
7831 unsigned int more_words
,
7832 bfd_vma data_offset
,
7833 Elf_Internal_Shdr
* data_sec
,
7834 struct arm_section
* data_arm_sec
)
7836 struct absaddr addr
;
7838 /* Decode the unwinding instructions. */
7841 unsigned int op
, op2
;
7850 printf (" 0x%02x ", op
);
7852 if ((op
& 0xc0) == 0x00)
7854 int offset
= ((op
& 0x3f) << 3) + 8;
7855 printf (" sp = sp + %d", offset
);
7857 else if ((op
& 0xc0) == 0x80)
7860 if (op
== 0x80 && op2
== 0)
7861 printf (_("Refuse to unwind"));
7864 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7866 printf ("pop compact {");
7870 decode_tic6x_unwind_regmask (mask
);
7874 else if ((op
& 0xf0) == 0xc0)
7882 unsigned int offset
;
7886 /* Scan entire instruction first so that GET_OP output is not
7887 interleaved with disassembly. */
7889 for (i
= 0; nregs
< (op
& 0xf); i
++)
7895 regpos
[nregs
].offset
= i
* 2;
7896 regpos
[nregs
].reg
= reg
;
7903 regpos
[nregs
].offset
= i
* 2 + 1;
7904 regpos
[nregs
].reg
= reg
;
7909 printf (_("pop frame {"));
7911 for (i
= i
* 2; i
> 0; i
--)
7913 if (regpos
[reg
].offset
== i
- 1)
7915 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7922 fputs (name
, stdout
);
7929 else if (op
== 0xd0)
7930 printf (" MOV FP, SP");
7931 else if (op
== 0xd1)
7932 printf (" __c6xabi_pop_rts");
7933 else if (op
== 0xd2)
7935 unsigned char buf
[9];
7936 unsigned int i
, len
;
7937 unsigned long offset
;
7939 for (i
= 0; i
< sizeof (buf
); i
++)
7942 if ((buf
[i
] & 0x80) == 0)
7945 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7946 if (i
== sizeof (buf
))
7948 printf ("<corrupt sp adjust>\n");
7949 warn (_("Corrupt stack pointer adjustment detected\n"));
7953 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7954 assert (len
== i
+ 1);
7955 offset
= offset
* 8 + 0x408;
7956 printf (_("sp = sp + %ld"), offset
);
7958 else if ((op
& 0xf0) == 0xe0)
7960 if ((op
& 0x0f) == 7)
7963 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7967 printf (_(" [unsupported opcode]"));
7974 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7978 offset
= word
& 0x7fffffff;
7979 if (offset
& 0x40000000)
7980 offset
|= ~ (bfd_vma
) 0x7fffffff;
7982 if (elf_header
.e_machine
== EM_TI_C6000
)
7985 return offset
+ where
;
7989 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7991 unsigned int remaining
,
7992 bfd_vma data_offset
,
7993 Elf_Internal_Shdr
* data_sec
,
7994 struct arm_section
* data_arm_sec
)
7997 unsigned int more_words
= 0;
7998 struct absaddr addr
;
7999 bfd_vma sym_name
= (bfd_vma
) -1;
8003 /* Fetch the first word.
8004 Note - when decoding an object file the address extracted
8005 here will always be 0. So we also pass in the sym_name
8006 parameter so that we can find the symbol associated with
8007 the personality routine. */
8008 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8009 & word
, & addr
, & sym_name
))
8015 if ((word
& 0x80000000) == 0)
8017 /* Expand prel31 for personality routine. */
8019 const char *procname
;
8021 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8022 printf (_(" Personality routine: "));
8024 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8025 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8027 procname
= aux
->strtab
+ sym_name
;
8028 print_vma (fn
, PREFIX_HEX
);
8031 fputs (" <", stdout
);
8032 fputs (procname
, stdout
);
8033 fputc ('>', stdout
);
8037 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8038 fputc ('\n', stdout
);
8040 /* The GCC personality routines use the standard compact
8041 encoding, starting with one byte giving the number of
8043 if (procname
!= NULL
8044 && (const_strneq (procname
, "__gcc_personality_v0")
8045 || const_strneq (procname
, "__gxx_personality_v0")
8046 || const_strneq (procname
, "__gcj_personality_v0")
8047 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8054 printf (_(" [Truncated data]\n"));
8057 more_words
= word
>> 24;
8067 /* ARM EHABI Section 6.3:
8069 An exception-handling table entry for the compact model looks like:
8073 1 0 index Data for personalityRoutine[index] */
8075 if (elf_header
.e_machine
== EM_ARM
8076 && (word
& 0x70000000))
8077 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8079 per_index
= (word
>> 24) & 0x7f;
8080 printf (_(" Compact model index: %d\n"), per_index
);
8087 else if (per_index
< 3)
8089 more_words
= (word
>> 16) & 0xff;
8095 switch (elf_header
.e_machine
)
8100 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8101 data_offset
, data_sec
, data_arm_sec
);
8105 warn (_("Unknown ARM compact model index encountered\n"));
8106 printf (_(" [reserved]\n"));
8113 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8114 data_offset
, data_sec
, data_arm_sec
);
8116 else if (per_index
< 5)
8118 if (((word
>> 17) & 0x7f) == 0x7f)
8119 printf (_(" Restore stack from frame pointer\n"));
8121 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8122 printf (_(" Registers restored: "));
8124 printf (" (compact) ");
8125 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8127 printf (_(" Return register: %s\n"),
8128 tic6x_unwind_regnames
[word
& 0xf]);
8131 printf (_(" [reserved (%d)]\n"), per_index
);
8135 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8136 elf_header
.e_machine
);
8139 /* Decode the descriptors. Not implemented. */
8143 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8145 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8146 unsigned int i
, exidx_len
;
8147 unsigned long j
, nfuns
;
8149 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8150 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8151 exidx_len
= exidx_sec
->sh_size
/ 8;
8153 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8154 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8155 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8156 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8158 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8160 for (i
= 0; i
< exidx_len
; i
++)
8162 unsigned int exidx_fn
, exidx_entry
;
8163 struct absaddr fn_addr
, entry_addr
;
8166 fputc ('\n', stdout
);
8168 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8169 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8170 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8171 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8174 arm_free_section (& exidx_arm_sec
);
8175 arm_free_section (& extab_arm_sec
);
8179 /* ARM EHABI, Section 5:
8180 An index table entry consists of 2 words.
8181 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8182 if (exidx_fn
& 0x80000000)
8183 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8185 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8187 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8188 fputs (": ", stdout
);
8190 if (exidx_entry
== 1)
8192 print_vma (exidx_entry
, PREFIX_HEX
);
8193 fputs (" [cantunwind]\n", stdout
);
8195 else if (exidx_entry
& 0x80000000)
8197 print_vma (exidx_entry
, PREFIX_HEX
);
8198 fputc ('\n', stdout
);
8199 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8203 bfd_vma table
, table_offset
= 0;
8204 Elf_Internal_Shdr
*table_sec
;
8206 fputs ("@", stdout
);
8207 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8208 print_vma (table
, PREFIX_HEX
);
8211 /* Locate the matching .ARM.extab. */
8212 if (entry_addr
.section
!= SHN_UNDEF
8213 && entry_addr
.section
< elf_header
.e_shnum
)
8215 table_sec
= section_headers
+ entry_addr
.section
;
8216 table_offset
= entry_addr
.offset
;
8220 table_sec
= find_section_by_address (table
);
8221 if (table_sec
!= NULL
)
8222 table_offset
= table
- table_sec
->sh_addr
;
8224 if (table_sec
== NULL
)
8226 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8227 (unsigned long) table
);
8230 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8238 arm_free_section (&exidx_arm_sec
);
8239 arm_free_section (&extab_arm_sec
);
8242 /* Used for both ARM and C6X unwinding tables. */
8245 arm_process_unwind (FILE *file
)
8247 struct arm_unw_aux_info aux
;
8248 Elf_Internal_Shdr
*unwsec
= NULL
;
8249 Elf_Internal_Shdr
*strsec
;
8250 Elf_Internal_Shdr
*sec
;
8252 unsigned int sec_type
;
8254 switch (elf_header
.e_machine
)
8257 sec_type
= SHT_ARM_EXIDX
;
8261 sec_type
= SHT_C6000_UNWIND
;
8265 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8266 elf_header
.e_machine
);
8270 if (string_table
== NULL
)
8273 memset (& aux
, 0, sizeof (aux
));
8276 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8278 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8280 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8282 strsec
= section_headers
+ sec
->sh_link
;
8284 /* PR binutils/17531 file: 011-12666-0.004. */
8285 if (aux
.strtab
!= NULL
)
8287 error (_("Multiple string tables found in file.\n"));
8290 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8291 1, strsec
->sh_size
, _("string table"));
8292 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8294 else if (sec
->sh_type
== sec_type
)
8299 printf (_("\nThere are no unwind sections in this file.\n"));
8301 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8303 if (sec
->sh_type
== sec_type
)
8305 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8306 printable_section_name (sec
),
8307 (unsigned long) sec
->sh_offset
,
8308 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8310 dump_arm_unwind (&aux
, sec
);
8317 free ((char *) aux
.strtab
);
8321 process_unwind (FILE * file
)
8323 struct unwind_handler
8326 void (* handler
)(FILE *);
8329 { EM_ARM
, arm_process_unwind
},
8330 { EM_IA_64
, ia64_process_unwind
},
8331 { EM_PARISC
, hppa_process_unwind
},
8332 { EM_TI_C6000
, arm_process_unwind
},
8340 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8341 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8343 handlers
[i
].handler (file
);
8347 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8348 get_machine_name (elf_header
.e_machine
));
8352 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8354 switch (entry
->d_tag
)
8357 if (entry
->d_un
.d_val
== 0)
8361 static const char * opts
[] =
8363 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8364 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8365 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8366 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8372 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8373 if (entry
->d_un
.d_val
& (1 << cnt
))
8375 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8381 case DT_MIPS_IVERSION
:
8382 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8383 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8387 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8388 /* Note: coded this way so that there is a single string for translation. */
8389 printf (_("<corrupt: %s>"), buf
);
8393 case DT_MIPS_TIME_STAMP
:
8397 time_t atime
= entry
->d_un
.d_val
;
8399 tmp
= gmtime (&atime
);
8400 /* PR 17531: file: 6accc532. */
8402 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8404 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8405 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8406 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8407 printf (_("Time Stamp: %s"), timebuf
);
8411 case DT_MIPS_RLD_VERSION
:
8412 case DT_MIPS_LOCAL_GOTNO
:
8413 case DT_MIPS_CONFLICTNO
:
8414 case DT_MIPS_LIBLISTNO
:
8415 case DT_MIPS_SYMTABNO
:
8416 case DT_MIPS_UNREFEXTNO
:
8417 case DT_MIPS_HIPAGENO
:
8418 case DT_MIPS_DELTA_CLASS_NO
:
8419 case DT_MIPS_DELTA_INSTANCE_NO
:
8420 case DT_MIPS_DELTA_RELOC_NO
:
8421 case DT_MIPS_DELTA_SYM_NO
:
8422 case DT_MIPS_DELTA_CLASSSYM_NO
:
8423 case DT_MIPS_COMPACT_SIZE
:
8424 print_vma (entry
->d_un
.d_ptr
, DEC
);
8428 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8434 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8436 switch (entry
->d_tag
)
8438 case DT_HP_DLD_FLAGS
:
8447 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8448 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8449 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8450 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8451 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8452 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8453 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8454 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8455 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8456 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8457 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8458 { DT_HP_GST
, "HP_GST" },
8459 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8460 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8461 { DT_HP_NODELETE
, "HP_NODELETE" },
8462 { DT_HP_GROUP
, "HP_GROUP" },
8463 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8467 bfd_vma val
= entry
->d_un
.d_val
;
8469 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8470 if (val
& flags
[cnt
].bit
)
8474 fputs (flags
[cnt
].str
, stdout
);
8476 val
^= flags
[cnt
].bit
;
8479 if (val
!= 0 || first
)
8483 print_vma (val
, HEX
);
8489 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8497 /* VMS vs Unix time offset and factor. */
8499 #define VMS_EPOCH_OFFSET 35067168000000000LL
8500 #define VMS_GRANULARITY_FACTOR 10000000
8502 /* Display a VMS time in a human readable format. */
8505 print_vms_time (bfd_int64_t vmstime
)
8510 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8511 tm
= gmtime (&unxtime
);
8512 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8513 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8514 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8519 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8521 switch (entry
->d_tag
)
8523 case DT_IA_64_PLT_RESERVE
:
8524 /* First 3 slots reserved. */
8525 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8527 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8530 case DT_IA_64_VMS_LINKTIME
:
8532 print_vms_time (entry
->d_un
.d_val
);
8536 case DT_IA_64_VMS_LNKFLAGS
:
8537 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8538 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8539 printf (" CALL_DEBUG");
8540 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8541 printf (" NOP0BUFS");
8542 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8543 printf (" P0IMAGE");
8544 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8545 printf (" MKTHREADS");
8546 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8547 printf (" UPCALLS");
8548 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8550 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8551 printf (" INITIALIZE");
8552 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8554 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8555 printf (" EXE_INIT");
8556 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8557 printf (" TBK_IN_IMG");
8558 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8559 printf (" DBG_IN_IMG");
8560 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8561 printf (" TBK_IN_DSF");
8562 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8563 printf (" DBG_IN_DSF");
8564 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8565 printf (" SIGNATURES");
8566 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8567 printf (" REL_SEG_OFF");
8571 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8578 get_32bit_dynamic_section (FILE * file
)
8580 Elf32_External_Dyn
* edyn
;
8581 Elf32_External_Dyn
* ext
;
8582 Elf_Internal_Dyn
* entry
;
8584 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8585 dynamic_size
, _("dynamic section"));
8589 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8590 might not have the luxury of section headers. Look for the DT_NULL
8591 terminator to determine the number of entries. */
8592 for (ext
= edyn
, dynamic_nent
= 0;
8593 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8597 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8601 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8603 if (dynamic_section
== NULL
)
8605 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8606 (unsigned long) dynamic_nent
);
8611 for (ext
= edyn
, entry
= dynamic_section
;
8612 entry
< dynamic_section
+ dynamic_nent
;
8615 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8616 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8625 get_64bit_dynamic_section (FILE * file
)
8627 Elf64_External_Dyn
* edyn
;
8628 Elf64_External_Dyn
* ext
;
8629 Elf_Internal_Dyn
* entry
;
8631 /* Read in the data. */
8632 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8633 dynamic_size
, _("dynamic section"));
8637 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8638 might not have the luxury of section headers. Look for the DT_NULL
8639 terminator to determine the number of entries. */
8640 for (ext
= edyn
, dynamic_nent
= 0;
8641 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8642 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8646 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8650 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8652 if (dynamic_section
== NULL
)
8654 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8655 (unsigned long) dynamic_nent
);
8660 /* Convert from external to internal formats. */
8661 for (ext
= edyn
, entry
= dynamic_section
;
8662 entry
< dynamic_section
+ dynamic_nent
;
8665 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8666 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8675 print_dynamic_flags (bfd_vma flags
)
8683 flag
= flags
& - flags
;
8693 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8694 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8695 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8696 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8697 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8698 default: fputs (_("unknown"), stdout
); break;
8704 /* Parse and display the contents of the dynamic section. */
8707 process_dynamic_section (FILE * file
)
8709 Elf_Internal_Dyn
* entry
;
8711 if (dynamic_size
== 0)
8714 printf (_("\nThere is no dynamic section in this file.\n"));
8721 if (! get_32bit_dynamic_section (file
))
8724 else if (! get_64bit_dynamic_section (file
))
8727 /* Find the appropriate symbol table. */
8728 if (dynamic_symbols
== NULL
)
8730 for (entry
= dynamic_section
;
8731 entry
< dynamic_section
+ dynamic_nent
;
8734 Elf_Internal_Shdr section
;
8736 if (entry
->d_tag
!= DT_SYMTAB
)
8739 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8741 /* Since we do not know how big the symbol table is,
8742 we default to reading in the entire file (!) and
8743 processing that. This is overkill, I know, but it
8745 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8747 if (archive_file_offset
!= 0)
8748 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8751 if (fseek (file
, 0, SEEK_END
))
8752 error (_("Unable to seek to end of file!\n"));
8754 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8758 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8760 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8761 section
.sh_name
= string_table_length
;
8763 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8764 if (num_dynamic_syms
< 1)
8766 error (_("Unable to determine the number of symbols to load\n"));
8772 /* Similarly find a string table. */
8773 if (dynamic_strings
== NULL
)
8775 for (entry
= dynamic_section
;
8776 entry
< dynamic_section
+ dynamic_nent
;
8779 unsigned long offset
;
8782 if (entry
->d_tag
!= DT_STRTAB
)
8785 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8787 /* Since we do not know how big the string table is,
8788 we default to reading in the entire file (!) and
8789 processing that. This is overkill, I know, but it
8792 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8794 if (archive_file_offset
!= 0)
8795 str_tab_len
= archive_file_size
- offset
;
8798 if (fseek (file
, 0, SEEK_END
))
8799 error (_("Unable to seek to end of file\n"));
8800 str_tab_len
= ftell (file
) - offset
;
8803 if (str_tab_len
< 1)
8806 (_("Unable to determine the length of the dynamic string table\n"));
8810 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8812 _("dynamic string table"));
8813 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8818 /* And find the syminfo section if available. */
8819 if (dynamic_syminfo
== NULL
)
8821 unsigned long syminsz
= 0;
8823 for (entry
= dynamic_section
;
8824 entry
< dynamic_section
+ dynamic_nent
;
8827 if (entry
->d_tag
== DT_SYMINENT
)
8829 /* Note: these braces are necessary to avoid a syntax
8830 error from the SunOS4 C compiler. */
8831 /* PR binutils/17531: A corrupt file can trigger this test.
8832 So do not use an assert, instead generate an error message. */
8833 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8834 error (_("Bad value (%d) for SYMINENT entry\n"),
8835 (int) entry
->d_un
.d_val
);
8837 else if (entry
->d_tag
== DT_SYMINSZ
)
8838 syminsz
= entry
->d_un
.d_val
;
8839 else if (entry
->d_tag
== DT_SYMINFO
)
8840 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8844 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8846 Elf_External_Syminfo
* extsyminfo
;
8847 Elf_External_Syminfo
* extsym
;
8848 Elf_Internal_Syminfo
* syminfo
;
8850 /* There is a syminfo section. Read the data. */
8851 extsyminfo
= (Elf_External_Syminfo
*)
8852 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8853 _("symbol information"));
8857 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8858 if (dynamic_syminfo
== NULL
)
8860 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8861 (unsigned long) syminsz
);
8865 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8866 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8867 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8868 ++syminfo
, ++extsym
)
8870 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8871 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8878 if (do_dynamic
&& dynamic_addr
)
8879 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8880 dynamic_addr
, (unsigned long) dynamic_nent
);
8882 printf (_(" Tag Type Name/Value\n"));
8884 for (entry
= dynamic_section
;
8885 entry
< dynamic_section
+ dynamic_nent
;
8893 print_vma (entry
->d_tag
, FULL_HEX
);
8894 dtype
= get_dynamic_type (entry
->d_tag
);
8895 printf (" (%s)%*s", dtype
,
8896 ((is_32bit_elf
? 27 : 19)
8897 - (int) strlen (dtype
)),
8901 switch (entry
->d_tag
)
8905 print_dynamic_flags (entry
->d_un
.d_val
);
8915 switch (entry
->d_tag
)
8918 printf (_("Auxiliary library"));
8922 printf (_("Filter library"));
8926 printf (_("Configuration file"));
8930 printf (_("Dependency audit library"));
8934 printf (_("Audit library"));
8938 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8939 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8943 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8952 printf (_("Flags:"));
8954 if (entry
->d_un
.d_val
== 0)
8955 printf (_(" None\n"));
8958 unsigned long int val
= entry
->d_un
.d_val
;
8960 if (val
& DTF_1_PARINIT
)
8962 printf (" PARINIT");
8963 val
^= DTF_1_PARINIT
;
8965 if (val
& DTF_1_CONFEXP
)
8967 printf (" CONFEXP");
8968 val
^= DTF_1_CONFEXP
;
8971 printf (" %lx", val
);
8980 printf (_("Flags:"));
8982 if (entry
->d_un
.d_val
== 0)
8983 printf (_(" None\n"));
8986 unsigned long int val
= entry
->d_un
.d_val
;
8988 if (val
& DF_P1_LAZYLOAD
)
8990 printf (" LAZYLOAD");
8991 val
^= DF_P1_LAZYLOAD
;
8993 if (val
& DF_P1_GROUPPERM
)
8995 printf (" GROUPPERM");
8996 val
^= DF_P1_GROUPPERM
;
8999 printf (" %lx", val
);
9008 printf (_("Flags:"));
9009 if (entry
->d_un
.d_val
== 0)
9010 printf (_(" None\n"));
9013 unsigned long int val
= entry
->d_un
.d_val
;
9020 if (val
& DF_1_GLOBAL
)
9025 if (val
& DF_1_GROUP
)
9030 if (val
& DF_1_NODELETE
)
9032 printf (" NODELETE");
9033 val
^= DF_1_NODELETE
;
9035 if (val
& DF_1_LOADFLTR
)
9037 printf (" LOADFLTR");
9038 val
^= DF_1_LOADFLTR
;
9040 if (val
& DF_1_INITFIRST
)
9042 printf (" INITFIRST");
9043 val
^= DF_1_INITFIRST
;
9045 if (val
& DF_1_NOOPEN
)
9050 if (val
& DF_1_ORIGIN
)
9055 if (val
& DF_1_DIRECT
)
9060 if (val
& DF_1_TRANS
)
9065 if (val
& DF_1_INTERPOSE
)
9067 printf (" INTERPOSE");
9068 val
^= DF_1_INTERPOSE
;
9070 if (val
& DF_1_NODEFLIB
)
9072 printf (" NODEFLIB");
9073 val
^= DF_1_NODEFLIB
;
9075 if (val
& DF_1_NODUMP
)
9080 if (val
& DF_1_CONFALT
)
9082 printf (" CONFALT");
9083 val
^= DF_1_CONFALT
;
9085 if (val
& DF_1_ENDFILTEE
)
9087 printf (" ENDFILTEE");
9088 val
^= DF_1_ENDFILTEE
;
9090 if (val
& DF_1_DISPRELDNE
)
9092 printf (" DISPRELDNE");
9093 val
^= DF_1_DISPRELDNE
;
9095 if (val
& DF_1_DISPRELPND
)
9097 printf (" DISPRELPND");
9098 val
^= DF_1_DISPRELPND
;
9100 if (val
& DF_1_NODIRECT
)
9102 printf (" NODIRECT");
9103 val
^= DF_1_NODIRECT
;
9105 if (val
& DF_1_IGNMULDEF
)
9107 printf (" IGNMULDEF");
9108 val
^= DF_1_IGNMULDEF
;
9110 if (val
& DF_1_NOKSYMS
)
9112 printf (" NOKSYMS");
9113 val
^= DF_1_NOKSYMS
;
9115 if (val
& DF_1_NOHDR
)
9120 if (val
& DF_1_EDITED
)
9125 if (val
& DF_1_NORELOC
)
9127 printf (" NORELOC");
9128 val
^= DF_1_NORELOC
;
9130 if (val
& DF_1_SYMINTPOSE
)
9132 printf (" SYMINTPOSE");
9133 val
^= DF_1_SYMINTPOSE
;
9135 if (val
& DF_1_GLOBAUDIT
)
9137 printf (" GLOBAUDIT");
9138 val
^= DF_1_GLOBAUDIT
;
9140 if (val
& DF_1_SINGLETON
)
9142 printf (" SINGLETON");
9143 val
^= DF_1_SINGLETON
;
9146 printf (" %lx", val
);
9153 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9155 puts (get_dynamic_type (entry
->d_un
.d_val
));
9175 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9181 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9182 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9188 switch (entry
->d_tag
)
9191 printf (_("Shared library: [%s]"), name
);
9193 if (streq (name
, program_interpreter
))
9194 printf (_(" program interpreter"));
9198 printf (_("Library soname: [%s]"), name
);
9202 printf (_("Library rpath: [%s]"), name
);
9206 printf (_("Library runpath: [%s]"), name
);
9210 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9215 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9228 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9232 case DT_INIT_ARRAYSZ
:
9233 case DT_FINI_ARRAYSZ
:
9234 case DT_GNU_CONFLICTSZ
:
9235 case DT_GNU_LIBLISTSZ
:
9238 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9239 printf (_(" (bytes)\n"));
9249 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9262 if (entry
->d_tag
== DT_USED
9263 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9265 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9269 printf (_("Not needed object: [%s]\n"), name
);
9274 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9280 /* The value of this entry is ignored. */
9285 case DT_GNU_PRELINKED
:
9289 time_t atime
= entry
->d_un
.d_val
;
9291 tmp
= gmtime (&atime
);
9292 /* PR 17533 file: 041-1244816-0.004. */
9294 printf (_("<corrupt time val: %lx"),
9295 (unsigned long) atime
);
9297 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9298 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9299 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9305 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9308 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9314 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9315 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9320 switch (elf_header
.e_machine
)
9323 case EM_MIPS_RS3_LE
:
9324 dynamic_section_mips_val (entry
);
9327 dynamic_section_parisc_val (entry
);
9330 dynamic_section_ia64_val (entry
);
9333 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9345 get_ver_flags (unsigned int flags
)
9347 static char buff
[32];
9354 if (flags
& VER_FLG_BASE
)
9355 strcat (buff
, "BASE ");
9357 if (flags
& VER_FLG_WEAK
)
9359 if (flags
& VER_FLG_BASE
)
9360 strcat (buff
, "| ");
9362 strcat (buff
, "WEAK ");
9365 if (flags
& VER_FLG_INFO
)
9367 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9368 strcat (buff
, "| ");
9370 strcat (buff
, "INFO ");
9373 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9374 strcat (buff
, _("| <unknown>"));
9379 /* Display the contents of the version sections. */
9382 process_version_sections (FILE * file
)
9384 Elf_Internal_Shdr
* section
;
9391 for (i
= 0, section
= section_headers
;
9392 i
< elf_header
.e_shnum
;
9395 switch (section
->sh_type
)
9397 case SHT_GNU_verdef
:
9399 Elf_External_Verdef
* edefs
;
9406 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9407 printable_section_name (section
),
9410 printf (_(" Addr: 0x"));
9411 printf_vma (section
->sh_addr
);
9412 printf (_(" Offset: %#08lx Link: %u (%s)"),
9413 (unsigned long) section
->sh_offset
, section
->sh_link
,
9414 printable_section_name_from_index (section
->sh_link
));
9416 edefs
= (Elf_External_Verdef
*)
9417 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9418 _("version definition section"));
9421 endbuf
= (char *) edefs
+ section
->sh_size
;
9423 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9426 Elf_External_Verdef
* edef
;
9427 Elf_Internal_Verdef ent
;
9428 Elf_External_Verdaux
* eaux
;
9429 Elf_Internal_Verdaux aux
;
9433 /* Check for very large indicies. */
9434 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9437 vstart
= ((char *) edefs
) + idx
;
9438 if (vstart
+ sizeof (*edef
) > endbuf
)
9441 edef
= (Elf_External_Verdef
*) vstart
;
9443 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9444 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9445 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9446 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9447 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9448 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9449 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9451 printf (_(" %#06x: Rev: %d Flags: %s"),
9452 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9454 printf (_(" Index: %d Cnt: %d "),
9455 ent
.vd_ndx
, ent
.vd_cnt
);
9457 /* Check for overflow. */
9458 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9461 vstart
+= ent
.vd_aux
;
9463 eaux
= (Elf_External_Verdaux
*) vstart
;
9465 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9466 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9468 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9469 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9471 printf (_("Name index: %ld\n"), aux
.vda_name
);
9473 isum
= idx
+ ent
.vd_aux
;
9475 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9477 /* Check for overflow. */
9478 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9481 isum
+= aux
.vda_next
;
9482 vstart
+= aux
.vda_next
;
9484 eaux
= (Elf_External_Verdaux
*) vstart
;
9485 if (vstart
+ sizeof (*eaux
) > endbuf
)
9488 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9489 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9491 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9492 printf (_(" %#06x: Parent %d: %s\n"),
9493 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9495 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9496 isum
, j
, aux
.vda_name
);
9500 printf (_(" Version def aux past end of section\n"));
9502 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9503 if (idx
+ ent
.vd_next
<= idx
)
9509 if (cnt
< section
->sh_info
)
9510 printf (_(" Version definition past end of section\n"));
9516 case SHT_GNU_verneed
:
9518 Elf_External_Verneed
* eneed
;
9525 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9526 printable_section_name (section
), section
->sh_info
);
9528 printf (_(" Addr: 0x"));
9529 printf_vma (section
->sh_addr
);
9530 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9531 (unsigned long) section
->sh_offset
, section
->sh_link
,
9532 printable_section_name_from_index (section
->sh_link
));
9534 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9535 section
->sh_offset
, 1,
9537 _("Version Needs section"));
9540 endbuf
= (char *) eneed
+ section
->sh_size
;
9542 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9544 Elf_External_Verneed
* entry
;
9545 Elf_Internal_Verneed ent
;
9550 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9553 vstart
= ((char *) eneed
) + idx
;
9554 if (vstart
+ sizeof (*entry
) > endbuf
)
9557 entry
= (Elf_External_Verneed
*) vstart
;
9559 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9560 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9561 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9562 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9563 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9565 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9567 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9568 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9570 printf (_(" File: %lx"), ent
.vn_file
);
9572 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9574 /* Check for overflow. */
9575 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9577 vstart
+= ent
.vn_aux
;
9579 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9581 Elf_External_Vernaux
* eaux
;
9582 Elf_Internal_Vernaux aux
;
9584 if (vstart
+ sizeof (*eaux
) > endbuf
)
9586 eaux
= (Elf_External_Vernaux
*) vstart
;
9588 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9589 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9590 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9591 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9592 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9594 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9595 printf (_(" %#06x: Name: %s"),
9596 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9598 printf (_(" %#06x: Name index: %lx"),
9599 isum
, aux
.vna_name
);
9601 printf (_(" Flags: %s Version: %d\n"),
9602 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9604 /* Check for overflow. */
9605 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9606 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9608 warn (_("Invalid vna_next field of %lx\n"),
9613 isum
+= aux
.vna_next
;
9614 vstart
+= aux
.vna_next
;
9618 warn (_("Missing Version Needs auxillary information\n"));
9620 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9622 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9623 cnt
= section
->sh_info
;
9629 if (cnt
< section
->sh_info
)
9630 warn (_("Missing Version Needs information\n"));
9636 case SHT_GNU_versym
:
9638 Elf_Internal_Shdr
* link_section
;
9641 unsigned char * edata
;
9642 unsigned short * data
;
9644 Elf_Internal_Sym
* symbols
;
9645 Elf_Internal_Shdr
* string_sec
;
9646 unsigned long num_syms
;
9649 if (section
->sh_link
>= elf_header
.e_shnum
)
9652 link_section
= section_headers
+ section
->sh_link
;
9653 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9655 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9660 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9661 if (symbols
== NULL
)
9664 string_sec
= section_headers
+ link_section
->sh_link
;
9666 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9667 string_sec
->sh_size
,
9668 _("version string table"));
9675 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9676 printable_section_name (section
), (unsigned long) total
);
9678 printf (_(" Addr: "));
9679 printf_vma (section
->sh_addr
);
9680 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9681 (unsigned long) section
->sh_offset
, section
->sh_link
,
9682 printable_section_name (link_section
));
9684 off
= offset_from_vma (file
,
9685 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9686 total
* sizeof (short));
9687 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9689 _("version symbol data"));
9697 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9699 for (cnt
= total
; cnt
--;)
9700 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9705 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9708 int check_def
, check_need
;
9711 printf (" %03x:", cnt
);
9713 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9714 switch (data
[cnt
+ j
])
9717 fputs (_(" 0 (*local*) "), stdout
);
9721 fputs (_(" 1 (*global*) "), stdout
);
9725 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9726 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9728 /* If this index value is greater than the size of the symbols
9729 array, break to avoid an out-of-bounds read. */
9730 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9732 warn (_("invalid index into symbol array\n"));
9738 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9739 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9742 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9749 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9751 Elf_Internal_Verneed ivn
;
9752 unsigned long offset
;
9754 offset
= offset_from_vma
9755 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9756 sizeof (Elf_External_Verneed
));
9760 Elf_Internal_Vernaux ivna
;
9761 Elf_External_Verneed evn
;
9762 Elf_External_Vernaux evna
;
9763 unsigned long a_off
;
9765 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9766 _("version need")) == NULL
)
9769 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9770 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9772 a_off
= offset
+ ivn
.vn_aux
;
9776 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9777 1, _("version need aux (2)")) == NULL
)
9784 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9785 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9788 a_off
+= ivna
.vna_next
;
9790 while (ivna
.vna_other
!= data
[cnt
+ j
]
9791 && ivna
.vna_next
!= 0);
9793 if (ivna
.vna_other
== data
[cnt
+ j
])
9795 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9797 if (ivna
.vna_name
>= string_sec
->sh_size
)
9798 name
= _("*invalid*");
9800 name
= strtab
+ ivna
.vna_name
;
9801 nn
+= printf ("(%s%-*s",
9803 12 - (int) strlen (name
),
9809 offset
+= ivn
.vn_next
;
9811 while (ivn
.vn_next
);
9814 if (check_def
&& data
[cnt
+ j
] != 0x8001
9815 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9817 Elf_Internal_Verdef ivd
;
9818 Elf_External_Verdef evd
;
9819 unsigned long offset
;
9821 offset
= offset_from_vma
9822 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9827 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9828 _("version def")) == NULL
)
9831 /* PR 17531: file: 046-1082287-0.004. */
9832 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9837 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9838 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9841 offset
+= ivd
.vd_next
;
9843 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9844 && ivd
.vd_next
!= 0);
9846 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9848 Elf_External_Verdaux evda
;
9849 Elf_Internal_Verdaux ivda
;
9851 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9853 if (get_data (&evda
, file
,
9854 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9856 _("version def aux")) == NULL
)
9859 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9861 if (ivda
.vda_name
>= string_sec
->sh_size
)
9862 name
= _("*invalid*");
9864 name
= strtab
+ ivda
.vda_name
;
9865 nn
+= printf ("(%s%-*s",
9867 12 - (int) strlen (name
),
9873 printf ("%*c", 18 - nn
, ' ');
9891 printf (_("\nNo version information found in this file.\n"));
9897 get_symbol_binding (unsigned int binding
)
9899 static char buff
[32];
9903 case STB_LOCAL
: return "LOCAL";
9904 case STB_GLOBAL
: return "GLOBAL";
9905 case STB_WEAK
: return "WEAK";
9907 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9908 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9910 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9912 if (binding
== STB_GNU_UNIQUE
9913 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9914 /* GNU is still using the default value 0. */
9915 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9917 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9920 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9926 get_symbol_type (unsigned int type
)
9928 static char buff
[32];
9932 case STT_NOTYPE
: return "NOTYPE";
9933 case STT_OBJECT
: return "OBJECT";
9934 case STT_FUNC
: return "FUNC";
9935 case STT_SECTION
: return "SECTION";
9936 case STT_FILE
: return "FILE";
9937 case STT_COMMON
: return "COMMON";
9938 case STT_TLS
: return "TLS";
9939 case STT_RELC
: return "RELC";
9940 case STT_SRELC
: return "SRELC";
9942 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9944 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9945 return "THUMB_FUNC";
9947 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9950 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9951 return "PARISC_MILLI";
9953 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9955 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9957 if (elf_header
.e_machine
== EM_PARISC
)
9959 if (type
== STT_HP_OPAQUE
)
9961 if (type
== STT_HP_STUB
)
9965 if (type
== STT_GNU_IFUNC
9966 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9967 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9968 /* GNU is still using the default value 0. */
9969 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9972 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9975 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9981 get_symbol_visibility (unsigned int visibility
)
9985 case STV_DEFAULT
: return "DEFAULT";
9986 case STV_INTERNAL
: return "INTERNAL";
9987 case STV_HIDDEN
: return "HIDDEN";
9988 case STV_PROTECTED
: return "PROTECTED";
9990 error (_("Unrecognized visibility value: %u"), visibility
);
9991 return _("<unknown>");
9996 get_mips_symbol_other (unsigned int other
)
10006 case STO_MICROMIPS
:
10007 return "MICROMIPS";
10008 case STO_MICROMIPS
| STO_MIPS_PIC
:
10009 return "MICROMIPS, MIPS PIC";
10017 static const char *
10018 get_ia64_symbol_other (unsigned int other
)
10020 if (is_ia64_vms ())
10022 static char res
[32];
10026 /* Function types is for images and .STB files only. */
10027 switch (elf_header
.e_type
)
10031 switch (VMS_ST_FUNC_TYPE (other
))
10033 case VMS_SFT_CODE_ADDR
:
10034 strcat (res
, " CA");
10036 case VMS_SFT_SYMV_IDX
:
10037 strcat (res
, " VEC");
10040 strcat (res
, " FD");
10042 case VMS_SFT_RESERVE
:
10043 strcat (res
, " RSV");
10046 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10047 VMS_ST_FUNC_TYPE (other
));
10048 strcat (res
, " <unknown>");
10055 switch (VMS_ST_LINKAGE (other
))
10057 case VMS_STL_IGNORE
:
10058 strcat (res
, " IGN");
10060 case VMS_STL_RESERVE
:
10061 strcat (res
, " RSV");
10064 strcat (res
, " STD");
10067 strcat (res
, " LNK");
10070 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10071 VMS_ST_LINKAGE (other
));
10072 strcat (res
, " <unknown>");
10084 static const char *
10085 get_ppc64_symbol_other (unsigned int other
)
10087 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10089 static char buf
[32];
10090 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10091 PPC64_LOCAL_ENTRY_OFFSET (other
));
10097 static const char *
10098 get_symbol_other (unsigned int other
)
10100 const char * result
= NULL
;
10101 static char buff
[32];
10106 switch (elf_header
.e_machine
)
10109 result
= get_mips_symbol_other (other
);
10112 result
= get_ia64_symbol_other (other
);
10115 result
= get_ppc64_symbol_other (other
);
10124 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10128 static const char *
10129 get_symbol_index_type (unsigned int type
)
10131 static char buff
[32];
10135 case SHN_UNDEF
: return "UND";
10136 case SHN_ABS
: return "ABS";
10137 case SHN_COMMON
: return "COM";
10139 if (type
== SHN_IA_64_ANSI_COMMON
10140 && elf_header
.e_machine
== EM_IA_64
10141 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10143 else if ((elf_header
.e_machine
== EM_X86_64
10144 || elf_header
.e_machine
== EM_L1OM
10145 || elf_header
.e_machine
== EM_K1OM
)
10146 && type
== SHN_X86_64_LCOMMON
)
10147 return "LARGE_COM";
10148 else if ((type
== SHN_MIPS_SCOMMON
10149 && elf_header
.e_machine
== EM_MIPS
)
10150 || (type
== SHN_TIC6X_SCOMMON
10151 && elf_header
.e_machine
== EM_TI_C6000
))
10153 else if (type
== SHN_MIPS_SUNDEFINED
10154 && elf_header
.e_machine
== EM_MIPS
)
10156 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10157 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10158 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10159 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10160 else if (type
>= SHN_LORESERVE
)
10161 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10162 else if (type
>= elf_header
.e_shnum
)
10163 sprintf (buff
, _("bad section index[%3d]"), type
);
10165 sprintf (buff
, "%3d", type
);
10173 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10175 unsigned char * e_data
;
10178 /* If the size_t type is smaller than the bfd_size_type, eg because
10179 you are building a 32-bit tool on a 64-bit host, then make sure
10180 that when (number) is cast to (size_t) no information is lost. */
10181 if (sizeof (size_t) < sizeof (bfd_size_type
)
10182 && (bfd_size_type
) ((size_t) number
) != number
)
10184 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10185 (unsigned long long) number
, ent_size
);
10189 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10190 attempting to allocate memory when the read is bound to fail. */
10191 if (ent_size
* number
> current_file_size
)
10193 error (_("Invalid number of dynamic entries: %llu\n"),
10194 (unsigned long long) number
);
10198 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10199 if (e_data
== NULL
)
10201 error (_("Out of memory reading %llu dynamic entries\n"),
10202 (unsigned long long) number
);
10206 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10208 error (_("Unable to read in %llu bytes of dynamic data\n"),
10209 (unsigned long long) (number
* ent_size
));
10214 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10215 if (i_data
== NULL
)
10217 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10218 (unsigned long long) number
);
10224 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10232 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10234 Elf_Internal_Sym
* psym
;
10237 n
= print_vma (si
, DEC_5
);
10239 fputs (&" "[n
], stdout
);
10240 printf (" %3lu: ", hn
);
10242 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10244 printf (_("<No info available for dynamic symbol number %lu>\n"),
10245 (unsigned long) si
);
10249 psym
= dynamic_symbols
+ si
;
10250 print_vma (psym
->st_value
, LONG_HEX
);
10252 print_vma (psym
->st_size
, DEC_5
);
10254 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10255 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10256 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10257 /* Check to see if any other bits in the st_other field are set.
10258 Note - displaying this information disrupts the layout of the
10259 table being generated, but for the moment this case is very
10261 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10262 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10263 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10264 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10265 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10267 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10271 static const char *
10272 get_symbol_version_string (FILE *file
, int is_dynsym
,
10273 const char *strtab
,
10274 unsigned long int strtab_size
,
10275 unsigned int si
, Elf_Internal_Sym
*psym
,
10276 enum versioned_symbol_info
*sym_info
,
10277 unsigned short *vna_other
)
10279 const char *version_string
= NULL
;
10282 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10284 unsigned char data
[2];
10285 unsigned short vers_data
;
10286 unsigned long offset
;
10290 offset
= offset_from_vma
10291 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10292 sizeof data
+ si
* sizeof (vers_data
));
10294 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10295 sizeof (data
), 1, _("version data")) == NULL
)
10298 vers_data
= byte_get (data
, 2);
10300 is_nobits
= (section_headers
!= NULL
10301 && psym
->st_shndx
< elf_header
.e_shnum
10302 && section_headers
[psym
->st_shndx
].sh_type
10305 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10307 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10309 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10310 && (is_nobits
|| ! check_def
))
10312 Elf_External_Verneed evn
;
10313 Elf_Internal_Verneed ivn
;
10314 Elf_Internal_Vernaux ivna
;
10316 /* We must test both. */
10317 offset
= offset_from_vma
10318 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10323 unsigned long vna_off
;
10325 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10326 _("version need")) == NULL
)
10329 ivna
.vna_other
= 0;
10334 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10335 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10337 vna_off
= offset
+ ivn
.vn_aux
;
10341 Elf_External_Vernaux evna
;
10343 if (get_data (&evna
, file
, vna_off
,
10345 _("version need aux (3)")) == NULL
)
10348 ivna
.vna_other
= 0;
10353 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10354 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10355 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10358 vna_off
+= ivna
.vna_next
;
10360 while (ivna
.vna_other
!= vers_data
10361 && ivna
.vna_next
!= 0);
10363 if (ivna
.vna_other
== vers_data
)
10366 offset
+= ivn
.vn_next
;
10368 while (ivn
.vn_next
!= 0);
10370 if (ivna
.vna_other
== vers_data
)
10372 *sym_info
= symbol_undefined
;
10373 *vna_other
= ivna
.vna_other
;
10374 version_string
= (ivna
.vna_name
< strtab_size
10375 ? strtab
+ ivna
.vna_name
10379 else if (! is_nobits
)
10380 error (_("bad dynamic symbol\n"));
10387 if (vers_data
!= 0x8001
10388 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10390 Elf_Internal_Verdef ivd
;
10391 Elf_Internal_Verdaux ivda
;
10392 Elf_External_Verdaux evda
;
10395 off
= offset_from_vma
10397 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10398 sizeof (Elf_External_Verdef
));
10402 Elf_External_Verdef evd
;
10404 if (get_data (&evd
, file
, off
, sizeof (evd
),
10405 1, _("version def")) == NULL
)
10413 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10414 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10415 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10418 off
+= ivd
.vd_next
;
10420 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10421 && ivd
.vd_next
!= 0);
10423 off
-= ivd
.vd_next
;
10426 if (get_data (&evda
, file
, off
, sizeof (evda
),
10427 1, _("version def aux")) == NULL
)
10428 return version_string
;
10430 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10432 if (psym
->st_name
!= ivda
.vda_name
)
10434 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10435 ? symbol_hidden
: symbol_public
);
10436 version_string
= (ivda
.vda_name
< strtab_size
10437 ? strtab
+ ivda
.vda_name
10444 return version_string
;
10447 /* Dump the symbol table. */
10449 process_symbol_table (FILE * file
)
10451 Elf_Internal_Shdr
* section
;
10452 bfd_size_type nbuckets
= 0;
10453 bfd_size_type nchains
= 0;
10454 bfd_vma
* buckets
= NULL
;
10455 bfd_vma
* chains
= NULL
;
10456 bfd_vma ngnubuckets
= 0;
10457 bfd_vma
* gnubuckets
= NULL
;
10458 bfd_vma
* gnuchains
= NULL
;
10459 bfd_vma gnusymidx
= 0;
10460 bfd_size_type ngnuchains
= 0;
10462 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10465 if (dynamic_info
[DT_HASH
]
10467 || (do_using_dynamic
10469 && dynamic_strings
!= NULL
)))
10471 unsigned char nb
[8];
10472 unsigned char nc
[8];
10473 unsigned int hash_ent_size
= 4;
10475 if ((elf_header
.e_machine
== EM_ALPHA
10476 || elf_header
.e_machine
== EM_S390
10477 || elf_header
.e_machine
== EM_S390_OLD
)
10478 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10482 (archive_file_offset
10483 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10484 sizeof nb
+ sizeof nc
)),
10487 error (_("Unable to seek to start of dynamic information\n"));
10491 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10493 error (_("Failed to read in number of buckets\n"));
10497 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10499 error (_("Failed to read in number of chains\n"));
10503 nbuckets
= byte_get (nb
, hash_ent_size
);
10504 nchains
= byte_get (nc
, hash_ent_size
);
10506 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10507 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10510 if (buckets
== NULL
|| chains
== NULL
)
10512 if (do_using_dynamic
)
10523 if (dynamic_info_DT_GNU_HASH
10525 || (do_using_dynamic
10527 && dynamic_strings
!= NULL
)))
10529 unsigned char nb
[16];
10530 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10531 bfd_vma buckets_vma
;
10534 (archive_file_offset
10535 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10539 error (_("Unable to seek to start of dynamic information\n"));
10543 if (fread (nb
, 16, 1, file
) != 1)
10545 error (_("Failed to read in number of buckets\n"));
10549 ngnubuckets
= byte_get (nb
, 4);
10550 gnusymidx
= byte_get (nb
+ 4, 4);
10551 bitmaskwords
= byte_get (nb
+ 8, 4);
10552 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10554 buckets_vma
+= bitmaskwords
* 4;
10556 buckets_vma
+= bitmaskwords
* 8;
10559 (archive_file_offset
10560 + offset_from_vma (file
, buckets_vma
, 4)),
10563 error (_("Unable to seek to start of dynamic information\n"));
10567 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10569 if (gnubuckets
== NULL
)
10572 for (i
= 0; i
< ngnubuckets
; i
++)
10573 if (gnubuckets
[i
] != 0)
10575 if (gnubuckets
[i
] < gnusymidx
)
10578 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10579 maxchain
= gnubuckets
[i
];
10582 if (maxchain
== 0xffffffff)
10585 maxchain
-= gnusymidx
;
10588 (archive_file_offset
10589 + offset_from_vma (file
, buckets_vma
10590 + 4 * (ngnubuckets
+ maxchain
), 4)),
10593 error (_("Unable to seek to start of dynamic information\n"));
10599 if (fread (nb
, 4, 1, file
) != 1)
10601 error (_("Failed to determine last chain length\n"));
10605 if (maxchain
+ 1 == 0)
10610 while ((byte_get (nb
, 4) & 1) == 0);
10613 (archive_file_offset
10614 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10617 error (_("Unable to seek to start of dynamic information\n"));
10621 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10622 ngnuchains
= maxchain
;
10625 if (gnuchains
== NULL
)
10630 if (do_using_dynamic
)
10635 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10637 && do_using_dynamic
10638 && dynamic_strings
!= NULL
10639 && dynamic_symbols
!= NULL
)
10643 if (dynamic_info
[DT_HASH
])
10647 printf (_("\nSymbol table for image:\n"));
10649 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10651 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10653 for (hn
= 0; hn
< nbuckets
; hn
++)
10658 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10659 print_dynamic_symbol (si
, hn
);
10663 if (dynamic_info_DT_GNU_HASH
)
10665 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10667 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10669 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10671 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10672 if (gnubuckets
[hn
] != 0)
10674 bfd_vma si
= gnubuckets
[hn
];
10675 bfd_vma off
= si
- gnusymidx
;
10679 print_dynamic_symbol (si
, hn
);
10682 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10686 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10687 && section_headers
!= NULL
)
10691 for (i
= 0, section
= section_headers
;
10692 i
< elf_header
.e_shnum
;
10696 char * strtab
= NULL
;
10697 unsigned long int strtab_size
= 0;
10698 Elf_Internal_Sym
* symtab
;
10699 Elf_Internal_Sym
* psym
;
10700 unsigned long num_syms
;
10702 if ((section
->sh_type
!= SHT_SYMTAB
10703 && section
->sh_type
!= SHT_DYNSYM
)
10705 && section
->sh_type
== SHT_SYMTAB
))
10708 if (section
->sh_entsize
== 0)
10710 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10711 printable_section_name (section
));
10715 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10716 printable_section_name (section
),
10717 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10720 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10722 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10724 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10725 if (symtab
== NULL
)
10728 if (section
->sh_link
== elf_header
.e_shstrndx
)
10730 strtab
= string_table
;
10731 strtab_size
= string_table_length
;
10733 else if (section
->sh_link
< elf_header
.e_shnum
)
10735 Elf_Internal_Shdr
* string_sec
;
10737 string_sec
= section_headers
+ section
->sh_link
;
10739 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10740 1, string_sec
->sh_size
,
10741 _("string table"));
10742 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10745 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10747 const char *version_string
;
10748 enum versioned_symbol_info sym_info
;
10749 unsigned short vna_other
;
10751 printf ("%6d: ", si
);
10752 print_vma (psym
->st_value
, LONG_HEX
);
10754 print_vma (psym
->st_size
, DEC_5
);
10755 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10756 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10757 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10758 /* Check to see if any other bits in the st_other field are set.
10759 Note - displaying this information disrupts the layout of the
10760 table being generated, but for the moment this case is very rare. */
10761 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10762 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10763 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10764 print_symbol (25, psym
->st_name
< strtab_size
10765 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10768 = get_symbol_version_string (file
,
10769 section
->sh_type
== SHT_DYNSYM
,
10770 strtab
, strtab_size
, si
,
10771 psym
, &sym_info
, &vna_other
);
10772 if (version_string
)
10774 if (sym_info
== symbol_undefined
)
10775 printf ("@%s (%d)", version_string
, vna_other
);
10777 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10785 if (strtab
!= string_table
)
10791 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10793 if (do_histogram
&& buckets
!= NULL
)
10795 unsigned long * lengths
;
10796 unsigned long * counts
;
10799 unsigned long maxlength
= 0;
10800 unsigned long nzero_counts
= 0;
10801 unsigned long nsyms
= 0;
10802 unsigned long chained
;
10804 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10805 (unsigned long) nbuckets
);
10807 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10808 if (lengths
== NULL
)
10810 error (_("Out of memory allocating space for histogram buckets\n"));
10814 printf (_(" Length Number %% of total Coverage\n"));
10815 for (hn
= 0; hn
< nbuckets
; ++hn
)
10817 for (si
= buckets
[hn
], chained
= 0;
10818 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
10819 si
= chains
[si
], ++chained
)
10822 if (maxlength
< ++lengths
[hn
])
10826 /* PR binutils/17531: A corrupt binary could contain broken
10827 histogram data. Do not go into an infinite loop trying
10829 if (chained
> nchains
)
10831 error (_("histogram chain is corrupt\n"));
10836 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10837 if (counts
== NULL
)
10840 error (_("Out of memory allocating space for histogram counts\n"));
10844 for (hn
= 0; hn
< nbuckets
; ++hn
)
10845 ++counts
[lengths
[hn
]];
10850 printf (" 0 %-10lu (%5.1f%%)\n",
10851 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10852 for (i
= 1; i
<= maxlength
; ++i
)
10854 nzero_counts
+= counts
[i
] * i
;
10855 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10856 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10857 (nzero_counts
* 100.0) / nsyms
);
10865 if (buckets
!= NULL
)
10871 if (do_histogram
&& gnubuckets
!= NULL
)
10873 unsigned long * lengths
;
10874 unsigned long * counts
;
10876 unsigned long maxlength
= 0;
10877 unsigned long nzero_counts
= 0;
10878 unsigned long nsyms
= 0;
10880 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10881 (unsigned long) ngnubuckets
);
10883 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10884 if (lengths
== NULL
)
10886 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10890 printf (_(" Length Number %% of total Coverage\n"));
10892 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10893 if (gnubuckets
[hn
] != 0)
10895 bfd_vma off
, length
= 1;
10897 for (off
= gnubuckets
[hn
] - gnusymidx
;
10898 /* PR 17531 file: 010-77222-0.004. */
10899 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10902 lengths
[hn
] = length
;
10903 if (length
> maxlength
)
10904 maxlength
= length
;
10908 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10909 if (counts
== NULL
)
10912 error (_("Out of memory allocating space for gnu histogram counts\n"));
10916 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10917 ++counts
[lengths
[hn
]];
10919 if (ngnubuckets
> 0)
10922 printf (" 0 %-10lu (%5.1f%%)\n",
10923 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10924 for (j
= 1; j
<= maxlength
; ++j
)
10926 nzero_counts
+= counts
[j
] * j
;
10927 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10928 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10929 (nzero_counts
* 100.0) / nsyms
);
10943 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10947 if (dynamic_syminfo
== NULL
10949 /* No syminfo, this is ok. */
10952 /* There better should be a dynamic symbol section. */
10953 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10957 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10958 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10960 printf (_(" Num: Name BoundTo Flags\n"));
10961 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10963 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10965 printf ("%4d: ", i
);
10966 if (i
>= num_dynamic_syms
)
10967 printf (_("<corrupt index>"));
10968 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10969 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10971 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10974 switch (dynamic_syminfo
[i
].si_boundto
)
10976 case SYMINFO_BT_SELF
:
10977 fputs ("SELF ", stdout
);
10979 case SYMINFO_BT_PARENT
:
10980 fputs ("PARENT ", stdout
);
10983 if (dynamic_syminfo
[i
].si_boundto
> 0
10984 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10985 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10987 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10991 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10995 if (flags
& SYMINFO_FLG_DIRECT
)
10996 printf (" DIRECT");
10997 if (flags
& SYMINFO_FLG_PASSTHRU
)
10998 printf (" PASSTHRU");
10999 if (flags
& SYMINFO_FLG_COPY
)
11001 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11002 printf (" LAZYLOAD");
11010 /* Check to see if the given reloc needs to be handled in a target specific
11011 manner. If so then process the reloc and return TRUE otherwise return
11015 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11016 unsigned char * start
,
11017 Elf_Internal_Sym
* symtab
)
11019 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11021 switch (elf_header
.e_machine
)
11024 case EM_MSP430_OLD
:
11026 static Elf_Internal_Sym
* saved_sym
= NULL
;
11028 switch (reloc_type
)
11030 case 10: /* R_MSP430_SYM_DIFF */
11031 if (uses_msp430x_relocs ())
11033 case 21: /* R_MSP430X_SYM_DIFF */
11034 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11037 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11038 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11039 goto handle_sym_diff
;
11041 case 5: /* R_MSP430_16_BYTE */
11042 case 9: /* R_MSP430_8 */
11043 if (uses_msp430x_relocs ())
11045 goto handle_sym_diff
;
11047 case 2: /* R_MSP430_ABS16 */
11048 case 15: /* R_MSP430X_ABS16 */
11049 if (! uses_msp430x_relocs ())
11051 goto handle_sym_diff
;
11054 if (saved_sym
!= NULL
)
11058 value
= reloc
->r_addend
11059 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11060 - saved_sym
->st_value
);
11062 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11070 if (saved_sym
!= NULL
)
11071 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11078 case EM_CYGNUS_MN10300
:
11080 static Elf_Internal_Sym
* saved_sym
= NULL
;
11082 switch (reloc_type
)
11084 case 34: /* R_MN10300_ALIGN */
11086 case 33: /* R_MN10300_SYM_DIFF */
11087 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11089 case 1: /* R_MN10300_32 */
11090 case 2: /* R_MN10300_16 */
11091 if (saved_sym
!= NULL
)
11095 value
= reloc
->r_addend
11096 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11097 - saved_sym
->st_value
);
11099 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11106 if (saved_sym
!= NULL
)
11107 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11117 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11118 DWARF debug sections. This is a target specific test. Note - we do not
11119 go through the whole including-target-headers-multiple-times route, (as
11120 we have already done with <elf/h8.h>) because this would become very
11121 messy and even then this function would have to contain target specific
11122 information (the names of the relocs instead of their numeric values).
11123 FIXME: This is not the correct way to solve this problem. The proper way
11124 is to have target specific reloc sizing and typing functions created by
11125 the reloc-macros.h header, in the same way that it already creates the
11126 reloc naming functions. */
11129 is_32bit_abs_reloc (unsigned int reloc_type
)
11131 switch (elf_header
.e_machine
)
11135 return reloc_type
== 1; /* R_386_32. */
11137 return reloc_type
== 1; /* R_68K_32. */
11139 return reloc_type
== 1; /* R_860_32. */
11141 return reloc_type
== 2; /* R_960_32. */
11143 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11145 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11147 return reloc_type
== 1; /* R_ARC_32. */
11149 return reloc_type
== 2; /* R_ARM_ABS32 */
11152 return reloc_type
== 1;
11153 case EM_ADAPTEVA_EPIPHANY
:
11154 return reloc_type
== 3;
11156 return reloc_type
== 0x12; /* R_byte4_data. */
11158 return reloc_type
== 3; /* R_CRIS_32. */
11160 return reloc_type
== 3; /* R_CR16_NUM32. */
11162 return reloc_type
== 15; /* R_CRX_NUM32. */
11163 case EM_CYGNUS_FRV
:
11164 return reloc_type
== 1;
11165 case EM_CYGNUS_D10V
:
11167 return reloc_type
== 6; /* R_D10V_32. */
11168 case EM_CYGNUS_D30V
:
11170 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11172 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11173 case EM_CYGNUS_FR30
:
11175 return reloc_type
== 3; /* R_FR30_32. */
11177 return reloc_type
== 1; /* R_FT32_32. */
11181 return reloc_type
== 1; /* R_H8_DIR32. */
11183 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
11186 return reloc_type
== 2; /* R_IP2K_32. */
11188 return reloc_type
== 2; /* R_IQ2000_32. */
11189 case EM_LATTICEMICO32
:
11190 return reloc_type
== 3; /* R_LM32_32. */
11193 return reloc_type
== 3; /* R_M32C_32. */
11195 return reloc_type
== 34; /* R_M32R_32_RELA. */
11197 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11198 case EM_CYGNUS_MEP
:
11199 return reloc_type
== 4; /* R_MEP_32. */
11201 return reloc_type
== 2; /* R_METAG_ADDR32. */
11202 case EM_MICROBLAZE
:
11203 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11205 return reloc_type
== 2; /* R_MIPS_32. */
11207 return reloc_type
== 4; /* R_MMIX_32. */
11208 case EM_CYGNUS_MN10200
:
11210 return reloc_type
== 1; /* R_MN10200_32. */
11211 case EM_CYGNUS_MN10300
:
11213 return reloc_type
== 1; /* R_MN10300_32. */
11215 return reloc_type
== 1; /* R_MOXIE_32. */
11216 case EM_MSP430_OLD
:
11218 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11220 return reloc_type
== 2; /* R_MT_32. */
11222 return reloc_type
== 20; /* R_NDS32_RELA. */
11223 case EM_ALTERA_NIOS2
:
11224 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11226 return reloc_type
== 1; /* R_NIOS_32. */
11228 return reloc_type
== 1; /* R_OR1K_32. */
11230 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11231 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11234 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11236 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11238 return reloc_type
== 1; /* R_PPC_ADDR32. */
11240 return reloc_type
== 1; /* R_RL78_DIR32. */
11242 return reloc_type
== 1; /* R_RX_DIR32. */
11244 return reloc_type
== 1; /* R_I370_ADDR31. */
11247 return reloc_type
== 4; /* R_S390_32. */
11249 return reloc_type
== 8; /* R_SCORE_ABS32. */
11251 return reloc_type
== 1; /* R_SH_DIR32. */
11252 case EM_SPARC32PLUS
:
11255 return reloc_type
== 3 /* R_SPARC_32. */
11256 || reloc_type
== 23; /* R_SPARC_UA32. */
11258 return reloc_type
== 6; /* R_SPU_ADDR32 */
11260 return reloc_type
== 1; /* R_C6000_ABS32. */
11262 return reloc_type
== 2; /* R_TILEGX_32. */
11264 return reloc_type
== 1; /* R_TILEPRO_32. */
11265 case EM_CYGNUS_V850
:
11267 return reloc_type
== 6; /* R_V850_ABS32. */
11269 return reloc_type
== 0x33; /* R_V810_WORD. */
11271 return reloc_type
== 1; /* R_VAX_32. */
11273 return reloc_type
== 3; /* R_VISIUM_32. */
11277 return reloc_type
== 10; /* R_X86_64_32. */
11280 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11282 return reloc_type
== 4; /* R_XGATE_32. */
11284 return reloc_type
== 1; /* R_XSTROMY16_32. */
11285 case EM_XTENSA_OLD
:
11287 return reloc_type
== 1; /* R_XTENSA_32. */
11290 static unsigned int prev_warn
= 0;
11292 /* Avoid repeating the same warning multiple times. */
11293 if (prev_warn
!= elf_header
.e_machine
)
11294 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11295 elf_header
.e_machine
);
11296 prev_warn
= elf_header
.e_machine
;
11302 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11303 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11306 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11308 switch (elf_header
.e_machine
)
11312 return reloc_type
== 2; /* R_386_PC32. */
11314 return reloc_type
== 4; /* R_68K_PC32. */
11316 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11317 case EM_ADAPTEVA_EPIPHANY
:
11318 return reloc_type
== 6;
11320 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11322 return reloc_type
== 3; /* R_ARM_REL32 */
11323 case EM_MICROBLAZE
:
11324 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11326 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11328 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11330 return reloc_type
== 26; /* R_PPC_REL32. */
11332 return reloc_type
== 26; /* R_PPC64_REL32. */
11335 return reloc_type
== 5; /* R_390_PC32. */
11337 return reloc_type
== 2; /* R_SH_REL32. */
11338 case EM_SPARC32PLUS
:
11341 return reloc_type
== 6; /* R_SPARC_DISP32. */
11343 return reloc_type
== 13; /* R_SPU_REL32. */
11345 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11347 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11349 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11353 return reloc_type
== 2; /* R_X86_64_PC32. */
11354 case EM_XTENSA_OLD
:
11356 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11358 /* Do not abort or issue an error message here. Not all targets use
11359 pc-relative 32-bit relocs in their DWARF debug information and we
11360 have already tested for target coverage in is_32bit_abs_reloc. A
11361 more helpful warning message will be generated by apply_relocations
11362 anyway, so just return. */
11367 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11368 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11371 is_64bit_abs_reloc (unsigned int reloc_type
)
11373 switch (elf_header
.e_machine
)
11376 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11378 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11380 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11382 return reloc_type
== 80; /* R_PARISC_DIR64. */
11384 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11385 case EM_SPARC32PLUS
:
11388 return reloc_type
== 54; /* R_SPARC_UA64. */
11392 return reloc_type
== 1; /* R_X86_64_64. */
11395 return reloc_type
== 22; /* R_S390_64. */
11397 return reloc_type
== 1; /* R_TILEGX_64. */
11399 return reloc_type
== 18; /* R_MIPS_64. */
11405 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11406 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11409 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11411 switch (elf_header
.e_machine
)
11414 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11416 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11418 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11420 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11422 return reloc_type
== 44; /* R_PPC64_REL64. */
11423 case EM_SPARC32PLUS
:
11426 return reloc_type
== 46; /* R_SPARC_DISP64. */
11430 return reloc_type
== 24; /* R_X86_64_PC64. */
11433 return reloc_type
== 23; /* R_S390_PC64. */
11435 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11441 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11442 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11445 is_24bit_abs_reloc (unsigned int reloc_type
)
11447 switch (elf_header
.e_machine
)
11449 case EM_CYGNUS_MN10200
:
11451 return reloc_type
== 4; /* R_MN10200_24. */
11457 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11458 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11461 is_16bit_abs_reloc (unsigned int reloc_type
)
11463 switch (elf_header
.e_machine
)
11467 return reloc_type
== 4; /* R_AVR_16. */
11468 case EM_ADAPTEVA_EPIPHANY
:
11469 return reloc_type
== 5;
11470 case EM_CYGNUS_D10V
:
11472 return reloc_type
== 3; /* R_D10V_16. */
11476 return reloc_type
== R_H8_DIR16
;
11479 return reloc_type
== 1; /* R_IP2K_16. */
11482 return reloc_type
== 1; /* R_M32C_16 */
11484 if (uses_msp430x_relocs ())
11485 return reloc_type
== 2; /* R_MSP430_ABS16. */
11486 case EM_MSP430_OLD
:
11487 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11489 return reloc_type
== 19; /* R_NDS32_RELA. */
11490 case EM_ALTERA_NIOS2
:
11491 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11493 return reloc_type
== 9; /* R_NIOS_16. */
11495 return reloc_type
== 2; /* R_OR1K_16. */
11497 return reloc_type
== 2; /* R_C6000_ABS16. */
11500 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11501 case EM_CYGNUS_MN10200
:
11503 return reloc_type
== 2; /* R_MN10200_16. */
11504 case EM_CYGNUS_MN10300
:
11506 return reloc_type
== 2; /* R_MN10300_16. */
11508 return reloc_type
== 2; /* R_VISIUM_16. */
11510 return reloc_type
== 3; /* R_XGATE_16. */
11516 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11517 relocation entries (possibly formerly used for SHT_GROUP sections). */
11520 is_none_reloc (unsigned int reloc_type
)
11522 switch (elf_header
.e_machine
)
11524 case EM_68K
: /* R_68K_NONE. */
11525 case EM_386
: /* R_386_NONE. */
11526 case EM_SPARC32PLUS
:
11528 case EM_SPARC
: /* R_SPARC_NONE. */
11529 case EM_MIPS
: /* R_MIPS_NONE. */
11530 case EM_PARISC
: /* R_PARISC_NONE. */
11531 case EM_ALPHA
: /* R_ALPHA_NONE. */
11532 case EM_ADAPTEVA_EPIPHANY
:
11533 case EM_PPC
: /* R_PPC_NONE. */
11534 case EM_PPC64
: /* R_PPC64_NONE. */
11535 case EM_ARM
: /* R_ARM_NONE. */
11536 case EM_IA_64
: /* R_IA64_NONE. */
11537 case EM_SH
: /* R_SH_NONE. */
11539 case EM_S390
: /* R_390_NONE. */
11540 case EM_CRIS
: /* R_CRIS_NONE. */
11541 case EM_X86_64
: /* R_X86_64_NONE. */
11542 case EM_L1OM
: /* R_X86_64_NONE. */
11543 case EM_K1OM
: /* R_X86_64_NONE. */
11544 case EM_MN10300
: /* R_MN10300_NONE. */
11545 case EM_FT32
: /* R_FT32_NONE. */
11546 case EM_MOXIE
: /* R_MOXIE_NONE. */
11547 case EM_M32R
: /* R_M32R_NONE. */
11548 case EM_TI_C6000
:/* R_C6000_NONE. */
11549 case EM_TILEGX
: /* R_TILEGX_NONE. */
11550 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11552 case EM_C166
: /* R_XC16X_NONE. */
11553 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11554 case EM_NIOS32
: /* R_NIOS_NONE. */
11555 case EM_OR1K
: /* R_OR1K_NONE. */
11556 return reloc_type
== 0;
11558 return reloc_type
== 0 || reloc_type
== 256;
11560 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11561 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11562 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11563 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11564 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11565 case EM_XTENSA_OLD
:
11567 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11568 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11569 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11570 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11572 return reloc_type
== 3; /* R_METAG_NONE. */
11577 /* Apply relocations to a section.
11578 Note: So far support has been added only for those relocations
11579 which can be found in debug sections.
11580 FIXME: Add support for more relocations ? */
11583 apply_relocations (void * file
,
11584 Elf_Internal_Shdr
* section
,
11585 unsigned char * start
)
11587 Elf_Internal_Shdr
* relsec
;
11588 unsigned char * end
= start
+ section
->sh_size
;
11590 if (elf_header
.e_type
!= ET_REL
)
11593 /* Find the reloc section associated with the section. */
11594 for (relsec
= section_headers
;
11595 relsec
< section_headers
+ elf_header
.e_shnum
;
11598 bfd_boolean is_rela
;
11599 unsigned long num_relocs
;
11600 Elf_Internal_Rela
* relocs
;
11601 Elf_Internal_Rela
* rp
;
11602 Elf_Internal_Shdr
* symsec
;
11603 Elf_Internal_Sym
* symtab
;
11604 unsigned long num_syms
;
11605 Elf_Internal_Sym
* sym
;
11607 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11608 || relsec
->sh_info
>= elf_header
.e_shnum
11609 || section_headers
+ relsec
->sh_info
!= section
11610 || relsec
->sh_size
== 0
11611 || relsec
->sh_link
>= elf_header
.e_shnum
)
11614 is_rela
= relsec
->sh_type
== SHT_RELA
;
11618 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11619 relsec
->sh_size
, & relocs
, & num_relocs
))
11624 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11625 relsec
->sh_size
, & relocs
, & num_relocs
))
11629 /* SH uses RELA but uses in place value instead of the addend field. */
11630 if (elf_header
.e_machine
== EM_SH
)
11633 symsec
= section_headers
+ relsec
->sh_link
;
11634 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11636 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11639 unsigned int reloc_type
;
11640 unsigned int reloc_size
;
11641 unsigned char * rloc
;
11642 unsigned long sym_index
;
11644 reloc_type
= get_reloc_type (rp
->r_info
);
11646 if (target_specific_reloc_handling (rp
, start
, symtab
))
11648 else if (is_none_reloc (reloc_type
))
11650 else if (is_32bit_abs_reloc (reloc_type
)
11651 || is_32bit_pcrel_reloc (reloc_type
))
11653 else if (is_64bit_abs_reloc (reloc_type
)
11654 || is_64bit_pcrel_reloc (reloc_type
))
11656 else if (is_24bit_abs_reloc (reloc_type
))
11658 else if (is_16bit_abs_reloc (reloc_type
))
11662 static unsigned int prev_reloc
= 0;
11663 if (reloc_type
!= prev_reloc
)
11664 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11665 reloc_type
, printable_section_name (section
));
11666 prev_reloc
= reloc_type
;
11670 rloc
= start
+ rp
->r_offset
;
11671 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11673 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11674 (unsigned long) rp
->r_offset
,
11675 printable_section_name (section
));
11679 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11680 if (sym_index
>= num_syms
)
11682 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11683 sym_index
, printable_section_name (section
));
11686 sym
= symtab
+ sym_index
;
11688 /* If the reloc has a symbol associated with it,
11689 make sure that it is of an appropriate type.
11691 Relocations against symbols without type can happen.
11692 Gcc -feliminate-dwarf2-dups may generate symbols
11693 without type for debug info.
11695 Icc generates relocations against function symbols
11696 instead of local labels.
11698 Relocations against object symbols can happen, eg when
11699 referencing a global array. For an example of this see
11700 the _clz.o binary in libgcc.a. */
11702 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11704 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11705 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11706 (long int)(rp
- relocs
),
11707 printable_section_name (relsec
));
11713 addend
+= rp
->r_addend
;
11714 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11715 partial_inplace. */
11717 || (elf_header
.e_machine
== EM_XTENSA
11718 && reloc_type
== 1)
11719 || ((elf_header
.e_machine
== EM_PJ
11720 || elf_header
.e_machine
== EM_PJ_OLD
)
11721 && reloc_type
== 1)
11722 || ((elf_header
.e_machine
== EM_D30V
11723 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11724 && reloc_type
== 12))
11725 addend
+= byte_get (rloc
, reloc_size
);
11727 if (is_32bit_pcrel_reloc (reloc_type
)
11728 || is_64bit_pcrel_reloc (reloc_type
))
11730 /* On HPPA, all pc-relative relocations are biased by 8. */
11731 if (elf_header
.e_machine
== EM_PARISC
)
11733 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11737 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11746 #ifdef SUPPORT_DISASSEMBLY
11748 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11750 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11752 /* FIXME: XXX -- to be done --- XXX */
11758 /* Reads in the contents of SECTION from FILE, returning a pointer
11759 to a malloc'ed buffer or NULL if something went wrong. */
11762 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11764 bfd_size_type num_bytes
;
11766 num_bytes
= section
->sh_size
;
11768 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11770 printf (_("\nSection '%s' has no data to dump.\n"),
11771 printable_section_name (section
));
11775 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11776 _("section contents"));
11781 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11783 Elf_Internal_Shdr
* relsec
;
11784 bfd_size_type num_bytes
;
11788 bfd_boolean some_strings_shown
;
11790 start
= get_section_contents (section
, file
);
11794 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11796 /* If the section being dumped has relocations against it the user might
11797 be expecting these relocations to have been applied. Check for this
11798 case and issue a warning message in order to avoid confusion.
11799 FIXME: Maybe we ought to have an option that dumps a section with
11800 relocs applied ? */
11801 for (relsec
= section_headers
;
11802 relsec
< section_headers
+ elf_header
.e_shnum
;
11805 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11806 || relsec
->sh_info
>= elf_header
.e_shnum
11807 || section_headers
+ relsec
->sh_info
!= section
11808 || relsec
->sh_size
== 0
11809 || relsec
->sh_link
>= elf_header
.e_shnum
)
11812 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11816 num_bytes
= section
->sh_size
;
11818 end
= start
+ num_bytes
;
11819 some_strings_shown
= FALSE
;
11823 while (!ISPRINT (* data
))
11824 if (++ data
>= end
)
11829 size_t maxlen
= end
- data
;
11832 /* PR 11128: Use two separate invocations in order to work
11833 around bugs in the Solaris 8 implementation of printf. */
11834 printf (" [%6tx] ", data
- start
);
11836 printf (" [%6Ix] ", (size_t) (data
- start
));
11840 print_symbol ((int) maxlen
, data
);
11842 data
+= strnlen (data
, maxlen
);
11846 printf (_("<corrupt>\n"));
11849 some_strings_shown
= TRUE
;
11853 if (! some_strings_shown
)
11854 printf (_(" No strings found in this section."));
11862 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11864 bfd_boolean relocate
)
11866 Elf_Internal_Shdr
* relsec
;
11867 bfd_size_type bytes
;
11869 unsigned char * data
;
11870 unsigned char * start
;
11872 start
= (unsigned char *) get_section_contents (section
, file
);
11876 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11880 apply_relocations (file
, section
, start
);
11884 /* If the section being dumped has relocations against it the user might
11885 be expecting these relocations to have been applied. Check for this
11886 case and issue a warning message in order to avoid confusion.
11887 FIXME: Maybe we ought to have an option that dumps a section with
11888 relocs applied ? */
11889 for (relsec
= section_headers
;
11890 relsec
< section_headers
+ elf_header
.e_shnum
;
11893 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11894 || relsec
->sh_info
>= elf_header
.e_shnum
11895 || section_headers
+ relsec
->sh_info
!= section
11896 || relsec
->sh_size
== 0
11897 || relsec
->sh_link
>= elf_header
.e_shnum
)
11900 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11905 addr
= section
->sh_addr
;
11906 bytes
= section
->sh_size
;
11915 lbytes
= (bytes
> 16 ? 16 : bytes
);
11917 printf (" 0x%8.8lx ", (unsigned long) addr
);
11919 for (j
= 0; j
< 16; j
++)
11922 printf ("%2.2x", data
[j
]);
11930 for (j
= 0; j
< lbytes
; j
++)
11933 if (k
>= ' ' && k
< 0x7f)
11951 /* Uncompresses a section that was compressed using zlib, in place. */
11954 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11955 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11957 #ifndef HAVE_ZLIB_H
11960 dwarf_size_type compressed_size
= *size
;
11961 unsigned char * compressed_buffer
= *buffer
;
11962 dwarf_size_type uncompressed_size
;
11963 unsigned char * uncompressed_buffer
;
11966 dwarf_size_type header_size
= 12;
11968 /* Read the zlib header. In this case, it should be "ZLIB" followed
11969 by the uncompressed section size, 8 bytes in big-endian order. */
11970 if (compressed_size
< header_size
11971 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11974 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11975 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11976 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11977 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11978 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11979 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11980 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11981 uncompressed_size
+= compressed_buffer
[11];
11983 /* It is possible the section consists of several compressed
11984 buffers concatenated together, so we uncompress in a loop. */
11985 strm
.zalloc
= NULL
;
11987 strm
.opaque
= NULL
;
11988 strm
.avail_in
= compressed_size
- header_size
;
11989 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11990 strm
.avail_out
= uncompressed_size
;
11991 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11993 rc
= inflateInit (& strm
);
11994 while (strm
.avail_in
> 0)
11998 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11999 + (uncompressed_size
- strm
.avail_out
));
12000 rc
= inflate (&strm
, Z_FINISH
);
12001 if (rc
!= Z_STREAM_END
)
12003 rc
= inflateReset (& strm
);
12005 rc
= inflateEnd (& strm
);
12007 || strm
.avail_out
!= 0)
12010 free (compressed_buffer
);
12011 *buffer
= uncompressed_buffer
;
12012 *size
= uncompressed_size
;
12016 free (uncompressed_buffer
);
12017 /* Indicate decompression failure. */
12020 #endif /* HAVE_ZLIB_H */
12024 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12025 Elf_Internal_Shdr
* sec
, void * file
)
12027 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12030 /* If it is already loaded, do nothing. */
12031 if (section
->start
!= NULL
)
12034 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12035 section
->address
= sec
->sh_addr
;
12036 section
->user_data
= NULL
;
12037 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12039 sec
->sh_size
, buf
);
12040 if (section
->start
== NULL
)
12044 section
->size
= sec
->sh_size
;
12045 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
12046 sec
->sh_size
= section
->size
;
12049 if (section
->start
== NULL
)
12052 if (debug_displays
[debug
].relocate
)
12053 apply_relocations ((FILE *) file
, sec
, section
->start
);
12058 /* If this is not NULL, load_debug_section will only look for sections
12059 within the list of sections given here. */
12060 unsigned int *section_subset
= NULL
;
12063 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12065 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12066 Elf_Internal_Shdr
* sec
;
12068 /* Locate the debug section. */
12069 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12071 section
->name
= section
->uncompressed_name
;
12074 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12076 section
->name
= section
->compressed_name
;
12081 /* If we're loading from a subset of sections, and we've loaded
12082 a section matching this name before, it's likely that it's a
12084 if (section_subset
!= NULL
)
12085 free_debug_section (debug
);
12087 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12091 free_debug_section (enum dwarf_section_display_enum debug
)
12093 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12095 if (section
->start
== NULL
)
12098 free ((char *) section
->start
);
12099 section
->start
= NULL
;
12100 section
->address
= 0;
12105 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12107 char * name
= SECTION_NAME (section
);
12108 const char * print_name
= printable_section_name (section
);
12109 bfd_size_type length
;
12113 length
= section
->sh_size
;
12116 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12119 if (section
->sh_type
== SHT_NOBITS
)
12121 /* There is no point in dumping the contents of a debugging section
12122 which has the NOBITS type - the bits in the file will be random.
12123 This can happen when a file containing a .eh_frame section is
12124 stripped with the --only-keep-debug command line option. */
12125 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12130 if (const_strneq (name
, ".gnu.linkonce.wi."))
12131 name
= ".debug_info";
12133 /* See if we know how to display the contents of this section. */
12134 for (i
= 0; i
< max
; i
++)
12135 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12136 || (i
== line
&& const_strneq (name
, ".debug_line."))
12137 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12139 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12140 int secondary
= (section
!= find_section (name
));
12143 free_debug_section ((enum dwarf_section_display_enum
) i
);
12145 if (i
== line
&& const_strneq (name
, ".debug_line."))
12147 else if (streq (sec
->uncompressed_name
, name
))
12148 sec
->name
= sec
->uncompressed_name
;
12150 sec
->name
= sec
->compressed_name
;
12151 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12154 /* If this debug section is part of a CU/TU set in a .dwp file,
12155 restrict load_debug_section to the sections in that set. */
12156 section_subset
= find_cu_tu_set (file
, shndx
);
12158 result
&= debug_displays
[i
].display (sec
, file
);
12160 section_subset
= NULL
;
12162 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12163 free_debug_section ((enum dwarf_section_display_enum
) i
);
12171 printf (_("Unrecognized debug section: %s\n"), print_name
);
12178 /* Set DUMP_SECTS for all sections where dumps were requested
12179 based on section name. */
12182 initialise_dumps_byname (void)
12184 struct dump_list_entry
* cur
;
12186 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12191 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12192 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12194 request_dump_bynumber (i
, cur
->type
);
12199 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12205 process_section_contents (FILE * file
)
12207 Elf_Internal_Shdr
* section
;
12213 initialise_dumps_byname ();
12215 for (i
= 0, section
= section_headers
;
12216 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12219 #ifdef SUPPORT_DISASSEMBLY
12220 if (dump_sects
[i
] & DISASS_DUMP
)
12221 disassemble_section (section
, file
);
12223 if (dump_sects
[i
] & HEX_DUMP
)
12224 dump_section_as_bytes (section
, file
, FALSE
);
12226 if (dump_sects
[i
] & RELOC_DUMP
)
12227 dump_section_as_bytes (section
, file
, TRUE
);
12229 if (dump_sects
[i
] & STRING_DUMP
)
12230 dump_section_as_strings (section
, file
);
12232 if (dump_sects
[i
] & DEBUG_DUMP
)
12233 display_debug_section (i
, section
, file
);
12236 /* Check to see if the user requested a
12237 dump of a section that does not exist. */
12238 while (i
++ < num_dump_sects
)
12240 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12244 process_mips_fpe_exception (int mask
)
12249 if (mask
& OEX_FPU_INEX
)
12250 fputs ("INEX", stdout
), first
= 0;
12251 if (mask
& OEX_FPU_UFLO
)
12252 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12253 if (mask
& OEX_FPU_OFLO
)
12254 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12255 if (mask
& OEX_FPU_DIV0
)
12256 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12257 if (mask
& OEX_FPU_INVAL
)
12258 printf ("%sINVAL", first
? "" : "|");
12261 fputs ("0", stdout
);
12264 /* Display's the value of TAG at location P. If TAG is
12265 greater than 0 it is assumed to be an unknown tag, and
12266 a message is printed to this effect. Otherwise it is
12267 assumed that a message has already been printed.
12269 If the bottom bit of TAG is set it assumed to have a
12270 string value, otherwise it is assumed to have an integer
12273 Returns an updated P pointing to the first unread byte
12274 beyond the end of TAG's value.
12276 Reads at or beyond END will not be made. */
12278 static unsigned char *
12279 display_tag_value (int tag
,
12281 const unsigned char * const end
)
12286 printf (" Tag_unknown_%d: ", tag
);
12290 warn (_("<corrupt tag>\n"));
12294 /* PR 17531 file: 027-19978-0.004. */
12295 size_t maxlen
= (end
- p
) - 1;
12300 print_symbol ((int) maxlen
, (const char *) p
);
12301 p
+= strnlen ((char *) p
, maxlen
) + 1;
12305 printf (_("<corrupt string tag>"));
12306 p
= (unsigned char *) end
;
12314 val
= read_uleb128 (p
, &len
, end
);
12316 printf ("%ld (0x%lx)\n", val
, val
);
12323 /* ARM EABI attributes section. */
12328 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12330 const char ** table
;
12331 } arm_attr_public_tag
;
12333 static const char * arm_attr_tag_CPU_arch
[] =
12334 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12335 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12336 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12337 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12338 {"No", "Thumb-1", "Thumb-2"};
12339 static const char * arm_attr_tag_FP_arch
[] =
12340 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12341 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12342 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12343 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12344 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12345 static const char * arm_attr_tag_PCS_config
[] =
12346 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12347 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12348 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12349 {"V6", "SB", "TLS", "Unused"};
12350 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12351 {"Absolute", "PC-relative", "SB-relative", "None"};
12352 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12353 {"Absolute", "PC-relative", "None"};
12354 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12355 {"None", "direct", "GOT-indirect"};
12356 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12357 {"None", "??? 1", "2", "??? 3", "4"};
12358 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12359 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12360 {"Unused", "Needed", "Sign only"};
12361 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12362 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12363 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12364 {"Unused", "Finite", "RTABI", "IEEE 754"};
12365 static const char * arm_attr_tag_ABI_enum_size
[] =
12366 {"Unused", "small", "int", "forced to int"};
12367 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12368 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12369 static const char * arm_attr_tag_ABI_VFP_args
[] =
12370 {"AAPCS", "VFP registers", "custom", "compatible"};
12371 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12372 {"AAPCS", "WMMX registers", "custom"};
12373 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12374 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12375 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12376 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12377 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12378 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12379 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12380 static const char * arm_attr_tag_FP_HP_extension
[] =
12381 {"Not Allowed", "Allowed"};
12382 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12383 {"None", "IEEE 754", "Alternative Format"};
12384 static const char * arm_attr_tag_MPextension_use
[] =
12385 {"Not Allowed", "Allowed"};
12386 static const char * arm_attr_tag_DIV_use
[] =
12387 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12388 "Allowed in v7-A with integer division extension"};
12389 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12390 static const char * arm_attr_tag_Virtualization_use
[] =
12391 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12392 "TrustZone and Virtualization Extensions"};
12393 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12394 {"Not Allowed", "Allowed"};
12396 #define LOOKUP(id, name) \
12397 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12398 static arm_attr_public_tag arm_attr_public_tags
[] =
12400 {4, "CPU_raw_name", 1, NULL
},
12401 {5, "CPU_name", 1, NULL
},
12402 LOOKUP(6, CPU_arch
),
12403 {7, "CPU_arch_profile", 0, NULL
},
12404 LOOKUP(8, ARM_ISA_use
),
12405 LOOKUP(9, THUMB_ISA_use
),
12406 LOOKUP(10, FP_arch
),
12407 LOOKUP(11, WMMX_arch
),
12408 LOOKUP(12, Advanced_SIMD_arch
),
12409 LOOKUP(13, PCS_config
),
12410 LOOKUP(14, ABI_PCS_R9_use
),
12411 LOOKUP(15, ABI_PCS_RW_data
),
12412 LOOKUP(16, ABI_PCS_RO_data
),
12413 LOOKUP(17, ABI_PCS_GOT_use
),
12414 LOOKUP(18, ABI_PCS_wchar_t
),
12415 LOOKUP(19, ABI_FP_rounding
),
12416 LOOKUP(20, ABI_FP_denormal
),
12417 LOOKUP(21, ABI_FP_exceptions
),
12418 LOOKUP(22, ABI_FP_user_exceptions
),
12419 LOOKUP(23, ABI_FP_number_model
),
12420 {24, "ABI_align_needed", 0, NULL
},
12421 {25, "ABI_align_preserved", 0, NULL
},
12422 LOOKUP(26, ABI_enum_size
),
12423 LOOKUP(27, ABI_HardFP_use
),
12424 LOOKUP(28, ABI_VFP_args
),
12425 LOOKUP(29, ABI_WMMX_args
),
12426 LOOKUP(30, ABI_optimization_goals
),
12427 LOOKUP(31, ABI_FP_optimization_goals
),
12428 {32, "compatibility", 0, NULL
},
12429 LOOKUP(34, CPU_unaligned_access
),
12430 LOOKUP(36, FP_HP_extension
),
12431 LOOKUP(38, ABI_FP_16bit_format
),
12432 LOOKUP(42, MPextension_use
),
12433 LOOKUP(44, DIV_use
),
12434 {64, "nodefaults", 0, NULL
},
12435 {65, "also_compatible_with", 0, NULL
},
12436 LOOKUP(66, T2EE_use
),
12437 {67, "conformance", 1, NULL
},
12438 LOOKUP(68, Virtualization_use
),
12439 LOOKUP(70, MPextension_use_legacy
)
12443 static unsigned char *
12444 display_arm_attribute (unsigned char * p
,
12445 const unsigned char * const end
)
12450 arm_attr_public_tag
* attr
;
12454 tag
= read_uleb128 (p
, &len
, end
);
12457 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12459 if (arm_attr_public_tags
[i
].tag
== tag
)
12461 attr
= &arm_attr_public_tags
[i
];
12468 printf (" Tag_%s: ", attr
->name
);
12469 switch (attr
->type
)
12474 case 7: /* Tag_CPU_arch_profile. */
12475 val
= read_uleb128 (p
, &len
, end
);
12479 case 0: printf (_("None\n")); break;
12480 case 'A': printf (_("Application\n")); break;
12481 case 'R': printf (_("Realtime\n")); break;
12482 case 'M': printf (_("Microcontroller\n")); break;
12483 case 'S': printf (_("Application or Realtime\n")); break;
12484 default: printf ("??? (%d)\n", val
); break;
12488 case 24: /* Tag_align_needed. */
12489 val
= read_uleb128 (p
, &len
, end
);
12493 case 0: printf (_("None\n")); break;
12494 case 1: printf (_("8-byte\n")); break;
12495 case 2: printf (_("4-byte\n")); break;
12496 case 3: printf ("??? 3\n"); break;
12499 printf (_("8-byte and up to %d-byte extended\n"),
12502 printf ("??? (%d)\n", val
);
12507 case 25: /* Tag_align_preserved. */
12508 val
= read_uleb128 (p
, &len
, end
);
12512 case 0: printf (_("None\n")); break;
12513 case 1: printf (_("8-byte, except leaf SP\n")); break;
12514 case 2: printf (_("8-byte\n")); break;
12515 case 3: printf ("??? 3\n"); break;
12518 printf (_("8-byte and up to %d-byte extended\n"),
12521 printf ("??? (%d)\n", val
);
12526 case 32: /* Tag_compatibility. */
12528 val
= read_uleb128 (p
, &len
, end
);
12530 printf (_("flag = %d, vendor = "), val
);
12533 size_t maxlen
= (end
- p
) - 1;
12535 print_symbol ((int) maxlen
, (const char *) p
);
12536 p
+= strnlen ((char *) p
, maxlen
) + 1;
12540 printf (_("<corrupt>"));
12541 p
= (unsigned char *) end
;
12547 case 64: /* Tag_nodefaults. */
12548 /* PR 17531: file: 001-505008-0.01. */
12551 printf (_("True\n"));
12554 case 65: /* Tag_also_compatible_with. */
12555 val
= read_uleb128 (p
, &len
, end
);
12557 if (val
== 6 /* Tag_CPU_arch. */)
12559 val
= read_uleb128 (p
, &len
, end
);
12561 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12562 printf ("??? (%d)\n", val
);
12564 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12568 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12573 printf (_("<unknown: %d>\n"), tag
);
12579 return display_tag_value (-1, p
, end
);
12581 return display_tag_value (0, p
, end
);
12584 assert (attr
->type
& 0x80);
12585 val
= read_uleb128 (p
, &len
, end
);
12587 type
= attr
->type
& 0x7f;
12589 printf ("??? (%d)\n", val
);
12591 printf ("%s\n", attr
->table
[val
]);
12596 return display_tag_value (tag
, p
, end
);
12599 static unsigned char *
12600 display_gnu_attribute (unsigned char * p
,
12601 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12602 const unsigned char * const end
)
12608 tag
= read_uleb128 (p
, &len
, end
);
12611 /* Tag_compatibility is the only generic GNU attribute defined at
12615 val
= read_uleb128 (p
, &len
, end
);
12618 printf (_("flag = %d, vendor = "), val
);
12621 printf (_("<corrupt>\n"));
12622 warn (_("corrupt vendor attribute\n"));
12628 size_t maxlen
= (end
- p
) - 1;
12630 print_symbol ((int) maxlen
, (const char *) p
);
12631 p
+= strnlen ((char *) p
, maxlen
) + 1;
12635 printf (_("<corrupt>"));
12636 p
= (unsigned char *) end
;
12643 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12644 return display_proc_gnu_attribute (p
, tag
, end
);
12646 return display_tag_value (tag
, p
, end
);
12649 static unsigned char *
12650 display_power_gnu_attribute (unsigned char * p
,
12652 const unsigned char * const end
)
12657 if (tag
== Tag_GNU_Power_ABI_FP
)
12659 val
= read_uleb128 (p
, &len
, end
);
12661 printf (" Tag_GNU_Power_ABI_FP: ");
12666 printf (_("Hard or soft float\n"));
12669 printf (_("Hard float\n"));
12672 printf (_("Soft float\n"));
12675 printf (_("Single-precision hard float\n"));
12678 printf ("??? (%d)\n", val
);
12684 if (tag
== Tag_GNU_Power_ABI_Vector
)
12686 val
= read_uleb128 (p
, &len
, end
);
12688 printf (" Tag_GNU_Power_ABI_Vector: ");
12692 printf (_("Any\n"));
12695 printf (_("Generic\n"));
12698 printf ("AltiVec\n");
12704 printf ("??? (%d)\n", val
);
12710 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12714 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12718 val
= read_uleb128 (p
, &len
, end
);
12720 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12724 printf (_("Any\n"));
12727 printf ("r3/r4\n");
12730 printf (_("Memory\n"));
12733 printf ("??? (%d)\n", val
);
12739 return display_tag_value (tag
& 1, p
, end
);
12743 display_sparc_hwcaps (int mask
)
12749 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12750 fputs ("mul32", stdout
), first
= 0;
12751 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12752 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12753 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12754 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12755 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12756 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12757 if (mask
& ELF_SPARC_HWCAP_POPC
)
12758 printf ("%spopc", first
? "" : "|"), first
= 0;
12759 if (mask
& ELF_SPARC_HWCAP_VIS
)
12760 printf ("%svis", first
? "" : "|"), first
= 0;
12761 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12762 printf ("%svis2", first
? "" : "|"), first
= 0;
12763 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12764 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12765 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12766 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12767 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12768 printf ("%svis3", first
? "" : "|"), first
= 0;
12769 if (mask
& ELF_SPARC_HWCAP_HPC
)
12770 printf ("%shpc", first
? "" : "|"), first
= 0;
12771 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12772 printf ("%srandom", first
? "" : "|"), first
= 0;
12773 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12774 printf ("%strans", first
? "" : "|"), first
= 0;
12775 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12776 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12777 if (mask
& ELF_SPARC_HWCAP_IMA
)
12778 printf ("%sima", first
? "" : "|"), first
= 0;
12779 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12780 printf ("%scspare", first
? "" : "|"), first
= 0;
12783 fputc ('0', stdout
);
12784 fputc ('\n', stdout
);
12788 display_sparc_hwcaps2 (int mask
)
12794 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12795 fputs ("fjathplus", stdout
), first
= 0;
12796 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12797 printf ("%svis3b", first
? "" : "|"), first
= 0;
12798 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12799 printf ("%sadp", first
? "" : "|"), first
= 0;
12800 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12801 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12802 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12803 printf ("%smwait", first
? "" : "|"), first
= 0;
12804 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12805 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12806 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12807 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12808 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12809 printf ("%snsec", first
? "" : "|"), first
= 0;
12810 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12811 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12812 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12813 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12814 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12815 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12818 fputc ('0', stdout
);
12819 fputc ('\n', stdout
);
12822 static unsigned char *
12823 display_sparc_gnu_attribute (unsigned char * p
,
12825 const unsigned char * const end
)
12830 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12832 val
= read_uleb128 (p
, &len
, end
);
12834 printf (" Tag_GNU_Sparc_HWCAPS: ");
12835 display_sparc_hwcaps (val
);
12838 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12840 val
= read_uleb128 (p
, &len
, end
);
12842 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12843 display_sparc_hwcaps2 (val
);
12847 return display_tag_value (tag
, p
, end
);
12851 print_mips_fp_abi_value (int val
)
12855 case Val_GNU_MIPS_ABI_FP_ANY
:
12856 printf (_("Hard or soft float\n"));
12858 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12859 printf (_("Hard float (double precision)\n"));
12861 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12862 printf (_("Hard float (single precision)\n"));
12864 case Val_GNU_MIPS_ABI_FP_SOFT
:
12865 printf (_("Soft float\n"));
12867 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12868 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12870 case Val_GNU_MIPS_ABI_FP_XX
:
12871 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12873 case Val_GNU_MIPS_ABI_FP_64
:
12874 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12876 case Val_GNU_MIPS_ABI_FP_64A
:
12877 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12880 printf ("??? (%d)\n", val
);
12885 static unsigned char *
12886 display_mips_gnu_attribute (unsigned char * p
,
12888 const unsigned char * const end
)
12890 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12895 val
= read_uleb128 (p
, &len
, end
);
12897 printf (" Tag_GNU_MIPS_ABI_FP: ");
12899 print_mips_fp_abi_value (val
);
12904 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12909 val
= read_uleb128 (p
, &len
, end
);
12911 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12915 case Val_GNU_MIPS_ABI_MSA_ANY
:
12916 printf (_("Any MSA or not\n"));
12918 case Val_GNU_MIPS_ABI_MSA_128
:
12919 printf (_("128-bit MSA\n"));
12922 printf ("??? (%d)\n", val
);
12928 return display_tag_value (tag
& 1, p
, end
);
12931 static unsigned char *
12932 display_tic6x_attribute (unsigned char * p
,
12933 const unsigned char * const end
)
12939 tag
= read_uleb128 (p
, &len
, end
);
12945 val
= read_uleb128 (p
, &len
, end
);
12947 printf (" Tag_ISA: ");
12951 case C6XABI_Tag_ISA_none
:
12952 printf (_("None\n"));
12954 case C6XABI_Tag_ISA_C62X
:
12957 case C6XABI_Tag_ISA_C67X
:
12960 case C6XABI_Tag_ISA_C67XP
:
12961 printf ("C67x+\n");
12963 case C6XABI_Tag_ISA_C64X
:
12966 case C6XABI_Tag_ISA_C64XP
:
12967 printf ("C64x+\n");
12969 case C6XABI_Tag_ISA_C674X
:
12970 printf ("C674x\n");
12973 printf ("??? (%d)\n", val
);
12978 case Tag_ABI_wchar_t
:
12979 val
= read_uleb128 (p
, &len
, end
);
12981 printf (" Tag_ABI_wchar_t: ");
12985 printf (_("Not used\n"));
12988 printf (_("2 bytes\n"));
12991 printf (_("4 bytes\n"));
12994 printf ("??? (%d)\n", val
);
12999 case Tag_ABI_stack_align_needed
:
13000 val
= read_uleb128 (p
, &len
, end
);
13002 printf (" Tag_ABI_stack_align_needed: ");
13006 printf (_("8-byte\n"));
13009 printf (_("16-byte\n"));
13012 printf ("??? (%d)\n", val
);
13017 case Tag_ABI_stack_align_preserved
:
13018 val
= read_uleb128 (p
, &len
, end
);
13020 printf (" Tag_ABI_stack_align_preserved: ");
13024 printf (_("8-byte\n"));
13027 printf (_("16-byte\n"));
13030 printf ("??? (%d)\n", val
);
13036 val
= read_uleb128 (p
, &len
, end
);
13038 printf (" Tag_ABI_DSBT: ");
13042 printf (_("DSBT addressing not used\n"));
13045 printf (_("DSBT addressing used\n"));
13048 printf ("??? (%d)\n", val
);
13054 val
= read_uleb128 (p
, &len
, end
);
13056 printf (" Tag_ABI_PID: ");
13060 printf (_("Data addressing position-dependent\n"));
13063 printf (_("Data addressing position-independent, GOT near DP\n"));
13066 printf (_("Data addressing position-independent, GOT far from DP\n"));
13069 printf ("??? (%d)\n", val
);
13075 val
= read_uleb128 (p
, &len
, end
);
13077 printf (" Tag_ABI_PIC: ");
13081 printf (_("Code addressing position-dependent\n"));
13084 printf (_("Code addressing position-independent\n"));
13087 printf ("??? (%d)\n", val
);
13092 case Tag_ABI_array_object_alignment
:
13093 val
= read_uleb128 (p
, &len
, end
);
13095 printf (" Tag_ABI_array_object_alignment: ");
13099 printf (_("8-byte\n"));
13102 printf (_("4-byte\n"));
13105 printf (_("16-byte\n"));
13108 printf ("??? (%d)\n", val
);
13113 case Tag_ABI_array_object_align_expected
:
13114 val
= read_uleb128 (p
, &len
, end
);
13116 printf (" Tag_ABI_array_object_align_expected: ");
13120 printf (_("8-byte\n"));
13123 printf (_("4-byte\n"));
13126 printf (_("16-byte\n"));
13129 printf ("??? (%d)\n", val
);
13134 case Tag_ABI_compatibility
:
13136 val
= read_uleb128 (p
, &len
, end
);
13138 printf (" Tag_ABI_compatibility: ");
13139 printf (_("flag = %d, vendor = "), val
);
13142 size_t maxlen
= (end
- p
) - 1;
13144 print_symbol ((int) maxlen
, (const char *) p
);
13145 p
+= strnlen ((char *) p
, maxlen
) + 1;
13149 printf (_("<corrupt>"));
13150 p
= (unsigned char *) end
;
13156 case Tag_ABI_conformance
:
13158 printf (" Tag_ABI_conformance: \"");
13161 size_t maxlen
= (end
- p
) - 1;
13163 print_symbol ((int) maxlen
, (const char *) p
);
13164 p
+= strnlen ((char *) p
, maxlen
) + 1;
13168 printf (_("<corrupt>"));
13169 p
= (unsigned char *) end
;
13176 return display_tag_value (tag
, p
, end
);
13180 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13182 unsigned long addr
= 0;
13183 size_t bytes
= end
- p
;
13190 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13192 printf (" 0x%8.8lx ", addr
);
13194 for (j
= 0; j
< 16; j
++)
13197 printf ("%2.2x", p
[j
]);
13205 for (j
= 0; j
< lbytes
; j
++)
13208 if (k
>= ' ' && k
< 0x7f)
13224 static unsigned char *
13225 display_msp430x_attribute (unsigned char * p
,
13226 const unsigned char * const end
)
13232 tag
= read_uleb128 (p
, & len
, end
);
13237 case OFBA_MSPABI_Tag_ISA
:
13238 val
= read_uleb128 (p
, &len
, end
);
13240 printf (" Tag_ISA: ");
13243 case 0: printf (_("None\n")); break;
13244 case 1: printf (_("MSP430\n")); break;
13245 case 2: printf (_("MSP430X\n")); break;
13246 default: printf ("??? (%d)\n", val
); break;
13250 case OFBA_MSPABI_Tag_Code_Model
:
13251 val
= read_uleb128 (p
, &len
, end
);
13253 printf (" Tag_Code_Model: ");
13256 case 0: printf (_("None\n")); break;
13257 case 1: printf (_("Small\n")); break;
13258 case 2: printf (_("Large\n")); break;
13259 default: printf ("??? (%d)\n", val
); break;
13263 case OFBA_MSPABI_Tag_Data_Model
:
13264 val
= read_uleb128 (p
, &len
, end
);
13266 printf (" Tag_Data_Model: ");
13269 case 0: printf (_("None\n")); break;
13270 case 1: printf (_("Small\n")); break;
13271 case 2: printf (_("Large\n")); break;
13272 case 3: printf (_("Restricted Large\n")); break;
13273 default: printf ("??? (%d)\n", val
); break;
13278 printf (_(" <unknown tag %d>: "), tag
);
13285 size_t maxlen
= (end
- p
) - 1;
13287 print_symbol ((int) maxlen
, (const char *) p
);
13288 p
+= strnlen ((char *) p
, maxlen
) + 1;
13292 printf (_("<corrupt>"));
13293 p
= (unsigned char *) end
;
13299 val
= read_uleb128 (p
, &len
, end
);
13301 printf ("%d (0x%x)\n", val
, val
);
13311 process_attributes (FILE * file
,
13312 const char * public_name
,
13313 unsigned int proc_type
,
13314 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13315 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13317 Elf_Internal_Shdr
* sect
;
13320 /* Find the section header so that we get the size. */
13321 for (i
= 0, sect
= section_headers
;
13322 i
< elf_header
.e_shnum
;
13325 unsigned char * contents
;
13328 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13331 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13332 sect
->sh_size
, _("attributes"));
13333 if (contents
== NULL
)
13339 bfd_vma section_len
;
13341 section_len
= sect
->sh_size
- 1;
13344 while (section_len
> 0)
13347 unsigned int namelen
;
13348 bfd_boolean public_section
;
13349 bfd_boolean gnu_section
;
13351 if (section_len
<= 4)
13353 error (_("Tag section ends prematurely\n"));
13356 attr_len
= byte_get (p
, 4);
13359 if (attr_len
> section_len
)
13361 error (_("Bad attribute length (%u > %u)\n"),
13362 (unsigned) attr_len
, (unsigned) section_len
);
13363 attr_len
= section_len
;
13365 /* PR 17531: file: 001-101425-0.004 */
13366 else if (attr_len
< 5)
13368 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13372 section_len
-= attr_len
;
13375 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13376 if (namelen
== 0 || namelen
>= attr_len
)
13378 error (_("Corrupt attribute section name\n"));
13382 printf (_("Attribute Section: "));
13383 print_symbol (INT_MAX
, (const char *) p
);
13386 if (public_name
&& streq ((char *) p
, public_name
))
13387 public_section
= TRUE
;
13389 public_section
= FALSE
;
13391 if (streq ((char *) p
, "gnu"))
13392 gnu_section
= TRUE
;
13394 gnu_section
= FALSE
;
13397 attr_len
-= namelen
;
13399 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13404 unsigned char * end
;
13406 /* PR binutils/17531: Safe handling of corrupt files. */
13409 error (_("Unused bytes at end of section\n"));
13415 size
= byte_get (p
, 4);
13416 if (size
> attr_len
)
13418 error (_("Bad subsection length (%u > %u)\n"),
13419 (unsigned) size
, (unsigned) attr_len
);
13422 /* PR binutils/17531: Safe handling of corrupt files. */
13425 error (_("Bad subsection length (%u < 6)\n"),
13432 end
= p
+ size
- 1;
13433 assert (end
<= contents
+ sect
->sh_size
);
13439 printf (_("File Attributes\n"));
13442 printf (_("Section Attributes:"));
13445 printf (_("Symbol Attributes:"));
13451 val
= read_uleb128 (p
, &j
, end
);
13455 printf (" %d", val
);
13460 printf (_("Unknown tag: %d\n"), tag
);
13461 public_section
= FALSE
;
13465 if (public_section
&& display_pub_attribute
!= NULL
)
13468 p
= display_pub_attribute (p
, end
);
13471 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13474 p
= display_gnu_attribute (p
,
13475 display_proc_gnu_attribute
,
13481 printf (_(" Unknown attribute:\n"));
13482 display_raw_attribute (p
, end
);
13491 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13499 process_arm_specific (FILE * file
)
13501 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13502 display_arm_attribute
, NULL
);
13506 process_power_specific (FILE * file
)
13508 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13509 display_power_gnu_attribute
);
13513 process_sparc_specific (FILE * file
)
13515 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13516 display_sparc_gnu_attribute
);
13520 process_tic6x_specific (FILE * file
)
13522 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13523 display_tic6x_attribute
, NULL
);
13527 process_msp430x_specific (FILE * file
)
13529 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13530 display_msp430x_attribute
, NULL
);
13533 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13534 Print the Address, Access and Initial fields of an entry at VMA ADDR
13535 and return the VMA of the next entry, or -1 if there was a problem.
13536 Does not read from DATA_END or beyond. */
13539 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13540 unsigned char * data_end
)
13543 print_vma (addr
, LONG_HEX
);
13545 if (addr
< pltgot
+ 0xfff0)
13546 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13548 printf ("%10s", "");
13551 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13555 unsigned char * from
= data
+ addr
- pltgot
;
13557 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
13559 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13560 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
13561 return (bfd_vma
) -1;
13565 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13566 print_vma (entry
, LONG_HEX
);
13569 return addr
+ (is_32bit_elf
? 4 : 8);
13572 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13573 PLTGOT. Print the Address and Initial fields of an entry at VMA
13574 ADDR and return the VMA of the next entry. */
13577 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13580 print_vma (addr
, LONG_HEX
);
13583 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13588 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13589 print_vma (entry
, LONG_HEX
);
13591 return addr
+ (is_32bit_elf
? 4 : 8);
13595 print_mips_ases (unsigned int mask
)
13597 if (mask
& AFL_ASE_DSP
)
13598 fputs ("\n\tDSP ASE", stdout
);
13599 if (mask
& AFL_ASE_DSPR2
)
13600 fputs ("\n\tDSP R2 ASE", stdout
);
13601 if (mask
& AFL_ASE_EVA
)
13602 fputs ("\n\tEnhanced VA Scheme", stdout
);
13603 if (mask
& AFL_ASE_MCU
)
13604 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13605 if (mask
& AFL_ASE_MDMX
)
13606 fputs ("\n\tMDMX ASE", stdout
);
13607 if (mask
& AFL_ASE_MIPS3D
)
13608 fputs ("\n\tMIPS-3D ASE", stdout
);
13609 if (mask
& AFL_ASE_MT
)
13610 fputs ("\n\tMT ASE", stdout
);
13611 if (mask
& AFL_ASE_SMARTMIPS
)
13612 fputs ("\n\tSmartMIPS ASE", stdout
);
13613 if (mask
& AFL_ASE_VIRT
)
13614 fputs ("\n\tVZ ASE", stdout
);
13615 if (mask
& AFL_ASE_MSA
)
13616 fputs ("\n\tMSA ASE", stdout
);
13617 if (mask
& AFL_ASE_MIPS16
)
13618 fputs ("\n\tMIPS16 ASE", stdout
);
13619 if (mask
& AFL_ASE_MICROMIPS
)
13620 fputs ("\n\tMICROMIPS ASE", stdout
);
13621 if (mask
& AFL_ASE_XPA
)
13622 fputs ("\n\tXPA ASE", stdout
);
13624 fprintf (stdout
, "\n\t%s", _("None"));
13625 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13626 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13630 print_mips_isa_ext (unsigned int isa_ext
)
13635 fputs (_("None"), stdout
);
13638 fputs ("RMI XLR", stdout
);
13640 case AFL_EXT_OCTEON3
:
13641 fputs ("Cavium Networks Octeon3", stdout
);
13643 case AFL_EXT_OCTEON2
:
13644 fputs ("Cavium Networks Octeon2", stdout
);
13646 case AFL_EXT_OCTEONP
:
13647 fputs ("Cavium Networks OcteonP", stdout
);
13649 case AFL_EXT_LOONGSON_3A
:
13650 fputs ("Loongson 3A", stdout
);
13652 case AFL_EXT_OCTEON
:
13653 fputs ("Cavium Networks Octeon", stdout
);
13656 fputs ("Toshiba R5900", stdout
);
13659 fputs ("MIPS R4650", stdout
);
13662 fputs ("LSI R4010", stdout
);
13665 fputs ("NEC VR4100", stdout
);
13668 fputs ("Toshiba R3900", stdout
);
13670 case AFL_EXT_10000
:
13671 fputs ("MIPS R10000", stdout
);
13674 fputs ("Broadcom SB-1", stdout
);
13677 fputs ("NEC VR4111/VR4181", stdout
);
13680 fputs ("NEC VR4120", stdout
);
13683 fputs ("NEC VR5400", stdout
);
13686 fputs ("NEC VR5500", stdout
);
13688 case AFL_EXT_LOONGSON_2E
:
13689 fputs ("ST Microelectronics Loongson 2E", stdout
);
13691 case AFL_EXT_LOONGSON_2F
:
13692 fputs ("ST Microelectronics Loongson 2F", stdout
);
13695 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13700 get_mips_reg_size (int reg_size
)
13702 return (reg_size
== AFL_REG_NONE
) ? 0
13703 : (reg_size
== AFL_REG_32
) ? 32
13704 : (reg_size
== AFL_REG_64
) ? 64
13705 : (reg_size
== AFL_REG_128
) ? 128
13710 process_mips_specific (FILE * file
)
13712 Elf_Internal_Dyn
* entry
;
13713 Elf_Internal_Shdr
*sect
= NULL
;
13714 size_t liblist_offset
= 0;
13715 size_t liblistno
= 0;
13716 size_t conflictsno
= 0;
13717 size_t options_offset
= 0;
13718 size_t conflicts_offset
= 0;
13719 size_t pltrelsz
= 0;
13721 bfd_vma pltgot
= 0;
13722 bfd_vma mips_pltgot
= 0;
13723 bfd_vma jmprel
= 0;
13724 bfd_vma local_gotno
= 0;
13725 bfd_vma gotsym
= 0;
13726 bfd_vma symtabno
= 0;
13728 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13729 display_mips_gnu_attribute
);
13731 sect
= find_section (".MIPS.abiflags");
13735 Elf_External_ABIFlags_v0
*abiflags_ext
;
13736 Elf_Internal_ABIFlags_v0 abiflags_in
;
13738 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13739 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13742 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13743 sect
->sh_size
, _("MIPS ABI Flags section"));
13746 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13747 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13748 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13749 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13750 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13751 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13752 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13753 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13754 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13755 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13756 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13758 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13759 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13760 if (abiflags_in
.isa_rev
> 1)
13761 printf ("r%d", abiflags_in
.isa_rev
);
13762 printf ("\nGPR size: %d",
13763 get_mips_reg_size (abiflags_in
.gpr_size
));
13764 printf ("\nCPR1 size: %d",
13765 get_mips_reg_size (abiflags_in
.cpr1_size
));
13766 printf ("\nCPR2 size: %d",
13767 get_mips_reg_size (abiflags_in
.cpr2_size
));
13768 fputs ("\nFP ABI: ", stdout
);
13769 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13770 fputs ("ISA Extension: ", stdout
);
13771 print_mips_isa_ext (abiflags_in
.isa_ext
);
13772 fputs ("\nASEs:", stdout
);
13773 print_mips_ases (abiflags_in
.ases
);
13774 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13775 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13776 fputc ('\n', stdout
);
13777 free (abiflags_ext
);
13782 /* We have a lot of special sections. Thanks SGI! */
13783 if (dynamic_section
== NULL
)
13784 /* No information available. */
13787 for (entry
= dynamic_section
;
13788 /* PR 17531 file: 012-50589-0.004. */
13789 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
13791 switch (entry
->d_tag
)
13793 case DT_MIPS_LIBLIST
:
13795 = offset_from_vma (file
, entry
->d_un
.d_val
,
13796 liblistno
* sizeof (Elf32_External_Lib
));
13798 case DT_MIPS_LIBLISTNO
:
13799 liblistno
= entry
->d_un
.d_val
;
13801 case DT_MIPS_OPTIONS
:
13802 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13804 case DT_MIPS_CONFLICT
:
13806 = offset_from_vma (file
, entry
->d_un
.d_val
,
13807 conflictsno
* sizeof (Elf32_External_Conflict
));
13809 case DT_MIPS_CONFLICTNO
:
13810 conflictsno
= entry
->d_un
.d_val
;
13813 pltgot
= entry
->d_un
.d_ptr
;
13815 case DT_MIPS_LOCAL_GOTNO
:
13816 local_gotno
= entry
->d_un
.d_val
;
13818 case DT_MIPS_GOTSYM
:
13819 gotsym
= entry
->d_un
.d_val
;
13821 case DT_MIPS_SYMTABNO
:
13822 symtabno
= entry
->d_un
.d_val
;
13824 case DT_MIPS_PLTGOT
:
13825 mips_pltgot
= entry
->d_un
.d_ptr
;
13828 pltrel
= entry
->d_un
.d_val
;
13831 pltrelsz
= entry
->d_un
.d_val
;
13834 jmprel
= entry
->d_un
.d_ptr
;
13840 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13842 Elf32_External_Lib
* elib
;
13845 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13847 sizeof (Elf32_External_Lib
),
13848 _("liblist section data"));
13851 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13852 (unsigned long) liblistno
);
13853 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13856 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13863 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13864 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13865 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13866 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13867 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13869 tmp
= gmtime (&atime
);
13870 snprintf (timebuf
, sizeof (timebuf
),
13871 "%04u-%02u-%02uT%02u:%02u:%02u",
13872 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13873 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13875 printf ("%3lu: ", (unsigned long) cnt
);
13876 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13877 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13879 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13880 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13881 liblist
.l_version
);
13883 if (liblist
.l_flags
== 0)
13887 static const struct
13894 { " EXACT_MATCH", LL_EXACT_MATCH
},
13895 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13896 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13897 { " EXPORTS", LL_EXPORTS
},
13898 { " DELAY_LOAD", LL_DELAY_LOAD
},
13899 { " DELTA", LL_DELTA
}
13901 int flags
= liblist
.l_flags
;
13904 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13905 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13907 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13908 flags
^= l_flags_vals
[fcnt
].bit
;
13911 printf (" %#x", (unsigned int) flags
);
13921 if (options_offset
!= 0)
13923 Elf_External_Options
* eopt
;
13924 Elf_Internal_Options
* iopt
;
13925 Elf_Internal_Options
* option
;
13928 sect
= section_headers
;
13930 /* Find the section header so that we get the size. */
13931 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
13932 /* PR 17533 file: 012-277276-0.004. */
13935 error (_("No MIPS_OPTIONS header found\n"));
13939 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13940 sect
->sh_size
, _("options"));
13943 iopt
= (Elf_Internal_Options
*)
13944 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13947 error (_("Out of memory allocatinf space for MIPS options\n"));
13954 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
13956 Elf_External_Options
* eoption
;
13958 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13960 option
->kind
= BYTE_GET (eoption
->kind
);
13961 option
->size
= BYTE_GET (eoption
->size
);
13962 option
->section
= BYTE_GET (eoption
->section
);
13963 option
->info
= BYTE_GET (eoption
->info
);
13965 /* PR 17531: file: ffa0fa3b. */
13966 if (option
->size
< sizeof (* eopt
)
13967 || offset
+ option
->size
> sect
->sh_size
)
13969 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
13972 offset
+= option
->size
;
13978 printf (_("\nSection '%s' contains %d entries:\n"),
13979 printable_section_name (sect
), cnt
);
13988 switch (option
->kind
)
13991 /* This shouldn't happen. */
13992 printf (" NULL %d %lx", option
->section
, option
->info
);
13995 printf (" REGINFO ");
13996 if (elf_header
.e_machine
== EM_MIPS
)
13999 Elf32_External_RegInfo
* ereg
;
14000 Elf32_RegInfo reginfo
;
14002 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14003 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14004 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14005 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14006 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14007 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14008 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14010 printf ("GPR %08lx GP 0x%lx\n",
14011 reginfo
.ri_gprmask
,
14012 (unsigned long) reginfo
.ri_gp_value
);
14013 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14014 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14015 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14020 Elf64_External_RegInfo
* ereg
;
14021 Elf64_Internal_RegInfo reginfo
;
14023 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14024 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14025 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14026 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14027 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14028 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14029 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14031 printf ("GPR %08lx GP 0x",
14032 reginfo
.ri_gprmask
);
14033 printf_vma (reginfo
.ri_gp_value
);
14036 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14037 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14038 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14042 case ODK_EXCEPTIONS
:
14043 fputs (" EXCEPTIONS fpe_min(", stdout
);
14044 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14045 fputs (") fpe_max(", stdout
);
14046 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14047 fputs (")", stdout
);
14049 if (option
->info
& OEX_PAGE0
)
14050 fputs (" PAGE0", stdout
);
14051 if (option
->info
& OEX_SMM
)
14052 fputs (" SMM", stdout
);
14053 if (option
->info
& OEX_FPDBUG
)
14054 fputs (" FPDBUG", stdout
);
14055 if (option
->info
& OEX_DISMISS
)
14056 fputs (" DISMISS", stdout
);
14059 fputs (" PAD ", stdout
);
14060 if (option
->info
& OPAD_PREFIX
)
14061 fputs (" PREFIX", stdout
);
14062 if (option
->info
& OPAD_POSTFIX
)
14063 fputs (" POSTFIX", stdout
);
14064 if (option
->info
& OPAD_SYMBOL
)
14065 fputs (" SYMBOL", stdout
);
14068 fputs (" HWPATCH ", stdout
);
14069 if (option
->info
& OHW_R4KEOP
)
14070 fputs (" R4KEOP", stdout
);
14071 if (option
->info
& OHW_R8KPFETCH
)
14072 fputs (" R8KPFETCH", stdout
);
14073 if (option
->info
& OHW_R5KEOP
)
14074 fputs (" R5KEOP", stdout
);
14075 if (option
->info
& OHW_R5KCVTL
)
14076 fputs (" R5KCVTL", stdout
);
14079 fputs (" FILL ", stdout
);
14080 /* XXX Print content of info word? */
14083 fputs (" TAGS ", stdout
);
14084 /* XXX Print content of info word? */
14087 fputs (" HWAND ", stdout
);
14088 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14089 fputs (" R4KEOP_CHECKED", stdout
);
14090 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14091 fputs (" R4KEOP_CLEAN", stdout
);
14094 fputs (" HWOR ", stdout
);
14095 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14096 fputs (" R4KEOP_CHECKED", stdout
);
14097 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14098 fputs (" R4KEOP_CLEAN", stdout
);
14101 printf (" GP_GROUP %#06lx self-contained %#06lx",
14102 option
->info
& OGP_GROUP
,
14103 (option
->info
& OGP_SELF
) >> 16);
14106 printf (" IDENT %#06lx self-contained %#06lx",
14107 option
->info
& OGP_GROUP
,
14108 (option
->info
& OGP_SELF
) >> 16);
14111 /* This shouldn't happen. */
14112 printf (" %3d ??? %d %lx",
14113 option
->kind
, option
->section
, option
->info
);
14117 len
= sizeof (* eopt
);
14118 while (len
< option
->size
)
14120 char datum
= * ((char *) eopt
+ offset
+ len
);
14122 if (ISPRINT (datum
))
14123 printf ("%c", datum
);
14125 printf ("\\%03o", datum
);
14128 fputs ("\n", stdout
);
14130 offset
+= option
->size
;
14138 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14140 Elf32_Conflict
* iconf
;
14143 if (dynamic_symbols
== NULL
)
14145 error (_("conflict list found without a dynamic symbol table\n"));
14149 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14152 error (_("Out of memory allocating space for dynamic conflicts\n"));
14158 Elf32_External_Conflict
* econf32
;
14160 econf32
= (Elf32_External_Conflict
*)
14161 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14162 sizeof (* econf32
), _("conflict"));
14166 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14167 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14173 Elf64_External_Conflict
* econf64
;
14175 econf64
= (Elf64_External_Conflict
*)
14176 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14177 sizeof (* econf64
), _("conflict"));
14181 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14182 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14187 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14188 (unsigned long) conflictsno
);
14189 puts (_(" Num: Index Value Name"));
14191 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14193 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14195 if (iconf
[cnt
] >= num_dynamic_syms
)
14196 printf (_("<corrupt symbol index>"));
14199 Elf_Internal_Sym
* psym
;
14201 psym
= & dynamic_symbols
[iconf
[cnt
]];
14202 print_vma (psym
->st_value
, FULL_HEX
);
14204 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14205 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14207 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14215 if (pltgot
!= 0 && local_gotno
!= 0)
14217 bfd_vma ent
, local_end
, global_end
;
14219 unsigned char * data
;
14220 unsigned char * data_end
;
14224 addr_size
= (is_32bit_elf
? 4 : 8);
14225 local_end
= pltgot
+ local_gotno
* addr_size
;
14227 /* PR binutils/17533 file: 012-111227-0.004 */
14228 if (symtabno
< gotsym
)
14230 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14231 (unsigned long) gotsym
, (unsigned long) symtabno
);
14235 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14236 /* PR 17531: file: 54c91a34. */
14237 if (global_end
< local_end
)
14239 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14243 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14244 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14245 global_end
- pltgot
, 1,
14246 _("Global Offset Table data"));
14249 data_end
= data
+ (global_end
- pltgot
);
14251 printf (_("\nPrimary GOT:\n"));
14252 printf (_(" Canonical gp value: "));
14253 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14256 printf (_(" Reserved entries:\n"));
14257 printf (_(" %*s %10s %*s Purpose\n"),
14258 addr_size
* 2, _("Address"), _("Access"),
14259 addr_size
* 2, _("Initial"));
14260 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14261 printf (_(" Lazy resolver\n"));
14262 if (ent
== (bfd_vma
) -1)
14263 goto got_print_fail
;
14265 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14266 >> (addr_size
* 8 - 1)) != 0)
14268 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14269 printf (_(" Module pointer (GNU extension)\n"));
14270 if (ent
== (bfd_vma
) -1)
14271 goto got_print_fail
;
14275 if (ent
< local_end
)
14277 printf (_(" Local entries:\n"));
14278 printf (" %*s %10s %*s\n",
14279 addr_size
* 2, _("Address"), _("Access"),
14280 addr_size
* 2, _("Initial"));
14281 while (ent
< local_end
)
14283 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14285 if (ent
== (bfd_vma
) -1)
14286 goto got_print_fail
;
14291 if (gotsym
< symtabno
)
14295 printf (_(" Global entries:\n"));
14296 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14297 addr_size
* 2, _("Address"),
14299 addr_size
* 2, _("Initial"),
14300 addr_size
* 2, _("Sym.Val."),
14302 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14303 _("Ndx"), _("Name"));
14305 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14307 for (i
= gotsym
; i
< symtabno
; i
++)
14309 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14312 if (dynamic_symbols
== NULL
)
14313 printf (_("<no dynamic symbols>"));
14314 else if (i
< num_dynamic_syms
)
14316 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14318 print_vma (psym
->st_value
, LONG_HEX
);
14319 printf (" %-7s %3s ",
14320 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14321 get_symbol_index_type (psym
->st_shndx
));
14323 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14324 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14326 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14329 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14330 (unsigned long) i
);
14333 if (ent
== (bfd_vma
) -1)
14344 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14347 size_t offset
, rel_offset
;
14348 unsigned long count
, i
;
14349 unsigned char * data
;
14350 int addr_size
, sym_width
;
14351 Elf_Internal_Rela
* rels
;
14353 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14354 if (pltrel
== DT_RELA
)
14356 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14361 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14366 addr_size
= (is_32bit_elf
? 4 : 8);
14367 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14369 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14370 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14371 1, _("Procedure Linkage Table data"));
14375 printf ("\nPLT GOT:\n\n");
14376 printf (_(" Reserved entries:\n"));
14377 printf (_(" %*s %*s Purpose\n"),
14378 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14379 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14380 printf (_(" PLT lazy resolver\n"));
14381 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14382 printf (_(" Module pointer\n"));
14385 printf (_(" Entries:\n"));
14386 printf (" %*s %*s %*s %-7s %3s %s\n",
14387 addr_size
* 2, _("Address"),
14388 addr_size
* 2, _("Initial"),
14389 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14390 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14391 for (i
= 0; i
< count
; i
++)
14393 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14395 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14398 if (idx
>= num_dynamic_syms
)
14399 printf (_("<corrupt symbol index: %lu>"), idx
);
14402 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14404 print_vma (psym
->st_value
, LONG_HEX
);
14405 printf (" %-7s %3s ",
14406 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14407 get_symbol_index_type (psym
->st_shndx
));
14408 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14409 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14411 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14426 process_nds32_specific (FILE * file
)
14428 Elf_Internal_Shdr
*sect
= NULL
;
14430 sect
= find_section (".nds32_e_flags");
14433 unsigned int *flag
;
14435 printf ("\nNDS32 elf flags section:\n");
14436 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14437 sect
->sh_size
, _("NDS32 elf flags section"));
14439 switch ((*flag
) & 0x3)
14442 printf ("(VEC_SIZE):\tNo entry.\n");
14445 printf ("(VEC_SIZE):\t4 bytes\n");
14448 printf ("(VEC_SIZE):\t16 bytes\n");
14451 printf ("(VEC_SIZE):\treserved\n");
14460 process_gnu_liblist (FILE * file
)
14462 Elf_Internal_Shdr
* section
;
14463 Elf_Internal_Shdr
* string_sec
;
14464 Elf32_External_Lib
* elib
;
14466 size_t strtab_size
;
14473 for (i
= 0, section
= section_headers
;
14474 i
< elf_header
.e_shnum
;
14477 switch (section
->sh_type
)
14479 case SHT_GNU_LIBLIST
:
14480 if (section
->sh_link
>= elf_header
.e_shnum
)
14483 elib
= (Elf32_External_Lib
*)
14484 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14485 _("liblist section data"));
14489 string_sec
= section_headers
+ section
->sh_link
;
14491 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14492 string_sec
->sh_size
,
14493 _("liblist string table"));
14495 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14501 strtab_size
= string_sec
->sh_size
;
14503 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14504 printable_section_name (section
),
14505 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14507 puts (_(" Library Time Stamp Checksum Version Flags"));
14509 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14517 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14518 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14519 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14520 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14521 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14523 tmp
= gmtime (&atime
);
14524 snprintf (timebuf
, sizeof (timebuf
),
14525 "%04u-%02u-%02uT%02u:%02u:%02u",
14526 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14527 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14529 printf ("%3lu: ", (unsigned long) cnt
);
14531 printf ("%-20s", liblist
.l_name
< strtab_size
14532 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14534 printf ("%-20.20s", liblist
.l_name
< strtab_size
14535 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14536 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14537 liblist
.l_version
, liblist
.l_flags
);
14548 static const char *
14549 get_note_type (unsigned e_type
)
14551 static char buff
[64];
14553 if (elf_header
.e_type
== ET_CORE
)
14557 return _("NT_AUXV (auxiliary vector)");
14559 return _("NT_PRSTATUS (prstatus structure)");
14561 return _("NT_FPREGSET (floating point registers)");
14563 return _("NT_PRPSINFO (prpsinfo structure)");
14564 case NT_TASKSTRUCT
:
14565 return _("NT_TASKSTRUCT (task structure)");
14567 return _("NT_PRXFPREG (user_xfpregs structure)");
14569 return _("NT_PPC_VMX (ppc Altivec registers)");
14571 return _("NT_PPC_VSX (ppc VSX registers)");
14573 return _("NT_386_TLS (x86 TLS information)");
14574 case NT_386_IOPERM
:
14575 return _("NT_386_IOPERM (x86 I/O permissions)");
14576 case NT_X86_XSTATE
:
14577 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14578 case NT_S390_HIGH_GPRS
:
14579 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14580 case NT_S390_TIMER
:
14581 return _("NT_S390_TIMER (s390 timer register)");
14582 case NT_S390_TODCMP
:
14583 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14584 case NT_S390_TODPREG
:
14585 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14587 return _("NT_S390_CTRS (s390 control registers)");
14588 case NT_S390_PREFIX
:
14589 return _("NT_S390_PREFIX (s390 prefix register)");
14590 case NT_S390_LAST_BREAK
:
14591 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14592 case NT_S390_SYSTEM_CALL
:
14593 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14595 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14596 case NT_S390_VXRS_LOW
:
14597 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14598 case NT_S390_VXRS_HIGH
:
14599 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14601 return _("NT_ARM_VFP (arm VFP registers)");
14603 return _("NT_ARM_TLS (AArch TLS registers)");
14604 case NT_ARM_HW_BREAK
:
14605 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14606 case NT_ARM_HW_WATCH
:
14607 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14609 return _("NT_PSTATUS (pstatus structure)");
14611 return _("NT_FPREGS (floating point registers)");
14613 return _("NT_PSINFO (psinfo structure)");
14615 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14617 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14618 case NT_WIN32PSTATUS
:
14619 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14621 return _("NT_SIGINFO (siginfo_t data)");
14623 return _("NT_FILE (mapped files)");
14631 return _("NT_VERSION (version)");
14633 return _("NT_ARCH (architecture)");
14638 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14643 print_core_note (Elf_Internal_Note
*pnote
)
14645 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14646 bfd_vma count
, page_size
;
14647 unsigned char *descdata
, *filenames
, *descend
;
14649 if (pnote
->type
!= NT_FILE
)
14655 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14656 /* Still "successful". */
14661 if (pnote
->descsz
< 2 * addr_size
)
14663 printf (_(" Malformed note - too short for header\n"));
14667 descdata
= (unsigned char *) pnote
->descdata
;
14668 descend
= descdata
+ pnote
->descsz
;
14670 if (descdata
[pnote
->descsz
- 1] != '\0')
14672 printf (_(" Malformed note - does not end with \\0\n"));
14676 count
= byte_get (descdata
, addr_size
);
14677 descdata
+= addr_size
;
14679 page_size
= byte_get (descdata
, addr_size
);
14680 descdata
+= addr_size
;
14682 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
14684 printf (_(" Malformed note - too short for supplied file count\n"));
14688 printf (_(" Page size: "));
14689 print_vma (page_size
, DEC
);
14692 printf (_(" %*s%*s%*s\n"),
14693 (int) (2 + 2 * addr_size
), _("Start"),
14694 (int) (4 + 2 * addr_size
), _("End"),
14695 (int) (4 + 2 * addr_size
), _("Page Offset"));
14696 filenames
= descdata
+ count
* 3 * addr_size
;
14697 while (--count
> 0)
14699 bfd_vma start
, end
, file_ofs
;
14701 if (filenames
== descend
)
14703 printf (_(" Malformed note - filenames end too early\n"));
14707 start
= byte_get (descdata
, addr_size
);
14708 descdata
+= addr_size
;
14709 end
= byte_get (descdata
, addr_size
);
14710 descdata
+= addr_size
;
14711 file_ofs
= byte_get (descdata
, addr_size
);
14712 descdata
+= addr_size
;
14715 print_vma (start
, FULL_HEX
);
14717 print_vma (end
, FULL_HEX
);
14719 print_vma (file_ofs
, FULL_HEX
);
14720 printf ("\n %s\n", filenames
);
14722 filenames
+= 1 + strlen ((char *) filenames
);
14728 static const char *
14729 get_gnu_elf_note_type (unsigned e_type
)
14731 static char buff
[64];
14735 case NT_GNU_ABI_TAG
:
14736 return _("NT_GNU_ABI_TAG (ABI version tag)");
14738 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14739 case NT_GNU_BUILD_ID
:
14740 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14741 case NT_GNU_GOLD_VERSION
:
14742 return _("NT_GNU_GOLD_VERSION (gold version)");
14747 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14752 print_gnu_note (Elf_Internal_Note
*pnote
)
14754 switch (pnote
->type
)
14756 case NT_GNU_BUILD_ID
:
14760 printf (_(" Build ID: "));
14761 for (i
= 0; i
< pnote
->descsz
; ++i
)
14762 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14767 case NT_GNU_ABI_TAG
:
14769 unsigned long os
, major
, minor
, subminor
;
14770 const char *osname
;
14772 /* PR 17531: file: 030-599401-0.004. */
14773 if (pnote
->descsz
< 16)
14775 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14779 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14780 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14781 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14782 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14786 case GNU_ABI_TAG_LINUX
:
14789 case GNU_ABI_TAG_HURD
:
14792 case GNU_ABI_TAG_SOLARIS
:
14793 osname
= "Solaris";
14795 case GNU_ABI_TAG_FREEBSD
:
14796 osname
= "FreeBSD";
14798 case GNU_ABI_TAG_NETBSD
:
14802 osname
= "Unknown";
14806 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14807 major
, minor
, subminor
);
14811 case NT_GNU_GOLD_VERSION
:
14815 printf (_(" Version: "));
14816 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14817 printf ("%c", pnote
->descdata
[i
]);
14826 static const char *
14827 get_v850_elf_note_type (enum v850_notes n_type
)
14829 static char buff
[64];
14833 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
14834 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
14835 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
14836 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
14837 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
14838 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
14840 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
14846 print_v850_note (Elf_Internal_Note
* pnote
)
14850 if (pnote
->descsz
!= 4)
14852 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
14856 printf (_("not set\n"));
14860 switch (pnote
->type
)
14862 case V850_NOTE_ALIGNMENT
:
14865 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
14866 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
14870 case V850_NOTE_DATA_SIZE
:
14873 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
14874 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
14878 case V850_NOTE_FPU_INFO
:
14881 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
14882 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
14886 case V850_NOTE_MMU_INFO
:
14887 case V850_NOTE_CACHE_INFO
:
14888 case V850_NOTE_SIMD_INFO
:
14889 if (val
== EF_RH850_SIMD
)
14891 printf (_("yes\n"));
14897 /* An 'unknown note type' message will already have been displayed. */
14901 printf (_("unknown value: %x\n"), val
);
14905 static const char *
14906 get_netbsd_elfcore_note_type (unsigned e_type
)
14908 static char buff
[64];
14910 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14912 /* NetBSD core "procinfo" structure. */
14913 return _("NetBSD procinfo structure");
14916 /* As of Jan 2002 there are no other machine-independent notes
14917 defined for NetBSD core files. If the note type is less
14918 than the start of the machine-dependent note types, we don't
14921 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14923 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14927 switch (elf_header
.e_machine
)
14929 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14930 and PT_GETFPREGS == mach+2. */
14935 case EM_SPARC32PLUS
:
14939 case NT_NETBSDCORE_FIRSTMACH
+ 0:
14940 return _("PT_GETREGS (reg structure)");
14941 case NT_NETBSDCORE_FIRSTMACH
+ 2:
14942 return _("PT_GETFPREGS (fpreg structure)");
14948 /* On all other arch's, PT_GETREGS == mach+1 and
14949 PT_GETFPREGS == mach+3. */
14953 case NT_NETBSDCORE_FIRSTMACH
+ 1:
14954 return _("PT_GETREGS (reg structure)");
14955 case NT_NETBSDCORE_FIRSTMACH
+ 3:
14956 return _("PT_GETFPREGS (fpreg structure)");
14962 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
14963 e_type
- NT_NETBSDCORE_FIRSTMACH
);
14967 static const char *
14968 get_stapsdt_note_type (unsigned e_type
)
14970 static char buff
[64];
14975 return _("NT_STAPSDT (SystemTap probe descriptors)");
14981 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14986 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14988 int addr_size
= is_32bit_elf
? 4 : 8;
14989 char *data
= pnote
->descdata
;
14990 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
14991 bfd_vma pc
, base_addr
, semaphore
;
14992 char *provider
, *probe
, *arg_fmt
;
14994 pc
= byte_get ((unsigned char *) data
, addr_size
);
14996 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
14998 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15002 data
+= strlen (data
) + 1;
15004 data
+= strlen (data
) + 1;
15006 data
+= strlen (data
) + 1;
15008 printf (_(" Provider: %s\n"), provider
);
15009 printf (_(" Name: %s\n"), probe
);
15010 printf (_(" Location: "));
15011 print_vma (pc
, FULL_HEX
);
15012 printf (_(", Base: "));
15013 print_vma (base_addr
, FULL_HEX
);
15014 printf (_(", Semaphore: "));
15015 print_vma (semaphore
, FULL_HEX
);
15017 printf (_(" Arguments: %s\n"), arg_fmt
);
15019 return data
== data_end
;
15022 static const char *
15023 get_ia64_vms_note_type (unsigned e_type
)
15025 static char buff
[64];
15030 return _("NT_VMS_MHD (module header)");
15032 return _("NT_VMS_LNM (language name)");
15034 return _("NT_VMS_SRC (source files)");
15036 return "NT_VMS_TITLE";
15038 return _("NT_VMS_EIDC (consistency check)");
15039 case NT_VMS_FPMODE
:
15040 return _("NT_VMS_FPMODE (FP mode)");
15041 case NT_VMS_LINKTIME
:
15042 return "NT_VMS_LINKTIME";
15043 case NT_VMS_IMGNAM
:
15044 return _("NT_VMS_IMGNAM (image name)");
15046 return _("NT_VMS_IMGID (image id)");
15047 case NT_VMS_LINKID
:
15048 return _("NT_VMS_LINKID (link id)");
15049 case NT_VMS_IMGBID
:
15050 return _("NT_VMS_IMGBID (build id)");
15051 case NT_VMS_GSTNAM
:
15052 return _("NT_VMS_GSTNAM (sym table name)");
15053 case NT_VMS_ORIG_DYN
:
15054 return "NT_VMS_ORIG_DYN";
15055 case NT_VMS_PATCHTIME
:
15056 return "NT_VMS_PATCHTIME";
15058 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15064 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15066 switch (pnote
->type
)
15069 if (pnote
->descsz
> 36)
15071 size_t l
= strlen (pnote
->descdata
+ 34);
15072 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15073 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15074 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15075 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15078 printf (_(" Invalid size\n"));
15081 printf (_(" Language: %s\n"), pnote
->descdata
);
15084 case NT_VMS_FPMODE
:
15085 printf (_(" Floating Point mode: "));
15086 printf ("0x%016" BFD_VMA_FMT
"x\n",
15087 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15089 case NT_VMS_LINKTIME
:
15090 printf (_(" Link time: "));
15092 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15095 case NT_VMS_PATCHTIME
:
15096 printf (_(" Patch time: "));
15098 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15101 case NT_VMS_ORIG_DYN
:
15102 printf (_(" Major id: %u, minor id: %u\n"),
15103 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15104 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15105 printf (_(" Last modified : "));
15107 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15108 printf (_("\n Link flags : "));
15109 printf ("0x%016" BFD_VMA_FMT
"x\n",
15110 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15111 printf (_(" Header flags: 0x%08x\n"),
15112 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15113 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15116 case NT_VMS_IMGNAM
:
15117 printf (_(" Image name: %s\n"), pnote
->descdata
);
15119 case NT_VMS_GSTNAM
:
15120 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15123 printf (_(" Image id: %s\n"), pnote
->descdata
);
15125 case NT_VMS_LINKID
:
15126 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15134 /* Note that by the ELF standard, the name field is already null byte
15135 terminated, and namesz includes the terminating null byte.
15136 I.E. the value of namesz for the name "FSF" is 4.
15138 If the value of namesz is zero, there is no name present. */
15140 process_note (Elf_Internal_Note
* pnote
)
15142 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15145 if (pnote
->namesz
== 0)
15146 /* If there is no note name, then use the default set of
15147 note type strings. */
15148 nt
= get_note_type (pnote
->type
);
15150 else if (const_strneq (pnote
->namedata
, "GNU"))
15151 /* GNU-specific object file notes. */
15152 nt
= get_gnu_elf_note_type (pnote
->type
);
15154 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15155 /* NetBSD-specific core file notes. */
15156 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15158 else if (strneq (pnote
->namedata
, "SPU/", 4))
15160 /* SPU-specific core file notes. */
15161 nt
= pnote
->namedata
+ 4;
15165 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15166 /* VMS/ia64-specific file notes. */
15167 nt
= get_ia64_vms_note_type (pnote
->type
);
15169 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15170 nt
= get_stapsdt_note_type (pnote
->type
);
15173 /* Don't recognize this note name; just use the default set of
15174 note type strings. */
15175 nt
= get_note_type (pnote
->type
);
15177 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15179 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15180 return print_ia64_vms_note (pnote
);
15181 else if (const_strneq (pnote
->namedata
, "GNU"))
15182 return print_gnu_note (pnote
);
15183 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15184 return print_stapsdt_note (pnote
);
15185 else if (const_strneq (pnote
->namedata
, "CORE"))
15186 return print_core_note (pnote
);
15193 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15195 Elf_External_Note
* pnotes
;
15196 Elf_External_Note
* external
;
15203 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15205 if (pnotes
== NULL
)
15210 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15211 (unsigned long) offset
, (unsigned long) length
);
15212 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15214 end
= (char *) pnotes
+ length
;
15215 while ((char *) external
< end
)
15217 Elf_Internal_Note inote
;
15220 char * temp
= NULL
;
15221 size_t data_remaining
= end
- (char *) external
;
15223 if (!is_ia64_vms ())
15225 /* PR binutils/15191
15226 Make sure that there is enough data to read. */
15227 min_notesz
= offsetof (Elf_External_Note
, name
);
15228 if (data_remaining
< min_notesz
)
15230 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15231 (int) data_remaining
);
15234 inote
.type
= BYTE_GET (external
->type
);
15235 inote
.namesz
= BYTE_GET (external
->namesz
);
15236 inote
.namedata
= external
->name
;
15237 inote
.descsz
= BYTE_GET (external
->descsz
);
15238 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15239 /* PR 17531: file: 3443835e. */
15240 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15242 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15243 inote
.descdata
= inote
.namedata
;
15247 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15248 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15252 Elf64_External_VMS_Note
*vms_external
;
15254 /* PR binutils/15191
15255 Make sure that there is enough data to read. */
15256 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15257 if (data_remaining
< min_notesz
)
15259 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15260 (int) data_remaining
);
15264 vms_external
= (Elf64_External_VMS_Note
*) external
;
15265 inote
.type
= BYTE_GET (vms_external
->type
);
15266 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15267 inote
.namedata
= vms_external
->name
;
15268 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15269 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15270 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15271 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15274 if (inote
.descdata
< (char *) external
+ min_notesz
15275 || next
< (char *) external
+ min_notesz
15276 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15277 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15278 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15279 || data_remaining
< (size_t)(next
- (char *) external
))
15281 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15282 (unsigned long) ((char *) external
- (char *) pnotes
));
15283 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15284 inote
.type
, inote
.namesz
, inote
.descsz
);
15288 external
= (Elf_External_Note
*) next
;
15290 /* Verify that name is null terminated. It appears that at least
15291 one version of Linux (RedHat 6.0) generates corefiles that don't
15292 comply with the ELF spec by failing to include the null byte in
15294 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15296 temp
= (char *) malloc (inote
.namesz
+ 1);
15299 error (_("Out of memory allocating space for inote name\n"));
15304 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15305 temp
[inote
.namesz
] = 0;
15307 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15308 inote
.namedata
= temp
;
15311 res
&= process_note (& inote
);
15326 process_corefile_note_segments (FILE * file
)
15328 Elf_Internal_Phdr
* segment
;
15332 if (! get_program_headers (file
))
15335 for (i
= 0, segment
= program_headers
;
15336 i
< elf_header
.e_phnum
;
15339 if (segment
->p_type
== PT_NOTE
)
15340 res
&= process_corefile_note_segment (file
,
15341 (bfd_vma
) segment
->p_offset
,
15342 (bfd_vma
) segment
->p_filesz
);
15349 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15351 Elf_External_Note
* pnotes
;
15352 Elf_External_Note
* external
;
15359 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15361 if (pnotes
== NULL
)
15365 end
= (char*) pnotes
+ length
;
15367 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15368 (unsigned long) offset
, (unsigned long) length
);
15370 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15372 Elf_External_Note
* next
;
15373 Elf_Internal_Note inote
;
15375 inote
.type
= BYTE_GET (external
->type
);
15376 inote
.namesz
= BYTE_GET (external
->namesz
);
15377 inote
.namedata
= external
->name
;
15378 inote
.descsz
= BYTE_GET (external
->descsz
);
15379 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15380 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15382 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15384 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15385 inote
.descdata
= inote
.namedata
;
15389 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15391 if ( ((char *) next
> end
)
15392 || ((char *) next
< (char *) pnotes
))
15394 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15395 (unsigned long) ((char *) external
- (char *) pnotes
));
15396 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15397 inote
.type
, inote
.namesz
, inote
.descsz
);
15403 /* Prevent out-of-bounds indexing. */
15404 if ( inote
.namedata
+ inote
.namesz
> end
15405 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15407 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15408 (unsigned long) ((char *) external
- (char *) pnotes
));
15409 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15410 inote
.type
, inote
.namesz
, inote
.descsz
);
15414 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15416 if (! print_v850_note (& inote
))
15419 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15420 inote
.namesz
, inote
.descsz
);
15430 process_note_sections (FILE * file
)
15432 Elf_Internal_Shdr
* section
;
15437 for (i
= 0, section
= section_headers
;
15438 i
< elf_header
.e_shnum
&& section
!= NULL
;
15441 if (section
->sh_type
== SHT_NOTE
)
15443 res
&= process_corefile_note_segment (file
,
15444 (bfd_vma
) section
->sh_offset
,
15445 (bfd_vma
) section
->sh_size
);
15449 if (( elf_header
.e_machine
== EM_V800
15450 || elf_header
.e_machine
== EM_V850
15451 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15452 && section
->sh_type
== SHT_RENESAS_INFO
)
15454 res
&= process_v850_notes (file
,
15455 (bfd_vma
) section
->sh_offset
,
15456 (bfd_vma
) section
->sh_size
);
15462 /* Try processing NOTE segments instead. */
15463 return process_corefile_note_segments (file
);
15469 process_notes (FILE * file
)
15471 /* If we have not been asked to display the notes then do nothing. */
15475 if (elf_header
.e_type
!= ET_CORE
)
15476 return process_note_sections (file
);
15478 /* No program headers means no NOTE segment. */
15479 if (elf_header
.e_phnum
> 0)
15480 return process_corefile_note_segments (file
);
15482 printf (_("No note segments present in the core file.\n"));
15487 process_arch_specific (FILE * file
)
15492 switch (elf_header
.e_machine
)
15495 return process_arm_specific (file
);
15497 case EM_MIPS_RS3_LE
:
15498 return process_mips_specific (file
);
15501 return process_nds32_specific (file
);
15504 return process_power_specific (file
);
15507 case EM_SPARC32PLUS
:
15509 return process_sparc_specific (file
);
15512 return process_tic6x_specific (file
);
15515 return process_msp430x_specific (file
);
15523 get_file_header (FILE * file
)
15525 /* Read in the identity array. */
15526 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15529 /* Determine how to read the rest of the header. */
15530 switch (elf_header
.e_ident
[EI_DATA
])
15532 default: /* fall through */
15533 case ELFDATANONE
: /* fall through */
15535 byte_get
= byte_get_little_endian
;
15536 byte_put
= byte_put_little_endian
;
15539 byte_get
= byte_get_big_endian
;
15540 byte_put
= byte_put_big_endian
;
15544 /* For now we only support 32 bit and 64 bit ELF files. */
15545 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15547 /* Read in the rest of the header. */
15550 Elf32_External_Ehdr ehdr32
;
15552 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15555 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15556 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15557 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15558 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15559 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15560 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15561 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15562 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15563 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15564 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15565 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15566 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15567 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15571 Elf64_External_Ehdr ehdr64
;
15573 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15574 we will not be able to cope with the 64bit data found in
15575 64 ELF files. Detect this now and abort before we start
15576 overwriting things. */
15577 if (sizeof (bfd_vma
) < 8)
15579 error (_("This instance of readelf has been built without support for a\n\
15580 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15584 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15587 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15588 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15589 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15590 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15591 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15592 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15593 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15594 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15595 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15596 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15597 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15598 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15599 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15602 if (elf_header
.e_shoff
)
15604 /* There may be some extensions in the first section header. Don't
15605 bomb if we can't read it. */
15607 get_32bit_section_headers (file
, TRUE
);
15609 get_64bit_section_headers (file
, TRUE
);
15615 /* Process one ELF object file according to the command line options.
15616 This file may actually be stored in an archive. The file is
15617 positioned at the start of the ELF object. */
15620 process_object (char * file_name
, FILE * file
)
15624 if (! get_file_header (file
))
15626 error (_("%s: Failed to read file header\n"), file_name
);
15630 /* Initialise per file variables. */
15631 for (i
= ARRAY_SIZE (version_info
); i
--;)
15632 version_info
[i
] = 0;
15634 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15635 dynamic_info
[i
] = 0;
15636 dynamic_info_DT_GNU_HASH
= 0;
15638 /* Process the file. */
15640 printf (_("\nFile: %s\n"), file_name
);
15642 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15643 Note we do this even if cmdline_dump_sects is empty because we
15644 must make sure that the dump_sets array is zeroed out before each
15645 object file is processed. */
15646 if (num_dump_sects
> num_cmdline_dump_sects
)
15647 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15649 if (num_cmdline_dump_sects
> 0)
15651 if (num_dump_sects
== 0)
15652 /* A sneaky way of allocating the dump_sects array. */
15653 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15655 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15656 memcpy (dump_sects
, cmdline_dump_sects
,
15657 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15660 if (! process_file_header ())
15663 if (! process_section_headers (file
))
15665 /* Without loaded section headers we cannot process lots of
15667 do_unwind
= do_version
= do_dump
= do_arch
= 0;
15669 if (! do_using_dynamic
)
15670 do_syms
= do_dyn_syms
= do_reloc
= 0;
15673 if (! process_section_groups (file
))
15675 /* Without loaded section groups we cannot process unwind. */
15679 if (process_program_headers (file
))
15680 process_dynamic_section (file
);
15682 process_relocs (file
);
15684 process_unwind (file
);
15686 process_symbol_table (file
);
15688 process_syminfo (file
);
15690 process_version_sections (file
);
15692 process_section_contents (file
);
15694 process_notes (file
);
15696 process_gnu_liblist (file
);
15698 process_arch_specific (file
);
15700 if (program_headers
)
15702 free (program_headers
);
15703 program_headers
= NULL
;
15706 if (section_headers
)
15708 free (section_headers
);
15709 section_headers
= NULL
;
15714 free (string_table
);
15715 string_table
= NULL
;
15716 string_table_length
= 0;
15719 if (dynamic_strings
)
15721 free (dynamic_strings
);
15722 dynamic_strings
= NULL
;
15723 dynamic_strings_length
= 0;
15726 if (dynamic_symbols
)
15728 free (dynamic_symbols
);
15729 dynamic_symbols
= NULL
;
15730 num_dynamic_syms
= 0;
15733 if (dynamic_syminfo
)
15735 free (dynamic_syminfo
);
15736 dynamic_syminfo
= NULL
;
15739 if (dynamic_section
)
15741 free (dynamic_section
);
15742 dynamic_section
= NULL
;
15745 if (section_headers_groups
)
15747 free (section_headers_groups
);
15748 section_headers_groups
= NULL
;
15751 if (section_groups
)
15753 struct group_list
* g
;
15754 struct group_list
* next
;
15756 for (i
= 0; i
< group_count
; i
++)
15758 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
15765 free (section_groups
);
15766 section_groups
= NULL
;
15769 free_debug_memory ();
15774 /* Process an ELF archive.
15775 On entry the file is positioned just after the ARMAG string. */
15778 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
15780 struct archive_info arch
;
15781 struct archive_info nested_arch
;
15787 /* The ARCH structure is used to hold information about this archive. */
15788 arch
.file_name
= NULL
;
15790 arch
.index_array
= NULL
;
15791 arch
.sym_table
= NULL
;
15792 arch
.longnames
= NULL
;
15794 /* The NESTED_ARCH structure is used as a single-item cache of information
15795 about a nested archive (when members of a thin archive reside within
15796 another regular archive file). */
15797 nested_arch
.file_name
= NULL
;
15798 nested_arch
.file
= NULL
;
15799 nested_arch
.index_array
= NULL
;
15800 nested_arch
.sym_table
= NULL
;
15801 nested_arch
.longnames
= NULL
;
15803 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
15809 if (do_archive_index
)
15811 if (arch
.sym_table
== NULL
)
15812 error (_("%s: unable to dump the index as none was found\n"), file_name
);
15815 unsigned long i
, l
;
15816 unsigned long current_pos
;
15818 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15819 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
15820 current_pos
= ftell (file
);
15822 for (i
= l
= 0; i
< arch
.index_num
; i
++)
15824 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
15826 char * member_name
;
15828 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
15830 if (member_name
!= NULL
)
15832 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
15834 if (qualified_name
!= NULL
)
15836 printf (_("Contents of binary %s at offset "), qualified_name
);
15837 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
15839 free (qualified_name
);
15844 if (l
>= arch
.sym_size
)
15846 error (_("%s: end of the symbol table reached before the end of the index\n"),
15850 /* PR 17531: file: 0b6630b2. */
15851 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
15852 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
15855 if (arch
.uses_64bit_indicies
)
15860 if (l
< arch
.sym_size
)
15861 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15862 file_name
, arch
.sym_size
- l
);
15864 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
15866 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
15872 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
15873 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
15874 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
15875 && !do_section_groups
&& !do_dyn_syms
)
15877 ret
= 0; /* Archive index only. */
15888 char * qualified_name
;
15890 /* Read the next archive header. */
15891 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
15893 error (_("%s: failed to seek to next archive header\n"), file_name
);
15896 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
15897 if (got
!= sizeof arch
.arhdr
)
15901 error (_("%s: failed to read archive header\n"), file_name
);
15905 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
15907 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
15912 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
15914 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
15915 if (archive_file_size
& 01)
15916 ++archive_file_size
;
15918 name
= get_archive_member_name (&arch
, &nested_arch
);
15921 error (_("%s: bad archive file name\n"), file_name
);
15925 namelen
= strlen (name
);
15927 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15928 if (qualified_name
== NULL
)
15930 error (_("%s: bad archive file name\n"), file_name
);
15935 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
15937 /* This is a proxy for an external member of a thin archive. */
15938 FILE * member_file
;
15939 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
15940 if (member_file_name
== NULL
)
15946 member_file
= fopen (member_file_name
, "rb");
15947 if (member_file
== NULL
)
15949 error (_("Input file '%s' is not readable.\n"), member_file_name
);
15950 free (member_file_name
);
15955 archive_file_offset
= arch
.nested_member_origin
;
15957 ret
|= process_object (qualified_name
, member_file
);
15959 fclose (member_file
);
15960 free (member_file_name
);
15962 else if (is_thin_archive
)
15964 /* PR 15140: Allow for corrupt thin archives. */
15965 if (nested_arch
.file
== NULL
)
15967 error (_("%s: contains corrupt thin archive: %s\n"),
15973 /* This is a proxy for a member of a nested archive. */
15974 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
15976 /* The nested archive file will have been opened and setup by
15977 get_archive_member_name. */
15978 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
15980 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
15985 ret
|= process_object (qualified_name
, nested_arch
.file
);
15989 archive_file_offset
= arch
.next_arhdr_offset
;
15990 arch
.next_arhdr_offset
+= archive_file_size
;
15992 ret
|= process_object (qualified_name
, file
);
15995 if (dump_sects
!= NULL
)
15999 num_dump_sects
= 0;
16002 free (qualified_name
);
16006 if (nested_arch
.file
!= NULL
)
16007 fclose (nested_arch
.file
);
16008 release_archive (&nested_arch
);
16009 release_archive (&arch
);
16015 process_file (char * file_name
)
16018 struct stat statbuf
;
16019 char armag
[SARMAG
];
16022 if (stat (file_name
, &statbuf
) < 0)
16024 if (errno
== ENOENT
)
16025 error (_("'%s': No such file\n"), file_name
);
16027 error (_("Could not locate '%s'. System error message: %s\n"),
16028 file_name
, strerror (errno
));
16032 if (! S_ISREG (statbuf
.st_mode
))
16034 error (_("'%s' is not an ordinary file\n"), file_name
);
16038 file
= fopen (file_name
, "rb");
16041 error (_("Input file '%s' is not readable.\n"), file_name
);
16045 if (fread (armag
, SARMAG
, 1, file
) != 1)
16047 error (_("%s: Failed to read file's magic number\n"), file_name
);
16052 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16054 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16055 ret
= process_archive (file_name
, file
, FALSE
);
16056 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16057 ret
= process_archive (file_name
, file
, TRUE
);
16060 if (do_archive_index
)
16061 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16065 archive_file_size
= archive_file_offset
= 0;
16066 ret
= process_object (file_name
, file
);
16071 current_file_size
= 0;
16075 #ifdef SUPPORT_DISASSEMBLY
16076 /* Needed by the i386 disassembler. For extra credit, someone could
16077 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16081 print_address (unsigned int addr
, FILE * outfile
)
16083 fprintf (outfile
,"0x%8.8x", addr
);
16086 /* Needed by the i386 disassembler. */
16088 db_task_printsym (unsigned int addr
)
16090 print_address (addr
, stderr
);
16095 main (int argc
, char ** argv
)
16099 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16100 setlocale (LC_MESSAGES
, "");
16102 #if defined (HAVE_SETLOCALE)
16103 setlocale (LC_CTYPE
, "");
16105 bindtextdomain (PACKAGE
, LOCALEDIR
);
16106 textdomain (PACKAGE
);
16108 expandargv (&argc
, &argv
);
16110 parse_args (argc
, argv
);
16112 if (num_dump_sects
> 0)
16114 /* Make a copy of the dump_sects array. */
16115 cmdline_dump_sects
= (dump_type
*)
16116 malloc (num_dump_sects
* sizeof (* dump_sects
));
16117 if (cmdline_dump_sects
== NULL
)
16118 error (_("Out of memory allocating dump request table.\n"));
16121 memcpy (cmdline_dump_sects
, dump_sects
,
16122 num_dump_sects
* sizeof (* dump_sects
));
16123 num_cmdline_dump_sects
= num_dump_sects
;
16127 if (optind
< (argc
- 1))
16129 else if (optind
>= argc
)
16131 warn (_("Nothing to do.\n"));
16136 while (optind
< argc
)
16137 err
|= process_file (argv
[optind
++]);
16139 if (dump_sects
!= NULL
)
16141 if (cmdline_dump_sects
!= NULL
)
16142 free (cmdline_dump_sects
);