1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 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. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 typedef struct filedata
202 const char * file_name
;
204 bfd_size_type file_size
;
205 Elf_Internal_Ehdr file_header
;
206 Elf_Internal_Shdr
* section_headers
;
207 Elf_Internal_Phdr
* program_headers
;
209 unsigned long string_table_length
;
210 /* A dynamic array of flags indicating for which sections a dump of
211 some kind has been requested. It is reset on a per-object file
212 basis and then initialised from the cmdline_dump_sects array,
213 the results of interpreting the -w switch, and the
214 dump_sects_byname list. */
215 dump_type
* dump_sects
;
216 unsigned int num_dump_sects
;
219 char * program_name
= "readelf";
221 static unsigned long archive_file_offset
;
222 static unsigned long archive_file_size
;
223 static unsigned long dynamic_addr
;
224 static bfd_size_type dynamic_size
;
225 static size_t dynamic_nent
;
226 static char * dynamic_strings
;
227 static unsigned long dynamic_strings_length
;
228 static unsigned long num_dynamic_syms
;
229 static bfd_size_type nbuckets
;
230 static bfd_size_type nchains
;
231 static bfd_vma
*buckets
;
232 static bfd_vma
*chains
;
233 static bfd_vma ngnubuckets
;
234 static bfd_vma
*gnubuckets
;
235 static bfd_vma
*gnuchains
;
236 static bfd_vma
*mipsxlat
;
237 static bfd_size_type ngnuchains
;
238 static bfd_vma gnusymidx
;
239 static Elf_Internal_Sym
* dynamic_symbols
;
240 static Elf_Internal_Syminfo
* dynamic_syminfo
;
241 static unsigned long dynamic_syminfo_offset
;
242 static unsigned int dynamic_syminfo_nent
;
243 static char program_interpreter
[PATH_MAX
];
244 static bfd_vma dynamic_info
[DT_ENCODING
];
245 static bfd_vma dynamic_info_DT_GNU_HASH
;
246 static bfd_vma dynamic_info_DT_MIPS_XHASH
;
247 static bfd_vma version_info
[16];
248 static Elf_Internal_Dyn
* dynamic_section
;
249 static elf_section_list
* symtab_shndx_list
;
250 static bfd_boolean show_name
= FALSE
;
251 static bfd_boolean do_dynamic
= FALSE
;
252 static bfd_boolean do_syms
= FALSE
;
253 static bfd_boolean do_dyn_syms
= FALSE
;
254 static bfd_boolean do_reloc
= FALSE
;
255 static bfd_boolean do_sections
= FALSE
;
256 static bfd_boolean do_section_groups
= FALSE
;
257 static bfd_boolean do_section_details
= FALSE
;
258 static bfd_boolean do_segments
= FALSE
;
259 static bfd_boolean do_unwind
= FALSE
;
260 static bfd_boolean do_using_dynamic
= FALSE
;
261 static bfd_boolean do_header
= FALSE
;
262 static bfd_boolean do_dump
= FALSE
;
263 static bfd_boolean do_version
= FALSE
;
264 static bfd_boolean do_histogram
= FALSE
;
265 static bfd_boolean do_debugging
= FALSE
;
266 static bfd_boolean do_ctf
= FALSE
;
267 static bfd_boolean do_arch
= FALSE
;
268 static bfd_boolean do_notes
= FALSE
;
269 static bfd_boolean do_archive_index
= FALSE
;
270 static bfd_boolean is_32bit_elf
= FALSE
;
271 static bfd_boolean decompress_dumps
= FALSE
;
273 static char *dump_ctf_parent_name
;
274 static char *dump_ctf_symtab_name
;
275 static char *dump_ctf_strtab_name
;
279 struct group_list
* next
;
280 unsigned int section_index
;
285 struct group_list
* root
;
286 unsigned int group_index
;
289 static size_t group_count
;
290 static struct group
* section_groups
;
291 static struct group
** section_headers_groups
;
293 /* A dynamic array of flags indicating for which sections a dump
294 has been requested via command line switches. */
295 static Filedata cmdline
;
297 static struct dump_list_entry
* dump_sects_byname
;
299 /* How to print a vma value. */
300 typedef enum print_mode
312 /* Versioned symbol info. */
313 enum versioned_symbol_info
320 static const char * get_symbol_version_string
321 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
322 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
326 #define SECTION_NAME(X) \
327 ((X) == NULL ? _("<none>") \
328 : filedata->string_table == NULL ? _("<no-strings>") \
329 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
330 : filedata->string_table + (X)->sh_name))
332 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
334 #define GET_ELF_SYMBOLS(file, section, sym_count) \
335 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
336 : get_64bit_elf_symbols (file, section, sym_count))
338 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
339 (strtab != NULL && offset < strtab_size)
340 #define VALID_DYNAMIC_NAME(offset) \
341 VALID_SYMBOL_NAME (dynamic_strings, dynamic_strings_length, offset)
342 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
343 already been called and verified that the string exists. */
344 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
346 #define REMOVE_ARCH_BITS(ADDR) \
349 if (filedata->file_header.e_machine == EM_ARM) \
354 /* Get the correct GNU hash section name. */
355 #define GNU_HASH_SECTION_NAME \
356 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
358 /* Print a BFD_VMA to an internal buffer, for use in error messages.
359 BFD_FMA_FMT can't be used in translated strings. */
362 bfd_vmatoa (char *fmtch
, bfd_vma value
)
364 /* bfd_vmatoa is used more then once in a printf call for output.
365 Cycle through an array of buffers. */
366 static int buf_pos
= 0;
367 static struct bfd_vmatoa_buf
374 ret
= buf
[buf_pos
++].place
;
375 buf_pos
%= ARRAY_SIZE (buf
);
377 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
378 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
382 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
383 OFFSET + the offset of the current archive member, if we are examining an
384 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
385 allocate a buffer using malloc and fill that. In either case return the
386 pointer to the start of the retrieved data or NULL if something went wrong.
387 If something does go wrong and REASON is not NULL then emit an error
388 message using REASON as part of the context. */
391 get_data (void * var
,
393 unsigned long offset
,
399 bfd_size_type amt
= size
* nmemb
;
401 if (size
== 0 || nmemb
== 0)
404 /* If the size_t type is smaller than the bfd_size_type, eg because
405 you are building a 32-bit tool on a 64-bit host, then make sure
406 that when the sizes are cast to (size_t) no information is lost. */
407 if ((size_t) size
!= size
408 || (size_t) nmemb
!= nmemb
409 || (size_t) amt
!= amt
)
412 error (_("Size truncation prevents reading %s"
413 " elements of size %s for %s\n"),
414 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
418 /* Check for size overflow. */
419 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
422 error (_("Size overflow prevents reading %s"
423 " elements of size %s for %s\n"),
424 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
428 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
429 attempting to allocate memory when the read is bound to fail. */
430 if (archive_file_offset
> filedata
->file_size
431 || offset
> filedata
->file_size
- archive_file_offset
432 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
435 error (_("Reading %s bytes extends past end of file for %s\n"),
436 bfd_vmatoa ("u", amt
), reason
);
440 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
443 error (_("Unable to seek to 0x%lx for %s\n"),
444 archive_file_offset
+ offset
, reason
);
451 /* + 1 so that we can '\0' terminate invalid string table sections. */
452 mvar
= malloc ((size_t) amt
+ 1);
457 error (_("Out of memory allocating %s bytes for %s\n"),
458 bfd_vmatoa ("u", amt
), reason
);
462 ((char *) mvar
)[amt
] = '\0';
465 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
468 error (_("Unable to read in %s bytes of %s\n"),
469 bfd_vmatoa ("u", amt
), reason
);
478 /* Print a VMA value in the MODE specified.
479 Returns the number of characters displayed. */
482 print_vma (bfd_vma vma
, print_mode mode
)
494 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
501 return printf ("%5" BFD_VMA_FMT
"d", vma
);
507 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
510 return printf ("%" BFD_VMA_FMT
"d", vma
);
513 return printf ("%" BFD_VMA_FMT
"u", vma
);
516 /* FIXME: Report unrecognised mode ? */
521 /* Display a symbol on stdout. Handles the display of control characters and
522 multibye characters (assuming the host environment supports them).
524 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
526 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
527 padding as necessary.
529 Returns the number of emitted characters. */
532 print_symbol (signed int width
, const char *symbol
)
534 bfd_boolean extra_padding
= FALSE
;
535 signed int num_printed
= 0;
536 #ifdef HAVE_MBSTATE_T
539 unsigned int width_remaining
;
543 /* Keep the width positive. This helps the code below. */
545 extra_padding
= TRUE
;
551 /* Set the remaining width to a very large value.
552 This simplifies the code below. */
553 width_remaining
= INT_MAX
;
555 width_remaining
= width
;
557 #ifdef HAVE_MBSTATE_T
558 /* Initialise the multibyte conversion state. */
559 memset (& state
, 0, sizeof (state
));
562 while (width_remaining
)
565 const char c
= *symbol
++;
570 /* Do not print control characters directly as they can affect terminal
571 settings. Such characters usually appear in the names generated
572 by the assembler for local labels. */
575 if (width_remaining
< 2)
578 printf ("^%c", c
+ 0x40);
579 width_remaining
-= 2;
582 else if (ISPRINT (c
))
590 #ifdef HAVE_MBSTATE_T
593 /* Let printf do the hard work of displaying multibyte characters. */
594 printf ("%.1s", symbol
- 1);
598 #ifdef HAVE_MBSTATE_T
599 /* Try to find out how many bytes made up the character that was
600 just printed. Advance the symbol pointer past the bytes that
602 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
606 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
611 if (extra_padding
&& num_printed
< width
)
613 /* Fill in the remaining spaces. */
614 printf ("%-*s", width
- num_printed
, " ");
621 /* Returns a pointer to a static buffer containing a printable version of
622 the given section's name. Like print_symbol, except that it does not try
623 to print multibyte characters, it just interprets them as hex values. */
626 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
628 #define MAX_PRINT_SEC_NAME_LEN 128
629 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
630 const char * name
= SECTION_NAME (sec
);
631 char * buf
= sec_name_buf
;
633 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
635 while ((c
= * name
++) != 0)
646 else if (ISPRINT (c
))
653 static char hex
[17] = "0123456789ABCDEF";
658 * buf
++ = hex
[(c
& 0xf0) >> 4];
659 * buf
++ = hex
[c
& 0x0f];
673 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
675 if (ndx
>= filedata
->file_header
.e_shnum
)
676 return _("<corrupt>");
678 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
681 /* Return a pointer to section NAME, or NULL if no such section exists. */
683 static Elf_Internal_Shdr
*
684 find_section (Filedata
* filedata
, const char * name
)
688 if (filedata
->section_headers
== NULL
)
691 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
692 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
693 return filedata
->section_headers
+ i
;
698 /* Return a pointer to a section containing ADDR, or NULL if no such
701 static Elf_Internal_Shdr
*
702 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
706 if (filedata
->section_headers
== NULL
)
709 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
711 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
713 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
720 static Elf_Internal_Shdr
*
721 find_section_by_type (Filedata
* filedata
, unsigned int type
)
725 if (filedata
->section_headers
== NULL
)
728 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
730 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
732 if (sec
->sh_type
== type
)
739 /* Return a pointer to section NAME, or NULL if no such section exists,
740 restricted to the list of sections given in SET. */
742 static Elf_Internal_Shdr
*
743 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
747 if (filedata
->section_headers
== NULL
)
752 while ((i
= *set
++) > 0)
754 /* See PR 21156 for a reproducer. */
755 if (i
>= filedata
->file_header
.e_shnum
)
756 continue; /* FIXME: Should we issue an error message ? */
758 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
759 return filedata
->section_headers
+ i
;
763 return find_section (filedata
, name
);
766 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
767 This OS has so many departures from the ELF standard that we test it at
770 static inline bfd_boolean
771 is_ia64_vms (Filedata
* filedata
)
773 return filedata
->file_header
.e_machine
== EM_IA_64
774 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
777 /* Guess the relocation size commonly used by the specific machines. */
780 guess_is_rela (unsigned int e_machine
)
784 /* Targets that use REL relocations. */
801 /* Targets that use RELA relocations. */
805 case EM_ADAPTEVA_EPIPHANY
:
807 case EM_ALTERA_NIOS2
:
810 case EM_ARC_COMPACT2
:
831 case EM_LATTICEMICO32
:
840 case EM_CYGNUS_MN10200
:
842 case EM_CYGNUS_MN10300
:
878 case EM_MICROBLAZE_OLD
:
900 warn (_("Don't know about relocations on this machine architecture\n"));
905 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
906 Returns TRUE upon success, FALSE otherwise. If successful then a
907 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
908 and the number of relocs loaded is placed in *NRELASP. It is the caller's
909 responsibility to free the allocated buffer. */
912 slurp_rela_relocs (Filedata
* filedata
,
913 unsigned long rel_offset
,
914 unsigned long rel_size
,
915 Elf_Internal_Rela
** relasp
,
916 unsigned long * nrelasp
)
918 Elf_Internal_Rela
* relas
;
924 Elf32_External_Rela
* erelas
;
926 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
927 rel_size
, _("32-bit relocation data"));
931 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
933 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
934 sizeof (Elf_Internal_Rela
));
939 error (_("out of memory parsing relocs\n"));
943 for (i
= 0; i
< nrelas
; i
++)
945 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
946 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
947 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
954 Elf64_External_Rela
* erelas
;
956 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
957 rel_size
, _("64-bit relocation data"));
961 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
963 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
964 sizeof (Elf_Internal_Rela
));
969 error (_("out of memory parsing relocs\n"));
973 for (i
= 0; i
< nrelas
; i
++)
975 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
976 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
977 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
979 /* The #ifdef BFD64 below is to prevent a compile time
980 warning. We know that if we do not have a 64 bit data
981 type that we will never execute this code anyway. */
983 if (filedata
->file_header
.e_machine
== EM_MIPS
984 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
986 /* In little-endian objects, r_info isn't really a
987 64-bit little-endian value: it has a 32-bit
988 little-endian symbol index followed by four
989 individual byte fields. Reorder INFO
991 bfd_vma inf
= relas
[i
].r_info
;
992 inf
= (((inf
& 0xffffffff) << 32)
993 | ((inf
>> 56) & 0xff)
994 | ((inf
>> 40) & 0xff00)
995 | ((inf
>> 24) & 0xff0000)
996 | ((inf
>> 8) & 0xff000000));
997 relas
[i
].r_info
= inf
;
1010 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1011 Returns TRUE upon success, FALSE otherwise. If successful then a
1012 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1013 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1014 responsibility to free the allocated buffer. */
1017 slurp_rel_relocs (Filedata
* filedata
,
1018 unsigned long rel_offset
,
1019 unsigned long rel_size
,
1020 Elf_Internal_Rela
** relsp
,
1021 unsigned long * nrelsp
)
1023 Elf_Internal_Rela
* rels
;
1029 Elf32_External_Rel
* erels
;
1031 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1032 rel_size
, _("32-bit relocation data"));
1036 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1038 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1043 error (_("out of memory parsing relocs\n"));
1047 for (i
= 0; i
< nrels
; i
++)
1049 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1050 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1051 rels
[i
].r_addend
= 0;
1058 Elf64_External_Rel
* erels
;
1060 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1061 rel_size
, _("64-bit relocation data"));
1065 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1067 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1072 error (_("out of memory parsing relocs\n"));
1076 for (i
= 0; i
< nrels
; i
++)
1078 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1079 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1080 rels
[i
].r_addend
= 0;
1082 /* The #ifdef BFD64 below is to prevent a compile time
1083 warning. We know that if we do not have a 64 bit data
1084 type that we will never execute this code anyway. */
1086 if (filedata
->file_header
.e_machine
== EM_MIPS
1087 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1089 /* In little-endian objects, r_info isn't really a
1090 64-bit little-endian value: it has a 32-bit
1091 little-endian symbol index followed by four
1092 individual byte fields. Reorder INFO
1094 bfd_vma inf
= rels
[i
].r_info
;
1095 inf
= (((inf
& 0xffffffff) << 32)
1096 | ((inf
>> 56) & 0xff)
1097 | ((inf
>> 40) & 0xff00)
1098 | ((inf
>> 24) & 0xff0000)
1099 | ((inf
>> 8) & 0xff000000));
1100 rels
[i
].r_info
= inf
;
1113 /* Returns the reloc type extracted from the reloc info field. */
1116 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1119 return ELF32_R_TYPE (reloc_info
);
1121 switch (filedata
->file_header
.e_machine
)
1124 /* Note: We assume that reloc_info has already been adjusted for us. */
1125 return ELF64_MIPS_R_TYPE (reloc_info
);
1128 return ELF64_R_TYPE_ID (reloc_info
);
1131 return ELF64_R_TYPE (reloc_info
);
1135 /* Return the symbol index extracted from the reloc info field. */
1138 get_reloc_symindex (bfd_vma reloc_info
)
1140 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1143 static inline bfd_boolean
1144 uses_msp430x_relocs (Filedata
* filedata
)
1147 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1148 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1149 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1150 /* TI compiler uses ELFOSABI_NONE. */
1151 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1154 /* Display the contents of the relocation data found at the specified
1158 dump_relocations (Filedata
* filedata
,
1159 unsigned long rel_offset
,
1160 unsigned long rel_size
,
1161 Elf_Internal_Sym
* symtab
,
1162 unsigned long nsyms
,
1164 unsigned long strtablen
,
1166 bfd_boolean is_dynsym
)
1169 Elf_Internal_Rela
* rels
;
1170 bfd_boolean res
= TRUE
;
1172 if (is_rela
== UNKNOWN
)
1173 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1177 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1182 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1191 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1193 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1198 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1200 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1208 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1210 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1215 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1217 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1221 for (i
= 0; i
< rel_size
; i
++)
1226 bfd_vma symtab_index
;
1229 offset
= rels
[i
].r_offset
;
1230 inf
= rels
[i
].r_info
;
1232 type
= get_reloc_type (filedata
, inf
);
1233 symtab_index
= get_reloc_symindex (inf
);
1237 printf ("%8.8lx %8.8lx ",
1238 (unsigned long) offset
& 0xffffffff,
1239 (unsigned long) inf
& 0xffffffff);
1243 #if BFD_HOST_64BIT_LONG
1245 ? "%16.16lx %16.16lx "
1246 : "%12.12lx %12.12lx ",
1248 #elif BFD_HOST_64BIT_LONG_LONG
1251 ? "%16.16llx %16.16llx "
1252 : "%12.12llx %12.12llx ",
1256 ? "%16.16I64x %16.16I64x "
1257 : "%12.12I64x %12.12I64x ",
1262 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1263 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1264 _bfd_int64_high (offset
),
1265 _bfd_int64_low (offset
),
1266 _bfd_int64_high (inf
),
1267 _bfd_int64_low (inf
));
1271 switch (filedata
->file_header
.e_machine
)
1278 rtype
= elf_aarch64_reloc_type (type
);
1282 case EM_CYGNUS_M32R
:
1283 rtype
= elf_m32r_reloc_type (type
);
1288 rtype
= elf_i386_reloc_type (type
);
1293 rtype
= elf_m68hc11_reloc_type (type
);
1297 rtype
= elf_s12z_reloc_type (type
);
1301 rtype
= elf_m68k_reloc_type (type
);
1305 rtype
= elf_i960_reloc_type (type
);
1310 rtype
= elf_avr_reloc_type (type
);
1313 case EM_OLD_SPARCV9
:
1314 case EM_SPARC32PLUS
:
1317 rtype
= elf_sparc_reloc_type (type
);
1321 rtype
= elf_spu_reloc_type (type
);
1325 rtype
= v800_reloc_type (type
);
1328 case EM_CYGNUS_V850
:
1329 rtype
= v850_reloc_type (type
);
1333 case EM_CYGNUS_D10V
:
1334 rtype
= elf_d10v_reloc_type (type
);
1338 case EM_CYGNUS_D30V
:
1339 rtype
= elf_d30v_reloc_type (type
);
1343 rtype
= elf_dlx_reloc_type (type
);
1347 rtype
= elf_sh_reloc_type (type
);
1351 case EM_CYGNUS_MN10300
:
1352 rtype
= elf_mn10300_reloc_type (type
);
1356 case EM_CYGNUS_MN10200
:
1357 rtype
= elf_mn10200_reloc_type (type
);
1361 case EM_CYGNUS_FR30
:
1362 rtype
= elf_fr30_reloc_type (type
);
1366 rtype
= elf_frv_reloc_type (type
);
1370 rtype
= elf_csky_reloc_type (type
);
1374 rtype
= elf_ft32_reloc_type (type
);
1378 rtype
= elf_mcore_reloc_type (type
);
1382 rtype
= elf_mmix_reloc_type (type
);
1386 rtype
= elf_moxie_reloc_type (type
);
1390 if (uses_msp430x_relocs (filedata
))
1392 rtype
= elf_msp430x_reloc_type (type
);
1397 rtype
= elf_msp430_reloc_type (type
);
1401 rtype
= elf_nds32_reloc_type (type
);
1405 rtype
= elf_ppc_reloc_type (type
);
1409 rtype
= elf_ppc64_reloc_type (type
);
1413 case EM_MIPS_RS3_LE
:
1414 rtype
= elf_mips_reloc_type (type
);
1418 rtype
= elf_riscv_reloc_type (type
);
1422 rtype
= elf_alpha_reloc_type (type
);
1426 rtype
= elf_arm_reloc_type (type
);
1430 case EM_ARC_COMPACT
:
1431 case EM_ARC_COMPACT2
:
1432 rtype
= elf_arc_reloc_type (type
);
1436 rtype
= elf_hppa_reloc_type (type
);
1442 rtype
= elf_h8_reloc_type (type
);
1446 rtype
= elf_or1k_reloc_type (type
);
1451 rtype
= elf_pj_reloc_type (type
);
1454 rtype
= elf_ia64_reloc_type (type
);
1458 rtype
= elf_cris_reloc_type (type
);
1462 rtype
= elf_i860_reloc_type (type
);
1468 rtype
= elf_x86_64_reloc_type (type
);
1472 rtype
= i370_reloc_type (type
);
1477 rtype
= elf_s390_reloc_type (type
);
1481 rtype
= elf_score_reloc_type (type
);
1485 rtype
= elf_xstormy16_reloc_type (type
);
1489 rtype
= elf_crx_reloc_type (type
);
1493 rtype
= elf_vax_reloc_type (type
);
1497 rtype
= elf_visium_reloc_type (type
);
1501 rtype
= elf_bpf_reloc_type (type
);
1504 case EM_ADAPTEVA_EPIPHANY
:
1505 rtype
= elf_epiphany_reloc_type (type
);
1510 rtype
= elf_ip2k_reloc_type (type
);
1514 rtype
= elf_iq2000_reloc_type (type
);
1519 rtype
= elf_xtensa_reloc_type (type
);
1522 case EM_LATTICEMICO32
:
1523 rtype
= elf_lm32_reloc_type (type
);
1528 rtype
= elf_m32c_reloc_type (type
);
1532 rtype
= elf_mt_reloc_type (type
);
1536 rtype
= elf_bfin_reloc_type (type
);
1540 rtype
= elf_mep_reloc_type (type
);
1544 rtype
= elf_cr16_reloc_type (type
);
1548 case EM_MICROBLAZE_OLD
:
1549 rtype
= elf_microblaze_reloc_type (type
);
1553 rtype
= elf_rl78_reloc_type (type
);
1557 rtype
= elf_rx_reloc_type (type
);
1561 rtype
= elf_metag_reloc_type (type
);
1566 rtype
= elf_xc16x_reloc_type (type
);
1570 rtype
= elf_tic6x_reloc_type (type
);
1574 rtype
= elf_tilegx_reloc_type (type
);
1578 rtype
= elf_tilepro_reloc_type (type
);
1581 case EM_WEBASSEMBLY
:
1582 rtype
= elf_wasm32_reloc_type (type
);
1586 rtype
= elf_xgate_reloc_type (type
);
1589 case EM_ALTERA_NIOS2
:
1590 rtype
= elf_nios2_reloc_type (type
);
1594 rtype
= elf_pru_reloc_type (type
);
1598 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1599 rtype
= elf_nfp3200_reloc_type (type
);
1601 rtype
= elf_nfp_reloc_type (type
);
1605 rtype
= elf_z80_reloc_type (type
);
1610 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1612 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1614 if (filedata
->file_header
.e_machine
== EM_ALPHA
1616 && streq (rtype
, "R_ALPHA_LITUSE")
1619 switch (rels
[i
].r_addend
)
1621 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1622 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1623 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1624 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1625 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1626 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1627 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1628 default: rtype
= NULL
;
1632 printf (" (%s)", rtype
);
1636 printf (_("<unknown addend: %lx>"),
1637 (unsigned long) rels
[i
].r_addend
);
1641 else if (symtab_index
)
1643 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1645 error (_(" bad symbol index: %08lx in reloc\n"),
1646 (unsigned long) symtab_index
);
1651 Elf_Internal_Sym
* psym
;
1652 const char * version_string
;
1653 enum versioned_symbol_info sym_info
;
1654 unsigned short vna_other
;
1656 psym
= symtab
+ symtab_index
;
1659 = get_symbol_version_string (filedata
, is_dynsym
,
1668 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1672 unsigned int width
= is_32bit_elf
? 8 : 14;
1674 /* Relocations against GNU_IFUNC symbols do not use the value
1675 of the symbol as the address to relocate against. Instead
1676 they invoke the function named by the symbol and use its
1677 result as the address for relocation.
1679 To indicate this to the user, do not display the value of
1680 the symbol in the "Symbols's Value" field. Instead show
1681 its name followed by () as a hint that the symbol is
1685 || psym
->st_name
== 0
1686 || psym
->st_name
>= strtablen
)
1689 name
= strtab
+ psym
->st_name
;
1691 len
= print_symbol (width
, name
);
1693 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1695 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1699 print_vma (psym
->st_value
, LONG_HEX
);
1701 printf (is_32bit_elf
? " " : " ");
1704 if (psym
->st_name
== 0)
1706 const char * sec_name
= "<null>";
1709 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1711 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1712 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1713 else if (psym
->st_shndx
== SHN_ABS
)
1715 else if (psym
->st_shndx
== SHN_COMMON
)
1716 sec_name
= "COMMON";
1717 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1718 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1719 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1720 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1721 sec_name
= "SCOMMON";
1722 else if (filedata
->file_header
.e_machine
== EM_MIPS
1723 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1724 sec_name
= "SUNDEF";
1725 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1726 || filedata
->file_header
.e_machine
== EM_L1OM
1727 || filedata
->file_header
.e_machine
== EM_K1OM
)
1728 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1729 sec_name
= "LARGE_COMMON";
1730 else if (filedata
->file_header
.e_machine
== EM_IA_64
1731 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1732 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1733 sec_name
= "ANSI_COM";
1734 else if (is_ia64_vms (filedata
)
1735 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1736 sec_name
= "VMS_SYMVEC";
1739 sprintf (name_buf
, "<section 0x%x>",
1740 (unsigned int) psym
->st_shndx
);
1741 sec_name
= name_buf
;
1744 print_symbol (22, sec_name
);
1746 else if (strtab
== NULL
)
1747 printf (_("<string table index: %3ld>"), psym
->st_name
);
1748 else if (psym
->st_name
>= strtablen
)
1750 error (_("<corrupt string table index: %3ld>\n"),
1756 print_symbol (22, strtab
+ psym
->st_name
);
1758 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1764 bfd_vma off
= rels
[i
].r_addend
;
1766 if ((bfd_signed_vma
) off
< 0)
1767 printf (" - %" BFD_VMA_FMT
"x", - off
);
1769 printf (" + %" BFD_VMA_FMT
"x", off
);
1775 bfd_vma off
= rels
[i
].r_addend
;
1777 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1778 if ((bfd_signed_vma
) off
< 0)
1779 printf ("-%" BFD_VMA_FMT
"x", - off
);
1781 printf ("%" BFD_VMA_FMT
"x", off
);
1784 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1786 && streq (rtype
, "R_SPARC_OLO10"))
1787 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1792 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1794 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1795 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1796 const char * rtype2
= elf_mips_reloc_type (type2
);
1797 const char * rtype3
= elf_mips_reloc_type (type3
);
1799 printf (" Type2: ");
1802 printf (_("unrecognized: %-7lx"),
1803 (unsigned long) type2
& 0xffffffff);
1805 printf ("%-17.17s", rtype2
);
1807 printf ("\n Type3: ");
1810 printf (_("unrecognized: %-7lx"),
1811 (unsigned long) type3
& 0xffffffff);
1813 printf ("%-17.17s", rtype3
);
1826 get_aarch64_dynamic_type (unsigned long type
)
1830 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1831 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1832 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1839 get_mips_dynamic_type (unsigned long type
)
1843 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1844 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1845 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1846 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1847 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1848 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1849 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1850 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1851 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1852 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1853 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1854 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1855 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1856 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1857 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1858 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1859 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1860 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1861 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1862 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1863 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1864 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1865 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1866 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1867 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1868 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1869 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1870 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1871 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1872 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1873 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1874 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1875 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1876 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1877 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1878 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1879 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1880 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1881 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1882 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1883 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1884 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1885 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1886 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1887 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1888 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1889 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1896 get_sparc64_dynamic_type (unsigned long type
)
1900 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1907 get_ppc_dynamic_type (unsigned long type
)
1911 case DT_PPC_GOT
: return "PPC_GOT";
1912 case DT_PPC_OPT
: return "PPC_OPT";
1919 get_ppc64_dynamic_type (unsigned long type
)
1923 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1924 case DT_PPC64_OPD
: return "PPC64_OPD";
1925 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1926 case DT_PPC64_OPT
: return "PPC64_OPT";
1933 get_parisc_dynamic_type (unsigned long type
)
1937 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1938 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1939 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1940 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1941 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1942 case DT_HP_PREINIT
: return "HP_PREINIT";
1943 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1944 case DT_HP_NEEDED
: return "HP_NEEDED";
1945 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1946 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1947 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1948 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1949 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1950 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1951 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1952 case DT_HP_FILTERED
: return "HP_FILTERED";
1953 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1954 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1955 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1956 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1957 case DT_PLT
: return "PLT";
1958 case DT_PLT_SIZE
: return "PLT_SIZE";
1959 case DT_DLT
: return "DLT";
1960 case DT_DLT_SIZE
: return "DLT_SIZE";
1967 get_ia64_dynamic_type (unsigned long type
)
1971 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1972 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1973 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1974 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1975 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1976 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1977 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1978 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1979 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1980 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1981 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1982 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1983 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1984 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1985 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1986 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1987 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1988 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1989 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1990 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1991 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1992 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1993 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1994 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1995 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1996 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1997 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1998 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1999 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2000 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2001 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2008 get_solaris_section_type (unsigned long type
)
2012 case 0x6fffffee: return "SUNW_ancillary";
2013 case 0x6fffffef: return "SUNW_capchain";
2014 case 0x6ffffff0: return "SUNW_capinfo";
2015 case 0x6ffffff1: return "SUNW_symsort";
2016 case 0x6ffffff2: return "SUNW_tlssort";
2017 case 0x6ffffff3: return "SUNW_LDYNSYM";
2018 case 0x6ffffff4: return "SUNW_dof";
2019 case 0x6ffffff5: return "SUNW_cap";
2020 case 0x6ffffff6: return "SUNW_SIGNATURE";
2021 case 0x6ffffff7: return "SUNW_ANNOTATE";
2022 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2023 case 0x6ffffff9: return "SUNW_DEBUG";
2024 case 0x6ffffffa: return "SUNW_move";
2025 case 0x6ffffffb: return "SUNW_COMDAT";
2026 case 0x6ffffffc: return "SUNW_syminfo";
2027 case 0x6ffffffd: return "SUNW_verdef";
2028 case 0x6ffffffe: return "SUNW_verneed";
2029 case 0x6fffffff: return "SUNW_versym";
2030 case 0x70000000: return "SPARC_GOTDATA";
2031 default: return NULL
;
2036 get_alpha_dynamic_type (unsigned long type
)
2040 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2041 default: return NULL
;
2046 get_score_dynamic_type (unsigned long type
)
2050 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2051 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2052 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2053 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2054 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2055 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2056 default: return NULL
;
2061 get_tic6x_dynamic_type (unsigned long type
)
2065 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2066 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2067 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2068 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2069 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2070 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2071 default: return NULL
;
2076 get_nios2_dynamic_type (unsigned long type
)
2080 case DT_NIOS2_GP
: return "NIOS2_GP";
2081 default: return NULL
;
2086 get_solaris_dynamic_type (unsigned long type
)
2090 case 0x6000000d: return "SUNW_AUXILIARY";
2091 case 0x6000000e: return "SUNW_RTLDINF";
2092 case 0x6000000f: return "SUNW_FILTER";
2093 case 0x60000010: return "SUNW_CAP";
2094 case 0x60000011: return "SUNW_SYMTAB";
2095 case 0x60000012: return "SUNW_SYMSZ";
2096 case 0x60000013: return "SUNW_SORTENT";
2097 case 0x60000014: return "SUNW_SYMSORT";
2098 case 0x60000015: return "SUNW_SYMSORTSZ";
2099 case 0x60000016: return "SUNW_TLSSORT";
2100 case 0x60000017: return "SUNW_TLSSORTSZ";
2101 case 0x60000018: return "SUNW_CAPINFO";
2102 case 0x60000019: return "SUNW_STRPAD";
2103 case 0x6000001a: return "SUNW_CAPCHAIN";
2104 case 0x6000001b: return "SUNW_LDMACH";
2105 case 0x6000001d: return "SUNW_CAPCHAINENT";
2106 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2107 case 0x60000021: return "SUNW_PARENT";
2108 case 0x60000023: return "SUNW_ASLR";
2109 case 0x60000025: return "SUNW_RELAX";
2110 case 0x60000029: return "SUNW_NXHEAP";
2111 case 0x6000002b: return "SUNW_NXSTACK";
2113 case 0x70000001: return "SPARC_REGISTER";
2114 case 0x7ffffffd: return "AUXILIARY";
2115 case 0x7ffffffe: return "USED";
2116 case 0x7fffffff: return "FILTER";
2118 default: return NULL
;
2123 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2125 static char buff
[64];
2129 case DT_NULL
: return "NULL";
2130 case DT_NEEDED
: return "NEEDED";
2131 case DT_PLTRELSZ
: return "PLTRELSZ";
2132 case DT_PLTGOT
: return "PLTGOT";
2133 case DT_HASH
: return "HASH";
2134 case DT_STRTAB
: return "STRTAB";
2135 case DT_SYMTAB
: return "SYMTAB";
2136 case DT_RELA
: return "RELA";
2137 case DT_RELASZ
: return "RELASZ";
2138 case DT_RELAENT
: return "RELAENT";
2139 case DT_STRSZ
: return "STRSZ";
2140 case DT_SYMENT
: return "SYMENT";
2141 case DT_INIT
: return "INIT";
2142 case DT_FINI
: return "FINI";
2143 case DT_SONAME
: return "SONAME";
2144 case DT_RPATH
: return "RPATH";
2145 case DT_SYMBOLIC
: return "SYMBOLIC";
2146 case DT_REL
: return "REL";
2147 case DT_RELSZ
: return "RELSZ";
2148 case DT_RELENT
: return "RELENT";
2149 case DT_PLTREL
: return "PLTREL";
2150 case DT_DEBUG
: return "DEBUG";
2151 case DT_TEXTREL
: return "TEXTREL";
2152 case DT_JMPREL
: return "JMPREL";
2153 case DT_BIND_NOW
: return "BIND_NOW";
2154 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2155 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2156 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2157 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2158 case DT_RUNPATH
: return "RUNPATH";
2159 case DT_FLAGS
: return "FLAGS";
2161 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2162 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2163 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2165 case DT_CHECKSUM
: return "CHECKSUM";
2166 case DT_PLTPADSZ
: return "PLTPADSZ";
2167 case DT_MOVEENT
: return "MOVEENT";
2168 case DT_MOVESZ
: return "MOVESZ";
2169 case DT_FEATURE
: return "FEATURE";
2170 case DT_POSFLAG_1
: return "POSFLAG_1";
2171 case DT_SYMINSZ
: return "SYMINSZ";
2172 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2174 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2175 case DT_CONFIG
: return "CONFIG";
2176 case DT_DEPAUDIT
: return "DEPAUDIT";
2177 case DT_AUDIT
: return "AUDIT";
2178 case DT_PLTPAD
: return "PLTPAD";
2179 case DT_MOVETAB
: return "MOVETAB";
2180 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2182 case DT_VERSYM
: return "VERSYM";
2184 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2185 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2186 case DT_RELACOUNT
: return "RELACOUNT";
2187 case DT_RELCOUNT
: return "RELCOUNT";
2188 case DT_FLAGS_1
: return "FLAGS_1";
2189 case DT_VERDEF
: return "VERDEF";
2190 case DT_VERDEFNUM
: return "VERDEFNUM";
2191 case DT_VERNEED
: return "VERNEED";
2192 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2194 case DT_AUXILIARY
: return "AUXILIARY";
2195 case DT_USED
: return "USED";
2196 case DT_FILTER
: return "FILTER";
2198 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2199 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2200 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2201 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2202 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2203 case DT_GNU_HASH
: return "GNU_HASH";
2206 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2208 const char * result
;
2210 switch (filedata
->file_header
.e_machine
)
2213 result
= get_aarch64_dynamic_type (type
);
2216 case EM_MIPS_RS3_LE
:
2217 result
= get_mips_dynamic_type (type
);
2220 result
= get_sparc64_dynamic_type (type
);
2223 result
= get_ppc_dynamic_type (type
);
2226 result
= get_ppc64_dynamic_type (type
);
2229 result
= get_ia64_dynamic_type (type
);
2232 result
= get_alpha_dynamic_type (type
);
2235 result
= get_score_dynamic_type (type
);
2238 result
= get_tic6x_dynamic_type (type
);
2240 case EM_ALTERA_NIOS2
:
2241 result
= get_nios2_dynamic_type (type
);
2244 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2245 result
= get_solaris_dynamic_type (type
);
2254 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2256 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2257 || (filedata
->file_header
.e_machine
== EM_PARISC
2258 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2260 const char * result
;
2262 switch (filedata
->file_header
.e_machine
)
2265 result
= get_parisc_dynamic_type (type
);
2268 result
= get_ia64_dynamic_type (type
);
2271 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2272 result
= get_solaris_dynamic_type (type
);
2281 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2285 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2292 get_file_type (unsigned e_type
)
2294 static char buff
[64];
2298 case ET_NONE
: return _("NONE (None)");
2299 case ET_REL
: return _("REL (Relocatable file)");
2300 case ET_EXEC
: return _("EXEC (Executable file)");
2301 case ET_DYN
: return _("DYN (Shared object file)");
2302 case ET_CORE
: return _("CORE (Core file)");
2305 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2306 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2307 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2308 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2310 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2316 get_machine_name (unsigned e_machine
)
2318 static char buff
[64]; /* XXX */
2322 /* Please keep this switch table sorted by increasing EM_ value. */
2324 case EM_NONE
: return _("None");
2325 case EM_M32
: return "WE32100";
2326 case EM_SPARC
: return "Sparc";
2327 case EM_386
: return "Intel 80386";
2328 case EM_68K
: return "MC68000";
2329 case EM_88K
: return "MC88000";
2330 case EM_IAMCU
: return "Intel MCU";
2331 case EM_860
: return "Intel 80860";
2332 case EM_MIPS
: return "MIPS R3000";
2333 case EM_S370
: return "IBM System/370";
2335 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2336 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2337 case EM_PARISC
: return "HPPA";
2338 case EM_VPP550
: return "Fujitsu VPP500";
2339 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2340 case EM_960
: return "Intel 80960";
2341 case EM_PPC
: return "PowerPC";
2343 case EM_PPC64
: return "PowerPC64";
2345 case EM_S390
: return "IBM S/390";
2346 case EM_SPU
: return "SPU";
2348 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2349 case EM_FR20
: return "Fujitsu FR20";
2350 case EM_RH32
: return "TRW RH32";
2351 case EM_MCORE
: return "MCORE";
2353 case EM_ARM
: return "ARM";
2354 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2355 case EM_SH
: return "Renesas / SuperH SH";
2356 case EM_SPARCV9
: return "Sparc v9";
2357 case EM_TRICORE
: return "Siemens Tricore";
2358 case EM_ARC
: return "ARC";
2359 case EM_H8_300
: return "Renesas H8/300";
2360 case EM_H8_300H
: return "Renesas H8/300H";
2361 case EM_H8S
: return "Renesas H8S";
2362 case EM_H8_500
: return "Renesas H8/500";
2364 case EM_IA_64
: return "Intel IA-64";
2365 case EM_MIPS_X
: return "Stanford MIPS-X";
2366 case EM_COLDFIRE
: return "Motorola Coldfire";
2367 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2368 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2369 case EM_PCP
: return "Siemens PCP";
2370 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2371 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2372 case EM_STARCORE
: return "Motorola Star*Core processor";
2373 case EM_ME16
: return "Toyota ME16 processor";
2375 case EM_ST100
: return "STMicroelectronics ST100 processor";
2376 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2377 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2378 case EM_PDSP
: return "Sony DSP processor";
2379 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2380 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2381 case EM_FX66
: return "Siemens FX66 microcontroller";
2382 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2383 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2384 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2386 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2387 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2388 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2389 case EM_SVX
: return "Silicon Graphics SVx";
2390 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2391 case EM_VAX
: return "Digital VAX";
2392 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2393 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2394 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2395 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2397 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2398 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2399 case EM_PRISM
: return "Vitesse Prism";
2401 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2402 case EM_CYGNUS_FR30
:
2403 case EM_FR30
: return "Fujitsu FR30";
2404 case EM_CYGNUS_D10V
:
2405 case EM_D10V
: return "d10v";
2406 case EM_CYGNUS_D30V
:
2407 case EM_D30V
: return "d30v";
2408 case EM_CYGNUS_V850
:
2409 case EM_V850
: return "Renesas V850";
2410 case EM_CYGNUS_M32R
:
2411 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2412 case EM_CYGNUS_MN10300
:
2413 case EM_MN10300
: return "mn10300";
2415 case EM_CYGNUS_MN10200
:
2416 case EM_MN10200
: return "mn10200";
2417 case EM_PJ
: return "picoJava";
2418 case EM_OR1K
: return "OpenRISC 1000";
2419 case EM_ARC_COMPACT
: return "ARCompact";
2421 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2422 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2423 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2424 case EM_NS32K
: return "National Semiconductor 32000 series";
2425 case EM_TPC
: return "Tenor Network TPC processor";
2426 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2428 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2430 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2431 case EM_MAX
: return "MAX Processor";
2432 case EM_CR
: return "National Semiconductor CompactRISC";
2433 case EM_F2MC16
: return "Fujitsu F2MC16";
2434 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2435 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2436 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2437 case EM_SEP
: return "Sharp embedded microprocessor";
2438 case EM_ARCA
: return "Arca RISC microprocessor";
2440 case EM_UNICORE
: return "Unicore";
2441 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2442 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2443 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2444 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2445 case EM_XGATE
: return "Motorola XGATE embedded processor";
2447 case EM_XC16X
: return "Infineon Technologies xc16x";
2448 case EM_M16C
: return "Renesas M16C series microprocessors";
2449 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2450 case EM_CE
: return "Freescale Communication Engine RISC core";
2452 case EM_M32C
: return "Renesas M32c";
2454 case EM_TSK3000
: return "Altium TSK3000 core";
2455 case EM_RS08
: return "Freescale RS08 embedded processor";
2456 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2457 case EM_SCORE
: return "SUNPLUS S+Core";
2458 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2459 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2460 case EM_LATTICEMICO32
: return "Lattice Mico32";
2461 case EM_SE_C17
: return "Seiko Epson C17 family";
2463 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2464 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2465 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2466 case EM_TI_PRU
: return "TI PRU I/O processor";
2468 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2469 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2470 case EM_R32C
: return "Renesas R32C series microprocessors";
2471 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2472 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2473 case EM_8051
: return "Intel 8051 and variants";
2474 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2475 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2476 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2477 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2479 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2480 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2481 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2482 case EM_RX
: return "Renesas RX";
2483 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2484 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2485 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2488 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2489 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2490 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2492 case EM_L1OM
: return "Intel L1OM";
2493 case EM_K1OM
: return "Intel K1OM";
2494 case EM_INTEL182
: return "Intel (reserved)";
2495 case EM_AARCH64
: return "AArch64";
2496 case EM_ARM184
: return "ARM (reserved)";
2497 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2498 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2499 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2500 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2502 case EM_CUDA
: return "NVIDIA CUDA architecture";
2503 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2504 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2505 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2506 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2507 case EM_ARC_COMPACT2
: return "ARCv2";
2508 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2509 case EM_RL78
: return "Renesas RL78";
2510 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2511 case EM_78K0R
: return "Renesas 78K0R";
2513 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2514 case EM_BA1
: return "Beyond BA1 CPU architecture";
2515 case EM_BA2
: return "Beyond BA2 CPU architecture";
2516 case EM_XCORE
: return "XMOS xCORE processor family";
2517 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2519 case EM_KM32
: return "KM211 KM32 32-bit processor";
2520 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2521 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2522 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2523 case EM_KVARC
: return "KM211 KVARC processor";
2524 case EM_CDP
: return "Paneve CDP architecture family";
2525 case EM_COGE
: return "Cognitive Smart Memory Processor";
2526 case EM_COOL
: return "Bluechip Systems CoolEngine";
2527 case EM_NORC
: return "Nanoradio Optimized RISC";
2528 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2530 case EM_Z80
: return "Zilog Z80";
2531 case EM_VISIUM
: return "CDS VISIUMcore processor";
2532 case EM_FT32
: return "FTDI Chip FT32";
2533 case EM_MOXIE
: return "Moxie";
2534 case EM_AMDGPU
: return "AMD GPU";
2535 case EM_RISCV
: return "RISC-V";
2536 case EM_LANAI
: return "Lanai 32-bit processor";
2537 case EM_BPF
: return "Linux BPF";
2538 case EM_NFP
: return "Netronome Flow Processor";
2540 /* Large numbers... */
2541 case EM_MT
: return "Morpho Techologies MT processor";
2542 case EM_ALPHA
: return "Alpha";
2543 case EM_WEBASSEMBLY
: return "Web Assembly";
2544 case EM_DLX
: return "OpenDLX";
2545 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2546 case EM_IQ2000
: return "Vitesse IQ2000";
2548 case EM_NIOS32
: return "Altera Nios";
2549 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2550 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2551 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2552 case EM_S12Z
: return "Freescale S12Z";
2553 case EM_CSKY
: return "C-SKY";
2556 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2562 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2564 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2565 other compilers don't a specific architecture type in the e_flags, and
2566 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2567 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2570 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2571 but also sets a specific architecture type in the e_flags field.
2573 However, when decoding the flags we don't worry if we see an
2574 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2575 ARCEM architecture type. */
2577 switch (e_flags
& EF_ARC_MACH_MSK
)
2579 /* We only expect these to occur for EM_ARC_COMPACT2. */
2580 case EF_ARC_CPU_ARCV2EM
:
2581 strcat (buf
, ", ARC EM");
2583 case EF_ARC_CPU_ARCV2HS
:
2584 strcat (buf
, ", ARC HS");
2587 /* We only expect these to occur for EM_ARC_COMPACT. */
2588 case E_ARC_MACH_ARC600
:
2589 strcat (buf
, ", ARC600");
2591 case E_ARC_MACH_ARC601
:
2592 strcat (buf
, ", ARC601");
2594 case E_ARC_MACH_ARC700
:
2595 strcat (buf
, ", ARC700");
2598 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2599 new ELF with new architecture being read by an old version of
2600 readelf, or (c) An ELF built with non-GNU compiler that does not
2601 set the architecture in the e_flags. */
2603 if (e_machine
== EM_ARC_COMPACT
)
2604 strcat (buf
, ", Unknown ARCompact");
2606 strcat (buf
, ", Unknown ARC");
2610 switch (e_flags
& EF_ARC_OSABI_MSK
)
2612 case E_ARC_OSABI_ORIG
:
2613 strcat (buf
, ", (ABI:legacy)");
2615 case E_ARC_OSABI_V2
:
2616 strcat (buf
, ", (ABI:v2)");
2618 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2619 case E_ARC_OSABI_V3
:
2620 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2622 case E_ARC_OSABI_V4
:
2623 strcat (buf
, ", v4 ABI");
2626 strcat (buf
, ", unrecognised ARC OSABI flag");
2632 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2635 bfd_boolean unknown
= FALSE
;
2637 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2638 e_flags
&= ~ EF_ARM_EABIMASK
;
2640 /* Handle "generic" ARM flags. */
2641 if (e_flags
& EF_ARM_RELEXEC
)
2643 strcat (buf
, ", relocatable executable");
2644 e_flags
&= ~ EF_ARM_RELEXEC
;
2647 if (e_flags
& EF_ARM_PIC
)
2649 strcat (buf
, ", position independent");
2650 e_flags
&= ~ EF_ARM_PIC
;
2653 /* Now handle EABI specific flags. */
2657 strcat (buf
, ", <unrecognized EABI>");
2662 case EF_ARM_EABI_VER1
:
2663 strcat (buf
, ", Version1 EABI");
2668 /* Process flags one bit at a time. */
2669 flag
= e_flags
& - e_flags
;
2674 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2675 strcat (buf
, ", sorted symbol tables");
2685 case EF_ARM_EABI_VER2
:
2686 strcat (buf
, ", Version2 EABI");
2691 /* Process flags one bit at a time. */
2692 flag
= e_flags
& - e_flags
;
2697 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2698 strcat (buf
, ", sorted symbol tables");
2701 case EF_ARM_DYNSYMSUSESEGIDX
:
2702 strcat (buf
, ", dynamic symbols use segment index");
2705 case EF_ARM_MAPSYMSFIRST
:
2706 strcat (buf
, ", mapping symbols precede others");
2716 case EF_ARM_EABI_VER3
:
2717 strcat (buf
, ", Version3 EABI");
2720 case EF_ARM_EABI_VER4
:
2721 strcat (buf
, ", Version4 EABI");
2726 /* Process flags one bit at a time. */
2727 flag
= e_flags
& - e_flags
;
2733 strcat (buf
, ", BE8");
2737 strcat (buf
, ", LE8");
2747 case EF_ARM_EABI_VER5
:
2748 strcat (buf
, ", Version5 EABI");
2753 /* Process flags one bit at a time. */
2754 flag
= e_flags
& - e_flags
;
2760 strcat (buf
, ", BE8");
2764 strcat (buf
, ", LE8");
2767 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2768 strcat (buf
, ", soft-float ABI");
2771 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2772 strcat (buf
, ", hard-float ABI");
2782 case EF_ARM_EABI_UNKNOWN
:
2783 strcat (buf
, ", GNU EABI");
2788 /* Process flags one bit at a time. */
2789 flag
= e_flags
& - e_flags
;
2794 case EF_ARM_INTERWORK
:
2795 strcat (buf
, ", interworking enabled");
2798 case EF_ARM_APCS_26
:
2799 strcat (buf
, ", uses APCS/26");
2802 case EF_ARM_APCS_FLOAT
:
2803 strcat (buf
, ", uses APCS/float");
2807 strcat (buf
, ", position independent");
2811 strcat (buf
, ", 8 bit structure alignment");
2814 case EF_ARM_NEW_ABI
:
2815 strcat (buf
, ", uses new ABI");
2818 case EF_ARM_OLD_ABI
:
2819 strcat (buf
, ", uses old ABI");
2822 case EF_ARM_SOFT_FLOAT
:
2823 strcat (buf
, ", software FP");
2826 case EF_ARM_VFP_FLOAT
:
2827 strcat (buf
, ", VFP");
2830 case EF_ARM_MAVERICK_FLOAT
:
2831 strcat (buf
, ", Maverick FP");
2842 strcat (buf
,_(", <unknown>"));
2846 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2848 --size
; /* Leave space for null terminator. */
2850 switch (e_flags
& EF_AVR_MACH
)
2852 case E_AVR_MACH_AVR1
:
2853 strncat (buf
, ", avr:1", size
);
2855 case E_AVR_MACH_AVR2
:
2856 strncat (buf
, ", avr:2", size
);
2858 case E_AVR_MACH_AVR25
:
2859 strncat (buf
, ", avr:25", size
);
2861 case E_AVR_MACH_AVR3
:
2862 strncat (buf
, ", avr:3", size
);
2864 case E_AVR_MACH_AVR31
:
2865 strncat (buf
, ", avr:31", size
);
2867 case E_AVR_MACH_AVR35
:
2868 strncat (buf
, ", avr:35", size
);
2870 case E_AVR_MACH_AVR4
:
2871 strncat (buf
, ", avr:4", size
);
2873 case E_AVR_MACH_AVR5
:
2874 strncat (buf
, ", avr:5", size
);
2876 case E_AVR_MACH_AVR51
:
2877 strncat (buf
, ", avr:51", size
);
2879 case E_AVR_MACH_AVR6
:
2880 strncat (buf
, ", avr:6", size
);
2882 case E_AVR_MACH_AVRTINY
:
2883 strncat (buf
, ", avr:100", size
);
2885 case E_AVR_MACH_XMEGA1
:
2886 strncat (buf
, ", avr:101", size
);
2888 case E_AVR_MACH_XMEGA2
:
2889 strncat (buf
, ", avr:102", size
);
2891 case E_AVR_MACH_XMEGA3
:
2892 strncat (buf
, ", avr:103", size
);
2894 case E_AVR_MACH_XMEGA4
:
2895 strncat (buf
, ", avr:104", size
);
2897 case E_AVR_MACH_XMEGA5
:
2898 strncat (buf
, ", avr:105", size
);
2900 case E_AVR_MACH_XMEGA6
:
2901 strncat (buf
, ", avr:106", size
);
2903 case E_AVR_MACH_XMEGA7
:
2904 strncat (buf
, ", avr:107", size
);
2907 strncat (buf
, ", avr:<unknown>", size
);
2911 size
-= strlen (buf
);
2912 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2913 strncat (buf
, ", link-relax", size
);
2917 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2923 bfd_boolean has_fpu
= FALSE
;
2926 static const char *ABI_STRINGS
[] =
2928 "ABI v0", /* use r5 as return register; only used in N1213HC */
2929 "ABI v1", /* use r0 as return register */
2930 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2931 "ABI v2fp", /* for FPU */
2935 static const char *VER_STRINGS
[] =
2937 "Andes ELF V1.3 or older",
2941 static const char *ARCH_STRINGS
[] =
2950 abi
= EF_NDS_ABI
& e_flags
;
2951 arch
= EF_NDS_ARCH
& e_flags
;
2952 config
= EF_NDS_INST
& e_flags
;
2953 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2955 memset (buf
, 0, size
);
2962 case E_NDS_ABI_V2FP
:
2963 case E_NDS_ABI_AABI
:
2964 case E_NDS_ABI_V2FP_PLUS
:
2965 /* In case there are holes in the array. */
2966 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2970 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2976 case E_NDS32_ELF_VER_1_2
:
2977 case E_NDS32_ELF_VER_1_3
:
2978 case E_NDS32_ELF_VER_1_4
:
2979 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2983 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2987 if (E_NDS_ABI_V0
== abi
)
2989 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2990 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2991 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2992 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2998 case E_NDS_ARCH_STAR_V1_0
:
2999 case E_NDS_ARCH_STAR_V2_0
:
3000 case E_NDS_ARCH_STAR_V3_0
:
3001 case E_NDS_ARCH_STAR_V3_M
:
3002 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3006 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3007 /* ARCH version determines how the e_flags are interpreted.
3008 If it is unknown, we cannot proceed. */
3012 /* Newer ABI; Now handle architecture specific flags. */
3013 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3015 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3016 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3018 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3019 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3021 if (config
& E_NDS32_HAS_DIV_INST
)
3022 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3024 if (config
& E_NDS32_HAS_16BIT_INST
)
3025 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3029 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3031 if (version
<= E_NDS32_ELF_VER_1_3
)
3032 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3034 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3037 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3038 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3040 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3041 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3043 if (config
& E_NDS32_HAS_16BIT_INST
)
3045 if (version
<= E_NDS32_ELF_VER_1_3
)
3046 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3048 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3052 if (config
& E_NDS32_HAS_EXT_INST
)
3053 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3055 if (config
& E_NDS32_HAS_EXT2_INST
)
3056 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3058 if (config
& E_NDS32_HAS_FPU_INST
)
3061 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3064 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3067 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3070 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3073 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3078 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3080 case E_NDS32_FPU_REG_8SP_4DP
:
3081 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3083 case E_NDS32_FPU_REG_16SP_8DP
:
3084 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3086 case E_NDS32_FPU_REG_32SP_16DP
:
3087 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3089 case E_NDS32_FPU_REG_32SP_32DP
:
3090 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3095 if (config
& E_NDS32_HAS_AUDIO_INST
)
3096 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3098 if (config
& E_NDS32_HAS_STRING_INST
)
3099 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3101 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3102 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3104 if (config
& E_NDS32_HAS_VIDEO_INST
)
3106 if (version
<= E_NDS32_ELF_VER_1_3
)
3107 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3109 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3112 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3113 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3115 if (config
& E_NDS32_HAS_L2C_INST
)
3116 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3120 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3122 static char buf
[1024];
3133 case EM_ARC_COMPACT2
:
3134 case EM_ARC_COMPACT
:
3135 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3139 decode_ARM_machine_flags (e_flags
, buf
);
3143 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3147 if (e_flags
& EF_BFIN_PIC
)
3148 strcat (buf
, ", PIC");
3150 if (e_flags
& EF_BFIN_FDPIC
)
3151 strcat (buf
, ", FDPIC");
3153 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3154 strcat (buf
, ", code in L1");
3156 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3157 strcat (buf
, ", data in L1");
3162 switch (e_flags
& EF_FRV_CPU_MASK
)
3164 case EF_FRV_CPU_GENERIC
:
3168 strcat (buf
, ", fr???");
3171 case EF_FRV_CPU_FR300
:
3172 strcat (buf
, ", fr300");
3175 case EF_FRV_CPU_FR400
:
3176 strcat (buf
, ", fr400");
3178 case EF_FRV_CPU_FR405
:
3179 strcat (buf
, ", fr405");
3182 case EF_FRV_CPU_FR450
:
3183 strcat (buf
, ", fr450");
3186 case EF_FRV_CPU_FR500
:
3187 strcat (buf
, ", fr500");
3189 case EF_FRV_CPU_FR550
:
3190 strcat (buf
, ", fr550");
3193 case EF_FRV_CPU_SIMPLE
:
3194 strcat (buf
, ", simple");
3196 case EF_FRV_CPU_TOMCAT
:
3197 strcat (buf
, ", tomcat");
3203 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3204 strcat (buf
, ", m68000");
3205 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3206 strcat (buf
, ", cpu32");
3207 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3208 strcat (buf
, ", fido_a");
3211 char const * isa
= _("unknown");
3212 char const * mac
= _("unknown mac");
3213 char const * additional
= NULL
;
3215 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3217 case EF_M68K_CF_ISA_A_NODIV
:
3219 additional
= ", nodiv";
3221 case EF_M68K_CF_ISA_A
:
3224 case EF_M68K_CF_ISA_A_PLUS
:
3227 case EF_M68K_CF_ISA_B_NOUSP
:
3229 additional
= ", nousp";
3231 case EF_M68K_CF_ISA_B
:
3234 case EF_M68K_CF_ISA_C
:
3237 case EF_M68K_CF_ISA_C_NODIV
:
3239 additional
= ", nodiv";
3242 strcat (buf
, ", cf, isa ");
3245 strcat (buf
, additional
);
3246 if (e_flags
& EF_M68K_CF_FLOAT
)
3247 strcat (buf
, ", float");
3248 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3253 case EF_M68K_CF_MAC
:
3256 case EF_M68K_CF_EMAC
:
3259 case EF_M68K_CF_EMAC_B
:
3272 switch (e_flags
& EF_MEP_CPU_MASK
)
3274 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3275 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3276 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3277 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3278 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3279 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3280 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3283 switch (e_flags
& EF_MEP_COP_MASK
)
3285 case EF_MEP_COP_NONE
: break;
3286 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3287 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3288 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3289 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3290 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3293 if (e_flags
& EF_MEP_LIBRARY
)
3294 strcat (buf
, ", Built for Library");
3296 if (e_flags
& EF_MEP_INDEX_MASK
)
3297 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3298 e_flags
& EF_MEP_INDEX_MASK
);
3300 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3301 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3302 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3306 if (e_flags
& EF_PPC_EMB
)
3307 strcat (buf
, ", emb");
3309 if (e_flags
& EF_PPC_RELOCATABLE
)
3310 strcat (buf
, _(", relocatable"));
3312 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3313 strcat (buf
, _(", relocatable-lib"));
3317 if (e_flags
& EF_PPC64_ABI
)
3319 char abi
[] = ", abiv0";
3321 abi
[6] += e_flags
& EF_PPC64_ABI
;
3327 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3328 strcat (buf
, ", RH850 ABI");
3330 if (e_flags
& EF_V800_850E3
)
3331 strcat (buf
, ", V3 architecture");
3333 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3334 strcat (buf
, ", FPU not used");
3336 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3337 strcat (buf
, ", regmode: COMMON");
3339 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3340 strcat (buf
, ", r4 not used");
3342 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3343 strcat (buf
, ", r30 not used");
3345 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3346 strcat (buf
, ", r5 not used");
3348 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3349 strcat (buf
, ", r2 not used");
3351 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3353 switch (e_flags
& - e_flags
)
3355 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3356 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3357 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3358 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3359 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3360 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3361 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3362 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3363 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3364 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3365 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3366 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3373 case EM_CYGNUS_V850
:
3374 switch (e_flags
& EF_V850_ARCH
)
3376 case E_V850E3V5_ARCH
:
3377 strcat (buf
, ", v850e3v5");
3379 case E_V850E2V3_ARCH
:
3380 strcat (buf
, ", v850e2v3");
3383 strcat (buf
, ", v850e2");
3386 strcat (buf
, ", v850e1");
3389 strcat (buf
, ", v850e");
3392 strcat (buf
, ", v850");
3395 strcat (buf
, _(", unknown v850 architecture variant"));
3401 case EM_CYGNUS_M32R
:
3402 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3403 strcat (buf
, ", m32r");
3407 case EM_MIPS_RS3_LE
:
3408 if (e_flags
& EF_MIPS_NOREORDER
)
3409 strcat (buf
, ", noreorder");
3411 if (e_flags
& EF_MIPS_PIC
)
3412 strcat (buf
, ", pic");
3414 if (e_flags
& EF_MIPS_CPIC
)
3415 strcat (buf
, ", cpic");
3417 if (e_flags
& EF_MIPS_UCODE
)
3418 strcat (buf
, ", ugen_reserved");
3420 if (e_flags
& EF_MIPS_ABI2
)
3421 strcat (buf
, ", abi2");
3423 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3424 strcat (buf
, ", odk first");
3426 if (e_flags
& EF_MIPS_32BITMODE
)
3427 strcat (buf
, ", 32bitmode");
3429 if (e_flags
& EF_MIPS_NAN2008
)
3430 strcat (buf
, ", nan2008");
3432 if (e_flags
& EF_MIPS_FP64
)
3433 strcat (buf
, ", fp64");
3435 switch ((e_flags
& EF_MIPS_MACH
))
3437 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3438 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3439 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3440 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3441 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3442 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3443 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3444 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3445 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3446 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3447 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3448 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3449 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3450 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3451 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3452 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3453 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3454 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3455 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3456 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3457 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3459 /* We simply ignore the field in this case to avoid confusion:
3460 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3463 default: strcat (buf
, _(", unknown CPU")); break;
3466 switch ((e_flags
& EF_MIPS_ABI
))
3468 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3469 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3470 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3471 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3473 /* We simply ignore the field in this case to avoid confusion:
3474 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3475 This means it is likely to be an o32 file, but not for
3478 default: strcat (buf
, _(", unknown ABI")); break;
3481 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3482 strcat (buf
, ", mdmx");
3484 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3485 strcat (buf
, ", mips16");
3487 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3488 strcat (buf
, ", micromips");
3490 switch ((e_flags
& EF_MIPS_ARCH
))
3492 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3493 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3494 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3495 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3496 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3497 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3498 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3499 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3500 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3501 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3502 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3503 default: strcat (buf
, _(", unknown ISA")); break;
3508 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3512 switch (EF_NFP_MACH (e_flags
))
3514 case E_NFP_MACH_3200
:
3515 strcat (buf
, ", NFP-32xx");
3517 case E_NFP_MACH_6000
:
3518 strcat (buf
, ", NFP-6xxx");
3524 if (e_flags
& EF_RISCV_RVC
)
3525 strcat (buf
, ", RVC");
3527 if (e_flags
& EF_RISCV_RVE
)
3528 strcat (buf
, ", RVE");
3530 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3532 case EF_RISCV_FLOAT_ABI_SOFT
:
3533 strcat (buf
, ", soft-float ABI");
3536 case EF_RISCV_FLOAT_ABI_SINGLE
:
3537 strcat (buf
, ", single-float ABI");
3540 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3541 strcat (buf
, ", double-float ABI");
3544 case EF_RISCV_FLOAT_ABI_QUAD
:
3545 strcat (buf
, ", quad-float ABI");
3551 switch ((e_flags
& EF_SH_MACH_MASK
))
3553 case EF_SH1
: strcat (buf
, ", sh1"); break;
3554 case EF_SH2
: strcat (buf
, ", sh2"); break;
3555 case EF_SH3
: strcat (buf
, ", sh3"); break;
3556 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3557 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3558 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3559 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3560 case EF_SH4
: strcat (buf
, ", sh4"); break;
3561 case EF_SH5
: strcat (buf
, ", sh5"); break;
3562 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3563 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3564 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3565 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3566 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3567 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3568 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3569 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3570 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3571 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3572 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3573 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3574 default: strcat (buf
, _(", unknown ISA")); break;
3577 if (e_flags
& EF_SH_PIC
)
3578 strcat (buf
, ", pic");
3580 if (e_flags
& EF_SH_FDPIC
)
3581 strcat (buf
, ", fdpic");
3585 if (e_flags
& EF_OR1K_NODELAY
)
3586 strcat (buf
, ", no delay");
3590 if (e_flags
& EF_SPARC_32PLUS
)
3591 strcat (buf
, ", v8+");
3593 if (e_flags
& EF_SPARC_SUN_US1
)
3594 strcat (buf
, ", ultrasparcI");
3596 if (e_flags
& EF_SPARC_SUN_US3
)
3597 strcat (buf
, ", ultrasparcIII");
3599 if (e_flags
& EF_SPARC_HAL_R1
)
3600 strcat (buf
, ", halr1");
3602 if (e_flags
& EF_SPARC_LEDATA
)
3603 strcat (buf
, ", ledata");
3605 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3606 strcat (buf
, ", tso");
3608 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3609 strcat (buf
, ", pso");
3611 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3612 strcat (buf
, ", rmo");
3616 switch (e_flags
& EF_PARISC_ARCH
)
3618 case EFA_PARISC_1_0
:
3619 strcpy (buf
, ", PA-RISC 1.0");
3621 case EFA_PARISC_1_1
:
3622 strcpy (buf
, ", PA-RISC 1.1");
3624 case EFA_PARISC_2_0
:
3625 strcpy (buf
, ", PA-RISC 2.0");
3630 if (e_flags
& EF_PARISC_TRAPNIL
)
3631 strcat (buf
, ", trapnil");
3632 if (e_flags
& EF_PARISC_EXT
)
3633 strcat (buf
, ", ext");
3634 if (e_flags
& EF_PARISC_LSB
)
3635 strcat (buf
, ", lsb");
3636 if (e_flags
& EF_PARISC_WIDE
)
3637 strcat (buf
, ", wide");
3638 if (e_flags
& EF_PARISC_NO_KABP
)
3639 strcat (buf
, ", no kabp");
3640 if (e_flags
& EF_PARISC_LAZYSWAP
)
3641 strcat (buf
, ", lazyswap");
3646 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3647 strcat (buf
, ", new calling convention");
3649 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3650 strcat (buf
, ", gnu calling convention");
3654 if ((e_flags
& EF_IA_64_ABI64
))
3655 strcat (buf
, ", 64-bit");
3657 strcat (buf
, ", 32-bit");
3658 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3659 strcat (buf
, ", reduced fp model");
3660 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3661 strcat (buf
, ", no function descriptors, constant gp");
3662 else if ((e_flags
& EF_IA_64_CONS_GP
))
3663 strcat (buf
, ", constant gp");
3664 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3665 strcat (buf
, ", absolute");
3666 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3668 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3669 strcat (buf
, ", vms_linkages");
3670 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3672 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3674 case EF_IA_64_VMS_COMCOD_WARNING
:
3675 strcat (buf
, ", warning");
3677 case EF_IA_64_VMS_COMCOD_ERROR
:
3678 strcat (buf
, ", error");
3680 case EF_IA_64_VMS_COMCOD_ABORT
:
3681 strcat (buf
, ", abort");
3684 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3685 e_flags
& EF_IA_64_VMS_COMCOD
);
3686 strcat (buf
, ", <unknown>");
3692 if ((e_flags
& EF_VAX_NONPIC
))
3693 strcat (buf
, ", non-PIC");
3694 if ((e_flags
& EF_VAX_DFLOAT
))
3695 strcat (buf
, ", D-Float");
3696 if ((e_flags
& EF_VAX_GFLOAT
))
3697 strcat (buf
, ", G-Float");
3701 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3702 strcat (buf
, ", mcm");
3703 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3704 strcat (buf
, ", mcm24");
3705 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3706 strcat (buf
, ", gr6");
3710 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3712 case E_FLAG_RL78_ANY_CPU
: break;
3713 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3714 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3715 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3717 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3718 strcat (buf
, ", 64-bit doubles");
3722 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3723 strcat (buf
, ", 64-bit doubles");
3724 if (e_flags
& E_FLAG_RX_DSP
)
3725 strcat (buf
, ", dsp");
3726 if (e_flags
& E_FLAG_RX_PID
)
3727 strcat (buf
, ", pid");
3728 if (e_flags
& E_FLAG_RX_ABI
)
3729 strcat (buf
, ", RX ABI");
3730 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3731 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3732 ? ", uses String instructions" : ", bans String instructions");
3733 if (e_flags
& E_FLAG_RX_V2
)
3734 strcat (buf
, ", V2");
3735 if (e_flags
& E_FLAG_RX_V3
)
3736 strcat (buf
, ", V3");
3740 if (e_flags
& EF_S390_HIGH_GPRS
)
3741 strcat (buf
, ", highgprs");
3745 if ((e_flags
& EF_C6000_REL
))
3746 strcat (buf
, ", relocatable module");
3750 strcat (buf
, _(": architecture variant: "));
3751 switch (e_flags
& EF_MSP430_MACH
)
3753 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3754 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3755 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3756 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3757 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3758 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3759 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3760 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3761 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3762 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3763 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3764 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3765 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3766 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3767 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3769 strcat (buf
, _(": unknown")); break;
3772 if (e_flags
& ~ EF_MSP430_MACH
)
3773 strcat (buf
, _(": unknown extra flag bits also present"));
3777 switch (e_flags
& EF_Z80_MACH_MSK
)
3779 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3780 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3781 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3782 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3783 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3784 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3785 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3787 strcat (buf
, _(", unknown")); break;
3797 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3799 static char buff
[32];
3803 case ELFOSABI_NONE
: return "UNIX - System V";
3804 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3805 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3806 case ELFOSABI_GNU
: return "UNIX - GNU";
3807 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3808 case ELFOSABI_AIX
: return "UNIX - AIX";
3809 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3810 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3811 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3812 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3813 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3814 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3815 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3816 case ELFOSABI_AROS
: return "AROS";
3817 case ELFOSABI_FENIXOS
: return "FenixOS";
3818 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3819 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3822 switch (filedata
->file_header
.e_machine
)
3827 case ELFOSABI_ARM
: return "ARM";
3828 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3839 case ELFOSABI_STANDALONE
: return _("Standalone App");
3848 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3849 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3858 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3864 get_aarch64_segment_type (unsigned long type
)
3868 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3869 default: return NULL
;
3874 get_arm_segment_type (unsigned long type
)
3878 case PT_ARM_EXIDX
: return "EXIDX";
3879 default: return NULL
;
3884 get_s390_segment_type (unsigned long type
)
3888 case PT_S390_PGSTE
: return "S390_PGSTE";
3889 default: return NULL
;
3894 get_mips_segment_type (unsigned long type
)
3898 case PT_MIPS_REGINFO
: return "REGINFO";
3899 case PT_MIPS_RTPROC
: return "RTPROC";
3900 case PT_MIPS_OPTIONS
: return "OPTIONS";
3901 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3902 default: return NULL
;
3907 get_parisc_segment_type (unsigned long type
)
3911 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3912 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3913 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3914 default: return NULL
;
3919 get_ia64_segment_type (unsigned long type
)
3923 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3924 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3925 default: return NULL
;
3930 get_tic6x_segment_type (unsigned long type
)
3934 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3935 default: return NULL
;
3940 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3942 if (e_machine
== EM_PARISC
)
3945 case PT_HP_TLS
: return "HP_TLS";
3946 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3947 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3948 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3949 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3950 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3951 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3952 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3953 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3954 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3955 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3956 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3957 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3958 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3959 case PT_HP_STACK
: return "HP_STACK";
3960 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3961 default: return NULL
;
3964 if (e_machine
== EM_IA_64
)
3967 case PT_HP_TLS
: return "HP_TLS";
3968 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3969 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3970 case PT_IA_64_HP_STACK
: return "HP_STACK";
3971 default: return NULL
;
3978 get_solaris_segment_type (unsigned long type
)
3982 case 0x6464e550: return "PT_SUNW_UNWIND";
3983 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3984 case 0x6ffffff7: return "PT_LOSUNW";
3985 case 0x6ffffffa: return "PT_SUNWBSS";
3986 case 0x6ffffffb: return "PT_SUNWSTACK";
3987 case 0x6ffffffc: return "PT_SUNWDTRACE";
3988 case 0x6ffffffd: return "PT_SUNWCAP";
3989 case 0x6fffffff: return "PT_HISUNW";
3990 default: return NULL
;
3995 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3997 static char buff
[32];
4001 case PT_NULL
: return "NULL";
4002 case PT_LOAD
: return "LOAD";
4003 case PT_DYNAMIC
: return "DYNAMIC";
4004 case PT_INTERP
: return "INTERP";
4005 case PT_NOTE
: return "NOTE";
4006 case PT_SHLIB
: return "SHLIB";
4007 case PT_PHDR
: return "PHDR";
4008 case PT_TLS
: return "TLS";
4009 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4010 case PT_GNU_STACK
: return "GNU_STACK";
4011 case PT_GNU_RELRO
: return "GNU_RELRO";
4012 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4015 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4017 const char * result
;
4019 switch (filedata
->file_header
.e_machine
)
4022 result
= get_aarch64_segment_type (p_type
);
4025 result
= get_arm_segment_type (p_type
);
4028 case EM_MIPS_RS3_LE
:
4029 result
= get_mips_segment_type (p_type
);
4032 result
= get_parisc_segment_type (p_type
);
4035 result
= get_ia64_segment_type (p_type
);
4038 result
= get_tic6x_segment_type (p_type
);
4042 result
= get_s390_segment_type (p_type
);
4052 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4054 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4056 const char * result
= NULL
;
4058 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4061 case ELFOSABI_FREEBSD
:
4062 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4064 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4069 result
= get_hpux_segment_type (p_type
,
4070 filedata
->file_header
.e_machine
);
4072 case ELFOSABI_SOLARIS
:
4073 result
= get_solaris_segment_type (p_type
);
4081 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4084 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4091 get_arc_section_type_name (unsigned int sh_type
)
4095 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4103 get_mips_section_type_name (unsigned int sh_type
)
4107 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4108 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4109 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4110 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4111 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4112 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4113 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4114 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4115 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4116 case SHT_MIPS_RELD
: return "MIPS_RELD";
4117 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4118 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4119 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4120 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4121 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4122 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4123 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4124 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4125 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4126 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4127 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4128 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4129 case SHT_MIPS_LINE
: return "MIPS_LINE";
4130 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4131 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4132 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4133 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4134 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4135 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4136 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4137 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4138 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4139 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4140 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4141 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4142 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4143 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4144 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4145 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4146 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4147 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4155 get_parisc_section_type_name (unsigned int sh_type
)
4159 case SHT_PARISC_EXT
: return "PARISC_EXT";
4160 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4161 case SHT_PARISC_DOC
: return "PARISC_DOC";
4162 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4163 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4164 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4165 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4166 default: return NULL
;
4171 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4173 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4174 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4175 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4179 case SHT_IA_64_EXT
: return "IA_64_EXT";
4180 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4181 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4182 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4183 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4184 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4185 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4186 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4187 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4188 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4196 get_x86_64_section_type_name (unsigned int sh_type
)
4200 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4201 default: return NULL
;
4206 get_aarch64_section_type_name (unsigned int sh_type
)
4210 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4211 default: return NULL
;
4216 get_arm_section_type_name (unsigned int sh_type
)
4220 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4221 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4222 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4223 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4224 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4225 default: return NULL
;
4230 get_tic6x_section_type_name (unsigned int sh_type
)
4234 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4235 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4236 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4237 case SHT_TI_ICODE
: return "TI_ICODE";
4238 case SHT_TI_XREF
: return "TI_XREF";
4239 case SHT_TI_HANDLER
: return "TI_HANDLER";
4240 case SHT_TI_INITINFO
: return "TI_INITINFO";
4241 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4242 default: return NULL
;
4247 get_msp430x_section_type_name (unsigned int sh_type
)
4251 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4252 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4253 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4254 default: return NULL
;
4259 get_nfp_section_type_name (unsigned int sh_type
)
4263 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4264 case SHT_NFP_INITREG
: return "NFP_INITREG";
4265 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4266 default: return NULL
;
4271 get_v850_section_type_name (unsigned int sh_type
)
4275 case SHT_V850_SCOMMON
: return "V850 Small Common";
4276 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4277 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4278 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4279 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4280 default: return NULL
;
4285 get_riscv_section_type_name (unsigned int sh_type
)
4289 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4290 default: return NULL
;
4295 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4297 static char buff
[32];
4298 const char * result
;
4302 case SHT_NULL
: return "NULL";
4303 case SHT_PROGBITS
: return "PROGBITS";
4304 case SHT_SYMTAB
: return "SYMTAB";
4305 case SHT_STRTAB
: return "STRTAB";
4306 case SHT_RELA
: return "RELA";
4307 case SHT_HASH
: return "HASH";
4308 case SHT_DYNAMIC
: return "DYNAMIC";
4309 case SHT_NOTE
: return "NOTE";
4310 case SHT_NOBITS
: return "NOBITS";
4311 case SHT_REL
: return "REL";
4312 case SHT_SHLIB
: return "SHLIB";
4313 case SHT_DYNSYM
: return "DYNSYM";
4314 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4315 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4316 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4317 case SHT_GNU_HASH
: return "GNU_HASH";
4318 case SHT_GROUP
: return "GROUP";
4319 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4320 case SHT_GNU_verdef
: return "VERDEF";
4321 case SHT_GNU_verneed
: return "VERNEED";
4322 case SHT_GNU_versym
: return "VERSYM";
4323 case 0x6ffffff0: return "VERSYM";
4324 case 0x6ffffffc: return "VERDEF";
4325 case 0x7ffffffd: return "AUXILIARY";
4326 case 0x7fffffff: return "FILTER";
4327 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4330 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4332 switch (filedata
->file_header
.e_machine
)
4335 case EM_ARC_COMPACT
:
4336 case EM_ARC_COMPACT2
:
4337 result
= get_arc_section_type_name (sh_type
);
4340 case EM_MIPS_RS3_LE
:
4341 result
= get_mips_section_type_name (sh_type
);
4344 result
= get_parisc_section_type_name (sh_type
);
4347 result
= get_ia64_section_type_name (filedata
, sh_type
);
4352 result
= get_x86_64_section_type_name (sh_type
);
4355 result
= get_aarch64_section_type_name (sh_type
);
4358 result
= get_arm_section_type_name (sh_type
);
4361 result
= get_tic6x_section_type_name (sh_type
);
4364 result
= get_msp430x_section_type_name (sh_type
);
4367 result
= get_nfp_section_type_name (sh_type
);
4371 case EM_CYGNUS_V850
:
4372 result
= get_v850_section_type_name (sh_type
);
4375 result
= get_riscv_section_type_name (sh_type
);
4385 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4387 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4389 switch (filedata
->file_header
.e_machine
)
4392 result
= get_ia64_section_type_name (filedata
, sh_type
);
4395 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4396 result
= get_solaris_section_type (sh_type
);
4401 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4402 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4403 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4404 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4416 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4418 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4420 switch (filedata
->file_header
.e_machine
)
4424 case EM_CYGNUS_V850
:
4425 result
= get_v850_section_type_name (sh_type
);
4435 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4438 /* This message is probably going to be displayed in a 15
4439 character wide field, so put the hex value first. */
4440 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4446 #define OPTION_DEBUG_DUMP 512
4447 #define OPTION_DYN_SYMS 513
4448 #define OPTION_DWARF_DEPTH 514
4449 #define OPTION_DWARF_START 515
4450 #define OPTION_DWARF_CHECK 516
4451 #define OPTION_CTF_DUMP 517
4452 #define OPTION_CTF_PARENT 518
4453 #define OPTION_CTF_SYMBOLS 519
4454 #define OPTION_CTF_STRINGS 520
4456 static struct option options
[] =
4458 {"all", no_argument
, 0, 'a'},
4459 {"file-header", no_argument
, 0, 'h'},
4460 {"program-headers", no_argument
, 0, 'l'},
4461 {"headers", no_argument
, 0, 'e'},
4462 {"histogram", no_argument
, 0, 'I'},
4463 {"segments", no_argument
, 0, 'l'},
4464 {"sections", no_argument
, 0, 'S'},
4465 {"section-headers", no_argument
, 0, 'S'},
4466 {"section-groups", no_argument
, 0, 'g'},
4467 {"section-details", no_argument
, 0, 't'},
4468 {"full-section-name",no_argument
, 0, 'N'},
4469 {"symbols", no_argument
, 0, 's'},
4470 {"syms", no_argument
, 0, 's'},
4471 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4472 {"relocs", no_argument
, 0, 'r'},
4473 {"notes", no_argument
, 0, 'n'},
4474 {"dynamic", no_argument
, 0, 'd'},
4475 {"arch-specific", no_argument
, 0, 'A'},
4476 {"version-info", no_argument
, 0, 'V'},
4477 {"use-dynamic", no_argument
, 0, 'D'},
4478 {"unwind", no_argument
, 0, 'u'},
4479 {"archive-index", no_argument
, 0, 'c'},
4480 {"hex-dump", required_argument
, 0, 'x'},
4481 {"relocated-dump", required_argument
, 0, 'R'},
4482 {"string-dump", required_argument
, 0, 'p'},
4483 {"decompress", no_argument
, 0, 'z'},
4484 #ifdef SUPPORT_DISASSEMBLY
4485 {"instruction-dump", required_argument
, 0, 'i'},
4487 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4489 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4490 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4491 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4493 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4495 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4496 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4497 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4499 {"version", no_argument
, 0, 'v'},
4500 {"wide", no_argument
, 0, 'W'},
4501 {"help", no_argument
, 0, 'H'},
4502 {0, no_argument
, 0, 0}
4506 usage (FILE * stream
)
4508 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4509 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4510 fprintf (stream
, _(" Options are:\n\
4511 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4512 -h --file-header Display the ELF file header\n\
4513 -l --program-headers Display the program headers\n\
4514 --segments An alias for --program-headers\n\
4515 -S --section-headers Display the sections' header\n\
4516 --sections An alias for --section-headers\n\
4517 -g --section-groups Display the section groups\n\
4518 -t --section-details Display the section details\n\
4519 -e --headers Equivalent to: -h -l -S\n\
4520 -s --syms Display the symbol table\n\
4521 --symbols An alias for --syms\n\
4522 --dyn-syms Display the dynamic symbol table\n\
4523 -n --notes Display the core notes (if present)\n\
4524 -r --relocs Display the relocations (if present)\n\
4525 -u --unwind Display the unwind info (if present)\n\
4526 -d --dynamic Display the dynamic section (if present)\n\
4527 -V --version-info Display the version sections (if present)\n\
4528 -A --arch-specific Display architecture specific information (if any)\n\
4529 -c --archive-index Display the symbol/file index in an archive\n\
4530 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4531 -x --hex-dump=<number|name>\n\
4532 Dump the contents of section <number|name> as bytes\n\
4533 -p --string-dump=<number|name>\n\
4534 Dump the contents of section <number|name> as strings\n\
4535 -R --relocated-dump=<number|name>\n\
4536 Dump the contents of section <number|name> as relocated bytes\n\
4537 -z --decompress Decompress section before dumping it\n\
4538 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4539 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4540 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4541 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4542 =addr,=cu_index,=links,=follow-links]\n\
4543 Display the contents of DWARF debug sections\n"));
4544 fprintf (stream
, _("\
4545 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4546 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4548 fprintf (stream
, _("\
4549 --ctf=<number|name> Display CTF info from section <number|name>\n\
4550 --ctf-parent=<number|name>\n\
4551 Use section <number|name> as the CTF parent\n\n\
4552 --ctf-symbols=<number|name>\n\
4553 Use section <number|name> as the CTF external symtab\n\n\
4554 --ctf-strings=<number|name>\n\
4555 Use section <number|name> as the CTF external strtab\n\n"));
4557 #ifdef SUPPORT_DISASSEMBLY
4558 fprintf (stream
, _("\
4559 -i --instruction-dump=<number|name>\n\
4560 Disassemble the contents of section <number|name>\n"));
4562 fprintf (stream
, _("\
4563 -I --histogram Display histogram of bucket list lengths\n\
4564 -W --wide Allow output width to exceed 80 characters\n\
4565 @<file> Read options from <file>\n\
4566 -H --help Display this information\n\
4567 -v --version Display the version number of readelf\n"));
4569 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4570 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4572 exit (stream
== stdout
? 0 : 1);
4575 /* Record the fact that the user wants the contents of section number
4576 SECTION to be displayed using the method(s) encoded as flags bits
4577 in TYPE. Note, TYPE can be zero if we are creating the array for
4581 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4583 if (section
>= filedata
->num_dump_sects
)
4585 dump_type
* new_dump_sects
;
4587 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4588 sizeof (* new_dump_sects
));
4590 if (new_dump_sects
== NULL
)
4591 error (_("Out of memory allocating dump request table.\n"));
4594 if (filedata
->dump_sects
)
4596 /* Copy current flag settings. */
4597 memcpy (new_dump_sects
, filedata
->dump_sects
,
4598 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4600 free (filedata
->dump_sects
);
4603 filedata
->dump_sects
= new_dump_sects
;
4604 filedata
->num_dump_sects
= section
+ 1;
4608 if (filedata
->dump_sects
)
4609 filedata
->dump_sects
[section
] |= type
;
4612 /* Request a dump by section name. */
4615 request_dump_byname (const char * section
, dump_type type
)
4617 struct dump_list_entry
* new_request
;
4619 new_request
= (struct dump_list_entry
*)
4620 malloc (sizeof (struct dump_list_entry
));
4622 error (_("Out of memory allocating dump request table.\n"));
4624 new_request
->name
= strdup (section
);
4625 if (!new_request
->name
)
4626 error (_("Out of memory allocating dump request table.\n"));
4628 new_request
->type
= type
;
4630 new_request
->next
= dump_sects_byname
;
4631 dump_sects_byname
= new_request
;
4635 request_dump (Filedata
* filedata
, dump_type type
)
4641 section
= strtoul (optarg
, & cp
, 0);
4643 if (! *cp
&& section
>= 0)
4644 request_dump_bynumber (filedata
, section
, type
);
4646 request_dump_byname (optarg
, type
);
4650 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4657 while ((c
= getopt_long
4658 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4676 do_section_groups
= TRUE
;
4679 do_histogram
= TRUE
;
4684 do_section_groups
= TRUE
;
4689 do_section_details
= TRUE
;
4700 do_using_dynamic
= TRUE
;
4724 do_histogram
= TRUE
;
4730 do_archive_index
= TRUE
;
4733 request_dump (filedata
, HEX_DUMP
);
4736 request_dump (filedata
, STRING_DUMP
);
4739 request_dump (filedata
, RELOC_DUMP
);
4742 decompress_dumps
= TRUE
;
4748 do_debugging
= TRUE
;
4749 dwarf_select_sections_all ();
4753 do_debugging
= FALSE
;
4754 dwarf_select_sections_by_letters (optarg
);
4757 case OPTION_DEBUG_DUMP
:
4760 do_debugging
= TRUE
;
4763 do_debugging
= FALSE
;
4764 dwarf_select_sections_by_names (optarg
);
4767 case OPTION_DWARF_DEPTH
:
4771 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4774 case OPTION_DWARF_START
:
4778 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4781 case OPTION_DWARF_CHECK
:
4784 case OPTION_CTF_DUMP
:
4786 request_dump (filedata
, CTF_DUMP
);
4788 case OPTION_CTF_SYMBOLS
:
4789 dump_ctf_symtab_name
= strdup (optarg
);
4791 case OPTION_CTF_STRINGS
:
4792 dump_ctf_strtab_name
= strdup (optarg
);
4794 case OPTION_CTF_PARENT
:
4795 dump_ctf_parent_name
= strdup (optarg
);
4797 case OPTION_DYN_SYMS
:
4800 #ifdef SUPPORT_DISASSEMBLY
4802 request_dump (filedata
, DISASS_DUMP
);
4806 print_version (program_name
);
4815 /* xgettext:c-format */
4816 error (_("Invalid option '-%c'\n"), c
);
4823 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4824 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4825 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4826 && !do_section_groups
&& !do_archive_index
4832 get_elf_class (unsigned int elf_class
)
4834 static char buff
[32];
4838 case ELFCLASSNONE
: return _("none");
4839 case ELFCLASS32
: return "ELF32";
4840 case ELFCLASS64
: return "ELF64";
4842 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4848 get_data_encoding (unsigned int encoding
)
4850 static char buff
[32];
4854 case ELFDATANONE
: return _("none");
4855 case ELFDATA2LSB
: return _("2's complement, little endian");
4856 case ELFDATA2MSB
: return _("2's complement, big endian");
4858 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4863 /* Decode the data held in 'filedata->file_header'. */
4866 process_file_header (Filedata
* filedata
)
4868 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4870 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4871 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4872 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4873 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4876 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4880 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4886 printf (_("ELF Header:\n"));
4887 printf (_(" Magic: "));
4888 for (i
= 0; i
< EI_NIDENT
; i
++)
4889 printf ("%2.2x ", header
->e_ident
[i
]);
4891 printf (_(" Class: %s\n"),
4892 get_elf_class (header
->e_ident
[EI_CLASS
]));
4893 printf (_(" Data: %s\n"),
4894 get_data_encoding (header
->e_ident
[EI_DATA
]));
4895 printf (_(" Version: %d%s\n"),
4896 header
->e_ident
[EI_VERSION
],
4897 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4899 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4902 printf (_(" OS/ABI: %s\n"),
4903 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4904 printf (_(" ABI Version: %d\n"),
4905 header
->e_ident
[EI_ABIVERSION
]);
4906 printf (_(" Type: %s\n"),
4907 get_file_type (header
->e_type
));
4908 printf (_(" Machine: %s\n"),
4909 get_machine_name (header
->e_machine
));
4910 printf (_(" Version: 0x%lx\n"),
4913 printf (_(" Entry point address: "));
4914 print_vma (header
->e_entry
, PREFIX_HEX
);
4915 printf (_("\n Start of program headers: "));
4916 print_vma (header
->e_phoff
, DEC
);
4917 printf (_(" (bytes into file)\n Start of section headers: "));
4918 print_vma (header
->e_shoff
, DEC
);
4919 printf (_(" (bytes into file)\n"));
4921 printf (_(" Flags: 0x%lx%s\n"),
4923 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4924 printf (_(" Size of this header: %u (bytes)\n"),
4926 printf (_(" Size of program headers: %u (bytes)\n"),
4927 header
->e_phentsize
);
4928 printf (_(" Number of program headers: %u"),
4930 if (filedata
->section_headers
!= NULL
4931 && header
->e_phnum
== PN_XNUM
4932 && filedata
->section_headers
[0].sh_info
!= 0)
4934 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4935 printf (" (%u)", header
->e_phnum
);
4937 putc ('\n', stdout
);
4938 printf (_(" Size of section headers: %u (bytes)\n"),
4939 header
->e_shentsize
);
4940 printf (_(" Number of section headers: %u"),
4942 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4944 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4945 printf (" (%u)", header
->e_shnum
);
4947 putc ('\n', stdout
);
4948 printf (_(" Section header string table index: %u"),
4949 header
->e_shstrndx
);
4950 if (filedata
->section_headers
!= NULL
4951 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4953 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4954 printf (" (%u)", header
->e_shstrndx
);
4956 if (header
->e_shstrndx
!= SHN_UNDEF
4957 && header
->e_shstrndx
>= header
->e_shnum
)
4959 header
->e_shstrndx
= SHN_UNDEF
;
4960 printf (_(" <corrupt: out of range>"));
4962 putc ('\n', stdout
);
4965 if (filedata
->section_headers
!= NULL
)
4967 if (header
->e_phnum
== PN_XNUM
4968 && filedata
->section_headers
[0].sh_info
!= 0)
4969 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4970 if (header
->e_shnum
== SHN_UNDEF
)
4971 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4972 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4973 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4974 if (header
->e_shstrndx
>= header
->e_shnum
)
4975 header
->e_shstrndx
= SHN_UNDEF
;
4976 free (filedata
->section_headers
);
4977 filedata
->section_headers
= NULL
;
4983 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4984 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4987 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4989 Elf32_External_Phdr
* phdrs
;
4990 Elf32_External_Phdr
* external
;
4991 Elf_Internal_Phdr
* internal
;
4993 unsigned int size
= filedata
->file_header
.e_phentsize
;
4994 unsigned int num
= filedata
->file_header
.e_phnum
;
4996 /* PR binutils/17531: Cope with unexpected section header sizes. */
4997 if (size
== 0 || num
== 0)
4999 if (size
< sizeof * phdrs
)
5001 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5004 if (size
> sizeof * phdrs
)
5005 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5007 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5008 size
, num
, _("program headers"));
5012 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5013 i
< filedata
->file_header
.e_phnum
;
5014 i
++, internal
++, external
++)
5016 internal
->p_type
= BYTE_GET (external
->p_type
);
5017 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5018 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5019 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5020 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5021 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5022 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5023 internal
->p_align
= BYTE_GET (external
->p_align
);
5030 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5031 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5034 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5036 Elf64_External_Phdr
* phdrs
;
5037 Elf64_External_Phdr
* external
;
5038 Elf_Internal_Phdr
* internal
;
5040 unsigned int size
= filedata
->file_header
.e_phentsize
;
5041 unsigned int num
= filedata
->file_header
.e_phnum
;
5043 /* PR binutils/17531: Cope with unexpected section header sizes. */
5044 if (size
== 0 || num
== 0)
5046 if (size
< sizeof * phdrs
)
5048 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5051 if (size
> sizeof * phdrs
)
5052 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5054 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5055 size
, num
, _("program headers"));
5059 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5060 i
< filedata
->file_header
.e_phnum
;
5061 i
++, internal
++, external
++)
5063 internal
->p_type
= BYTE_GET (external
->p_type
);
5064 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5065 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5066 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5067 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5068 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5069 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5070 internal
->p_align
= BYTE_GET (external
->p_align
);
5077 /* Returns TRUE if the program headers were read into `program_headers'. */
5080 get_program_headers (Filedata
* filedata
)
5082 Elf_Internal_Phdr
* phdrs
;
5084 /* Check cache of prior read. */
5085 if (filedata
->program_headers
!= NULL
)
5088 /* Be kind to memory checkers by looking for
5089 e_phnum values which we know must be invalid. */
5090 if (filedata
->file_header
.e_phnum
5091 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5092 >= filedata
->file_size
)
5094 error (_("Too many program headers - %#x - the file is not that big\n"),
5095 filedata
->file_header
.e_phnum
);
5099 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5100 sizeof (Elf_Internal_Phdr
));
5103 error (_("Out of memory reading %u program headers\n"),
5104 filedata
->file_header
.e_phnum
);
5109 ? get_32bit_program_headers (filedata
, phdrs
)
5110 : get_64bit_program_headers (filedata
, phdrs
))
5112 filedata
->program_headers
= phdrs
;
5120 /* Returns TRUE if the program headers were loaded. */
5123 process_program_headers (Filedata
* filedata
)
5125 Elf_Internal_Phdr
* segment
;
5127 Elf_Internal_Phdr
* previous_load
= NULL
;
5132 if (filedata
->file_header
.e_phnum
== 0)
5134 /* PR binutils/12467. */
5135 if (filedata
->file_header
.e_phoff
!= 0)
5137 warn (_("possibly corrupt ELF header - it has a non-zero program"
5138 " header offset, but no program headers\n"));
5141 else if (do_segments
)
5142 printf (_("\nThere are no program headers in this file.\n"));
5146 if (do_segments
&& !do_header
)
5148 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5149 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5150 printf (ngettext ("There is %d program header, starting at offset %s\n",
5151 "There are %d program headers, starting at offset %s\n",
5152 filedata
->file_header
.e_phnum
),
5153 filedata
->file_header
.e_phnum
,
5154 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5157 if (! get_program_headers (filedata
))
5162 if (filedata
->file_header
.e_phnum
> 1)
5163 printf (_("\nProgram Headers:\n"));
5165 printf (_("\nProgram Headers:\n"));
5169 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5172 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5176 (_(" Type Offset VirtAddr PhysAddr\n"));
5178 (_(" FileSiz MemSiz Flags Align\n"));
5182 for (i
= 0, segment
= filedata
->program_headers
;
5183 i
< filedata
->file_header
.e_phnum
;
5188 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5192 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5193 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5194 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5195 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5196 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5198 (segment
->p_flags
& PF_R
? 'R' : ' '),
5199 (segment
->p_flags
& PF_W
? 'W' : ' '),
5200 (segment
->p_flags
& PF_X
? 'E' : ' '));
5201 printf ("%#lx", (unsigned long) segment
->p_align
);
5205 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5206 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5209 print_vma (segment
->p_offset
, FULL_HEX
);
5213 print_vma (segment
->p_vaddr
, FULL_HEX
);
5215 print_vma (segment
->p_paddr
, FULL_HEX
);
5218 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5219 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5222 print_vma (segment
->p_filesz
, FULL_HEX
);
5226 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5227 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5230 print_vma (segment
->p_memsz
, FULL_HEX
);
5234 (segment
->p_flags
& PF_R
? 'R' : ' '),
5235 (segment
->p_flags
& PF_W
? 'W' : ' '),
5236 (segment
->p_flags
& PF_X
? 'E' : ' '));
5238 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5239 printf ("%#lx", (unsigned long) segment
->p_align
);
5242 print_vma (segment
->p_align
, PREFIX_HEX
);
5247 print_vma (segment
->p_offset
, FULL_HEX
);
5249 print_vma (segment
->p_vaddr
, FULL_HEX
);
5251 print_vma (segment
->p_paddr
, FULL_HEX
);
5253 print_vma (segment
->p_filesz
, FULL_HEX
);
5255 print_vma (segment
->p_memsz
, FULL_HEX
);
5257 (segment
->p_flags
& PF_R
? 'R' : ' '),
5258 (segment
->p_flags
& PF_W
? 'W' : ' '),
5259 (segment
->p_flags
& PF_X
? 'E' : ' '));
5260 print_vma (segment
->p_align
, PREFIX_HEX
);
5263 putc ('\n', stdout
);
5266 switch (segment
->p_type
)
5269 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5270 required by the ELF standard, several programs, including the Linux
5271 kernel, make use of non-ordered segments. */
5273 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5274 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5276 if (segment
->p_memsz
< segment
->p_filesz
)
5277 error (_("the segment's file size is larger than its memory size\n"));
5278 previous_load
= segment
;
5282 /* PR 20815 - Verify that the program header is loaded into memory. */
5283 if (i
> 0 && previous_load
!= NULL
)
5284 error (_("the PHDR segment must occur before any LOAD segment\n"));
5285 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5289 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5291 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5292 if (load
->p_type
== PT_LOAD
5293 && load
->p_offset
<= segment
->p_offset
5294 && (load
->p_offset
+ load
->p_filesz
5295 >= segment
->p_offset
+ segment
->p_filesz
)
5296 && load
->p_vaddr
<= segment
->p_vaddr
5297 && (load
->p_vaddr
+ load
->p_filesz
5298 >= segment
->p_vaddr
+ segment
->p_filesz
))
5301 if (j
== filedata
->file_header
.e_phnum
)
5302 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5308 error (_("more than one dynamic segment\n"));
5310 /* By default, assume that the .dynamic section is the first
5311 section in the DYNAMIC segment. */
5312 dynamic_addr
= segment
->p_offset
;
5313 dynamic_size
= segment
->p_filesz
;
5315 /* Try to locate the .dynamic section. If there is
5316 a section header table, we can easily locate it. */
5317 if (filedata
->section_headers
!= NULL
)
5319 Elf_Internal_Shdr
* sec
;
5321 sec
= find_section (filedata
, ".dynamic");
5322 if (sec
== NULL
|| sec
->sh_size
== 0)
5324 /* A corresponding .dynamic section is expected, but on
5325 IA-64/OpenVMS it is OK for it to be missing. */
5326 if (!is_ia64_vms (filedata
))
5327 error (_("no .dynamic section in the dynamic segment\n"));
5331 if (sec
->sh_type
== SHT_NOBITS
)
5337 dynamic_addr
= sec
->sh_offset
;
5338 dynamic_size
= sec
->sh_size
;
5340 if (dynamic_addr
< segment
->p_offset
5341 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5342 warn (_("the .dynamic section is not contained"
5343 " within the dynamic segment\n"));
5344 else if (dynamic_addr
> segment
->p_offset
)
5345 warn (_("the .dynamic section is not the first section"
5346 " in the dynamic segment.\n"));
5349 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5350 segment. Check this after matching against the section headers
5351 so we don't warn on debuginfo file (which have NOBITS .dynamic
5353 if (dynamic_addr
> filedata
->file_size
5354 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5356 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5357 dynamic_addr
= dynamic_size
= 0;
5362 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5364 error (_("Unable to find program interpreter name\n"));
5368 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5370 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5371 error (_("Internal error: failed to create format string to display program interpreter\n"));
5373 program_interpreter
[0] = 0;
5374 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5375 error (_("Unable to read program interpreter name\n"));
5378 printf (_(" [Requesting program interpreter: %s]\n"),
5379 program_interpreter
);
5386 && filedata
->section_headers
!= NULL
5387 && filedata
->string_table
!= NULL
)
5389 printf (_("\n Section to Segment mapping:\n"));
5390 printf (_(" Segment Sections...\n"));
5392 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5395 Elf_Internal_Shdr
* section
;
5397 segment
= filedata
->program_headers
+ i
;
5398 section
= filedata
->section_headers
+ 1;
5400 printf (" %2.2d ", i
);
5402 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5404 if (!ELF_TBSS_SPECIAL (section
, segment
)
5405 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5406 printf ("%s ", printable_section_name (filedata
, section
));
5417 /* Find the file offset corresponding to VMA by using the program headers. */
5420 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5422 Elf_Internal_Phdr
* seg
;
5424 if (! get_program_headers (filedata
))
5426 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5430 for (seg
= filedata
->program_headers
;
5431 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5434 if (seg
->p_type
!= PT_LOAD
)
5437 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5438 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5439 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5442 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5443 (unsigned long) vma
);
5448 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5449 If PROBE is true, this is just a probe and we do not generate any error
5450 messages if the load fails. */
5453 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5455 Elf32_External_Shdr
* shdrs
;
5456 Elf_Internal_Shdr
* internal
;
5458 unsigned int size
= filedata
->file_header
.e_shentsize
;
5459 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5461 /* PR binutils/17531: Cope with unexpected section header sizes. */
5462 if (size
== 0 || num
== 0)
5464 if (size
< sizeof * shdrs
)
5467 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5470 if (!probe
&& size
> sizeof * shdrs
)
5471 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5473 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5475 probe
? NULL
: _("section headers"));
5479 free (filedata
->section_headers
);
5480 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5481 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5482 if (filedata
->section_headers
== NULL
)
5485 error (_("Out of memory reading %u section headers\n"), num
);
5490 for (i
= 0, internal
= filedata
->section_headers
;
5494 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5495 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5496 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5497 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5498 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5499 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5500 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5501 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5502 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5503 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5504 if (!probe
&& internal
->sh_link
> num
)
5505 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5506 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5507 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5514 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5517 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5519 Elf64_External_Shdr
* shdrs
;
5520 Elf_Internal_Shdr
* internal
;
5522 unsigned int size
= filedata
->file_header
.e_shentsize
;
5523 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5525 /* PR binutils/17531: Cope with unexpected section header sizes. */
5526 if (size
== 0 || num
== 0)
5529 if (size
< sizeof * shdrs
)
5532 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5536 if (! probe
&& size
> sizeof * shdrs
)
5537 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5539 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5540 filedata
->file_header
.e_shoff
,
5542 probe
? NULL
: _("section headers"));
5546 free (filedata
->section_headers
);
5547 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5548 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5549 if (filedata
->section_headers
== NULL
)
5552 error (_("Out of memory reading %u section headers\n"), num
);
5557 for (i
= 0, internal
= filedata
->section_headers
;
5561 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5562 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5563 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5564 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5565 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5566 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5567 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5568 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5569 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5570 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5571 if (!probe
&& internal
->sh_link
> num
)
5572 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5573 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5574 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5581 static Elf_Internal_Sym
*
5582 get_32bit_elf_symbols (Filedata
* filedata
,
5583 Elf_Internal_Shdr
* section
,
5584 unsigned long * num_syms_return
)
5586 unsigned long number
= 0;
5587 Elf32_External_Sym
* esyms
= NULL
;
5588 Elf_External_Sym_Shndx
* shndx
= NULL
;
5589 Elf_Internal_Sym
* isyms
= NULL
;
5590 Elf_Internal_Sym
* psym
;
5592 elf_section_list
* entry
;
5594 if (section
->sh_size
== 0)
5596 if (num_syms_return
!= NULL
)
5597 * num_syms_return
= 0;
5601 /* Run some sanity checks first. */
5602 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5604 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5605 printable_section_name (filedata
, section
),
5606 (unsigned long) section
->sh_entsize
);
5610 if (section
->sh_size
> filedata
->file_size
)
5612 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5613 printable_section_name (filedata
, section
),
5614 (unsigned long) section
->sh_size
);
5618 number
= section
->sh_size
/ section
->sh_entsize
;
5620 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5622 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5623 (unsigned long) section
->sh_size
,
5624 printable_section_name (filedata
, section
),
5625 (unsigned long) section
->sh_entsize
);
5629 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5630 section
->sh_size
, _("symbols"));
5635 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5637 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5642 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5646 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5647 entry
->hdr
->sh_offset
,
5648 1, entry
->hdr
->sh_size
,
5649 _("symbol table section indices"));
5653 /* PR17531: file: heap-buffer-overflow */
5654 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5656 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5657 printable_section_name (filedata
, entry
->hdr
),
5658 (unsigned long) entry
->hdr
->sh_size
,
5659 (unsigned long) section
->sh_size
);
5664 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5668 error (_("Out of memory reading %lu symbols\n"),
5669 (unsigned long) number
);
5673 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5675 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5676 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5677 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5678 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5679 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5681 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5682 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5683 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5684 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5685 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5692 if (num_syms_return
!= NULL
)
5693 * num_syms_return
= isyms
== NULL
? 0 : number
;
5698 static Elf_Internal_Sym
*
5699 get_64bit_elf_symbols (Filedata
* filedata
,
5700 Elf_Internal_Shdr
* section
,
5701 unsigned long * num_syms_return
)
5703 unsigned long number
= 0;
5704 Elf64_External_Sym
* esyms
= NULL
;
5705 Elf_External_Sym_Shndx
* shndx
= NULL
;
5706 Elf_Internal_Sym
* isyms
= NULL
;
5707 Elf_Internal_Sym
* psym
;
5709 elf_section_list
* entry
;
5711 if (section
->sh_size
== 0)
5713 if (num_syms_return
!= NULL
)
5714 * num_syms_return
= 0;
5718 /* Run some sanity checks first. */
5719 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5721 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5722 printable_section_name (filedata
, section
),
5723 (unsigned long) section
->sh_entsize
);
5727 if (section
->sh_size
> filedata
->file_size
)
5729 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5730 printable_section_name (filedata
, section
),
5731 (unsigned long) section
->sh_size
);
5735 number
= section
->sh_size
/ section
->sh_entsize
;
5737 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5739 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5740 (unsigned long) section
->sh_size
,
5741 printable_section_name (filedata
, section
),
5742 (unsigned long) section
->sh_entsize
);
5746 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5747 section
->sh_size
, _("symbols"));
5752 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5754 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5759 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5763 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5764 entry
->hdr
->sh_offset
,
5765 1, entry
->hdr
->sh_size
,
5766 _("symbol table section indices"));
5770 /* PR17531: file: heap-buffer-overflow */
5771 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5773 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5774 printable_section_name (filedata
, entry
->hdr
),
5775 (unsigned long) entry
->hdr
->sh_size
,
5776 (unsigned long) section
->sh_size
);
5781 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5785 error (_("Out of memory reading %lu symbols\n"),
5786 (unsigned long) number
);
5790 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5792 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5793 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5794 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5795 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5797 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5799 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5800 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5801 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5803 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5804 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5811 if (num_syms_return
!= NULL
)
5812 * num_syms_return
= isyms
== NULL
? 0 : number
;
5818 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5820 static char buff
[1024];
5822 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5824 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5825 bfd_vma os_flags
= 0;
5826 bfd_vma proc_flags
= 0;
5827 bfd_vma unknown_flags
= 0;
5835 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5836 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5837 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5838 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5839 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5840 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5841 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5842 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5843 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5844 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5845 /* IA-64 specific. */
5846 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5847 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5848 /* IA-64 OpenVMS specific. */
5849 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5850 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5851 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5852 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5853 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5854 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5856 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5857 /* SPARC specific. */
5858 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5859 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5861 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5862 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5863 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5865 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5867 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5870 if (do_section_details
)
5872 sprintf (buff
, "[%*.*lx]: ",
5873 field_size
, field_size
, (unsigned long) sh_flags
);
5874 p
+= field_size
+ 4;
5881 flag
= sh_flags
& - sh_flags
;
5884 if (do_section_details
)
5888 case SHF_WRITE
: sindex
= 0; break;
5889 case SHF_ALLOC
: sindex
= 1; break;
5890 case SHF_EXECINSTR
: sindex
= 2; break;
5891 case SHF_MERGE
: sindex
= 3; break;
5892 case SHF_STRINGS
: sindex
= 4; break;
5893 case SHF_INFO_LINK
: sindex
= 5; break;
5894 case SHF_LINK_ORDER
: sindex
= 6; break;
5895 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5896 case SHF_GROUP
: sindex
= 8; break;
5897 case SHF_TLS
: sindex
= 9; break;
5898 case SHF_EXCLUDE
: sindex
= 18; break;
5899 case SHF_COMPRESSED
: sindex
= 20; break;
5900 case SHF_GNU_MBIND
: sindex
= 24; break;
5904 switch (filedata
->file_header
.e_machine
)
5907 if (flag
== SHF_IA_64_SHORT
)
5909 else if (flag
== SHF_IA_64_NORECOV
)
5912 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5915 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5916 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5917 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5918 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5919 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5920 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5931 case EM_OLD_SPARCV9
:
5932 case EM_SPARC32PLUS
:
5935 if (flag
== SHF_ORDERED
)
5942 case SHF_ENTRYSECT
: sindex
= 21; break;
5943 case SHF_ARM_PURECODE
: sindex
= 22; break;
5944 case SHF_COMDEF
: sindex
= 23; break;
5949 if (flag
== SHF_PPC_VLE
)
5960 if (p
!= buff
+ field_size
+ 4)
5962 if (size
< (10 + 2))
5964 warn (_("Internal error: not enough buffer room for section flag info"));
5965 return _("<unknown>");
5972 size
-= flags
[sindex
].len
;
5973 p
= stpcpy (p
, flags
[sindex
].str
);
5975 else if (flag
& SHF_MASKOS
)
5977 else if (flag
& SHF_MASKPROC
)
5980 unknown_flags
|= flag
;
5986 case SHF_WRITE
: *p
= 'W'; break;
5987 case SHF_ALLOC
: *p
= 'A'; break;
5988 case SHF_EXECINSTR
: *p
= 'X'; break;
5989 case SHF_MERGE
: *p
= 'M'; break;
5990 case SHF_STRINGS
: *p
= 'S'; break;
5991 case SHF_INFO_LINK
: *p
= 'I'; break;
5992 case SHF_LINK_ORDER
: *p
= 'L'; break;
5993 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5994 case SHF_GROUP
: *p
= 'G'; break;
5995 case SHF_TLS
: *p
= 'T'; break;
5996 case SHF_EXCLUDE
: *p
= 'E'; break;
5997 case SHF_COMPRESSED
: *p
= 'C'; break;
5998 case SHF_GNU_MBIND
: *p
= 'D'; break;
6001 if ((filedata
->file_header
.e_machine
== EM_X86_64
6002 || filedata
->file_header
.e_machine
== EM_L1OM
6003 || filedata
->file_header
.e_machine
== EM_K1OM
)
6004 && flag
== SHF_X86_64_LARGE
)
6006 else if (filedata
->file_header
.e_machine
== EM_ARM
6007 && flag
== SHF_ARM_PURECODE
)
6009 else if (filedata
->file_header
.e_machine
== EM_PPC
6010 && flag
== SHF_PPC_VLE
)
6012 else if (flag
& SHF_MASKOS
)
6015 sh_flags
&= ~ SHF_MASKOS
;
6017 else if (flag
& SHF_MASKPROC
)
6020 sh_flags
&= ~ SHF_MASKPROC
;
6030 if (do_section_details
)
6034 size
-= 5 + field_size
;
6035 if (p
!= buff
+ field_size
+ 4)
6039 warn (_("Internal error: not enough buffer room for section flag info"));
6040 return _("<unknown>");
6046 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6047 (unsigned long) os_flags
);
6048 p
+= 5 + field_size
;
6052 size
-= 7 + field_size
;
6053 if (p
!= buff
+ field_size
+ 4)
6057 warn (_("Internal error: not enough buffer room for section flag info"));
6058 return _("<unknown>");
6064 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6065 (unsigned long) proc_flags
);
6066 p
+= 7 + field_size
;
6070 size
-= 10 + field_size
;
6071 if (p
!= buff
+ field_size
+ 4)
6075 warn (_("Internal error: not enough buffer room for section flag info"));
6076 return _("<unknown>");
6082 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6083 (unsigned long) unknown_flags
);
6084 p
+= 10 + field_size
;
6092 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6093 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6097 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6099 if (size
< sizeof (* echdr
))
6101 error (_("Compressed section is too small even for a compression header\n"));
6105 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6106 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6107 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6108 return sizeof (*echdr
);
6112 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6114 if (size
< sizeof (* echdr
))
6116 error (_("Compressed section is too small even for a compression header\n"));
6120 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6121 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6122 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6123 return sizeof (*echdr
);
6128 process_section_headers (Filedata
* filedata
)
6130 Elf_Internal_Shdr
* section
;
6133 free (filedata
->section_headers
);
6134 filedata
->section_headers
= NULL
;
6135 free (dynamic_symbols
);
6136 dynamic_symbols
= NULL
;
6137 num_dynamic_syms
= 0;
6138 free (dynamic_strings
);
6139 dynamic_strings
= NULL
;
6140 dynamic_strings_length
= 0;
6141 free (dynamic_syminfo
);
6142 dynamic_syminfo
= NULL
;
6143 while (symtab_shndx_list
!= NULL
)
6145 elf_section_list
*next
= symtab_shndx_list
->next
;
6146 free (symtab_shndx_list
);
6147 symtab_shndx_list
= next
;
6150 if (filedata
->file_header
.e_shnum
== 0)
6152 /* PR binutils/12467. */
6153 if (filedata
->file_header
.e_shoff
!= 0)
6155 warn (_("possibly corrupt ELF file header - it has a non-zero"
6156 " section header offset, but no section headers\n"));
6159 else if (do_sections
)
6160 printf (_("\nThere are no sections in this file.\n"));
6165 if (do_sections
&& !do_header
)
6166 printf (ngettext ("There is %d section header, "
6167 "starting at offset 0x%lx:\n",
6168 "There are %d section headers, "
6169 "starting at offset 0x%lx:\n",
6170 filedata
->file_header
.e_shnum
),
6171 filedata
->file_header
.e_shnum
,
6172 (unsigned long) filedata
->file_header
.e_shoff
);
6176 if (! get_32bit_section_headers (filedata
, FALSE
))
6181 if (! get_64bit_section_headers (filedata
, FALSE
))
6185 /* Read in the string table, so that we have names to display. */
6186 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6187 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6189 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6191 if (section
->sh_size
!= 0)
6193 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6194 1, section
->sh_size
,
6197 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6201 /* Scan the sections for the dynamic symbol table
6202 and dynamic string table and debug sections. */
6203 eh_addr_size
= is_32bit_elf
? 4 : 8;
6204 switch (filedata
->file_header
.e_machine
)
6207 case EM_MIPS_RS3_LE
:
6208 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6209 FDE addresses. However, the ABI also has a semi-official ILP32
6210 variant for which the normal FDE address size rules apply.
6212 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6213 section, where XX is the size of longs in bits. Unfortunately,
6214 earlier compilers provided no way of distinguishing ILP32 objects
6215 from LP64 objects, so if there's any doubt, we should assume that
6216 the official LP64 form is being used. */
6217 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6218 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6224 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6226 case E_H8_MACH_H8300
:
6227 case E_H8_MACH_H8300HN
:
6228 case E_H8_MACH_H8300SN
:
6229 case E_H8_MACH_H8300SXN
:
6232 case E_H8_MACH_H8300H
:
6233 case E_H8_MACH_H8300S
:
6234 case E_H8_MACH_H8300SX
:
6242 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6244 case EF_M32C_CPU_M16C
:
6251 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6254 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6255 if (section->sh_entsize != expected_entsize) \
6258 sprintf_vma (buf, section->sh_entsize); \
6259 /* Note: coded this way so that there is a single string for \
6261 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6262 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6263 (unsigned) expected_entsize); \
6264 section->sh_entsize = expected_entsize; \
6269 #define CHECK_ENTSIZE(section, i, type) \
6270 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6271 sizeof (Elf64_External_##type))
6273 for (i
= 0, section
= filedata
->section_headers
;
6274 i
< filedata
->file_header
.e_shnum
;
6277 char * name
= SECTION_NAME (section
);
6279 if (section
->sh_type
== SHT_DYNSYM
)
6281 if (dynamic_symbols
!= NULL
)
6283 error (_("File contains multiple dynamic symbol tables\n"));
6287 CHECK_ENTSIZE (section
, i
, Sym
);
6288 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6290 else if (section
->sh_type
== SHT_STRTAB
6291 && streq (name
, ".dynstr"))
6293 if (dynamic_strings
!= NULL
)
6295 error (_("File contains multiple dynamic string tables\n"));
6299 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6300 1, section
->sh_size
,
6301 _("dynamic strings"));
6302 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6304 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6306 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6308 entry
->hdr
= section
;
6309 entry
->next
= symtab_shndx_list
;
6310 symtab_shndx_list
= entry
;
6312 else if (section
->sh_type
== SHT_SYMTAB
)
6313 CHECK_ENTSIZE (section
, i
, Sym
);
6314 else if (section
->sh_type
== SHT_GROUP
)
6315 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6316 else if (section
->sh_type
== SHT_REL
)
6317 CHECK_ENTSIZE (section
, i
, Rel
);
6318 else if (section
->sh_type
== SHT_RELA
)
6319 CHECK_ENTSIZE (section
, i
, Rela
);
6320 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6321 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6322 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6323 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6324 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6325 && (const_strneq (name
, ".debug_")
6326 || const_strneq (name
, ".zdebug_")))
6329 name
+= sizeof (".zdebug_") - 1;
6331 name
+= sizeof (".debug_") - 1;
6334 || (do_debug_info
&& const_strneq (name
, "info"))
6335 || (do_debug_info
&& const_strneq (name
, "types"))
6336 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6337 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6338 || (do_debug_lines
&& const_strneq (name
, "line."))
6339 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6340 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6341 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6342 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6343 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6344 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6345 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6346 || (do_debug_frames
&& const_strneq (name
, "frame"))
6347 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6348 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6349 || (do_debug_str
&& const_strneq (name
, "str"))
6350 || (do_debug_loc
&& const_strneq (name
, "loc"))
6351 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6352 || (do_debug_addr
&& const_strneq (name
, "addr"))
6353 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6354 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6356 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6358 /* Linkonce section to be combined with .debug_info at link time. */
6359 else if ((do_debugging
|| do_debug_info
)
6360 && const_strneq (name
, ".gnu.linkonce.wi."))
6361 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6362 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6363 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6364 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6365 || streq (name
, ".debug_names")))
6366 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6367 /* Trace sections for Itanium VMS. */
6368 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6369 || do_trace_aranges
)
6370 && const_strneq (name
, ".trace_"))
6372 name
+= sizeof (".trace_") - 1;
6375 || (do_trace_info
&& streq (name
, "info"))
6376 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6377 || (do_trace_aranges
&& streq (name
, "aranges"))
6379 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6381 else if ((do_debugging
|| do_debug_links
)
6382 && (const_strneq (name
, ".gnu_debuglink")
6383 || const_strneq (name
, ".gnu_debugaltlink")))
6384 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6390 if (filedata
->file_header
.e_shnum
> 1)
6391 printf (_("\nSection Headers:\n"));
6393 printf (_("\nSection Header:\n"));
6397 if (do_section_details
)
6399 printf (_(" [Nr] Name\n"));
6400 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6404 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6408 if (do_section_details
)
6410 printf (_(" [Nr] Name\n"));
6411 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6415 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6419 if (do_section_details
)
6421 printf (_(" [Nr] Name\n"));
6422 printf (_(" Type Address Offset Link\n"));
6423 printf (_(" Size EntSize Info Align\n"));
6427 printf (_(" [Nr] Name Type Address Offset\n"));
6428 printf (_(" Size EntSize Flags Link Info Align\n"));
6432 if (do_section_details
)
6433 printf (_(" Flags\n"));
6435 for (i
= 0, section
= filedata
->section_headers
;
6436 i
< filedata
->file_header
.e_shnum
;
6439 /* Run some sanity checks on the section header. */
6441 /* Check the sh_link field. */
6442 switch (section
->sh_type
)
6446 if (section
->sh_link
== 0
6447 && (filedata
->file_header
.e_type
== ET_EXEC
6448 || filedata
->file_header
.e_type
== ET_DYN
))
6449 /* A dynamic relocation section where all entries use a
6450 zero symbol index need not specify a symtab section. */
6453 case SHT_SYMTAB_SHNDX
:
6457 case SHT_GNU_versym
:
6458 if (section
->sh_link
== 0
6459 || section
->sh_link
>= filedata
->file_header
.e_shnum
6460 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6461 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6462 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6463 i
, section
->sh_link
);
6469 case SHT_GNU_verneed
:
6470 case SHT_GNU_verdef
:
6471 case SHT_GNU_LIBLIST
:
6472 if (section
->sh_link
== 0
6473 || section
->sh_link
>= filedata
->file_header
.e_shnum
6474 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6475 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6476 i
, section
->sh_link
);
6479 case SHT_INIT_ARRAY
:
6480 case SHT_FINI_ARRAY
:
6481 case SHT_PREINIT_ARRAY
:
6482 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6483 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6484 i
, section
->sh_link
);
6488 /* FIXME: Add support for target specific section types. */
6489 #if 0 /* Currently we do not check other section types as there are too
6490 many special cases. Stab sections for example have a type
6491 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6493 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6494 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6495 i
, section
->sh_link
);
6500 /* Check the sh_info field. */
6501 switch (section
->sh_type
)
6505 if (section
->sh_info
== 0
6506 && (filedata
->file_header
.e_type
== ET_EXEC
6507 || filedata
->file_header
.e_type
== ET_DYN
))
6508 /* Dynamic relocations apply to segments, so they do not
6509 need to specify the section they relocate. */
6511 if (section
->sh_info
== 0
6512 || section
->sh_info
>= filedata
->file_header
.e_shnum
6513 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6514 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6515 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6516 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6517 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6518 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6519 /* FIXME: Are other section types valid ? */
6520 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6521 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6522 i
, section
->sh_info
);
6527 case SHT_SYMTAB_SHNDX
:
6528 case SHT_INIT_ARRAY
:
6529 case SHT_FINI_ARRAY
:
6530 case SHT_PREINIT_ARRAY
:
6531 if (section
->sh_info
!= 0)
6532 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6533 i
, section
->sh_info
);
6539 /* A symbol index - we assume that it is valid. */
6543 /* FIXME: Add support for target specific section types. */
6544 if (section
->sh_type
== SHT_NOBITS
)
6545 /* NOBITS section headers with non-zero sh_info fields can be
6546 created when a binary is stripped of everything but its debug
6547 information. The stripped sections have their headers
6548 preserved but their types set to SHT_NOBITS. So do not check
6549 this type of section. */
6551 else if (section
->sh_flags
& SHF_INFO_LINK
)
6553 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6554 warn (_("[%2u]: Expected link to another section in info field"), i
);
6556 else if (section
->sh_type
< SHT_LOOS
6557 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6558 && section
->sh_info
!= 0)
6559 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6560 i
, section
->sh_info
);
6564 /* Check the sh_size field. */
6565 if (section
->sh_size
> filedata
->file_size
6566 && section
->sh_type
!= SHT_NOBITS
6567 && section
->sh_type
!= SHT_NULL
6568 && section
->sh_type
< SHT_LOOS
)
6569 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6571 printf (" [%2u] ", i
);
6572 if (do_section_details
)
6573 printf ("%s\n ", printable_section_name (filedata
, section
));
6575 print_symbol (-17, SECTION_NAME (section
));
6577 printf (do_wide
? " %-15s " : " %-15.15s ",
6578 get_section_type_name (filedata
, section
->sh_type
));
6582 const char * link_too_big
= NULL
;
6584 print_vma (section
->sh_addr
, LONG_HEX
);
6586 printf ( " %6.6lx %6.6lx %2.2lx",
6587 (unsigned long) section
->sh_offset
,
6588 (unsigned long) section
->sh_size
,
6589 (unsigned long) section
->sh_entsize
);
6591 if (do_section_details
)
6592 fputs (" ", stdout
);
6594 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6596 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6599 /* The sh_link value is out of range. Normally this indicates
6600 an error but it can have special values in Solaris binaries. */
6601 switch (filedata
->file_header
.e_machine
)
6608 case EM_OLD_SPARCV9
:
6609 case EM_SPARC32PLUS
:
6612 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6613 link_too_big
= "BEFORE";
6614 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6615 link_too_big
= "AFTER";
6622 if (do_section_details
)
6624 if (link_too_big
!= NULL
&& * link_too_big
)
6625 printf ("<%s> ", link_too_big
);
6627 printf ("%2u ", section
->sh_link
);
6628 printf ("%3u %2lu\n", section
->sh_info
,
6629 (unsigned long) section
->sh_addralign
);
6632 printf ("%2u %3u %2lu\n",
6635 (unsigned long) section
->sh_addralign
);
6637 if (link_too_big
&& ! * link_too_big
)
6638 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6639 i
, section
->sh_link
);
6643 print_vma (section
->sh_addr
, LONG_HEX
);
6645 if ((long) section
->sh_offset
== section
->sh_offset
)
6646 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6650 print_vma (section
->sh_offset
, LONG_HEX
);
6653 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6654 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6658 print_vma (section
->sh_size
, LONG_HEX
);
6661 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6662 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6666 print_vma (section
->sh_entsize
, LONG_HEX
);
6669 if (do_section_details
)
6670 fputs (" ", stdout
);
6672 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6674 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6676 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6677 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6680 print_vma (section
->sh_addralign
, DEC
);
6684 else if (do_section_details
)
6687 print_vma (section
->sh_addr
, LONG_HEX
);
6688 if ((long) section
->sh_offset
== section
->sh_offset
)
6689 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6693 print_vma (section
->sh_offset
, LONG_HEX
);
6695 printf (" %u\n ", section
->sh_link
);
6696 print_vma (section
->sh_size
, LONG_HEX
);
6698 print_vma (section
->sh_entsize
, LONG_HEX
);
6700 printf (" %-16u %lu\n",
6702 (unsigned long) section
->sh_addralign
);
6707 print_vma (section
->sh_addr
, LONG_HEX
);
6708 if ((long) section
->sh_offset
== section
->sh_offset
)
6709 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6713 print_vma (section
->sh_offset
, LONG_HEX
);
6716 print_vma (section
->sh_size
, LONG_HEX
);
6718 print_vma (section
->sh_entsize
, LONG_HEX
);
6720 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6722 printf (" %2u %3u %lu\n",
6725 (unsigned long) section
->sh_addralign
);
6728 if (do_section_details
)
6730 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6731 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6733 /* Minimum section size is 12 bytes for 32-bit compression
6734 header + 12 bytes for compressed data header. */
6735 unsigned char buf
[24];
6737 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6738 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6739 sizeof (buf
), _("compression header")))
6741 Elf_Internal_Chdr chdr
;
6743 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6744 printf (_(" [<corrupt>]\n"));
6747 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6750 printf (_(" [<unknown>: 0x%x], "),
6752 print_vma (chdr
.ch_size
, LONG_HEX
);
6753 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6760 if (!do_section_details
)
6762 /* The ordering of the letters shown here matches the ordering of the
6763 corresponding SHF_xxx values, and hence the order in which these
6764 letters will be displayed to the user. */
6765 printf (_("Key to Flags:\n\
6766 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6767 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6768 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6769 if (filedata
->file_header
.e_machine
== EM_X86_64
6770 || filedata
->file_header
.e_machine
== EM_L1OM
6771 || filedata
->file_header
.e_machine
== EM_K1OM
)
6772 printf (_("l (large), "));
6773 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6774 printf (_("y (purecode), "));
6775 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6776 printf (_("v (VLE), "));
6777 printf ("p (processor specific)\n");
6784 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6785 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6786 char **strtab
, unsigned long *strtablen
)
6790 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6792 if (*symtab
== NULL
)
6795 if (symsec
->sh_link
!= 0)
6797 Elf_Internal_Shdr
*strsec
;
6799 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6801 error (_("Bad sh_link in symbol table section\n"));
6808 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6810 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6811 1, strsec
->sh_size
, _("string table"));
6812 if (*strtab
== NULL
)
6819 *strtablen
= strsec
->sh_size
;
6825 get_group_flags (unsigned int flags
)
6827 static char buff
[128];
6831 else if (flags
== GRP_COMDAT
)
6834 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6836 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6837 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6838 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6839 ? _("<unknown>") : ""));
6845 process_section_groups (Filedata
* filedata
)
6847 Elf_Internal_Shdr
* section
;
6849 struct group
* group
;
6850 Elf_Internal_Shdr
* symtab_sec
;
6851 Elf_Internal_Shdr
* strtab_sec
;
6852 Elf_Internal_Sym
* symtab
;
6853 unsigned long num_syms
;
6857 /* Don't process section groups unless needed. */
6858 if (!do_unwind
&& !do_section_groups
)
6861 if (filedata
->file_header
.e_shnum
== 0)
6863 if (do_section_groups
)
6864 printf (_("\nThere are no sections to group in this file.\n"));
6869 if (filedata
->section_headers
== NULL
)
6871 error (_("Section headers are not available!\n"));
6872 /* PR 13622: This can happen with a corrupt ELF header. */
6876 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6877 sizeof (struct group
*));
6879 if (section_headers_groups
== NULL
)
6881 error (_("Out of memory reading %u section group headers\n"),
6882 filedata
->file_header
.e_shnum
);
6886 /* Scan the sections for the group section. */
6888 for (i
= 0, section
= filedata
->section_headers
;
6889 i
< filedata
->file_header
.e_shnum
;
6891 if (section
->sh_type
== SHT_GROUP
)
6894 if (group_count
== 0)
6896 if (do_section_groups
)
6897 printf (_("\nThere are no section groups in this file.\n"));
6902 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6904 if (section_groups
== NULL
)
6906 error (_("Out of memory reading %lu groups\n"),
6907 (unsigned long) group_count
);
6917 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6918 i
< filedata
->file_header
.e_shnum
;
6921 if (section
->sh_type
== SHT_GROUP
)
6923 const char * name
= printable_section_name (filedata
, section
);
6924 const char * group_name
;
6925 unsigned char * start
;
6926 unsigned char * indices
;
6927 unsigned int entry
, j
, size
;
6928 Elf_Internal_Shdr
* sec
;
6929 Elf_Internal_Sym
* sym
;
6931 /* Get the symbol table. */
6932 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6933 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6936 error (_("Bad sh_link in group section `%s'\n"), name
);
6940 if (symtab_sec
!= sec
)
6945 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6950 error (_("Corrupt header in group section `%s'\n"), name
);
6954 if (section
->sh_info
>= num_syms
)
6956 error (_("Bad sh_info in group section `%s'\n"), name
);
6960 sym
= symtab
+ section
->sh_info
;
6962 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6964 if (sym
->st_shndx
== 0
6965 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6967 error (_("Bad sh_info in group section `%s'\n"), name
);
6971 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6980 /* Get the string table. */
6981 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6990 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6996 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6997 1, strtab_sec
->sh_size
,
6999 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7001 group_name
= sym
->st_name
< strtab_size
7002 ? strtab
+ sym
->st_name
: _("<corrupt>");
7005 /* PR 17531: file: loop. */
7006 if (section
->sh_entsize
> section
->sh_size
)
7008 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7009 printable_section_name (filedata
, section
),
7010 (unsigned long) section
->sh_entsize
,
7011 (unsigned long) section
->sh_size
);
7015 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7016 1, section
->sh_size
,
7022 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7023 entry
= byte_get (indices
, 4);
7026 if (do_section_groups
)
7028 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7029 get_group_flags (entry
), i
, name
, group_name
, size
);
7031 printf (_(" [Index] Name\n"));
7034 group
->group_index
= i
;
7036 for (j
= 0; j
< size
; j
++)
7038 struct group_list
* g
;
7040 entry
= byte_get (indices
, 4);
7043 if (entry
>= filedata
->file_header
.e_shnum
)
7045 static unsigned num_group_errors
= 0;
7047 if (num_group_errors
++ < 10)
7049 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7050 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7051 if (num_group_errors
== 10)
7052 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7057 if (section_headers_groups
[entry
] != NULL
)
7061 static unsigned num_errs
= 0;
7063 if (num_errs
++ < 10)
7065 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7067 section_headers_groups
[entry
]->group_index
);
7069 warn (_("Further error messages about already contained group sections suppressed\n"));
7075 /* Intel C/C++ compiler may put section 0 in a
7076 section group. We just warn it the first time
7077 and ignore it afterwards. */
7078 static bfd_boolean warned
= FALSE
;
7081 error (_("section 0 in group section [%5u]\n"),
7082 section_headers_groups
[entry
]->group_index
);
7088 section_headers_groups
[entry
] = group
;
7090 if (do_section_groups
)
7092 sec
= filedata
->section_headers
+ entry
;
7093 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7096 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7097 g
->section_index
= entry
;
7098 g
->next
= group
->root
;
7116 /* Data used to display dynamic fixups. */
7118 struct ia64_vms_dynfixup
7120 bfd_vma needed_ident
; /* Library ident number. */
7121 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7122 bfd_vma fixup_needed
; /* Index of the library. */
7123 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7124 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7127 /* Data used to display dynamic relocations. */
7129 struct ia64_vms_dynimgrela
7131 bfd_vma img_rela_cnt
; /* Number of relocations. */
7132 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7135 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7139 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7140 struct ia64_vms_dynfixup
* fixup
,
7141 const char * strtab
,
7142 unsigned int strtab_sz
)
7144 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7146 const char * lib_name
;
7148 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7149 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7150 _("dynamic section image fixups"));
7154 if (fixup
->needed
< strtab_sz
)
7155 lib_name
= strtab
+ fixup
->needed
;
7158 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7159 (unsigned long) fixup
->needed
);
7163 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7164 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7166 (_("Seg Offset Type SymVec DataType\n"));
7168 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7173 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7174 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7175 type
= BYTE_GET (imfs
[i
].type
);
7176 rtype
= elf_ia64_reloc_type (type
);
7178 printf (" 0x%08x ", type
);
7180 printf (" %-32s ", rtype
);
7181 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7182 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7189 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7192 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7194 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7197 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7198 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7199 _("dynamic section image relocations"));
7203 printf (_("\nImage relocs\n"));
7205 (_("Seg Offset Type Addend Seg Sym Off\n"));
7207 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7212 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7213 printf ("%08" BFD_VMA_FMT
"x ",
7214 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7215 type
= BYTE_GET (imrs
[i
].type
);
7216 rtype
= elf_ia64_reloc_type (type
);
7218 printf ("0x%08x ", type
);
7220 printf ("%-31s ", rtype
);
7221 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7222 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7223 printf ("%08" BFD_VMA_FMT
"x\n",
7224 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7231 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7234 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7236 struct ia64_vms_dynfixup fixup
;
7237 struct ia64_vms_dynimgrela imgrela
;
7238 Elf_Internal_Dyn
*entry
;
7239 bfd_vma strtab_off
= 0;
7240 bfd_vma strtab_sz
= 0;
7241 char *strtab
= NULL
;
7242 bfd_boolean res
= TRUE
;
7244 memset (&fixup
, 0, sizeof (fixup
));
7245 memset (&imgrela
, 0, sizeof (imgrela
));
7247 /* Note: the order of the entries is specified by the OpenVMS specs. */
7248 for (entry
= dynamic_section
;
7249 entry
< dynamic_section
+ dynamic_nent
;
7252 switch (entry
->d_tag
)
7254 case DT_IA_64_VMS_STRTAB_OFFSET
:
7255 strtab_off
= entry
->d_un
.d_val
;
7258 strtab_sz
= entry
->d_un
.d_val
;
7260 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7261 1, strtab_sz
, _("dynamic string section"));
7266 case DT_IA_64_VMS_NEEDED_IDENT
:
7267 fixup
.needed_ident
= entry
->d_un
.d_val
;
7270 fixup
.needed
= entry
->d_un
.d_val
;
7272 case DT_IA_64_VMS_FIXUP_NEEDED
:
7273 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7275 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7276 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7278 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7279 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7280 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7283 case DT_IA_64_VMS_IMG_RELA_CNT
:
7284 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7286 case DT_IA_64_VMS_IMG_RELA_OFF
:
7287 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7288 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7310 dynamic_relocations
[] =
7312 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7313 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7314 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7317 /* Process the reloc section. */
7320 process_relocs (Filedata
* filedata
)
7322 unsigned long rel_size
;
7323 unsigned long rel_offset
;
7328 if (do_using_dynamic
)
7332 bfd_boolean has_dynamic_reloc
;
7335 has_dynamic_reloc
= FALSE
;
7337 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7339 is_rela
= dynamic_relocations
[i
].rela
;
7340 name
= dynamic_relocations
[i
].name
;
7341 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7342 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7345 has_dynamic_reloc
= TRUE
;
7347 if (is_rela
== UNKNOWN
)
7349 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7350 switch (dynamic_info
[DT_PLTREL
])
7364 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7365 name
, rel_offset
, rel_size
);
7367 dump_relocations (filedata
,
7368 offset_from_vma (filedata
, rel_offset
, rel_size
),
7370 dynamic_symbols
, num_dynamic_syms
,
7371 dynamic_strings
, dynamic_strings_length
,
7372 is_rela
, TRUE
/* is_dynamic */);
7376 if (is_ia64_vms (filedata
))
7377 if (process_ia64_vms_dynamic_relocs (filedata
))
7378 has_dynamic_reloc
= TRUE
;
7380 if (! has_dynamic_reloc
)
7381 printf (_("\nThere are no dynamic relocations in this file.\n"));
7385 Elf_Internal_Shdr
* section
;
7387 bfd_boolean found
= FALSE
;
7389 for (i
= 0, section
= filedata
->section_headers
;
7390 i
< filedata
->file_header
.e_shnum
;
7393 if ( section
->sh_type
!= SHT_RELA
7394 && section
->sh_type
!= SHT_REL
)
7397 rel_offset
= section
->sh_offset
;
7398 rel_size
= section
->sh_size
;
7403 unsigned long num_rela
;
7405 printf (_("\nRelocation section "));
7407 if (filedata
->string_table
== NULL
)
7408 printf ("%d", section
->sh_name
);
7410 printf ("'%s'", printable_section_name (filedata
, section
));
7412 num_rela
= rel_size
/ section
->sh_entsize
;
7413 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7414 " at offset 0x%lx contains %lu entries:\n",
7416 rel_offset
, num_rela
);
7418 is_rela
= section
->sh_type
== SHT_RELA
;
7420 if (section
->sh_link
!= 0
7421 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7423 Elf_Internal_Shdr
* symsec
;
7424 Elf_Internal_Sym
* symtab
;
7425 unsigned long nsyms
;
7426 unsigned long strtablen
= 0;
7427 char * strtab
= NULL
;
7429 symsec
= filedata
->section_headers
+ section
->sh_link
;
7430 if (symsec
->sh_type
!= SHT_SYMTAB
7431 && symsec
->sh_type
!= SHT_DYNSYM
)
7434 if (!get_symtab (filedata
, symsec
,
7435 &symtab
, &nsyms
, &strtab
, &strtablen
))
7438 dump_relocations (filedata
, rel_offset
, rel_size
,
7439 symtab
, nsyms
, strtab
, strtablen
,
7441 symsec
->sh_type
== SHT_DYNSYM
);
7447 dump_relocations (filedata
, rel_offset
, rel_size
,
7448 NULL
, 0, NULL
, 0, is_rela
,
7449 FALSE
/* is_dynamic */);
7457 /* Users sometimes forget the -D option, so try to be helpful. */
7458 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7460 if (dynamic_info
[dynamic_relocations
[i
].size
])
7462 printf (_("\nThere are no static relocations in this file."));
7463 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7468 if (i
== ARRAY_SIZE (dynamic_relocations
))
7469 printf (_("\nThere are no relocations in this file.\n"));
7476 /* An absolute address consists of a section and an offset. If the
7477 section is NULL, the offset itself is the address, otherwise, the
7478 address equals to LOAD_ADDRESS(section) + offset. */
7482 unsigned short section
;
7486 /* Find the nearest symbol at or below ADDR. Returns the symbol
7487 name, if found, and the offset from the symbol to ADDR. */
7490 find_symbol_for_address (Filedata
* filedata
,
7491 Elf_Internal_Sym
* symtab
,
7492 unsigned long nsyms
,
7493 const char * strtab
,
7494 unsigned long strtab_size
,
7495 struct absaddr addr
,
7496 const char ** symname
,
7499 bfd_vma dist
= 0x100000;
7500 Elf_Internal_Sym
* sym
;
7501 Elf_Internal_Sym
* beg
;
7502 Elf_Internal_Sym
* end
;
7503 Elf_Internal_Sym
* best
= NULL
;
7505 REMOVE_ARCH_BITS (addr
.offset
);
7507 end
= symtab
+ nsyms
;
7513 sym
= beg
+ (end
- beg
) / 2;
7515 value
= sym
->st_value
;
7516 REMOVE_ARCH_BITS (value
);
7518 if (sym
->st_name
!= 0
7519 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7520 && addr
.offset
>= value
7521 && addr
.offset
- value
< dist
)
7524 dist
= addr
.offset
- value
;
7529 if (addr
.offset
< value
)
7537 *symname
= (best
->st_name
>= strtab_size
7538 ? _("<corrupt>") : strtab
+ best
->st_name
);
7544 *offset
= addr
.offset
;
7547 static /* signed */ int
7548 symcmp (const void *p
, const void *q
)
7550 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7551 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7553 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7556 /* Process the unwind section. */
7558 #include "unwind-ia64.h"
7560 struct ia64_unw_table_entry
7562 struct absaddr start
;
7564 struct absaddr info
;
7567 struct ia64_unw_aux_info
7569 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7570 unsigned long table_len
; /* Length of unwind table. */
7571 unsigned char * info
; /* Unwind info. */
7572 unsigned long info_size
; /* Size of unwind info. */
7573 bfd_vma info_addr
; /* Starting address of unwind info. */
7574 bfd_vma seg_base
; /* Starting address of segment. */
7575 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7576 unsigned long nsyms
; /* Number of symbols. */
7577 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7578 unsigned long nfuns
; /* Number of entries in funtab. */
7579 char * strtab
; /* The string table. */
7580 unsigned long strtab_size
; /* Size of string table. */
7584 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7586 struct ia64_unw_table_entry
* tp
;
7587 unsigned long j
, nfuns
;
7589 bfd_boolean res
= TRUE
;
7591 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7592 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7593 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7594 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7596 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7598 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7602 const unsigned char * dp
;
7603 const unsigned char * head
;
7604 const unsigned char * end
;
7605 const char * procname
;
7607 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7608 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7610 fputs ("\n<", stdout
);
7614 fputs (procname
, stdout
);
7617 printf ("+%lx", (unsigned long) offset
);
7620 fputs (">: [", stdout
);
7621 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7622 fputc ('-', stdout
);
7623 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7624 printf ("], info at +0x%lx\n",
7625 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7627 /* PR 17531: file: 86232b32. */
7628 if (aux
->info
== NULL
)
7631 offset
= tp
->info
.offset
;
7632 if (tp
->info
.section
)
7634 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7636 warn (_("Invalid section %u in table entry %ld\n"),
7637 tp
->info
.section
, (long) (tp
- aux
->table
));
7641 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7643 offset
-= aux
->info_addr
;
7644 /* PR 17531: file: 0997b4d1. */
7645 if (offset
>= aux
->info_size
7646 || aux
->info_size
- offset
< 8)
7648 warn (_("Invalid offset %lx in table entry %ld\n"),
7649 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7654 head
= aux
->info
+ offset
;
7655 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7657 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7658 (unsigned) UNW_VER (stamp
),
7659 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7660 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7661 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7662 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7664 if (UNW_VER (stamp
) != 1)
7666 printf (_("\tUnknown version.\n"));
7671 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7672 /* PR 17531: file: 16ceda89. */
7673 if (end
> aux
->info
+ aux
->info_size
)
7674 end
= aux
->info
+ aux
->info_size
;
7675 for (dp
= head
+ 8; dp
< end
;)
7676 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7685 slurp_ia64_unwind_table (Filedata
* filedata
,
7686 struct ia64_unw_aux_info
* aux
,
7687 Elf_Internal_Shdr
* sec
)
7689 unsigned long size
, nrelas
, i
;
7690 Elf_Internal_Phdr
* seg
;
7691 struct ia64_unw_table_entry
* tep
;
7692 Elf_Internal_Shdr
* relsec
;
7693 Elf_Internal_Rela
* rela
;
7694 Elf_Internal_Rela
* rp
;
7695 unsigned char * table
;
7697 Elf_Internal_Sym
* sym
;
7698 const char * relname
;
7702 /* First, find the starting address of the segment that includes
7705 if (filedata
->file_header
.e_phnum
)
7707 if (! get_program_headers (filedata
))
7710 for (seg
= filedata
->program_headers
;
7711 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7714 if (seg
->p_type
!= PT_LOAD
)
7717 if (sec
->sh_addr
>= seg
->p_vaddr
7718 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7720 aux
->seg_base
= seg
->p_vaddr
;
7726 /* Second, build the unwind table from the contents of the unwind section: */
7727 size
= sec
->sh_size
;
7728 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7733 aux
->table_len
= size
/ (3 * eh_addr_size
);
7734 aux
->table
= (struct ia64_unw_table_entry
*)
7735 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7738 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7740 tep
->start
.section
= SHN_UNDEF
;
7741 tep
->end
.section
= SHN_UNDEF
;
7742 tep
->info
.section
= SHN_UNDEF
;
7743 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7744 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7745 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7746 tep
->start
.offset
+= aux
->seg_base
;
7747 tep
->end
.offset
+= aux
->seg_base
;
7748 tep
->info
.offset
+= aux
->seg_base
;
7752 /* Third, apply any relocations to the unwind table: */
7753 for (relsec
= filedata
->section_headers
;
7754 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7757 if (relsec
->sh_type
!= SHT_RELA
7758 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7759 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7762 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7771 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7773 unsigned int sym_ndx
;
7774 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7775 relname
= elf_ia64_reloc_type (r_type
);
7777 /* PR 17531: file: 9fa67536. */
7778 if (relname
== NULL
)
7780 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7784 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7786 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7790 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7792 /* PR 17531: file: 5bc8d9bf. */
7793 if (i
>= aux
->table_len
)
7795 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7799 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7800 if (sym_ndx
>= aux
->nsyms
)
7802 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7806 sym
= aux
->symtab
+ sym_ndx
;
7808 switch (rp
->r_offset
/ eh_addr_size
% 3)
7811 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7812 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7815 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7816 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7819 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7820 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7834 ia64_process_unwind (Filedata
* filedata
)
7836 Elf_Internal_Shdr
* sec
;
7837 Elf_Internal_Shdr
* unwsec
= NULL
;
7838 unsigned long i
, unwcount
= 0, unwstart
= 0;
7839 struct ia64_unw_aux_info aux
;
7840 bfd_boolean res
= TRUE
;
7842 memset (& aux
, 0, sizeof (aux
));
7844 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7846 if (sec
->sh_type
== SHT_SYMTAB
)
7850 error (_("Multiple symbol tables encountered\n"));
7856 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7857 &aux
.strtab
, &aux
.strtab_size
))
7860 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7865 printf (_("\nThere are no unwind sections in this file.\n"));
7867 while (unwcount
-- > 0)
7872 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7873 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7874 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7879 /* We have already counted the number of SHT_IA64_UNWIND
7880 sections so the loop above should never fail. */
7881 assert (unwsec
!= NULL
);
7884 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7886 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7888 /* We need to find which section group it is in. */
7889 struct group_list
* g
;
7891 if (section_headers_groups
== NULL
7892 || section_headers_groups
[i
] == NULL
)
7893 i
= filedata
->file_header
.e_shnum
;
7896 g
= section_headers_groups
[i
]->root
;
7898 for (; g
!= NULL
; g
= g
->next
)
7900 sec
= filedata
->section_headers
+ g
->section_index
;
7902 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7907 i
= filedata
->file_header
.e_shnum
;
7910 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7912 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7913 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7914 suffix
= SECTION_NAME (unwsec
) + len
;
7915 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7917 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7918 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7923 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7924 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7925 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7926 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7928 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7929 suffix
= SECTION_NAME (unwsec
) + len
;
7930 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7932 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7933 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7937 if (i
== filedata
->file_header
.e_shnum
)
7939 printf (_("\nCould not find unwind info section for "));
7941 if (filedata
->string_table
== NULL
)
7942 printf ("%d", unwsec
->sh_name
);
7944 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7948 aux
.info_addr
= sec
->sh_addr
;
7949 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7952 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7954 printf (_("\nUnwind section "));
7956 if (filedata
->string_table
== NULL
)
7957 printf ("%d", unwsec
->sh_name
);
7959 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7961 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7962 (unsigned long) unwsec
->sh_offset
,
7963 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7965 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7966 && aux
.table_len
> 0)
7967 dump_ia64_unwind (filedata
, & aux
);
7970 free ((char *) aux
.table
);
7972 free ((char *) aux
.info
);
7981 free ((char *) aux
.strtab
);
7986 struct hppa_unw_table_entry
7988 struct absaddr start
;
7990 unsigned int Cannot_unwind
:1; /* 0 */
7991 unsigned int Millicode
:1; /* 1 */
7992 unsigned int Millicode_save_sr0
:1; /* 2 */
7993 unsigned int Region_description
:2; /* 3..4 */
7994 unsigned int reserved1
:1; /* 5 */
7995 unsigned int Entry_SR
:1; /* 6 */
7996 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7997 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7998 unsigned int Args_stored
:1; /* 16 */
7999 unsigned int Variable_Frame
:1; /* 17 */
8000 unsigned int Separate_Package_Body
:1; /* 18 */
8001 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8002 unsigned int Stack_Overflow_Check
:1; /* 20 */
8003 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8004 unsigned int Ada_Region
:1; /* 22 */
8005 unsigned int cxx_info
:1; /* 23 */
8006 unsigned int cxx_try_catch
:1; /* 24 */
8007 unsigned int sched_entry_seq
:1; /* 25 */
8008 unsigned int reserved2
:1; /* 26 */
8009 unsigned int Save_SP
:1; /* 27 */
8010 unsigned int Save_RP
:1; /* 28 */
8011 unsigned int Save_MRP_in_frame
:1; /* 29 */
8012 unsigned int extn_ptr_defined
:1; /* 30 */
8013 unsigned int Cleanup_defined
:1; /* 31 */
8015 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8016 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8017 unsigned int Large_frame
:1; /* 2 */
8018 unsigned int Pseudo_SP_Set
:1; /* 3 */
8019 unsigned int reserved4
:1; /* 4 */
8020 unsigned int Total_frame_size
:27; /* 5..31 */
8023 struct hppa_unw_aux_info
8025 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8026 unsigned long table_len
; /* Length of unwind table. */
8027 bfd_vma seg_base
; /* Starting address of segment. */
8028 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8029 unsigned long nsyms
; /* Number of symbols. */
8030 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8031 unsigned long nfuns
; /* Number of entries in funtab. */
8032 char * strtab
; /* The string table. */
8033 unsigned long strtab_size
; /* Size of string table. */
8037 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8039 struct hppa_unw_table_entry
* tp
;
8040 unsigned long j
, nfuns
;
8041 bfd_boolean res
= TRUE
;
8043 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8044 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8045 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8046 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8048 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8050 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8053 const char * procname
;
8055 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8056 aux
->strtab_size
, tp
->start
, &procname
,
8059 fputs ("\n<", stdout
);
8063 fputs (procname
, stdout
);
8066 printf ("+%lx", (unsigned long) offset
);
8069 fputs (">: [", stdout
);
8070 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8071 fputc ('-', stdout
);
8072 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8075 #define PF(_m) if (tp->_m) printf (#_m " ");
8076 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8079 PF(Millicode_save_sr0
);
8080 /* PV(Region_description); */
8086 PF(Separate_Package_Body
);
8087 PF(Frame_Extension_Millicode
);
8088 PF(Stack_Overflow_Check
);
8089 PF(Two_Instruction_SP_Increment
);
8093 PF(sched_entry_seq
);
8096 PF(Save_MRP_in_frame
);
8097 PF(extn_ptr_defined
);
8098 PF(Cleanup_defined
);
8099 PF(MPE_XL_interrupt_marker
);
8100 PF(HP_UX_interrupt_marker
);
8103 PV(Total_frame_size
);
8116 slurp_hppa_unwind_table (Filedata
* filedata
,
8117 struct hppa_unw_aux_info
* aux
,
8118 Elf_Internal_Shdr
* sec
)
8120 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8121 Elf_Internal_Phdr
* seg
;
8122 struct hppa_unw_table_entry
* tep
;
8123 Elf_Internal_Shdr
* relsec
;
8124 Elf_Internal_Rela
* rela
;
8125 Elf_Internal_Rela
* rp
;
8126 unsigned char * table
;
8128 Elf_Internal_Sym
* sym
;
8129 const char * relname
;
8131 /* First, find the starting address of the segment that includes
8133 if (filedata
->file_header
.e_phnum
)
8135 if (! get_program_headers (filedata
))
8138 for (seg
= filedata
->program_headers
;
8139 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8142 if (seg
->p_type
!= PT_LOAD
)
8145 if (sec
->sh_addr
>= seg
->p_vaddr
8146 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8148 aux
->seg_base
= seg
->p_vaddr
;
8154 /* Second, build the unwind table from the contents of the unwind
8156 size
= sec
->sh_size
;
8157 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8163 nentries
= size
/ unw_ent_size
;
8164 size
= unw_ent_size
* nentries
;
8166 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8167 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8169 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8171 unsigned int tmp1
, tmp2
;
8173 tep
->start
.section
= SHN_UNDEF
;
8174 tep
->end
.section
= SHN_UNDEF
;
8176 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8177 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8178 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8179 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8181 tep
->start
.offset
+= aux
->seg_base
;
8182 tep
->end
.offset
+= aux
->seg_base
;
8184 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8185 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8186 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8187 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8188 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8189 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8190 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8191 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8192 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8193 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8194 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8195 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8196 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8197 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8198 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8199 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8200 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8201 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8202 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8203 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8204 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8205 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8206 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8207 tep
->Cleanup_defined
= tmp1
& 0x1;
8209 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8210 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8211 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8212 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8213 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8214 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8218 /* Third, apply any relocations to the unwind table. */
8219 for (relsec
= filedata
->section_headers
;
8220 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8223 if (relsec
->sh_type
!= SHT_RELA
8224 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8225 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8228 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8232 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8234 unsigned int sym_ndx
;
8235 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8236 relname
= elf_hppa_reloc_type (r_type
);
8238 if (relname
== NULL
)
8240 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8244 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8245 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8247 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8251 i
= rp
->r_offset
/ unw_ent_size
;
8252 if (i
>= aux
->table_len
)
8254 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8258 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8259 if (sym_ndx
>= aux
->nsyms
)
8261 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8265 sym
= aux
->symtab
+ sym_ndx
;
8267 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8270 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8271 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8274 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8275 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8285 aux
->table_len
= nentries
;
8291 hppa_process_unwind (Filedata
* filedata
)
8293 struct hppa_unw_aux_info aux
;
8294 Elf_Internal_Shdr
* unwsec
= NULL
;
8295 Elf_Internal_Shdr
* sec
;
8297 bfd_boolean res
= TRUE
;
8299 if (filedata
->string_table
== NULL
)
8302 memset (& aux
, 0, sizeof (aux
));
8304 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8306 if (sec
->sh_type
== SHT_SYMTAB
)
8310 error (_("Multiple symbol tables encountered\n"));
8316 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8317 &aux
.strtab
, &aux
.strtab_size
))
8320 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8325 printf (_("\nThere are no unwind sections in this file.\n"));
8327 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8329 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8331 unsigned long num_unwind
= sec
->sh_size
/ 16;
8333 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8334 "contains %lu entry:\n",
8335 "\nUnwind section '%s' at offset 0x%lx "
8336 "contains %lu entries:\n",
8338 printable_section_name (filedata
, sec
),
8339 (unsigned long) sec
->sh_offset
,
8342 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8345 if (res
&& aux
.table_len
> 0)
8347 if (! dump_hppa_unwind (filedata
, &aux
))
8352 free ((char *) aux
.table
);
8360 free ((char *) aux
.strtab
);
8367 unsigned char * data
; /* The unwind data. */
8368 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8369 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8370 unsigned long nrelas
; /* The number of relocations. */
8371 unsigned int rel_type
; /* REL or RELA ? */
8372 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8375 struct arm_unw_aux_info
8377 Filedata
* filedata
; /* The file containing the unwind sections. */
8378 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8379 unsigned long nsyms
; /* Number of symbols. */
8380 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8381 unsigned long nfuns
; /* Number of these symbols. */
8382 char * strtab
; /* The file's string table. */
8383 unsigned long strtab_size
; /* Size of string table. */
8387 arm_print_vma_and_name (Filedata
* filedata
,
8388 struct arm_unw_aux_info
* aux
,
8390 struct absaddr addr
)
8392 const char *procname
;
8395 if (addr
.section
== SHN_UNDEF
)
8398 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8399 aux
->strtab_size
, addr
, &procname
,
8402 print_vma (fn
, PREFIX_HEX
);
8406 fputs (" <", stdout
);
8407 fputs (procname
, stdout
);
8410 printf ("+0x%lx", (unsigned long) sym_offset
);
8411 fputc ('>', stdout
);
8418 arm_free_section (struct arm_section
*arm_sec
)
8420 if (arm_sec
->data
!= NULL
)
8421 free (arm_sec
->data
);
8423 if (arm_sec
->rela
!= NULL
)
8424 free (arm_sec
->rela
);
8427 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8428 cached section and install SEC instead.
8429 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8430 and return its valued in * WORDP, relocating if necessary.
8431 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8432 relocation's offset in ADDR.
8433 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8434 into the string table of the symbol associated with the reloc. If no
8435 reloc was applied store -1 there.
8436 5) Return TRUE upon success, FALSE otherwise. */
8439 get_unwind_section_word (Filedata
* filedata
,
8440 struct arm_unw_aux_info
* aux
,
8441 struct arm_section
* arm_sec
,
8442 Elf_Internal_Shdr
* sec
,
8443 bfd_vma word_offset
,
8444 unsigned int * wordp
,
8445 struct absaddr
* addr
,
8448 Elf_Internal_Rela
*rp
;
8449 Elf_Internal_Sym
*sym
;
8450 const char * relname
;
8452 bfd_boolean wrapped
;
8454 if (sec
== NULL
|| arm_sec
== NULL
)
8457 addr
->section
= SHN_UNDEF
;
8460 if (sym_name
!= NULL
)
8461 *sym_name
= (bfd_vma
) -1;
8463 /* If necessary, update the section cache. */
8464 if (sec
!= arm_sec
->sec
)
8466 Elf_Internal_Shdr
*relsec
;
8468 arm_free_section (arm_sec
);
8471 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8472 sec
->sh_size
, _("unwind data"));
8473 arm_sec
->rela
= NULL
;
8474 arm_sec
->nrelas
= 0;
8476 for (relsec
= filedata
->section_headers
;
8477 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8480 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8481 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8482 /* PR 15745: Check the section type as well. */
8483 || (relsec
->sh_type
!= SHT_REL
8484 && relsec
->sh_type
!= SHT_RELA
))
8487 arm_sec
->rel_type
= relsec
->sh_type
;
8488 if (relsec
->sh_type
== SHT_REL
)
8490 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8492 & arm_sec
->rela
, & arm_sec
->nrelas
))
8495 else /* relsec->sh_type == SHT_RELA */
8497 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8499 & arm_sec
->rela
, & arm_sec
->nrelas
))
8505 arm_sec
->next_rela
= arm_sec
->rela
;
8508 /* If there is no unwind data we can do nothing. */
8509 if (arm_sec
->data
== NULL
)
8512 /* If the offset is invalid then fail. */
8513 if (/* PR 21343 *//* PR 18879 */
8515 || word_offset
> (sec
->sh_size
- 4)
8516 || ((bfd_signed_vma
) word_offset
) < 0)
8519 /* Get the word at the required offset. */
8520 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8522 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8523 if (arm_sec
->rela
== NULL
)
8529 /* Look through the relocs to find the one that applies to the provided offset. */
8531 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8533 bfd_vma prelval
, offset
;
8535 if (rp
->r_offset
> word_offset
&& !wrapped
)
8540 if (rp
->r_offset
> word_offset
)
8543 if (rp
->r_offset
& 3)
8545 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8546 (unsigned long) rp
->r_offset
);
8550 if (rp
->r_offset
< word_offset
)
8553 /* PR 17531: file: 027-161405-0.004 */
8554 if (aux
->symtab
== NULL
)
8557 if (arm_sec
->rel_type
== SHT_REL
)
8559 offset
= word
& 0x7fffffff;
8560 if (offset
& 0x40000000)
8561 offset
|= ~ (bfd_vma
) 0x7fffffff;
8563 else if (arm_sec
->rel_type
== SHT_RELA
)
8564 offset
= rp
->r_addend
;
8567 error (_("Unknown section relocation type %d encountered\n"),
8572 /* PR 17531 file: 027-1241568-0.004. */
8573 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8575 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8576 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8580 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8581 offset
+= sym
->st_value
;
8582 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8584 /* Check that we are processing the expected reloc type. */
8585 if (filedata
->file_header
.e_machine
== EM_ARM
)
8587 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8588 if (relname
== NULL
)
8590 warn (_("Skipping unknown ARM relocation type: %d\n"),
8591 (int) ELF32_R_TYPE (rp
->r_info
));
8595 if (streq (relname
, "R_ARM_NONE"))
8598 if (! streq (relname
, "R_ARM_PREL31"))
8600 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8604 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8606 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8607 if (relname
== NULL
)
8609 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8610 (int) ELF32_R_TYPE (rp
->r_info
));
8614 if (streq (relname
, "R_C6000_NONE"))
8617 if (! streq (relname
, "R_C6000_PREL31"))
8619 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8627 /* This function currently only supports ARM and TI unwinders. */
8628 warn (_("Only TI and ARM unwinders are currently supported\n"));
8632 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8633 addr
->section
= sym
->st_shndx
;
8634 addr
->offset
= offset
;
8637 * sym_name
= sym
->st_name
;
8642 arm_sec
->next_rela
= rp
;
8647 static const char *tic6x_unwind_regnames
[16] =
8649 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8650 "A14", "A13", "A12", "A11", "A10",
8651 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8655 decode_tic6x_unwind_regmask (unsigned int mask
)
8659 for (i
= 12; mask
; mask
>>= 1, i
--)
8663 fputs (tic6x_unwind_regnames
[i
], stdout
);
8665 fputs (", ", stdout
);
8671 if (remaining == 0 && more_words) \
8674 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8675 data_offset, & word, & addr, NULL)) \
8681 #define GET_OP(OP) \
8686 (OP) = word >> 24; \
8691 printf (_("[Truncated opcode]\n")); \
8694 printf ("0x%02x ", OP)
8697 decode_arm_unwind_bytecode (Filedata
* filedata
,
8698 struct arm_unw_aux_info
* aux
,
8700 unsigned int remaining
,
8701 unsigned int more_words
,
8702 bfd_vma data_offset
,
8703 Elf_Internal_Shdr
* data_sec
,
8704 struct arm_section
* data_arm_sec
)
8706 struct absaddr addr
;
8707 bfd_boolean res
= TRUE
;
8709 /* Decode the unwinding instructions. */
8712 unsigned int op
, op2
;
8721 printf (" 0x%02x ", op
);
8723 if ((op
& 0xc0) == 0x00)
8725 int offset
= ((op
& 0x3f) << 2) + 4;
8727 printf (" vsp = vsp + %d", offset
);
8729 else if ((op
& 0xc0) == 0x40)
8731 int offset
= ((op
& 0x3f) << 2) + 4;
8733 printf (" vsp = vsp - %d", offset
);
8735 else if ((op
& 0xf0) == 0x80)
8738 if (op
== 0x80 && op2
== 0)
8739 printf (_("Refuse to unwind"));
8742 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8743 bfd_boolean first
= TRUE
;
8747 for (i
= 0; i
< 12; i
++)
8748 if (mask
& (1 << i
))
8754 printf ("r%d", 4 + i
);
8759 else if ((op
& 0xf0) == 0x90)
8761 if (op
== 0x9d || op
== 0x9f)
8762 printf (_(" [Reserved]"));
8764 printf (" vsp = r%d", op
& 0x0f);
8766 else if ((op
& 0xf0) == 0xa0)
8768 int end
= 4 + (op
& 0x07);
8769 bfd_boolean first
= TRUE
;
8773 for (i
= 4; i
<= end
; i
++)
8789 else if (op
== 0xb0)
8790 printf (_(" finish"));
8791 else if (op
== 0xb1)
8794 if (op2
== 0 || (op2
& 0xf0) != 0)
8795 printf (_("[Spare]"));
8798 unsigned int mask
= op2
& 0x0f;
8799 bfd_boolean first
= TRUE
;
8803 for (i
= 0; i
< 12; i
++)
8804 if (mask
& (1 << i
))
8815 else if (op
== 0xb2)
8817 unsigned char buf
[9];
8818 unsigned int i
, len
;
8819 unsigned long offset
;
8821 for (i
= 0; i
< sizeof (buf
); i
++)
8824 if ((buf
[i
] & 0x80) == 0)
8827 if (i
== sizeof (buf
))
8829 error (_("corrupt change to vsp\n"));
8834 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8835 assert (len
== i
+ 1);
8836 offset
= offset
* 4 + 0x204;
8837 printf ("vsp = vsp + %ld", offset
);
8840 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8842 unsigned int first
, last
;
8849 printf ("pop {D%d", first
);
8851 printf ("-D%d", first
+ last
);
8854 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8856 unsigned int count
= op
& 0x07;
8860 printf ("-D%d", 8 + count
);
8863 else if (op
>= 0xc0 && op
<= 0xc5)
8865 unsigned int count
= op
& 0x07;
8867 printf (" pop {wR10");
8869 printf ("-wR%d", 10 + count
);
8872 else if (op
== 0xc6)
8874 unsigned int first
, last
;
8879 printf ("pop {wR%d", first
);
8881 printf ("-wR%d", first
+ last
);
8884 else if (op
== 0xc7)
8887 if (op2
== 0 || (op2
& 0xf0) != 0)
8888 printf (_("[Spare]"));
8891 unsigned int mask
= op2
& 0x0f;
8892 bfd_boolean first
= TRUE
;
8896 for (i
= 0; i
< 4; i
++)
8897 if (mask
& (1 << i
))
8903 printf ("wCGR%d", i
);
8910 printf (_(" [unsupported opcode]"));
8921 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8922 struct arm_unw_aux_info
* aux
,
8924 unsigned int remaining
,
8925 unsigned int more_words
,
8926 bfd_vma data_offset
,
8927 Elf_Internal_Shdr
* data_sec
,
8928 struct arm_section
* data_arm_sec
)
8930 struct absaddr addr
;
8932 /* Decode the unwinding instructions. */
8935 unsigned int op
, op2
;
8944 printf (" 0x%02x ", op
);
8946 if ((op
& 0xc0) == 0x00)
8948 int offset
= ((op
& 0x3f) << 3) + 8;
8949 printf (" sp = sp + %d", offset
);
8951 else if ((op
& 0xc0) == 0x80)
8954 if (op
== 0x80 && op2
== 0)
8955 printf (_("Refuse to unwind"));
8958 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8960 printf ("pop compact {");
8964 decode_tic6x_unwind_regmask (mask
);
8968 else if ((op
& 0xf0) == 0xc0)
8976 unsigned int offset
;
8980 /* Scan entire instruction first so that GET_OP output is not
8981 interleaved with disassembly. */
8983 for (i
= 0; nregs
< (op
& 0xf); i
++)
8989 regpos
[nregs
].offset
= i
* 2;
8990 regpos
[nregs
].reg
= reg
;
8997 regpos
[nregs
].offset
= i
* 2 + 1;
8998 regpos
[nregs
].reg
= reg
;
9003 printf (_("pop frame {"));
9006 printf (_("*corrupt* - no registers specified"));
9011 for (i
= i
* 2; i
> 0; i
--)
9013 if (regpos
[reg
].offset
== i
- 1)
9015 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9022 fputs (name
, stdout
);
9030 else if (op
== 0xd0)
9031 printf (" MOV FP, SP");
9032 else if (op
== 0xd1)
9033 printf (" __c6xabi_pop_rts");
9034 else if (op
== 0xd2)
9036 unsigned char buf
[9];
9037 unsigned int i
, len
;
9038 unsigned long offset
;
9040 for (i
= 0; i
< sizeof (buf
); i
++)
9043 if ((buf
[i
] & 0x80) == 0)
9046 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9047 if (i
== sizeof (buf
))
9049 warn (_("Corrupt stack pointer adjustment detected\n"));
9053 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9054 assert (len
== i
+ 1);
9055 offset
= offset
* 8 + 0x408;
9056 printf (_("sp = sp + %ld"), offset
);
9058 else if ((op
& 0xf0) == 0xe0)
9060 if ((op
& 0x0f) == 7)
9063 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9067 printf (_(" [unsupported opcode]"));
9076 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9080 offset
= word
& 0x7fffffff;
9081 if (offset
& 0x40000000)
9082 offset
|= ~ (bfd_vma
) 0x7fffffff;
9084 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9087 return offset
+ where
;
9091 decode_arm_unwind (Filedata
* filedata
,
9092 struct arm_unw_aux_info
* aux
,
9094 unsigned int remaining
,
9095 bfd_vma data_offset
,
9096 Elf_Internal_Shdr
* data_sec
,
9097 struct arm_section
* data_arm_sec
)
9100 unsigned int more_words
= 0;
9101 struct absaddr addr
;
9102 bfd_vma sym_name
= (bfd_vma
) -1;
9103 bfd_boolean res
= TRUE
;
9107 /* Fetch the first word.
9108 Note - when decoding an object file the address extracted
9109 here will always be 0. So we also pass in the sym_name
9110 parameter so that we can find the symbol associated with
9111 the personality routine. */
9112 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9113 & word
, & addr
, & sym_name
))
9120 addr
.section
= SHN_UNDEF
;
9124 if ((word
& 0x80000000) == 0)
9126 /* Expand prel31 for personality routine. */
9128 const char *procname
;
9130 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9131 printf (_(" Personality routine: "));
9133 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9134 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9136 procname
= aux
->strtab
+ sym_name
;
9137 print_vma (fn
, PREFIX_HEX
);
9140 fputs (" <", stdout
);
9141 fputs (procname
, stdout
);
9142 fputc ('>', stdout
);
9146 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9147 fputc ('\n', stdout
);
9149 /* The GCC personality routines use the standard compact
9150 encoding, starting with one byte giving the number of
9152 if (procname
!= NULL
9153 && (const_strneq (procname
, "__gcc_personality_v0")
9154 || const_strneq (procname
, "__gxx_personality_v0")
9155 || const_strneq (procname
, "__gcj_personality_v0")
9156 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9163 printf (_(" [Truncated data]\n"));
9166 more_words
= word
>> 24;
9176 /* ARM EHABI Section 6.3:
9178 An exception-handling table entry for the compact model looks like:
9182 1 0 index Data for personalityRoutine[index] */
9184 if (filedata
->file_header
.e_machine
== EM_ARM
9185 && (word
& 0x70000000))
9187 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9191 per_index
= (word
>> 24) & 0x7f;
9192 printf (_(" Compact model index: %d\n"), per_index
);
9199 else if (per_index
< 3)
9201 more_words
= (word
>> 16) & 0xff;
9207 switch (filedata
->file_header
.e_machine
)
9212 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9213 data_offset
, data_sec
, data_arm_sec
))
9218 warn (_("Unknown ARM compact model index encountered\n"));
9219 printf (_(" [reserved]\n"));
9227 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9228 data_offset
, data_sec
, data_arm_sec
))
9231 else if (per_index
< 5)
9233 if (((word
>> 17) & 0x7f) == 0x7f)
9234 printf (_(" Restore stack from frame pointer\n"));
9236 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9237 printf (_(" Registers restored: "));
9239 printf (" (compact) ");
9240 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9242 printf (_(" Return register: %s\n"),
9243 tic6x_unwind_regnames
[word
& 0xf]);
9246 printf (_(" [reserved (%d)]\n"), per_index
);
9250 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9251 filedata
->file_header
.e_machine
);
9255 /* Decode the descriptors. Not implemented. */
9261 dump_arm_unwind (Filedata
* filedata
,
9262 struct arm_unw_aux_info
* aux
,
9263 Elf_Internal_Shdr
* exidx_sec
)
9265 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9266 unsigned int i
, exidx_len
;
9267 unsigned long j
, nfuns
;
9268 bfd_boolean res
= TRUE
;
9270 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9271 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9272 exidx_len
= exidx_sec
->sh_size
/ 8;
9274 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9275 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9276 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9277 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9279 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9281 for (i
= 0; i
< exidx_len
; i
++)
9283 unsigned int exidx_fn
, exidx_entry
;
9284 struct absaddr fn_addr
, entry_addr
;
9287 fputc ('\n', stdout
);
9289 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9290 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9291 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9292 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9295 arm_free_section (& exidx_arm_sec
);
9296 arm_free_section (& extab_arm_sec
);
9300 /* ARM EHABI, Section 5:
9301 An index table entry consists of 2 words.
9302 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9303 if (exidx_fn
& 0x80000000)
9305 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9309 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9311 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9312 fputs (": ", stdout
);
9314 if (exidx_entry
== 1)
9316 print_vma (exidx_entry
, PREFIX_HEX
);
9317 fputs (" [cantunwind]\n", stdout
);
9319 else if (exidx_entry
& 0x80000000)
9321 print_vma (exidx_entry
, PREFIX_HEX
);
9322 fputc ('\n', stdout
);
9323 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9327 bfd_vma table
, table_offset
= 0;
9328 Elf_Internal_Shdr
*table_sec
;
9330 fputs ("@", stdout
);
9331 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9332 print_vma (table
, PREFIX_HEX
);
9335 /* Locate the matching .ARM.extab. */
9336 if (entry_addr
.section
!= SHN_UNDEF
9337 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9339 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9340 table_offset
= entry_addr
.offset
;
9342 if (table_offset
> table_sec
->sh_size
9343 || ((bfd_signed_vma
) table_offset
) < 0)
9345 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9346 (unsigned long) table_offset
,
9347 printable_section_name (filedata
, table_sec
));
9354 table_sec
= find_section_by_address (filedata
, table
);
9355 if (table_sec
!= NULL
)
9356 table_offset
= table
- table_sec
->sh_addr
;
9359 if (table_sec
== NULL
)
9361 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9362 (unsigned long) table
);
9367 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9376 arm_free_section (&exidx_arm_sec
);
9377 arm_free_section (&extab_arm_sec
);
9382 /* Used for both ARM and C6X unwinding tables. */
9385 arm_process_unwind (Filedata
* filedata
)
9387 struct arm_unw_aux_info aux
;
9388 Elf_Internal_Shdr
*unwsec
= NULL
;
9389 Elf_Internal_Shdr
*sec
;
9391 unsigned int sec_type
;
9392 bfd_boolean res
= TRUE
;
9394 switch (filedata
->file_header
.e_machine
)
9397 sec_type
= SHT_ARM_EXIDX
;
9401 sec_type
= SHT_C6000_UNWIND
;
9405 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9406 filedata
->file_header
.e_machine
);
9410 if (filedata
->string_table
== NULL
)
9413 memset (& aux
, 0, sizeof (aux
));
9414 aux
.filedata
= filedata
;
9416 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9418 if (sec
->sh_type
== SHT_SYMTAB
)
9422 error (_("Multiple symbol tables encountered\n"));
9428 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9429 &aux
.strtab
, &aux
.strtab_size
))
9432 else if (sec
->sh_type
== sec_type
)
9437 printf (_("\nThere are no unwind sections in this file.\n"));
9439 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9441 if (sec
->sh_type
== sec_type
)
9443 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9444 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9445 "contains %lu entry:\n",
9446 "\nUnwind section '%s' at offset 0x%lx "
9447 "contains %lu entries:\n",
9449 printable_section_name (filedata
, sec
),
9450 (unsigned long) sec
->sh_offset
,
9453 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9461 free ((char *) aux
.strtab
);
9467 process_unwind (Filedata
* filedata
)
9469 struct unwind_handler
9471 unsigned int machtype
;
9472 bfd_boolean (* handler
)(Filedata
*);
9475 { EM_ARM
, arm_process_unwind
},
9476 { EM_IA_64
, ia64_process_unwind
},
9477 { EM_PARISC
, hppa_process_unwind
},
9478 { EM_TI_C6000
, arm_process_unwind
},
9486 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9487 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9488 return handlers
[i
].handler (filedata
);
9490 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9491 get_machine_name (filedata
->file_header
.e_machine
));
9496 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9498 switch (entry
->d_tag
)
9500 case DT_AARCH64_BTI_PLT
:
9501 case DT_AARCH64_PAC_PLT
:
9504 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9511 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9513 switch (entry
->d_tag
)
9516 if (entry
->d_un
.d_val
== 0)
9520 static const char * opts
[] =
9522 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9523 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9524 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9525 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9529 bfd_boolean first
= TRUE
;
9531 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9532 if (entry
->d_un
.d_val
& (1 << cnt
))
9534 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9540 case DT_MIPS_IVERSION
:
9541 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9542 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9546 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9547 /* Note: coded this way so that there is a single string for translation. */
9548 printf (_("<corrupt: %s>"), buf
);
9552 case DT_MIPS_TIME_STAMP
:
9556 time_t atime
= entry
->d_un
.d_val
;
9558 tmp
= gmtime (&atime
);
9559 /* PR 17531: file: 6accc532. */
9561 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9563 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9564 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9565 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9566 printf (_("Time Stamp: %s"), timebuf
);
9570 case DT_MIPS_RLD_VERSION
:
9571 case DT_MIPS_LOCAL_GOTNO
:
9572 case DT_MIPS_CONFLICTNO
:
9573 case DT_MIPS_LIBLISTNO
:
9574 case DT_MIPS_SYMTABNO
:
9575 case DT_MIPS_UNREFEXTNO
:
9576 case DT_MIPS_HIPAGENO
:
9577 case DT_MIPS_DELTA_CLASS_NO
:
9578 case DT_MIPS_DELTA_INSTANCE_NO
:
9579 case DT_MIPS_DELTA_RELOC_NO
:
9580 case DT_MIPS_DELTA_SYM_NO
:
9581 case DT_MIPS_DELTA_CLASSSYM_NO
:
9582 case DT_MIPS_COMPACT_SIZE
:
9583 print_vma (entry
->d_un
.d_val
, DEC
);
9587 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9588 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9589 /* Falls through. */
9592 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9598 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9600 switch (entry
->d_tag
)
9602 case DT_HP_DLD_FLAGS
:
9611 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9612 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9613 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9614 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9615 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9616 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9617 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9618 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9619 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9620 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9621 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9622 { DT_HP_GST
, "HP_GST" },
9623 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9624 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9625 { DT_HP_NODELETE
, "HP_NODELETE" },
9626 { DT_HP_GROUP
, "HP_GROUP" },
9627 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9629 bfd_boolean first
= TRUE
;
9631 bfd_vma val
= entry
->d_un
.d_val
;
9633 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9634 if (val
& flags
[cnt
].bit
)
9638 fputs (flags
[cnt
].str
, stdout
);
9640 val
^= flags
[cnt
].bit
;
9643 if (val
!= 0 || first
)
9647 print_vma (val
, HEX
);
9653 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9661 /* VMS vs Unix time offset and factor. */
9663 #define VMS_EPOCH_OFFSET 35067168000000000LL
9664 #define VMS_GRANULARITY_FACTOR 10000000
9666 /* Display a VMS time in a human readable format. */
9669 print_vms_time (bfd_int64_t vmstime
)
9674 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9675 tm
= gmtime (&unxtime
);
9676 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9677 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9678 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9683 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9685 switch (entry
->d_tag
)
9687 case DT_IA_64_PLT_RESERVE
:
9688 /* First 3 slots reserved. */
9689 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9691 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9694 case DT_IA_64_VMS_LINKTIME
:
9696 print_vms_time (entry
->d_un
.d_val
);
9700 case DT_IA_64_VMS_LNKFLAGS
:
9701 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9702 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9703 printf (" CALL_DEBUG");
9704 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9705 printf (" NOP0BUFS");
9706 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9707 printf (" P0IMAGE");
9708 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9709 printf (" MKTHREADS");
9710 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9711 printf (" UPCALLS");
9712 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9714 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9715 printf (" INITIALIZE");
9716 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9718 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9719 printf (" EXE_INIT");
9720 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9721 printf (" TBK_IN_IMG");
9722 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9723 printf (" DBG_IN_IMG");
9724 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9725 printf (" TBK_IN_DSF");
9726 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9727 printf (" DBG_IN_DSF");
9728 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9729 printf (" SIGNATURES");
9730 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9731 printf (" REL_SEG_OFF");
9735 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9742 get_32bit_dynamic_section (Filedata
* filedata
)
9744 Elf32_External_Dyn
* edyn
;
9745 Elf32_External_Dyn
* ext
;
9746 Elf_Internal_Dyn
* entry
;
9748 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9749 dynamic_size
, _("dynamic section"));
9753 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9754 might not have the luxury of section headers. Look for the DT_NULL
9755 terminator to determine the number of entries. */
9756 for (ext
= edyn
, dynamic_nent
= 0;
9757 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9761 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9765 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9767 if (dynamic_section
== NULL
)
9769 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9770 (unsigned long) dynamic_nent
);
9775 for (ext
= edyn
, entry
= dynamic_section
;
9776 entry
< dynamic_section
+ dynamic_nent
;
9779 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9780 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9789 get_64bit_dynamic_section (Filedata
* filedata
)
9791 Elf64_External_Dyn
* edyn
;
9792 Elf64_External_Dyn
* ext
;
9793 Elf_Internal_Dyn
* entry
;
9795 /* Read in the data. */
9796 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9797 dynamic_size
, _("dynamic section"));
9801 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9802 might not have the luxury of section headers. Look for the DT_NULL
9803 terminator to determine the number of entries. */
9804 for (ext
= edyn
, dynamic_nent
= 0;
9805 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9806 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9810 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9814 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9816 if (dynamic_section
== NULL
)
9818 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9819 (unsigned long) dynamic_nent
);
9824 /* Convert from external to internal formats. */
9825 for (ext
= edyn
, entry
= dynamic_section
;
9826 entry
< dynamic_section
+ dynamic_nent
;
9829 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9830 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9839 print_dynamic_flags (bfd_vma flags
)
9841 bfd_boolean first
= TRUE
;
9847 flag
= flags
& - flags
;
9857 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9858 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9859 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9860 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9861 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9862 default: fputs (_("unknown"), stdout
); break;
9869 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9871 unsigned char * e_data
;
9874 /* If the size_t type is smaller than the bfd_size_type, eg because
9875 you are building a 32-bit tool on a 64-bit host, then make sure
9876 that when (number) is cast to (size_t) no information is lost. */
9877 if (sizeof (size_t) < sizeof (bfd_size_type
)
9878 && (bfd_size_type
) ((size_t) number
) != number
)
9880 error (_("Size truncation prevents reading %s elements of size %u\n"),
9881 bfd_vmatoa ("u", number
), ent_size
);
9885 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9886 attempting to allocate memory when the read is bound to fail. */
9887 if (ent_size
* number
> filedata
->file_size
)
9889 error (_("Invalid number of dynamic entries: %s\n"),
9890 bfd_vmatoa ("u", number
));
9894 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9897 error (_("Out of memory reading %s dynamic entries\n"),
9898 bfd_vmatoa ("u", number
));
9902 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9904 error (_("Unable to read in %s bytes of dynamic data\n"),
9905 bfd_vmatoa ("u", number
* ent_size
));
9910 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9913 error (_("Out of memory allocating space for %s dynamic entries\n"),
9914 bfd_vmatoa ("u", number
));
9920 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9927 static unsigned long
9928 get_num_dynamic_syms (Filedata
* filedata
)
9930 unsigned long num_of_syms
= 0;
9932 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
9935 if (dynamic_info
[DT_HASH
])
9937 unsigned char nb
[8];
9938 unsigned char nc
[8];
9939 unsigned int hash_ent_size
= 4;
9941 if ((filedata
->file_header
.e_machine
== EM_ALPHA
9942 || filedata
->file_header
.e_machine
== EM_S390
9943 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
9944 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9947 if (fseek (filedata
->handle
,
9948 (archive_file_offset
9949 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
9950 sizeof nb
+ sizeof nc
)),
9953 error (_("Unable to seek to start of dynamic information\n"));
9957 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
9959 error (_("Failed to read in number of buckets\n"));
9963 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
9965 error (_("Failed to read in number of chains\n"));
9969 nbuckets
= byte_get (nb
, hash_ent_size
);
9970 nchains
= byte_get (nc
, hash_ent_size
);
9972 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
9973 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
9975 if (buckets
!= NULL
&& chains
!= NULL
)
9976 num_of_syms
= nchains
;
9979 if (num_of_syms
== 0)
9995 if (dynamic_info_DT_GNU_HASH
)
9997 unsigned char nb
[16];
9998 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9999 bfd_vma buckets_vma
;
10001 bfd_boolean gnu_hash_error
= FALSE
;
10003 if (fseek (filedata
->handle
,
10004 (archive_file_offset
10005 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
10009 error (_("Unable to seek to start of dynamic information\n"));
10010 gnu_hash_error
= TRUE
;
10014 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10016 error (_("Failed to read in number of buckets\n"));
10017 gnu_hash_error
= TRUE
;
10021 ngnubuckets
= byte_get (nb
, 4);
10022 gnusymidx
= byte_get (nb
+ 4, 4);
10023 bitmaskwords
= byte_get (nb
+ 8, 4);
10024 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10026 buckets_vma
+= bitmaskwords
* 4;
10028 buckets_vma
+= bitmaskwords
* 8;
10030 if (fseek (filedata
->handle
,
10031 (archive_file_offset
10032 + offset_from_vma (filedata
, buckets_vma
, 4)),
10035 error (_("Unable to seek to start of dynamic information\n"));
10036 gnu_hash_error
= TRUE
;
10040 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
10042 if (gnubuckets
== NULL
)
10044 gnu_hash_error
= TRUE
;
10048 for (i
= 0; i
< ngnubuckets
; i
++)
10049 if (gnubuckets
[i
] != 0)
10051 if (gnubuckets
[i
] < gnusymidx
)
10053 gnu_hash_error
= TRUE
;
10057 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10058 maxchain
= gnubuckets
[i
];
10061 if (maxchain
== 0xffffffff)
10063 gnu_hash_error
= TRUE
;
10067 maxchain
-= gnusymidx
;
10069 if (fseek (filedata
->handle
,
10070 (archive_file_offset
10071 + offset_from_vma (filedata
, buckets_vma
10072 + 4 * (ngnubuckets
+ maxchain
), 4)),
10075 error (_("Unable to seek to start of dynamic information\n"));
10076 gnu_hash_error
= TRUE
;
10082 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10084 error (_("Failed to determine last chain length\n"));
10085 gnu_hash_error
= TRUE
;
10089 if (maxchain
+ 1 == 0)
10091 gnu_hash_error
= TRUE
;
10097 while ((byte_get (nb
, 4) & 1) == 0);
10099 if (fseek (filedata
->handle
,
10100 (archive_file_offset
10101 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10104 error (_("Unable to seek to start of dynamic information\n"));
10105 gnu_hash_error
= TRUE
;
10109 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10110 ngnuchains
= maxchain
;
10112 if (gnuchains
== NULL
)
10114 gnu_hash_error
= TRUE
;
10118 if (dynamic_info_DT_MIPS_XHASH
)
10120 if (fseek (filedata
->handle
,
10121 (archive_file_offset
10122 + offset_from_vma (filedata
, (buckets_vma
10127 error (_("Unable to seek to start of dynamic information\n"));
10128 gnu_hash_error
= TRUE
;
10132 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10135 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10136 if (gnubuckets
[hn
] != 0)
10138 bfd_vma si
= gnubuckets
[hn
];
10139 bfd_vma off
= si
- gnusymidx
;
10143 if (dynamic_info_DT_MIPS_XHASH
)
10145 if (mipsxlat
[off
] >= num_of_syms
)
10146 num_of_syms
= mipsxlat
[off
] + 1;
10150 if (si
>= num_of_syms
)
10151 num_of_syms
= si
+ 1;
10155 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10159 if (gnu_hash_error
)
10181 return num_of_syms
;
10184 /* Parse and display the contents of the dynamic section. */
10187 process_dynamic_section (Filedata
* filedata
)
10189 Elf_Internal_Dyn
* entry
;
10191 if (dynamic_size
== 0)
10194 printf (_("\nThere is no dynamic section in this file.\n"));
10201 if (! get_32bit_dynamic_section (filedata
))
10206 if (! get_64bit_dynamic_section (filedata
))
10210 /* Find the appropriate symbol table. */
10211 if (dynamic_symbols
== NULL
|| do_histogram
)
10213 for (entry
= dynamic_section
;
10214 entry
< dynamic_section
+ dynamic_nent
;
10216 if (entry
->d_tag
== DT_SYMTAB
)
10217 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10218 else if (entry
->d_tag
== DT_SYMENT
)
10219 dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10220 else if (entry
->d_tag
== DT_HASH
)
10221 dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10222 else if (entry
->d_tag
== DT_GNU_HASH
)
10223 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10224 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10225 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10226 && entry
->d_tag
== DT_MIPS_XHASH
)
10228 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10229 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10232 if (dynamic_info
[DT_SYMTAB
] && dynamic_info
[DT_SYMENT
])
10234 Elf_Internal_Phdr
*seg
;
10235 bfd_vma vma
= dynamic_info
[DT_SYMTAB
];
10237 if (! get_program_headers (filedata
))
10239 error (_("Cannot interpret virtual addresses without program headers.\n"));
10243 for (seg
= filedata
->program_headers
;
10244 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10247 unsigned long num_of_syms
;
10249 if (seg
->p_type
!= PT_LOAD
)
10252 if ((seg
->p_offset
+ seg
->p_filesz
)
10253 > filedata
->file_size
)
10255 /* See PR 21379 for a reproducer. */
10256 error (_("Invalid PT_LOAD entry\n"));
10260 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10261 && vma
<= seg
->p_vaddr
+ seg
->p_filesz
10262 && (num_of_syms
= get_num_dynamic_syms (filedata
)) != 0
10263 && dynamic_symbols
== NULL
)
10265 /* Since we do not know how big the symbol table is,
10266 we default to reading in up to the end of PT_LOAD
10267 segment and processing that. This is overkill, I
10268 know, but it should work. */
10269 Elf_Internal_Shdr section
;
10270 section
.sh_offset
= (vma
- seg
->p_vaddr
10272 section
.sh_size
= (num_of_syms
10273 * dynamic_info
[DT_SYMENT
]);
10274 section
.sh_entsize
= dynamic_info
[DT_SYMENT
];
10275 section
.sh_name
= filedata
->string_table_length
;
10276 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
,
10278 & num_dynamic_syms
);
10279 if (dynamic_symbols
== NULL
10280 || num_dynamic_syms
!= num_of_syms
)
10282 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10290 /* Similarly find a string table. */
10291 if (dynamic_strings
== NULL
)
10292 for (entry
= dynamic_section
;
10293 entry
< dynamic_section
+ dynamic_nent
;
10296 if (entry
->d_tag
== DT_STRTAB
)
10297 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10299 if (entry
->d_tag
== DT_STRSZ
)
10300 dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10302 if (dynamic_info
[DT_STRTAB
] && dynamic_info
[DT_STRSZ
])
10304 unsigned long offset
;
10305 bfd_size_type str_tab_len
= dynamic_info
[DT_STRSZ
];
10307 offset
= offset_from_vma (filedata
,
10308 dynamic_info
[DT_STRTAB
],
10310 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
10312 _("dynamic string table"));
10313 if (dynamic_strings
== NULL
)
10315 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10319 dynamic_strings_length
= str_tab_len
;
10324 /* And find the syminfo section if available. */
10325 if (dynamic_syminfo
== NULL
)
10327 unsigned long syminsz
= 0;
10329 for (entry
= dynamic_section
;
10330 entry
< dynamic_section
+ dynamic_nent
;
10333 if (entry
->d_tag
== DT_SYMINENT
)
10335 /* Note: these braces are necessary to avoid a syntax
10336 error from the SunOS4 C compiler. */
10337 /* PR binutils/17531: A corrupt file can trigger this test.
10338 So do not use an assert, instead generate an error message. */
10339 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10340 error (_("Bad value (%d) for SYMINENT entry\n"),
10341 (int) entry
->d_un
.d_val
);
10343 else if (entry
->d_tag
== DT_SYMINSZ
)
10344 syminsz
= entry
->d_un
.d_val
;
10345 else if (entry
->d_tag
== DT_SYMINFO
)
10346 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
10350 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10352 Elf_External_Syminfo
* extsyminfo
;
10353 Elf_External_Syminfo
* extsym
;
10354 Elf_Internal_Syminfo
* syminfo
;
10356 /* There is a syminfo section. Read the data. */
10357 extsyminfo
= (Elf_External_Syminfo
*)
10358 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
10359 _("symbol information"));
10363 if (dynamic_syminfo
!= NULL
)
10365 error (_("Multiple dynamic symbol information sections found\n"));
10366 free (dynamic_syminfo
);
10368 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10369 if (dynamic_syminfo
== NULL
)
10371 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10372 (unsigned long) syminsz
);
10376 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10377 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10378 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10379 ++syminfo
, ++extsym
)
10381 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10382 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10389 if (do_dynamic
&& dynamic_addr
)
10390 printf (ngettext ("\nDynamic section at offset 0x%lx "
10391 "contains %lu entry:\n",
10392 "\nDynamic section at offset 0x%lx "
10393 "contains %lu entries:\n",
10395 dynamic_addr
, (unsigned long) dynamic_nent
);
10397 printf (_(" Tag Type Name/Value\n"));
10399 for (entry
= dynamic_section
;
10400 entry
< dynamic_section
+ dynamic_nent
;
10405 const char * dtype
;
10408 print_vma (entry
->d_tag
, FULL_HEX
);
10409 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10410 printf (" (%s)%*s", dtype
,
10411 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10414 switch (entry
->d_tag
)
10418 print_dynamic_flags (entry
->d_un
.d_val
);
10428 switch (entry
->d_tag
)
10431 printf (_("Auxiliary library"));
10435 printf (_("Filter library"));
10439 printf (_("Configuration file"));
10443 printf (_("Dependency audit library"));
10447 printf (_("Audit library"));
10451 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10452 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10456 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10465 printf (_("Flags:"));
10467 if (entry
->d_un
.d_val
== 0)
10468 printf (_(" None\n"));
10471 unsigned long int val
= entry
->d_un
.d_val
;
10473 if (val
& DTF_1_PARINIT
)
10475 printf (" PARINIT");
10476 val
^= DTF_1_PARINIT
;
10478 if (val
& DTF_1_CONFEXP
)
10480 printf (" CONFEXP");
10481 val
^= DTF_1_CONFEXP
;
10484 printf (" %lx", val
);
10493 printf (_("Flags:"));
10495 if (entry
->d_un
.d_val
== 0)
10496 printf (_(" None\n"));
10499 unsigned long int val
= entry
->d_un
.d_val
;
10501 if (val
& DF_P1_LAZYLOAD
)
10503 printf (" LAZYLOAD");
10504 val
^= DF_P1_LAZYLOAD
;
10506 if (val
& DF_P1_GROUPPERM
)
10508 printf (" GROUPPERM");
10509 val
^= DF_P1_GROUPPERM
;
10512 printf (" %lx", val
);
10521 printf (_("Flags:"));
10522 if (entry
->d_un
.d_val
== 0)
10523 printf (_(" None\n"));
10526 unsigned long int val
= entry
->d_un
.d_val
;
10528 if (val
& DF_1_NOW
)
10533 if (val
& DF_1_GLOBAL
)
10535 printf (" GLOBAL");
10536 val
^= DF_1_GLOBAL
;
10538 if (val
& DF_1_GROUP
)
10543 if (val
& DF_1_NODELETE
)
10545 printf (" NODELETE");
10546 val
^= DF_1_NODELETE
;
10548 if (val
& DF_1_LOADFLTR
)
10550 printf (" LOADFLTR");
10551 val
^= DF_1_LOADFLTR
;
10553 if (val
& DF_1_INITFIRST
)
10555 printf (" INITFIRST");
10556 val
^= DF_1_INITFIRST
;
10558 if (val
& DF_1_NOOPEN
)
10560 printf (" NOOPEN");
10561 val
^= DF_1_NOOPEN
;
10563 if (val
& DF_1_ORIGIN
)
10565 printf (" ORIGIN");
10566 val
^= DF_1_ORIGIN
;
10568 if (val
& DF_1_DIRECT
)
10570 printf (" DIRECT");
10571 val
^= DF_1_DIRECT
;
10573 if (val
& DF_1_TRANS
)
10578 if (val
& DF_1_INTERPOSE
)
10580 printf (" INTERPOSE");
10581 val
^= DF_1_INTERPOSE
;
10583 if (val
& DF_1_NODEFLIB
)
10585 printf (" NODEFLIB");
10586 val
^= DF_1_NODEFLIB
;
10588 if (val
& DF_1_NODUMP
)
10590 printf (" NODUMP");
10591 val
^= DF_1_NODUMP
;
10593 if (val
& DF_1_CONFALT
)
10595 printf (" CONFALT");
10596 val
^= DF_1_CONFALT
;
10598 if (val
& DF_1_ENDFILTEE
)
10600 printf (" ENDFILTEE");
10601 val
^= DF_1_ENDFILTEE
;
10603 if (val
& DF_1_DISPRELDNE
)
10605 printf (" DISPRELDNE");
10606 val
^= DF_1_DISPRELDNE
;
10608 if (val
& DF_1_DISPRELPND
)
10610 printf (" DISPRELPND");
10611 val
^= DF_1_DISPRELPND
;
10613 if (val
& DF_1_NODIRECT
)
10615 printf (" NODIRECT");
10616 val
^= DF_1_NODIRECT
;
10618 if (val
& DF_1_IGNMULDEF
)
10620 printf (" IGNMULDEF");
10621 val
^= DF_1_IGNMULDEF
;
10623 if (val
& DF_1_NOKSYMS
)
10625 printf (" NOKSYMS");
10626 val
^= DF_1_NOKSYMS
;
10628 if (val
& DF_1_NOHDR
)
10633 if (val
& DF_1_EDITED
)
10635 printf (" EDITED");
10636 val
^= DF_1_EDITED
;
10638 if (val
& DF_1_NORELOC
)
10640 printf (" NORELOC");
10641 val
^= DF_1_NORELOC
;
10643 if (val
& DF_1_SYMINTPOSE
)
10645 printf (" SYMINTPOSE");
10646 val
^= DF_1_SYMINTPOSE
;
10648 if (val
& DF_1_GLOBAUDIT
)
10650 printf (" GLOBAUDIT");
10651 val
^= DF_1_GLOBAUDIT
;
10653 if (val
& DF_1_SINGLETON
)
10655 printf (" SINGLETON");
10656 val
^= DF_1_SINGLETON
;
10658 if (val
& DF_1_STUB
)
10663 if (val
& DF_1_PIE
)
10668 if (val
& DF_1_KMOD
)
10673 if (val
& DF_1_WEAKFILTER
)
10675 printf (" WEAKFILTER");
10676 val
^= DF_1_WEAKFILTER
;
10678 if (val
& DF_1_NOCOMMON
)
10680 printf (" NOCOMMON");
10681 val
^= DF_1_NOCOMMON
;
10684 printf (" %lx", val
);
10691 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10693 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10713 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10719 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10720 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10726 switch (entry
->d_tag
)
10729 printf (_("Shared library: [%s]"), name
);
10731 if (streq (name
, program_interpreter
))
10732 printf (_(" program interpreter"));
10736 printf (_("Library soname: [%s]"), name
);
10740 printf (_("Library rpath: [%s]"), name
);
10744 printf (_("Library runpath: [%s]"), name
);
10748 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10753 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10766 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10767 /* Fall through. */
10771 case DT_INIT_ARRAYSZ
:
10772 case DT_FINI_ARRAYSZ
:
10773 case DT_GNU_CONFLICTSZ
:
10774 case DT_GNU_LIBLISTSZ
:
10777 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10778 printf (_(" (bytes)\n"));
10783 case DT_VERNEEDNUM
:
10788 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10797 case DT_INIT_ARRAY
:
10798 case DT_FINI_ARRAY
:
10801 if (entry
->d_tag
== DT_USED
10802 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10804 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10808 printf (_("Not needed object: [%s]\n"), name
);
10813 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10819 /* The value of this entry is ignored. */
10824 case DT_GNU_PRELINKED
:
10828 time_t atime
= entry
->d_un
.d_val
;
10830 tmp
= gmtime (&atime
);
10831 /* PR 17533 file: 041-1244816-0.004. */
10833 printf (_("<corrupt time val: %lx"),
10834 (unsigned long) atime
);
10836 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10837 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10838 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10844 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10847 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10853 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10854 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10859 switch (filedata
->file_header
.e_machine
)
10862 dynamic_section_aarch64_val (entry
);
10865 case EM_MIPS_RS3_LE
:
10866 dynamic_section_mips_val (entry
);
10869 dynamic_section_parisc_val (entry
);
10872 dynamic_section_ia64_val (entry
);
10875 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10887 get_ver_flags (unsigned int flags
)
10889 static char buff
[128];
10896 if (flags
& VER_FLG_BASE
)
10897 strcat (buff
, "BASE");
10899 if (flags
& VER_FLG_WEAK
)
10901 if (flags
& VER_FLG_BASE
)
10902 strcat (buff
, " | ");
10904 strcat (buff
, "WEAK");
10907 if (flags
& VER_FLG_INFO
)
10909 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10910 strcat (buff
, " | ");
10912 strcat (buff
, "INFO");
10915 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10917 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10918 strcat (buff
, " | ");
10920 strcat (buff
, _("<unknown>"));
10926 /* Display the contents of the version sections. */
10929 process_version_sections (Filedata
* filedata
)
10931 Elf_Internal_Shdr
* section
;
10933 bfd_boolean found
= FALSE
;
10938 for (i
= 0, section
= filedata
->section_headers
;
10939 i
< filedata
->file_header
.e_shnum
;
10942 switch (section
->sh_type
)
10944 case SHT_GNU_verdef
:
10946 Elf_External_Verdef
* edefs
;
10953 printf (ngettext ("\nVersion definition section '%s' "
10954 "contains %u entry:\n",
10955 "\nVersion definition section '%s' "
10956 "contains %u entries:\n",
10958 printable_section_name (filedata
, section
),
10961 printf (_(" Addr: 0x"));
10962 printf_vma (section
->sh_addr
);
10963 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10964 (unsigned long) section
->sh_offset
, section
->sh_link
,
10965 printable_section_name_from_index (filedata
, section
->sh_link
));
10967 edefs
= (Elf_External_Verdef
*)
10968 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10969 _("version definition section"));
10972 endbuf
= (char *) edefs
+ section
->sh_size
;
10974 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10977 Elf_External_Verdef
* edef
;
10978 Elf_Internal_Verdef ent
;
10979 Elf_External_Verdaux
* eaux
;
10980 Elf_Internal_Verdaux aux
;
10981 unsigned long isum
;
10984 vstart
= ((char *) edefs
) + idx
;
10985 if (vstart
+ sizeof (*edef
) > endbuf
)
10988 edef
= (Elf_External_Verdef
*) vstart
;
10990 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10991 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10992 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10993 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10994 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10995 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10996 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10998 printf (_(" %#06lx: Rev: %d Flags: %s"),
10999 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11001 printf (_(" Index: %d Cnt: %d "),
11002 ent
.vd_ndx
, ent
.vd_cnt
);
11004 /* Check for overflow. */
11005 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11008 vstart
+= ent
.vd_aux
;
11010 if (vstart
+ sizeof (*eaux
) > endbuf
)
11012 eaux
= (Elf_External_Verdaux
*) vstart
;
11014 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11015 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11017 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
11018 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
11020 printf (_("Name index: %ld\n"), aux
.vda_name
);
11022 isum
= idx
+ ent
.vd_aux
;
11024 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11026 if (aux
.vda_next
< sizeof (*eaux
)
11027 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11029 warn (_("Invalid vda_next field of %lx\n"),
11034 /* Check for overflow. */
11035 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11038 isum
+= aux
.vda_next
;
11039 vstart
+= aux
.vda_next
;
11041 if (vstart
+ sizeof (*eaux
) > endbuf
)
11043 eaux
= (Elf_External_Verdaux
*) vstart
;
11045 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11046 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11048 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
11049 printf (_(" %#06lx: Parent %d: %s\n"),
11050 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
11052 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11053 isum
, j
, aux
.vda_name
);
11056 if (j
< ent
.vd_cnt
)
11057 printf (_(" Version def aux past end of section\n"));
11060 file: id:000001,src:000172+005151,op:splice,rep:2. */
11061 if (ent
.vd_next
< sizeof (*edef
)
11062 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11064 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11065 cnt
= section
->sh_info
;
11068 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11071 idx
+= ent
.vd_next
;
11074 if (cnt
< section
->sh_info
)
11075 printf (_(" Version definition past end of section\n"));
11081 case SHT_GNU_verneed
:
11083 Elf_External_Verneed
* eneed
;
11090 printf (ngettext ("\nVersion needs section '%s' "
11091 "contains %u entry:\n",
11092 "\nVersion needs section '%s' "
11093 "contains %u entries:\n",
11095 printable_section_name (filedata
, section
), section
->sh_info
);
11097 printf (_(" Addr: 0x"));
11098 printf_vma (section
->sh_addr
);
11099 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11100 (unsigned long) section
->sh_offset
, section
->sh_link
,
11101 printable_section_name_from_index (filedata
, section
->sh_link
));
11103 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11104 section
->sh_offset
, 1,
11106 _("Version Needs section"));
11109 endbuf
= (char *) eneed
+ section
->sh_size
;
11111 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11113 Elf_External_Verneed
* entry
;
11114 Elf_Internal_Verneed ent
;
11115 unsigned long isum
;
11119 vstart
= ((char *) eneed
) + idx
;
11120 if (vstart
+ sizeof (*entry
) > endbuf
)
11123 entry
= (Elf_External_Verneed
*) vstart
;
11125 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11126 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11127 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11128 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11129 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11131 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11133 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
11134 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
11136 printf (_(" File: %lx"), ent
.vn_file
);
11138 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11140 /* Check for overflow. */
11141 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11143 vstart
+= ent
.vn_aux
;
11145 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11147 Elf_External_Vernaux
* eaux
;
11148 Elf_Internal_Vernaux aux
;
11150 if (vstart
+ sizeof (*eaux
) > endbuf
)
11152 eaux
= (Elf_External_Vernaux
*) vstart
;
11154 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11155 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11156 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11157 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11158 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11160 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
11161 printf (_(" %#06lx: Name: %s"),
11162 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
11164 printf (_(" %#06lx: Name index: %lx"),
11165 isum
, aux
.vna_name
);
11167 printf (_(" Flags: %s Version: %d\n"),
11168 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11170 if (aux
.vna_next
< sizeof (*eaux
)
11171 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11173 warn (_("Invalid vna_next field of %lx\n"),
11178 /* Check for overflow. */
11179 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11181 isum
+= aux
.vna_next
;
11182 vstart
+= aux
.vna_next
;
11185 if (j
< ent
.vn_cnt
)
11186 warn (_("Missing Version Needs auxillary information\n"));
11188 if (ent
.vn_next
< sizeof (*entry
)
11189 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11191 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11192 cnt
= section
->sh_info
;
11195 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11197 idx
+= ent
.vn_next
;
11200 if (cnt
< section
->sh_info
)
11201 warn (_("Missing Version Needs information\n"));
11207 case SHT_GNU_versym
:
11209 Elf_Internal_Shdr
* link_section
;
11212 unsigned char * edata
;
11213 unsigned short * data
;
11215 Elf_Internal_Sym
* symbols
;
11216 Elf_Internal_Shdr
* string_sec
;
11217 unsigned long num_syms
;
11220 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11223 link_section
= filedata
->section_headers
+ section
->sh_link
;
11224 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11226 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11231 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11232 if (symbols
== NULL
)
11235 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11237 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11238 string_sec
->sh_size
,
11239 _("version string table"));
11246 printf (ngettext ("\nVersion symbols section '%s' "
11247 "contains %lu entry:\n",
11248 "\nVersion symbols section '%s' "
11249 "contains %lu entries:\n",
11251 printable_section_name (filedata
, section
), (unsigned long) total
);
11253 printf (_(" Addr: 0x"));
11254 printf_vma (section
->sh_addr
);
11255 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11256 (unsigned long) section
->sh_offset
, section
->sh_link
,
11257 printable_section_name (filedata
, link_section
));
11259 off
= offset_from_vma (filedata
,
11260 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11261 total
* sizeof (short));
11262 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11263 sizeof (short), total
,
11264 _("version symbol data"));
11272 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11274 for (cnt
= total
; cnt
--;)
11275 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11280 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11284 char *invalid
= _("*invalid*");
11286 printf (" %03x:", cnt
);
11288 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11289 switch (data
[cnt
+ j
])
11292 fputs (_(" 0 (*local*) "), stdout
);
11296 fputs (_(" 1 (*global*) "), stdout
);
11300 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11301 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11303 /* If this index value is greater than the size of the symbols
11304 array, break to avoid an out-of-bounds read. */
11305 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11307 warn (_("invalid index into symbol array\n"));
11312 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11314 Elf_Internal_Verneed ivn
;
11315 unsigned long offset
;
11317 offset
= offset_from_vma
11318 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11319 sizeof (Elf_External_Verneed
));
11323 Elf_Internal_Vernaux ivna
;
11324 Elf_External_Verneed evn
;
11325 Elf_External_Vernaux evna
;
11326 unsigned long a_off
;
11328 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11329 _("version need")) == NULL
)
11332 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11333 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11335 a_off
= offset
+ ivn
.vn_aux
;
11339 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11340 1, _("version need aux (2)")) == NULL
)
11343 ivna
.vna_other
= 0;
11347 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11348 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11351 a_off
+= ivna
.vna_next
;
11353 while (ivna
.vna_other
!= data
[cnt
+ j
]
11354 && ivna
.vna_next
!= 0);
11356 if (ivna
.vna_other
== data
[cnt
+ j
])
11358 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11360 if (ivna
.vna_name
>= string_sec
->sh_size
)
11363 name
= strtab
+ ivna
.vna_name
;
11367 offset
+= ivn
.vn_next
;
11369 while (ivn
.vn_next
);
11372 if (data
[cnt
+ j
] != 0x8001
11373 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11375 Elf_Internal_Verdef ivd
;
11376 Elf_External_Verdef evd
;
11377 unsigned long offset
;
11379 offset
= offset_from_vma
11380 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11385 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11386 _("version def")) == NULL
)
11389 /* PR 17531: file: 046-1082287-0.004. */
11390 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11395 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11396 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11399 offset
+= ivd
.vd_next
;
11401 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11402 && ivd
.vd_next
!= 0);
11404 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11406 Elf_External_Verdaux evda
;
11407 Elf_Internal_Verdaux ivda
;
11409 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11411 if (get_data (&evda
, filedata
,
11412 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11414 _("version def aux")) == NULL
)
11417 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11419 if (ivda
.vda_name
>= string_sec
->sh_size
)
11421 else if (name
!= NULL
&& name
!= invalid
)
11422 name
= _("*both*");
11424 name
= strtab
+ ivda
.vda_name
;
11428 nn
+= printf ("(%s%-*s",
11430 12 - (int) strlen (name
),
11434 printf ("%*c", 18 - nn
, ' ');
11452 printf (_("\nNo version information found in this file.\n"));
11457 static const char *
11458 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11460 static char buff
[64];
11464 case STB_LOCAL
: return "LOCAL";
11465 case STB_GLOBAL
: return "GLOBAL";
11466 case STB_WEAK
: return "WEAK";
11468 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11469 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11471 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11473 if (binding
== STB_GNU_UNIQUE
11474 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11476 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11479 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11484 static const char *
11485 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11487 static char buff
[64];
11491 case STT_NOTYPE
: return "NOTYPE";
11492 case STT_OBJECT
: return "OBJECT";
11493 case STT_FUNC
: return "FUNC";
11494 case STT_SECTION
: return "SECTION";
11495 case STT_FILE
: return "FILE";
11496 case STT_COMMON
: return "COMMON";
11497 case STT_TLS
: return "TLS";
11498 case STT_RELC
: return "RELC";
11499 case STT_SRELC
: return "SRELC";
11501 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11503 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11504 return "THUMB_FUNC";
11506 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11509 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11510 return "PARISC_MILLI";
11512 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11514 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11516 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11518 if (type
== STT_HP_OPAQUE
)
11519 return "HP_OPAQUE";
11520 if (type
== STT_HP_STUB
)
11524 if (type
== STT_GNU_IFUNC
11525 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11526 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11529 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11532 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11537 static const char *
11538 get_symbol_visibility (unsigned int visibility
)
11540 switch (visibility
)
11542 case STV_DEFAULT
: return "DEFAULT";
11543 case STV_INTERNAL
: return "INTERNAL";
11544 case STV_HIDDEN
: return "HIDDEN";
11545 case STV_PROTECTED
: return "PROTECTED";
11547 error (_("Unrecognized visibility value: %u\n"), visibility
);
11548 return _("<unknown>");
11552 static const char *
11553 get_alpha_symbol_other (unsigned int other
)
11557 case STO_ALPHA_NOPV
: return "NOPV";
11558 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11560 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11561 return _("<unknown>");
11565 static const char *
11566 get_solaris_symbol_visibility (unsigned int visibility
)
11568 switch (visibility
)
11570 case 4: return "EXPORTED";
11571 case 5: return "SINGLETON";
11572 case 6: return "ELIMINATE";
11573 default: return get_symbol_visibility (visibility
);
11577 static const char *
11578 get_aarch64_symbol_other (unsigned int other
)
11580 static char buf
[32];
11582 if (other
& STO_AARCH64_VARIANT_PCS
)
11584 other
&= ~STO_AARCH64_VARIANT_PCS
;
11586 return "VARIANT_PCS";
11587 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11593 static const char *
11594 get_mips_symbol_other (unsigned int other
)
11598 case STO_OPTIONAL
: return "OPTIONAL";
11599 case STO_MIPS_PLT
: return "MIPS PLT";
11600 case STO_MIPS_PIC
: return "MIPS PIC";
11601 case STO_MICROMIPS
: return "MICROMIPS";
11602 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11603 case STO_MIPS16
: return "MIPS16";
11604 default: return NULL
;
11608 static const char *
11609 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11611 if (is_ia64_vms (filedata
))
11613 static char res
[32];
11617 /* Function types is for images and .STB files only. */
11618 switch (filedata
->file_header
.e_type
)
11622 switch (VMS_ST_FUNC_TYPE (other
))
11624 case VMS_SFT_CODE_ADDR
:
11625 strcat (res
, " CA");
11627 case VMS_SFT_SYMV_IDX
:
11628 strcat (res
, " VEC");
11631 strcat (res
, " FD");
11633 case VMS_SFT_RESERVE
:
11634 strcat (res
, " RSV");
11637 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11638 VMS_ST_FUNC_TYPE (other
));
11639 strcat (res
, " <unknown>");
11646 switch (VMS_ST_LINKAGE (other
))
11648 case VMS_STL_IGNORE
:
11649 strcat (res
, " IGN");
11651 case VMS_STL_RESERVE
:
11652 strcat (res
, " RSV");
11655 strcat (res
, " STD");
11658 strcat (res
, " LNK");
11661 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11662 VMS_ST_LINKAGE (other
));
11663 strcat (res
, " <unknown>");
11675 static const char *
11676 get_ppc64_symbol_other (unsigned int other
)
11678 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11681 other
>>= STO_PPC64_LOCAL_BIT
;
11684 static char buf
[64];
11686 other
= ppc64_decode_local_entry (other
);
11687 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11693 static const char *
11694 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11696 const char * result
= NULL
;
11697 static char buff
[64];
11702 switch (filedata
->file_header
.e_machine
)
11705 result
= get_alpha_symbol_other (other
);
11708 result
= get_aarch64_symbol_other (other
);
11711 result
= get_mips_symbol_other (other
);
11714 result
= get_ia64_symbol_other (filedata
, other
);
11717 result
= get_ppc64_symbol_other (other
);
11727 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11731 static const char *
11732 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11734 static char buff
[32];
11738 case SHN_UNDEF
: return "UND";
11739 case SHN_ABS
: return "ABS";
11740 case SHN_COMMON
: return "COM";
11742 if (type
== SHN_IA_64_ANSI_COMMON
11743 && filedata
->file_header
.e_machine
== EM_IA_64
11744 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11746 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11747 || filedata
->file_header
.e_machine
== EM_L1OM
11748 || filedata
->file_header
.e_machine
== EM_K1OM
)
11749 && type
== SHN_X86_64_LCOMMON
)
11750 return "LARGE_COM";
11751 else if ((type
== SHN_MIPS_SCOMMON
11752 && filedata
->file_header
.e_machine
== EM_MIPS
)
11753 || (type
== SHN_TIC6X_SCOMMON
11754 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11756 else if (type
== SHN_MIPS_SUNDEFINED
11757 && filedata
->file_header
.e_machine
== EM_MIPS
)
11759 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11760 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11761 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11762 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11763 else if (type
>= SHN_LORESERVE
)
11764 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11765 else if (filedata
->file_header
.e_shnum
!= 0
11766 && type
>= filedata
->file_header
.e_shnum
)
11767 sprintf (buff
, _("bad section index[%3d]"), type
);
11769 sprintf (buff
, "%3d", type
);
11776 static const char *
11777 get_symbol_version_string (Filedata
* filedata
,
11778 bfd_boolean is_dynsym
,
11779 const char * strtab
,
11780 unsigned long int strtab_size
,
11782 Elf_Internal_Sym
* psym
,
11783 enum versioned_symbol_info
* sym_info
,
11784 unsigned short * vna_other
)
11786 unsigned char data
[2];
11787 unsigned short vers_data
;
11788 unsigned long offset
;
11789 unsigned short max_vd_ndx
;
11792 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11795 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11796 sizeof data
+ si
* sizeof (vers_data
));
11798 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11799 sizeof (data
), 1, _("version data")) == NULL
)
11802 vers_data
= byte_get (data
, 2);
11804 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11807 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11810 /* Usually we'd only see verdef for defined symbols, and verneed for
11811 undefined symbols. However, symbols defined by the linker in
11812 .dynbss for variables copied from a shared library in order to
11813 avoid text relocations are defined yet have verneed. We could
11814 use a heuristic to detect the special case, for example, check
11815 for verneed first on symbols defined in SHT_NOBITS sections, but
11816 it is simpler and more reliable to just look for both verdef and
11817 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11819 if (psym
->st_shndx
!= SHN_UNDEF
11820 && vers_data
!= 0x8001
11821 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11823 Elf_Internal_Verdef ivd
;
11824 Elf_Internal_Verdaux ivda
;
11825 Elf_External_Verdaux evda
;
11828 off
= offset_from_vma (filedata
,
11829 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11830 sizeof (Elf_External_Verdef
));
11834 Elf_External_Verdef evd
;
11836 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11837 _("version def")) == NULL
)
11846 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11847 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11848 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11849 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11852 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11853 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11855 off
+= ivd
.vd_next
;
11857 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11859 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11861 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11864 off
-= ivd
.vd_next
;
11867 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11868 _("version def aux")) != NULL
)
11870 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11872 if (psym
->st_name
!= ivda
.vda_name
)
11873 return (ivda
.vda_name
< strtab_size
11874 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11879 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11881 Elf_External_Verneed evn
;
11882 Elf_Internal_Verneed ivn
;
11883 Elf_Internal_Vernaux ivna
;
11885 offset
= offset_from_vma (filedata
,
11886 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11890 unsigned long vna_off
;
11892 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11893 _("version need")) == NULL
)
11896 ivna
.vna_other
= 0;
11901 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11902 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11904 vna_off
= offset
+ ivn
.vn_aux
;
11908 Elf_External_Vernaux evna
;
11910 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11911 _("version need aux (3)")) == NULL
)
11914 ivna
.vna_other
= 0;
11919 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11920 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11921 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11924 vna_off
+= ivna
.vna_next
;
11926 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11928 if (ivna
.vna_other
== vers_data
)
11931 offset
+= ivn
.vn_next
;
11933 while (ivn
.vn_next
!= 0);
11935 if (ivna
.vna_other
== vers_data
)
11937 *sym_info
= symbol_undefined
;
11938 *vna_other
= ivna
.vna_other
;
11939 return (ivna
.vna_name
< strtab_size
11940 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11942 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11943 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11944 return _("<corrupt>");
11950 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
11951 Elf_Internal_Sym
*symtab
,
11952 Elf_Internal_Shdr
*section
,
11953 char *strtab
, size_t strtab_size
)
11955 const char *version_string
;
11956 enum versioned_symbol_info sym_info
;
11957 unsigned short vna_other
;
11958 Elf_Internal_Sym
*psym
= symtab
+ si
;
11960 printf ("%6ld: ", si
);
11961 print_vma (psym
->st_value
, LONG_HEX
);
11963 print_vma (psym
->st_size
, DEC_5
);
11964 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11965 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11966 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11967 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11970 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11972 printf (" %-7s", get_symbol_visibility (vis
));
11973 /* Check to see if any other bits in the st_other field are set.
11974 Note - displaying this information disrupts the layout of the
11975 table being generated, but for the moment this case is very rare. */
11976 if (psym
->st_other
^ vis
)
11977 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11979 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11980 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
11982 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11985 = get_symbol_version_string (filedata
,
11987 || section
->sh_type
== SHT_DYNSYM
),
11988 strtab
, strtab_size
, si
,
11989 psym
, &sym_info
, &vna_other
);
11990 if (version_string
)
11992 if (sym_info
== symbol_undefined
)
11993 printf ("@%s (%d)", version_string
, vna_other
);
11995 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12001 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12003 && si
>= section
->sh_info
12004 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12005 && filedata
->file_header
.e_machine
!= EM_MIPS
12006 /* Solaris binaries have been found to violate this requirement as
12007 well. Not sure if this is a bug or an ABI requirement. */
12008 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12009 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12010 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12013 /* Dump the symbol table. */
12015 process_symbol_table (Filedata
* filedata
)
12017 Elf_Internal_Shdr
* section
;
12019 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12022 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
12024 && do_using_dynamic
12025 && dynamic_strings
!= NULL
12026 && dynamic_symbols
!= NULL
)
12030 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12031 "\nSymbol table for image contains %lu entries:\n",
12032 num_dynamic_syms
), num_dynamic_syms
);
12034 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12036 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12038 for (si
= 0; si
< num_dynamic_syms
; si
++)
12039 print_dynamic_symbol (filedata
, si
, dynamic_symbols
, NULL
,
12040 dynamic_strings
, dynamic_strings_length
);
12042 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12043 && filedata
->section_headers
!= NULL
)
12047 for (i
= 0, section
= filedata
->section_headers
;
12048 i
< filedata
->file_header
.e_shnum
;
12051 char * strtab
= NULL
;
12052 unsigned long int strtab_size
= 0;
12053 Elf_Internal_Sym
* symtab
;
12054 unsigned long si
, num_syms
;
12056 if ((section
->sh_type
!= SHT_SYMTAB
12057 && section
->sh_type
!= SHT_DYNSYM
)
12059 && section
->sh_type
== SHT_SYMTAB
))
12062 if (section
->sh_entsize
== 0)
12064 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12065 printable_section_name (filedata
, section
));
12069 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12070 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12071 "\nSymbol table '%s' contains %lu entries:\n",
12073 printable_section_name (filedata
, section
),
12077 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12079 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12081 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12082 if (symtab
== NULL
)
12085 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12087 strtab
= filedata
->string_table
;
12088 strtab_size
= filedata
->string_table_length
;
12090 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12092 Elf_Internal_Shdr
* string_sec
;
12094 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12096 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12097 1, string_sec
->sh_size
,
12098 _("string table"));
12099 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12102 for (si
= 0; si
< num_syms
; si
++)
12103 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12104 strtab
, strtab_size
);
12107 if (strtab
!= filedata
->string_table
)
12113 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12115 if (do_histogram
&& buckets
!= NULL
)
12117 unsigned long * lengths
;
12118 unsigned long * counts
;
12121 unsigned long maxlength
= 0;
12122 unsigned long nzero_counts
= 0;
12123 unsigned long nsyms
= 0;
12126 printf (ngettext ("\nHistogram for bucket list length "
12127 "(total of %lu bucket):\n",
12128 "\nHistogram for bucket list length "
12129 "(total of %lu buckets):\n",
12130 (unsigned long) nbuckets
),
12131 (unsigned long) nbuckets
);
12133 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12134 if (lengths
== NULL
)
12136 error (_("Out of memory allocating space for histogram buckets\n"));
12139 visited
= xcmalloc (nchains
, 1);
12140 memset (visited
, 0, nchains
);
12142 printf (_(" Length Number %% of total Coverage\n"));
12143 for (hn
= 0; hn
< nbuckets
; ++hn
)
12145 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12148 if (maxlength
< ++lengths
[hn
])
12150 if (si
>= nchains
|| visited
[si
])
12152 error (_("histogram chain is corrupt\n"));
12160 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12161 if (counts
== NULL
)
12164 error (_("Out of memory allocating space for histogram counts\n"));
12168 for (hn
= 0; hn
< nbuckets
; ++hn
)
12169 ++counts
[lengths
[hn
]];
12174 printf (" 0 %-10lu (%5.1f%%)\n",
12175 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12176 for (i
= 1; i
<= maxlength
; ++i
)
12178 nzero_counts
+= counts
[i
] * i
;
12179 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12180 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12181 (nzero_counts
* 100.0) / nsyms
);
12195 if (do_histogram
&& gnubuckets
!= NULL
)
12197 unsigned long * lengths
;
12198 unsigned long * counts
;
12200 unsigned long maxlength
= 0;
12201 unsigned long nzero_counts
= 0;
12202 unsigned long nsyms
= 0;
12204 printf (ngettext ("\nHistogram for `%s' bucket list length "
12205 "(total of %lu bucket):\n",
12206 "\nHistogram for `%s' bucket list length "
12207 "(total of %lu buckets):\n",
12208 (unsigned long) ngnubuckets
),
12209 GNU_HASH_SECTION_NAME
,
12210 (unsigned long) ngnubuckets
);
12212 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12213 if (lengths
== NULL
)
12215 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12219 printf (_(" Length Number %% of total Coverage\n"));
12221 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12222 if (gnubuckets
[hn
] != 0)
12224 bfd_vma off
, length
= 1;
12226 for (off
= gnubuckets
[hn
] - gnusymidx
;
12227 /* PR 17531 file: 010-77222-0.004. */
12228 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12231 lengths
[hn
] = length
;
12232 if (length
> maxlength
)
12233 maxlength
= length
;
12237 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12238 if (counts
== NULL
)
12241 error (_("Out of memory allocating space for gnu histogram counts\n"));
12245 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12246 ++counts
[lengths
[hn
]];
12248 if (ngnubuckets
> 0)
12251 printf (" 0 %-10lu (%5.1f%%)\n",
12252 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12253 for (j
= 1; j
<= maxlength
; ++j
)
12255 nzero_counts
+= counts
[j
] * j
;
12256 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12257 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12258 (nzero_counts
* 100.0) / nsyms
);
12293 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12297 if (dynamic_syminfo
== NULL
12299 /* No syminfo, this is ok. */
12302 /* There better should be a dynamic symbol section. */
12303 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12307 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12308 "contains %d entry:\n",
12309 "\nDynamic info segment at offset 0x%lx "
12310 "contains %d entries:\n",
12311 dynamic_syminfo_nent
),
12312 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12314 printf (_(" Num: Name BoundTo Flags\n"));
12315 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12317 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12319 printf ("%4d: ", i
);
12320 if (i
>= num_dynamic_syms
)
12321 printf (_("<corrupt index>"));
12322 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12323 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12325 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12328 switch (dynamic_syminfo
[i
].si_boundto
)
12330 case SYMINFO_BT_SELF
:
12331 fputs ("SELF ", stdout
);
12333 case SYMINFO_BT_PARENT
:
12334 fputs ("PARENT ", stdout
);
12337 if (dynamic_syminfo
[i
].si_boundto
> 0
12338 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12339 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12341 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12345 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12349 if (flags
& SYMINFO_FLG_DIRECT
)
12350 printf (" DIRECT");
12351 if (flags
& SYMINFO_FLG_PASSTHRU
)
12352 printf (" PASSTHRU");
12353 if (flags
& SYMINFO_FLG_COPY
)
12355 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12356 printf (" LAZYLOAD");
12364 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12365 is contained by the region START .. END. The types of ADDR, START
12366 and END should all be the same. Note both ADDR + NELEM and END
12367 point to just beyond the end of the regions that are being tested. */
12368 #define IN_RANGE(START,END,ADDR,NELEM) \
12369 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12371 /* Check to see if the given reloc needs to be handled in a target specific
12372 manner. If so then process the reloc and return TRUE otherwise return
12375 If called with reloc == NULL, then this is a signal that reloc processing
12376 for the current section has finished, and any saved state should be
12380 target_specific_reloc_handling (Filedata
* filedata
,
12381 Elf_Internal_Rela
* reloc
,
12382 unsigned char * start
,
12383 unsigned char * end
,
12384 Elf_Internal_Sym
* symtab
,
12385 unsigned long num_syms
)
12387 unsigned int reloc_type
= 0;
12388 unsigned long sym_index
= 0;
12392 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12393 sym_index
= get_reloc_symindex (reloc
->r_info
);
12396 switch (filedata
->file_header
.e_machine
)
12399 case EM_MSP430_OLD
:
12401 static Elf_Internal_Sym
* saved_sym
= NULL
;
12409 switch (reloc_type
)
12411 case 10: /* R_MSP430_SYM_DIFF */
12412 if (uses_msp430x_relocs (filedata
))
12414 /* Fall through. */
12415 case 21: /* R_MSP430X_SYM_DIFF */
12417 if (sym_index
>= num_syms
)
12418 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12421 saved_sym
= symtab
+ sym_index
;
12424 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12425 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12426 goto handle_sym_diff
;
12428 case 5: /* R_MSP430_16_BYTE */
12429 case 9: /* R_MSP430_8 */
12430 if (uses_msp430x_relocs (filedata
))
12432 goto handle_sym_diff
;
12434 case 2: /* R_MSP430_ABS16 */
12435 case 15: /* R_MSP430X_ABS16 */
12436 if (! uses_msp430x_relocs (filedata
))
12438 goto handle_sym_diff
;
12441 if (saved_sym
!= NULL
)
12443 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12446 if (sym_index
>= num_syms
)
12447 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12451 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12452 - saved_sym
->st_value
);
12454 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12455 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12458 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12459 (long) reloc
->r_offset
);
12468 if (saved_sym
!= NULL
)
12469 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12476 case EM_CYGNUS_MN10300
:
12478 static Elf_Internal_Sym
* saved_sym
= NULL
;
12486 switch (reloc_type
)
12488 case 34: /* R_MN10300_ALIGN */
12490 case 33: /* R_MN10300_SYM_DIFF */
12491 if (sym_index
>= num_syms
)
12492 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12495 saved_sym
= symtab
+ sym_index
;
12498 case 1: /* R_MN10300_32 */
12499 case 2: /* R_MN10300_16 */
12500 if (saved_sym
!= NULL
)
12502 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12505 if (sym_index
>= num_syms
)
12506 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12510 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12511 - saved_sym
->st_value
);
12513 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12514 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12516 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12517 (long) reloc
->r_offset
);
12525 if (saved_sym
!= NULL
)
12526 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12534 static bfd_vma saved_sym1
= 0;
12535 static bfd_vma saved_sym2
= 0;
12536 static bfd_vma value
;
12540 saved_sym1
= saved_sym2
= 0;
12544 switch (reloc_type
)
12546 case 0x80: /* R_RL78_SYM. */
12547 saved_sym1
= saved_sym2
;
12548 if (sym_index
>= num_syms
)
12549 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12553 saved_sym2
= symtab
[sym_index
].st_value
;
12554 saved_sym2
+= reloc
->r_addend
;
12558 case 0x83: /* R_RL78_OPsub. */
12559 value
= saved_sym1
- saved_sym2
;
12560 saved_sym2
= saved_sym1
= 0;
12564 case 0x41: /* R_RL78_ABS32. */
12565 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12566 byte_put (start
+ reloc
->r_offset
, value
, 4);
12568 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12569 (long) reloc
->r_offset
);
12573 case 0x43: /* R_RL78_ABS16. */
12574 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12575 byte_put (start
+ reloc
->r_offset
, value
, 2);
12577 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12578 (long) reloc
->r_offset
);
12592 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12593 DWARF debug sections. This is a target specific test. Note - we do not
12594 go through the whole including-target-headers-multiple-times route, (as
12595 we have already done with <elf/h8.h>) because this would become very
12596 messy and even then this function would have to contain target specific
12597 information (the names of the relocs instead of their numeric values).
12598 FIXME: This is not the correct way to solve this problem. The proper way
12599 is to have target specific reloc sizing and typing functions created by
12600 the reloc-macros.h header, in the same way that it already creates the
12601 reloc naming functions. */
12604 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12606 /* Please keep this table alpha-sorted for ease of visual lookup. */
12607 switch (filedata
->file_header
.e_machine
)
12611 return reloc_type
== 1; /* R_386_32. */
12613 return reloc_type
== 1; /* R_68K_32. */
12615 return reloc_type
== 1; /* R_860_32. */
12617 return reloc_type
== 2; /* R_960_32. */
12619 return (reloc_type
== 258
12620 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12622 return reloc_type
== 11; /* R_BPF_DATA_32 */
12623 case EM_ADAPTEVA_EPIPHANY
:
12624 return reloc_type
== 3;
12626 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12628 return reloc_type
== 1; /* R_ARC_32. */
12629 case EM_ARC_COMPACT
:
12630 case EM_ARC_COMPACT2
:
12631 return reloc_type
== 4; /* R_ARC_32. */
12633 return reloc_type
== 2; /* R_ARM_ABS32 */
12636 return reloc_type
== 1;
12638 return reloc_type
== 0x12; /* R_byte4_data. */
12640 return reloc_type
== 3; /* R_CRIS_32. */
12642 return reloc_type
== 3; /* R_CR16_NUM32. */
12644 return reloc_type
== 15; /* R_CRX_NUM32. */
12646 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12647 case EM_CYGNUS_FRV
:
12648 return reloc_type
== 1;
12649 case EM_CYGNUS_D10V
:
12651 return reloc_type
== 6; /* R_D10V_32. */
12652 case EM_CYGNUS_D30V
:
12654 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12656 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12657 case EM_CYGNUS_FR30
:
12659 return reloc_type
== 3; /* R_FR30_32. */
12661 return reloc_type
== 1; /* R_FT32_32. */
12665 return reloc_type
== 1; /* R_H8_DIR32. */
12667 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12668 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12669 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12670 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12673 return reloc_type
== 2; /* R_IP2K_32. */
12675 return reloc_type
== 2; /* R_IQ2000_32. */
12676 case EM_LATTICEMICO32
:
12677 return reloc_type
== 3; /* R_LM32_32. */
12680 return reloc_type
== 3; /* R_M32C_32. */
12682 return reloc_type
== 34; /* R_M32R_32_RELA. */
12685 return reloc_type
== 6; /* R_M68HC11_32. */
12687 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12688 reloc_type
== 6; /* R_S12Z_CW32. */
12690 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12691 case EM_CYGNUS_MEP
:
12692 return reloc_type
== 4; /* R_MEP_32. */
12694 return reloc_type
== 2; /* R_METAG_ADDR32. */
12695 case EM_MICROBLAZE
:
12696 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12698 return reloc_type
== 2; /* R_MIPS_32. */
12700 return reloc_type
== 4; /* R_MMIX_32. */
12701 case EM_CYGNUS_MN10200
:
12703 return reloc_type
== 1; /* R_MN10200_32. */
12704 case EM_CYGNUS_MN10300
:
12706 return reloc_type
== 1; /* R_MN10300_32. */
12708 return reloc_type
== 1; /* R_MOXIE_32. */
12709 case EM_MSP430_OLD
:
12711 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12713 return reloc_type
== 2; /* R_MT_32. */
12715 return reloc_type
== 20; /* R_NDS32_RELA. */
12716 case EM_ALTERA_NIOS2
:
12717 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12719 return reloc_type
== 1; /* R_NIOS_32. */
12721 return reloc_type
== 1; /* R_OR1K_32. */
12723 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12724 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12725 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12728 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12730 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12732 return reloc_type
== 1; /* R_PPC_ADDR32. */
12734 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12736 return reloc_type
== 1; /* R_RISCV_32. */
12738 return reloc_type
== 1; /* R_RL78_DIR32. */
12740 return reloc_type
== 1; /* R_RX_DIR32. */
12742 return reloc_type
== 1; /* R_I370_ADDR31. */
12745 return reloc_type
== 4; /* R_S390_32. */
12747 return reloc_type
== 8; /* R_SCORE_ABS32. */
12749 return reloc_type
== 1; /* R_SH_DIR32. */
12750 case EM_SPARC32PLUS
:
12753 return reloc_type
== 3 /* R_SPARC_32. */
12754 || reloc_type
== 23; /* R_SPARC_UA32. */
12756 return reloc_type
== 6; /* R_SPU_ADDR32 */
12758 return reloc_type
== 1; /* R_C6000_ABS32. */
12760 return reloc_type
== 2; /* R_TILEGX_32. */
12762 return reloc_type
== 1; /* R_TILEPRO_32. */
12763 case EM_CYGNUS_V850
:
12765 return reloc_type
== 6; /* R_V850_ABS32. */
12767 return reloc_type
== 0x33; /* R_V810_WORD. */
12769 return reloc_type
== 1; /* R_VAX_32. */
12771 return reloc_type
== 3; /* R_VISIUM_32. */
12772 case EM_WEBASSEMBLY
:
12773 return reloc_type
== 1; /* R_WASM32_32. */
12777 return reloc_type
== 10; /* R_X86_64_32. */
12780 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12782 return reloc_type
== 4; /* R_XGATE_32. */
12784 return reloc_type
== 1; /* R_XSTROMY16_32. */
12785 case EM_XTENSA_OLD
:
12787 return reloc_type
== 1; /* R_XTENSA_32. */
12789 return reloc_type
== 6; /* R_Z80_32. */
12792 static unsigned int prev_warn
= 0;
12794 /* Avoid repeating the same warning multiple times. */
12795 if (prev_warn
!= filedata
->file_header
.e_machine
)
12796 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12797 filedata
->file_header
.e_machine
);
12798 prev_warn
= filedata
->file_header
.e_machine
;
12804 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12805 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12808 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12810 switch (filedata
->file_header
.e_machine
)
12811 /* Please keep this table alpha-sorted for ease of visual lookup. */
12815 return reloc_type
== 2; /* R_386_PC32. */
12817 return reloc_type
== 4; /* R_68K_PC32. */
12819 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12820 case EM_ADAPTEVA_EPIPHANY
:
12821 return reloc_type
== 6;
12823 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12824 case EM_ARC_COMPACT
:
12825 case EM_ARC_COMPACT2
:
12826 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12828 return reloc_type
== 3; /* R_ARM_REL32 */
12831 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12832 case EM_MICROBLAZE
:
12833 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12835 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12837 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12839 return reloc_type
== 26; /* R_PPC_REL32. */
12841 return reloc_type
== 26; /* R_PPC64_REL32. */
12843 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12846 return reloc_type
== 5; /* R_390_PC32. */
12848 return reloc_type
== 2; /* R_SH_REL32. */
12849 case EM_SPARC32PLUS
:
12852 return reloc_type
== 6; /* R_SPARC_DISP32. */
12854 return reloc_type
== 13; /* R_SPU_REL32. */
12856 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12858 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12860 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12864 return reloc_type
== 2; /* R_X86_64_PC32. */
12866 return reloc_type
== 4; /* R_VAX_PCREL32. */
12867 case EM_XTENSA_OLD
:
12869 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12871 /* Do not abort or issue an error message here. Not all targets use
12872 pc-relative 32-bit relocs in their DWARF debug information and we
12873 have already tested for target coverage in is_32bit_abs_reloc. A
12874 more helpful warning message will be generated by apply_relocations
12875 anyway, so just return. */
12880 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12881 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12884 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12886 switch (filedata
->file_header
.e_machine
)
12889 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12891 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12893 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12894 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12896 return reloc_type
== 80; /* R_PARISC_DIR64. */
12898 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12900 return reloc_type
== 2; /* R_RISCV_64. */
12901 case EM_SPARC32PLUS
:
12904 return reloc_type
== 32 /* R_SPARC_64. */
12905 || reloc_type
== 54; /* R_SPARC_UA64. */
12909 return reloc_type
== 1; /* R_X86_64_64. */
12912 return reloc_type
== 22; /* R_S390_64. */
12914 return reloc_type
== 1; /* R_TILEGX_64. */
12916 return reloc_type
== 18; /* R_MIPS_64. */
12922 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12923 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12926 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12928 switch (filedata
->file_header
.e_machine
)
12931 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12933 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12935 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12936 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12938 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12940 return reloc_type
== 44; /* R_PPC64_REL64. */
12941 case EM_SPARC32PLUS
:
12944 return reloc_type
== 46; /* R_SPARC_DISP64. */
12948 return reloc_type
== 24; /* R_X86_64_PC64. */
12951 return reloc_type
== 23; /* R_S390_PC64. */
12953 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12959 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12960 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12963 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12965 switch (filedata
->file_header
.e_machine
)
12967 case EM_CYGNUS_MN10200
:
12969 return reloc_type
== 4; /* R_MN10200_24. */
12971 return reloc_type
== 5; /* R_FT32_20. */
12973 return reloc_type
== 5; /* R_Z80_24. */
12979 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12980 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12983 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12985 /* Please keep this table alpha-sorted for ease of visual lookup. */
12986 switch (filedata
->file_header
.e_machine
)
12989 case EM_ARC_COMPACT
:
12990 case EM_ARC_COMPACT2
:
12991 return reloc_type
== 2; /* R_ARC_16. */
12992 case EM_ADAPTEVA_EPIPHANY
:
12993 return reloc_type
== 5;
12996 return reloc_type
== 4; /* R_AVR_16. */
12997 case EM_CYGNUS_D10V
:
12999 return reloc_type
== 3; /* R_D10V_16. */
13001 return reloc_type
== 2; /* R_FT32_16. */
13005 return reloc_type
== R_H8_DIR16
;
13008 return reloc_type
== 1; /* R_IP2K_16. */
13011 return reloc_type
== 1; /* R_M32C_16 */
13012 case EM_CYGNUS_MN10200
:
13014 return reloc_type
== 2; /* R_MN10200_16. */
13015 case EM_CYGNUS_MN10300
:
13017 return reloc_type
== 2; /* R_MN10300_16. */
13019 if (uses_msp430x_relocs (filedata
))
13020 return reloc_type
== 2; /* R_MSP430_ABS16. */
13021 /* Fall through. */
13022 case EM_MSP430_OLD
:
13023 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13025 return reloc_type
== 19; /* R_NDS32_RELA. */
13026 case EM_ALTERA_NIOS2
:
13027 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13029 return reloc_type
== 9; /* R_NIOS_16. */
13031 return reloc_type
== 2; /* R_OR1K_16. */
13033 return reloc_type
== 55; /* R_RISCV_SET16. */
13035 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13037 return reloc_type
== 2; /* R_C6000_ABS16. */
13039 return reloc_type
== 2; /* R_VISIUM_16. */
13042 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13044 return reloc_type
== 3; /* R_XGATE_16. */
13046 return reloc_type
== 4; /* R_Z80_16. */
13052 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13053 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13056 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13058 switch (filedata
->file_header
.e_machine
)
13061 return reloc_type
== 54; /* R_RISCV_SET8. */
13063 return reloc_type
== 1; /* R_Z80_8. */
13069 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13070 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13073 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13075 switch (filedata
->file_header
.e_machine
)
13078 return reloc_type
== 53; /* R_RISCV_SET6. */
13084 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13085 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13088 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13090 /* Please keep this table alpha-sorted for ease of visual lookup. */
13091 switch (filedata
->file_header
.e_machine
)
13094 return reloc_type
== 35; /* R_RISCV_ADD32. */
13100 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13101 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13104 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13106 /* Please keep this table alpha-sorted for ease of visual lookup. */
13107 switch (filedata
->file_header
.e_machine
)
13110 return reloc_type
== 39; /* R_RISCV_SUB32. */
13116 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13117 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13120 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13122 /* Please keep this table alpha-sorted for ease of visual lookup. */
13123 switch (filedata
->file_header
.e_machine
)
13126 return reloc_type
== 36; /* R_RISCV_ADD64. */
13132 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13133 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13136 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13138 /* Please keep this table alpha-sorted for ease of visual lookup. */
13139 switch (filedata
->file_header
.e_machine
)
13142 return reloc_type
== 40; /* R_RISCV_SUB64. */
13148 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13149 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13152 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13154 /* Please keep this table alpha-sorted for ease of visual lookup. */
13155 switch (filedata
->file_header
.e_machine
)
13158 return reloc_type
== 34; /* R_RISCV_ADD16. */
13164 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13165 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13168 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13170 /* Please keep this table alpha-sorted for ease of visual lookup. */
13171 switch (filedata
->file_header
.e_machine
)
13174 return reloc_type
== 38; /* R_RISCV_SUB16. */
13180 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13181 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13184 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13186 /* Please keep this table alpha-sorted for ease of visual lookup. */
13187 switch (filedata
->file_header
.e_machine
)
13190 return reloc_type
== 33; /* R_RISCV_ADD8. */
13196 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13197 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13200 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13202 /* Please keep this table alpha-sorted for ease of visual lookup. */
13203 switch (filedata
->file_header
.e_machine
)
13206 return reloc_type
== 37; /* R_RISCV_SUB8. */
13212 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13213 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13216 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13218 switch (filedata
->file_header
.e_machine
)
13221 return reloc_type
== 52; /* R_RISCV_SUB6. */
13227 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13228 relocation entries (possibly formerly used for SHT_GROUP sections). */
13231 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13233 switch (filedata
->file_header
.e_machine
)
13235 case EM_386
: /* R_386_NONE. */
13236 case EM_68K
: /* R_68K_NONE. */
13237 case EM_ADAPTEVA_EPIPHANY
:
13238 case EM_ALPHA
: /* R_ALPHA_NONE. */
13239 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13240 case EM_ARC
: /* R_ARC_NONE. */
13241 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13242 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13243 case EM_ARM
: /* R_ARM_NONE. */
13244 case EM_C166
: /* R_XC16X_NONE. */
13245 case EM_CRIS
: /* R_CRIS_NONE. */
13246 case EM_FT32
: /* R_FT32_NONE. */
13247 case EM_IA_64
: /* R_IA64_NONE. */
13248 case EM_K1OM
: /* R_X86_64_NONE. */
13249 case EM_L1OM
: /* R_X86_64_NONE. */
13250 case EM_M32R
: /* R_M32R_NONE. */
13251 case EM_MIPS
: /* R_MIPS_NONE. */
13252 case EM_MN10300
: /* R_MN10300_NONE. */
13253 case EM_MOXIE
: /* R_MOXIE_NONE. */
13254 case EM_NIOS32
: /* R_NIOS_NONE. */
13255 case EM_OR1K
: /* R_OR1K_NONE. */
13256 case EM_PARISC
: /* R_PARISC_NONE. */
13257 case EM_PPC64
: /* R_PPC64_NONE. */
13258 case EM_PPC
: /* R_PPC_NONE. */
13259 case EM_RISCV
: /* R_RISCV_NONE. */
13260 case EM_S390
: /* R_390_NONE. */
13262 case EM_SH
: /* R_SH_NONE. */
13263 case EM_SPARC32PLUS
:
13264 case EM_SPARC
: /* R_SPARC_NONE. */
13266 case EM_TILEGX
: /* R_TILEGX_NONE. */
13267 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13268 case EM_TI_C6000
:/* R_C6000_NONE. */
13269 case EM_X86_64
: /* R_X86_64_NONE. */
13271 case EM_Z80
: /* R_Z80_NONE. */
13272 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13273 return reloc_type
== 0;
13276 return reloc_type
== 0 || reloc_type
== 256;
13279 return (reloc_type
== 0 /* R_AVR_NONE. */
13280 || reloc_type
== 30 /* R_AVR_DIFF8. */
13281 || reloc_type
== 31 /* R_AVR_DIFF16. */
13282 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13284 return reloc_type
== 3; /* R_METAG_NONE. */
13286 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13287 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13288 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13289 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13290 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13292 return (reloc_type
== 0 /* R_PRU_NONE. */
13293 || reloc_type
== 65 /* R_PRU_DIFF8. */
13294 || reloc_type
== 66 /* R_PRU_DIFF16. */
13295 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13296 case EM_XTENSA_OLD
:
13298 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13299 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13300 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13301 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13306 /* Returns TRUE if there is a relocation against
13307 section NAME at OFFSET bytes. */
13310 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13312 Elf_Internal_Rela
* relocs
;
13313 Elf_Internal_Rela
* rp
;
13315 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13318 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13320 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13321 if (rp
->r_offset
== offset
)
13327 /* Apply relocations to a section.
13328 Returns TRUE upon success, FALSE otherwise.
13329 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13330 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13331 will be set to the number of relocs loaded.
13333 Note: So far support has been added only for those relocations
13334 which can be found in debug sections. FIXME: Add support for
13335 more relocations ? */
13338 apply_relocations (Filedata
* filedata
,
13339 const Elf_Internal_Shdr
* section
,
13340 unsigned char * start
,
13341 bfd_size_type size
,
13342 void ** relocs_return
,
13343 unsigned long * num_relocs_return
)
13345 Elf_Internal_Shdr
* relsec
;
13346 unsigned char * end
= start
+ size
;
13348 if (relocs_return
!= NULL
)
13350 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13351 * num_relocs_return
= 0;
13354 if (filedata
->file_header
.e_type
!= ET_REL
)
13355 /* No relocs to apply. */
13358 /* Find the reloc section associated with the section. */
13359 for (relsec
= filedata
->section_headers
;
13360 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13363 bfd_boolean is_rela
;
13364 unsigned long num_relocs
;
13365 Elf_Internal_Rela
* relocs
;
13366 Elf_Internal_Rela
* rp
;
13367 Elf_Internal_Shdr
* symsec
;
13368 Elf_Internal_Sym
* symtab
;
13369 unsigned long num_syms
;
13370 Elf_Internal_Sym
* sym
;
13372 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13373 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13374 || filedata
->section_headers
+ relsec
->sh_info
!= section
13375 || relsec
->sh_size
== 0
13376 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13379 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13380 if (symsec
->sh_type
!= SHT_SYMTAB
13381 && symsec
->sh_type
!= SHT_DYNSYM
)
13384 is_rela
= relsec
->sh_type
== SHT_RELA
;
13388 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13389 relsec
->sh_size
, & relocs
, & num_relocs
))
13394 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13395 relsec
->sh_size
, & relocs
, & num_relocs
))
13399 /* SH uses RELA but uses in place value instead of the addend field. */
13400 if (filedata
->file_header
.e_machine
== EM_SH
)
13403 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13405 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13408 unsigned int reloc_type
;
13409 unsigned int reloc_size
;
13410 bfd_boolean reloc_inplace
= FALSE
;
13411 bfd_boolean reloc_subtract
= FALSE
;
13412 unsigned char * rloc
;
13413 unsigned long sym_index
;
13415 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13417 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13419 else if (is_none_reloc (filedata
, reloc_type
))
13421 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13422 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13424 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13425 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13427 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13429 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13431 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13432 || is_6bit_abs_reloc (filedata
, reloc_type
))
13434 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13436 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13439 reloc_inplace
= TRUE
;
13441 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13443 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13446 reloc_inplace
= TRUE
;
13448 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13450 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13453 reloc_inplace
= TRUE
;
13455 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13457 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13460 reloc_inplace
= TRUE
;
13462 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13466 reloc_inplace
= TRUE
;
13470 static unsigned int prev_reloc
= 0;
13472 if (reloc_type
!= prev_reloc
)
13473 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13474 reloc_type
, printable_section_name (filedata
, section
));
13475 prev_reloc
= reloc_type
;
13479 rloc
= start
+ rp
->r_offset
;
13480 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13482 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13483 (unsigned long) rp
->r_offset
,
13484 printable_section_name (filedata
, section
));
13488 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13489 if (sym_index
>= num_syms
)
13491 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13492 sym_index
, printable_section_name (filedata
, section
));
13495 sym
= symtab
+ sym_index
;
13497 /* If the reloc has a symbol associated with it,
13498 make sure that it is of an appropriate type.
13500 Relocations against symbols without type can happen.
13501 Gcc -feliminate-dwarf2-dups may generate symbols
13502 without type for debug info.
13504 Icc generates relocations against function symbols
13505 instead of local labels.
13507 Relocations against object symbols can happen, eg when
13508 referencing a global array. For an example of this see
13509 the _clz.o binary in libgcc.a. */
13511 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13512 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13514 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13515 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13516 printable_section_name (filedata
, relsec
),
13517 (long int)(rp
- relocs
));
13523 addend
+= rp
->r_addend
;
13524 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13525 partial_inplace. */
13527 || (filedata
->file_header
.e_machine
== EM_XTENSA
13528 && reloc_type
== 1)
13529 || ((filedata
->file_header
.e_machine
== EM_PJ
13530 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13531 && reloc_type
== 1)
13532 || ((filedata
->file_header
.e_machine
== EM_D30V
13533 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13534 && reloc_type
== 12)
13537 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13538 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13540 addend
+= byte_get (rloc
, reloc_size
);
13543 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13544 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13546 /* On HPPA, all pc-relative relocations are biased by 8. */
13547 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13549 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13552 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13553 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13555 if (reloc_subtract
)
13556 addend
-= sym
->st_value
;
13558 addend
+= sym
->st_value
;
13559 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13560 byte_put (rloc
, addend
, reloc_size
);
13562 else if (reloc_subtract
)
13563 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13565 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13569 /* Let the target specific reloc processing code know that
13570 we have finished with these relocs. */
13571 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13575 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13576 * num_relocs_return
= num_relocs
;
13587 #ifdef SUPPORT_DISASSEMBLY
13589 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13591 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13593 /* FIXME: XXX -- to be done --- XXX */
13599 /* Reads in the contents of SECTION from FILE, returning a pointer
13600 to a malloc'ed buffer or NULL if something went wrong. */
13603 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13605 bfd_size_type num_bytes
= section
->sh_size
;
13607 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13609 printf (_("Section '%s' has no data to dump.\n"),
13610 printable_section_name (filedata
, section
));
13614 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13615 _("section contents"));
13618 /* Uncompresses a section that was compressed using zlib, in place. */
13621 uncompress_section_contents (unsigned char ** buffer
,
13622 dwarf_size_type uncompressed_size
,
13623 dwarf_size_type
* size
)
13625 dwarf_size_type compressed_size
= *size
;
13626 unsigned char * compressed_buffer
= *buffer
;
13627 unsigned char * uncompressed_buffer
;
13631 /* It is possible the section consists of several compressed
13632 buffers concatenated together, so we uncompress in a loop. */
13633 /* PR 18313: The state field in the z_stream structure is supposed
13634 to be invisible to the user (ie us), but some compilers will
13635 still complain about it being used without initialisation. So
13636 we first zero the entire z_stream structure and then set the fields
13638 memset (& strm
, 0, sizeof strm
);
13639 strm
.avail_in
= compressed_size
;
13640 strm
.next_in
= (Bytef
*) compressed_buffer
;
13641 strm
.avail_out
= uncompressed_size
;
13642 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13644 rc
= inflateInit (& strm
);
13645 while (strm
.avail_in
> 0)
13649 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13650 + (uncompressed_size
- strm
.avail_out
));
13651 rc
= inflate (&strm
, Z_FINISH
);
13652 if (rc
!= Z_STREAM_END
)
13654 rc
= inflateReset (& strm
);
13656 rc
= inflateEnd (& strm
);
13658 || strm
.avail_out
!= 0)
13661 *buffer
= uncompressed_buffer
;
13662 *size
= uncompressed_size
;
13666 free (uncompressed_buffer
);
13667 /* Indicate decompression failure. */
13673 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13675 Elf_Internal_Shdr
* relsec
;
13676 bfd_size_type num_bytes
;
13677 unsigned char * data
;
13678 unsigned char * end
;
13679 unsigned char * real_start
;
13680 unsigned char * start
;
13681 bfd_boolean some_strings_shown
;
13683 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13685 /* PR 21820: Do not fail if the section was empty. */
13686 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13688 num_bytes
= section
->sh_size
;
13690 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13692 if (decompress_dumps
)
13694 dwarf_size_type new_size
= num_bytes
;
13695 dwarf_size_type uncompressed_size
= 0;
13697 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13699 Elf_Internal_Chdr chdr
;
13700 unsigned int compression_header_size
13701 = get_compression_header (& chdr
, (unsigned char *) start
,
13703 if (compression_header_size
== 0)
13704 /* An error message will have already been generated
13705 by get_compression_header. */
13708 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13710 warn (_("section '%s' has unsupported compress type: %d\n"),
13711 printable_section_name (filedata
, section
), chdr
.ch_type
);
13714 uncompressed_size
= chdr
.ch_size
;
13715 start
+= compression_header_size
;
13716 new_size
-= compression_header_size
;
13718 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13720 /* Read the zlib header. In this case, it should be "ZLIB"
13721 followed by the uncompressed section size, 8 bytes in
13722 big-endian order. */
13723 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13724 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13725 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13726 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13727 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13728 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13729 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13730 uncompressed_size
+= start
[11];
13735 if (uncompressed_size
)
13737 if (uncompress_section_contents (& start
,
13738 uncompressed_size
, & new_size
))
13739 num_bytes
= new_size
;
13742 error (_("Unable to decompress section %s\n"),
13743 printable_section_name (filedata
, section
));
13748 start
= real_start
;
13751 /* If the section being dumped has relocations against it the user might
13752 be expecting these relocations to have been applied. Check for this
13753 case and issue a warning message in order to avoid confusion.
13754 FIXME: Maybe we ought to have an option that dumps a section with
13755 relocs applied ? */
13756 for (relsec
= filedata
->section_headers
;
13757 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13760 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13761 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13762 || filedata
->section_headers
+ relsec
->sh_info
!= section
13763 || relsec
->sh_size
== 0
13764 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13767 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13772 end
= start
+ num_bytes
;
13773 some_strings_shown
= FALSE
;
13775 #ifdef HAVE_MBSTATE_T
13777 /* Initialise the multibyte conversion state. */
13778 memset (& state
, 0, sizeof (state
));
13781 bfd_boolean continuing
= FALSE
;
13785 while (!ISPRINT (* data
))
13786 if (++ data
>= end
)
13791 size_t maxlen
= end
- data
;
13796 continuing
= FALSE
;
13801 /* PR 11128: Use two separate invocations in order to work
13802 around bugs in the Solaris 8 implementation of printf. */
13803 printf (" [%6tx] ", data
- start
);
13805 printf (" [%6Ix] ", (size_t) (data
- start
));
13820 /* PR 25543: Treat new-lines as string-ending characters. */
13829 /* Do not print control characters directly as they can affect terminal
13830 settings. Such characters usually appear in the names generated
13831 by the assembler for local labels. */
13834 printf ("^%c", c
+ 0x40);
13836 else if (ISPRINT (c
))
13843 #ifdef HAVE_MBSTATE_T
13846 /* Let printf do the hard work of displaying multibyte characters. */
13847 printf ("%.1s", data
- 1);
13848 #ifdef HAVE_MBSTATE_T
13849 /* Try to find out how many bytes made up the character that was
13850 just printed. Advance the symbol pointer past the bytes that
13852 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13856 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13866 printf (_("<corrupt>\n"));
13869 some_strings_shown
= TRUE
;
13873 if (! some_strings_shown
)
13874 printf (_(" No strings found in this section."));
13887 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13888 Filedata
* filedata
,
13889 bfd_boolean relocate
)
13891 Elf_Internal_Shdr
* relsec
;
13892 bfd_size_type bytes
;
13893 bfd_size_type section_size
;
13895 unsigned char * data
;
13896 unsigned char * real_start
;
13897 unsigned char * start
;
13899 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13901 /* PR 21820: Do not fail if the section was empty. */
13902 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13904 section_size
= section
->sh_size
;
13906 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13908 if (decompress_dumps
)
13910 dwarf_size_type new_size
= section_size
;
13911 dwarf_size_type uncompressed_size
= 0;
13913 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13915 Elf_Internal_Chdr chdr
;
13916 unsigned int compression_header_size
13917 = get_compression_header (& chdr
, start
, section_size
);
13919 if (compression_header_size
== 0)
13920 /* An error message will have already been generated
13921 by get_compression_header. */
13924 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13926 warn (_("section '%s' has unsupported compress type: %d\n"),
13927 printable_section_name (filedata
, section
), chdr
.ch_type
);
13930 uncompressed_size
= chdr
.ch_size
;
13931 start
+= compression_header_size
;
13932 new_size
-= compression_header_size
;
13934 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13936 /* Read the zlib header. In this case, it should be "ZLIB"
13937 followed by the uncompressed section size, 8 bytes in
13938 big-endian order. */
13939 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13940 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13941 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13942 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13943 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13944 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13945 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13946 uncompressed_size
+= start
[11];
13951 if (uncompressed_size
)
13953 if (uncompress_section_contents (& start
, uncompressed_size
,
13956 section_size
= new_size
;
13960 error (_("Unable to decompress section %s\n"),
13961 printable_section_name (filedata
, section
));
13962 /* FIXME: Print the section anyway ? */
13967 start
= real_start
;
13972 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13977 /* If the section being dumped has relocations against it the user might
13978 be expecting these relocations to have been applied. Check for this
13979 case and issue a warning message in order to avoid confusion.
13980 FIXME: Maybe we ought to have an option that dumps a section with
13981 relocs applied ? */
13982 for (relsec
= filedata
->section_headers
;
13983 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13986 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13987 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13988 || filedata
->section_headers
+ relsec
->sh_info
!= section
13989 || relsec
->sh_size
== 0
13990 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13993 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13998 addr
= section
->sh_addr
;
13999 bytes
= section_size
;
14008 lbytes
= (bytes
> 16 ? 16 : bytes
);
14010 printf (" 0x%8.8lx ", (unsigned long) addr
);
14012 for (j
= 0; j
< 16; j
++)
14015 printf ("%2.2x", data
[j
]);
14023 for (j
= 0; j
< lbytes
; j
++)
14026 if (k
>= ' ' && k
< 0x7f)
14049 static ctf_sect_t
*
14050 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14052 buf
->cts_name
= SECTION_NAME (shdr
);
14053 buf
->cts_size
= shdr
->sh_size
;
14054 buf
->cts_entsize
= shdr
->sh_entsize
;
14059 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14060 it is passed, or a pointer to newly-allocated storage, in which case
14061 dump_ctf() will free it when it no longer needs it. */
14063 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14064 char *s
, void *arg
)
14066 const char *blanks
= arg
;
14069 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14075 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14077 Elf_Internal_Shdr
* parent_sec
= NULL
;
14078 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14079 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14080 void * data
= NULL
;
14081 void * symdata
= NULL
;
14082 void * strdata
= NULL
;
14083 void * parentdata
= NULL
;
14084 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14085 ctf_sect_t
* symsectp
= NULL
;
14086 ctf_sect_t
* strsectp
= NULL
;
14087 ctf_file_t
* ctf
= NULL
;
14088 ctf_file_t
* parent
= NULL
;
14090 const char *things
[] = {"Header", "Labels", "Data objects",
14091 "Function objects", "Variables", "Types", "Strings",
14093 const char **thing
;
14095 bfd_boolean ret
= FALSE
;
14098 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14099 data
= get_section_contents (section
, filedata
);
14100 ctfsect
.cts_data
= data
;
14102 if (!dump_ctf_symtab_name
)
14103 dump_ctf_symtab_name
= strdup (".symtab");
14105 if (!dump_ctf_strtab_name
)
14106 dump_ctf_strtab_name
= strdup (".strtab");
14108 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14110 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14112 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14115 if ((symdata
= (void *) get_data (NULL
, filedata
,
14116 symtab_sec
->sh_offset
, 1,
14117 symtab_sec
->sh_size
,
14118 _("symbols"))) == NULL
)
14120 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14121 symsect
.cts_data
= symdata
;
14123 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14125 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14127 error (_("No string table section named %s\n"),
14128 dump_ctf_strtab_name
);
14131 if ((strdata
= (void *) get_data (NULL
, filedata
,
14132 strtab_sec
->sh_offset
, 1,
14133 strtab_sec
->sh_size
,
14134 _("strings"))) == NULL
)
14136 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14137 strsect
.cts_data
= strdata
;
14139 if (dump_ctf_parent_name
)
14141 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14143 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14146 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14147 parent_sec
->sh_offset
, 1,
14148 parent_sec
->sh_size
,
14149 _("CTF parent"))) == NULL
)
14151 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14152 parentsect
.cts_data
= parentdata
;
14155 /* Load the CTF file and dump it. */
14157 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14159 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14165 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14167 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14171 ctf_import (ctf
, parent
);
14176 printf (_("\nDump of CTF section '%s':\n"),
14177 printable_section_name (filedata
, section
));
14179 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14181 ctf_dump_state_t
*s
= NULL
;
14184 printf ("\n %s:\n", *thing
);
14185 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14186 (void *) " ")) != NULL
)
14188 printf ("%s\n", item
);
14192 if (ctf_errno (ctf
))
14194 error (_("Iteration failed: %s, %s\n"), *thing
,
14195 ctf_errmsg (ctf_errno (ctf
)));
14201 ctf_file_close (ctf
);
14202 ctf_file_close (parent
);
14211 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14212 const Elf_Internal_Shdr
* sec
,
14215 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14217 Filedata
* filedata
= (Filedata
*) data
;
14219 if (section
->start
!= NULL
)
14221 /* If it is already loaded, do nothing. */
14222 if (streq (section
->filename
, filedata
->file_name
))
14224 free (section
->start
);
14227 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14228 section
->address
= sec
->sh_addr
;
14229 section
->user_data
= NULL
;
14230 section
->filename
= filedata
->file_name
;
14231 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14233 sec
->sh_size
, buf
);
14234 if (section
->start
== NULL
)
14238 unsigned char *start
= section
->start
;
14239 dwarf_size_type size
= sec
->sh_size
;
14240 dwarf_size_type uncompressed_size
= 0;
14242 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14244 Elf_Internal_Chdr chdr
;
14245 unsigned int compression_header_size
;
14247 if (size
< (is_32bit_elf
14248 ? sizeof (Elf32_External_Chdr
)
14249 : sizeof (Elf64_External_Chdr
)))
14251 warn (_("compressed section %s is too small to contain a compression header\n"),
14256 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14257 if (compression_header_size
== 0)
14258 /* An error message will have already been generated
14259 by get_compression_header. */
14262 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14264 warn (_("section '%s' has unsupported compress type: %d\n"),
14265 section
->name
, chdr
.ch_type
);
14268 uncompressed_size
= chdr
.ch_size
;
14269 start
+= compression_header_size
;
14270 size
-= compression_header_size
;
14272 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14274 /* Read the zlib header. In this case, it should be "ZLIB"
14275 followed by the uncompressed section size, 8 bytes in
14276 big-endian order. */
14277 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14278 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14279 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14280 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14281 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14282 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14283 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14284 uncompressed_size
+= start
[11];
14289 if (uncompressed_size
)
14291 if (uncompress_section_contents (&start
, uncompressed_size
,
14294 /* Free the compressed buffer, update the section buffer
14295 and the section size if uncompress is successful. */
14296 free (section
->start
);
14297 section
->start
= start
;
14301 error (_("Unable to decompress section %s\n"),
14302 printable_section_name (filedata
, sec
));
14307 section
->size
= size
;
14310 if (section
->start
== NULL
)
14313 if (debug_displays
[debug
].relocate
)
14315 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14316 & section
->reloc_info
, & section
->num_relocs
))
14321 section
->reloc_info
= NULL
;
14322 section
->num_relocs
= 0;
14328 #if HAVE_LIBDEBUGINFOD
14329 /* Return a hex string representation of the build-id. */
14331 get_build_id (void * data
)
14333 Filedata
* filedata
= (Filedata
*)data
;
14334 Elf_Internal_Shdr
* shdr
;
14337 /* Iterate through notes to find note.gnu.build-id.
14338 FIXME: Only the first note in any note section is examined. */
14339 for (i
= 0, shdr
= filedata
->section_headers
;
14340 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14343 if (shdr
->sh_type
!= SHT_NOTE
)
14348 size_t data_remaining
;
14350 Elf_External_Note
* enote
;
14351 Elf_Internal_Note inote
;
14353 bfd_vma offset
= shdr
->sh_offset
;
14354 bfd_vma align
= shdr
->sh_addralign
;
14355 bfd_vma length
= shdr
->sh_size
;
14357 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14363 else if (align
!= 4 && align
!= 8)
14369 end
= (char *) enote
+ length
;
14370 data_remaining
= end
- (char *) enote
;
14372 if (!is_ia64_vms (filedata
))
14374 min_notesz
= offsetof (Elf_External_Note
, name
);
14375 if (data_remaining
< min_notesz
)
14378 malformed note encountered in section %s whilst scanning for build-id note\n"),
14379 printable_section_name (filedata
, shdr
));
14383 data_remaining
-= min_notesz
;
14385 inote
.type
= BYTE_GET (enote
->type
);
14386 inote
.namesz
= BYTE_GET (enote
->namesz
);
14387 inote
.namedata
= enote
->name
;
14388 inote
.descsz
= BYTE_GET (enote
->descsz
);
14389 inote
.descdata
= ((char *) enote
14390 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14391 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14392 next
= ((char *) enote
14393 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14397 Elf64_External_VMS_Note
*vms_enote
;
14399 /* PR binutils/15191
14400 Make sure that there is enough data to read. */
14401 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14402 if (data_remaining
< min_notesz
)
14405 malformed note encountered in section %s whilst scanning for build-id note\n"),
14406 printable_section_name (filedata
, shdr
));
14410 data_remaining
-= min_notesz
;
14412 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14413 inote
.type
= BYTE_GET (vms_enote
->type
);
14414 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14415 inote
.namedata
= vms_enote
->name
;
14416 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14417 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14418 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14419 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14422 /* Skip malformed notes. */
14423 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14424 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14425 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14426 || ((size_t) (next
- inote
.descdata
)
14427 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14430 malformed note encountered in section %s whilst scanning for build-id note\n"),
14431 printable_section_name (filedata
, shdr
));
14436 /* Check if this is the build-id note. If so then convert the build-id
14437 bytes to a hex string. */
14438 if (inote
.namesz
> 0
14439 && const_strneq (inote
.namedata
, "GNU")
14440 && inote
.type
== NT_GNU_BUILD_ID
)
14445 build_id
= malloc (inote
.descsz
* 2 + 1);
14446 if (build_id
== NULL
)
14452 for (j
= 0; j
< inote
.descsz
; ++j
)
14453 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14454 build_id
[inote
.descsz
* 2] = '\0';
14457 return (unsigned char *) build_id
;
14464 #endif /* HAVE_LIBDEBUGINFOD */
14466 /* If this is not NULL, load_debug_section will only look for sections
14467 within the list of sections given here. */
14468 static unsigned int * section_subset
= NULL
;
14471 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14473 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14474 Elf_Internal_Shdr
* sec
;
14475 Filedata
* filedata
= (Filedata
*) data
;
14477 /* Without section headers we cannot find any sections. */
14478 if (filedata
->section_headers
== NULL
)
14481 if (filedata
->string_table
== NULL
14482 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14483 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14485 Elf_Internal_Shdr
* strs
;
14487 /* Read in the string table, so that we have section names to scan. */
14488 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14490 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14492 filedata
->string_table
14493 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14494 1, strs
->sh_size
, _("string table"));
14496 filedata
->string_table_length
14497 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14501 /* Locate the debug section. */
14502 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14504 section
->name
= section
->uncompressed_name
;
14507 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14509 section
->name
= section
->compressed_name
;
14514 /* If we're loading from a subset of sections, and we've loaded
14515 a section matching this name before, it's likely that it's a
14517 if (section_subset
!= NULL
)
14518 free_debug_section (debug
);
14520 return load_specific_debug_section (debug
, sec
, data
);
14524 free_debug_section (enum dwarf_section_display_enum debug
)
14526 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14528 if (section
->start
== NULL
)
14531 free ((char *) section
->start
);
14532 section
->start
= NULL
;
14533 section
->address
= 0;
14536 if (section
->reloc_info
!= NULL
)
14538 free (section
->reloc_info
);
14539 section
->reloc_info
= NULL
;
14540 section
->num_relocs
= 0;
14545 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14547 char * name
= SECTION_NAME (section
);
14548 const char * print_name
= printable_section_name (filedata
, section
);
14549 bfd_size_type length
;
14550 bfd_boolean result
= TRUE
;
14553 length
= section
->sh_size
;
14556 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14559 if (section
->sh_type
== SHT_NOBITS
)
14561 /* There is no point in dumping the contents of a debugging section
14562 which has the NOBITS type - the bits in the file will be random.
14563 This can happen when a file containing a .eh_frame section is
14564 stripped with the --only-keep-debug command line option. */
14565 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14570 if (const_strneq (name
, ".gnu.linkonce.wi."))
14571 name
= ".debug_info";
14573 /* See if we know how to display the contents of this section. */
14574 for (i
= 0; i
< max
; i
++)
14576 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14577 struct dwarf_section_display
* display
= debug_displays
+ i
;
14578 struct dwarf_section
* sec
= & display
->section
;
14580 if (streq (sec
->uncompressed_name
, name
)
14581 || (id
== line
&& const_strneq (name
, ".debug_line."))
14582 || streq (sec
->compressed_name
, name
))
14584 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14587 free_debug_section (id
);
14589 if (i
== line
&& const_strneq (name
, ".debug_line."))
14591 else if (streq (sec
->uncompressed_name
, name
))
14592 sec
->name
= sec
->uncompressed_name
;
14594 sec
->name
= sec
->compressed_name
;
14596 if (load_specific_debug_section (id
, section
, filedata
))
14598 /* If this debug section is part of a CU/TU set in a .dwp file,
14599 restrict load_debug_section to the sections in that set. */
14600 section_subset
= find_cu_tu_set (filedata
, shndx
);
14602 result
&= display
->display (sec
, filedata
);
14604 section_subset
= NULL
;
14606 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14607 free_debug_section (id
);
14615 printf (_("Unrecognized debug section: %s\n"), print_name
);
14622 /* Set DUMP_SECTS for all sections where dumps were requested
14623 based on section name. */
14626 initialise_dumps_byname (Filedata
* filedata
)
14628 struct dump_list_entry
* cur
;
14630 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14633 bfd_boolean any
= FALSE
;
14635 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14636 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14638 request_dump_bynumber (filedata
, i
, cur
->type
);
14643 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14649 process_section_contents (Filedata
* filedata
)
14651 Elf_Internal_Shdr
* section
;
14653 bfd_boolean res
= TRUE
;
14658 initialise_dumps_byname (filedata
);
14660 for (i
= 0, section
= filedata
->section_headers
;
14661 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14664 dump_type dump
= filedata
->dump_sects
[i
];
14666 #ifdef SUPPORT_DISASSEMBLY
14667 if (dump
& DISASS_DUMP
)
14669 if (! disassemble_section (section
, filedata
))
14673 if (dump
& HEX_DUMP
)
14675 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14679 if (dump
& RELOC_DUMP
)
14681 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14685 if (dump
& STRING_DUMP
)
14687 if (! dump_section_as_strings (section
, filedata
))
14691 if (dump
& DEBUG_DUMP
)
14693 if (! display_debug_section (i
, section
, filedata
))
14697 if (dump
& CTF_DUMP
)
14699 if (! dump_section_as_ctf (section
, filedata
))
14704 /* Check to see if the user requested a
14705 dump of a section that does not exist. */
14706 while (i
< filedata
->num_dump_sects
)
14708 if (filedata
->dump_sects
[i
])
14710 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14720 process_mips_fpe_exception (int mask
)
14724 bfd_boolean first
= TRUE
;
14726 if (mask
& OEX_FPU_INEX
)
14727 fputs ("INEX", stdout
), first
= FALSE
;
14728 if (mask
& OEX_FPU_UFLO
)
14729 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14730 if (mask
& OEX_FPU_OFLO
)
14731 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14732 if (mask
& OEX_FPU_DIV0
)
14733 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14734 if (mask
& OEX_FPU_INVAL
)
14735 printf ("%sINVAL", first
? "" : "|");
14738 fputs ("0", stdout
);
14741 /* Display's the value of TAG at location P. If TAG is
14742 greater than 0 it is assumed to be an unknown tag, and
14743 a message is printed to this effect. Otherwise it is
14744 assumed that a message has already been printed.
14746 If the bottom bit of TAG is set it assumed to have a
14747 string value, otherwise it is assumed to have an integer
14750 Returns an updated P pointing to the first unread byte
14751 beyond the end of TAG's value.
14753 Reads at or beyond END will not be made. */
14755 static unsigned char *
14756 display_tag_value (signed int tag
,
14758 const unsigned char * const end
)
14763 printf (" Tag_unknown_%d: ", tag
);
14767 warn (_("<corrupt tag>\n"));
14771 /* PR 17531 file: 027-19978-0.004. */
14772 size_t maxlen
= (end
- p
) - 1;
14777 print_symbol ((int) maxlen
, (const char *) p
);
14778 p
+= strnlen ((char *) p
, maxlen
) + 1;
14782 printf (_("<corrupt string tag>"));
14783 p
= (unsigned char *) end
;
14789 READ_ULEB (val
, p
, end
);
14790 printf ("%ld (0x%lx)\n", val
, val
);
14797 /* ARC ABI attributes section. */
14799 static unsigned char *
14800 display_arc_attribute (unsigned char * p
,
14801 const unsigned char * const end
)
14806 READ_ULEB (tag
, p
, end
);
14810 case Tag_ARC_PCS_config
:
14811 READ_ULEB (val
, p
, end
);
14812 printf (" Tag_ARC_PCS_config: ");
14816 printf (_("Absent/Non standard\n"));
14819 printf (_("Bare metal/mwdt\n"));
14822 printf (_("Bare metal/newlib\n"));
14825 printf (_("Linux/uclibc\n"));
14828 printf (_("Linux/glibc\n"));
14831 printf (_("Unknown\n"));
14836 case Tag_ARC_CPU_base
:
14837 READ_ULEB (val
, p
, end
);
14838 printf (" Tag_ARC_CPU_base: ");
14843 printf (_("Absent\n"));
14845 case TAG_CPU_ARC6xx
:
14846 printf ("ARC6xx\n");
14848 case TAG_CPU_ARC7xx
:
14849 printf ("ARC7xx\n");
14851 case TAG_CPU_ARCEM
:
14852 printf ("ARCEM\n");
14854 case TAG_CPU_ARCHS
:
14855 printf ("ARCHS\n");
14860 case Tag_ARC_CPU_variation
:
14861 READ_ULEB (val
, p
, end
);
14862 printf (" Tag_ARC_CPU_variation: ");
14866 if (val
> 0 && val
< 16)
14867 printf ("Core%d\n", val
);
14869 printf ("Unknown\n");
14873 printf (_("Absent\n"));
14878 case Tag_ARC_CPU_name
:
14879 printf (" Tag_ARC_CPU_name: ");
14880 p
= display_tag_value (-1, p
, end
);
14883 case Tag_ARC_ABI_rf16
:
14884 READ_ULEB (val
, p
, end
);
14885 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14888 case Tag_ARC_ABI_osver
:
14889 READ_ULEB (val
, p
, end
);
14890 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14893 case Tag_ARC_ABI_pic
:
14894 case Tag_ARC_ABI_sda
:
14895 READ_ULEB (val
, p
, end
);
14896 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14897 : " Tag_ARC_ABI_pic: ");
14901 printf (_("Absent\n"));
14910 printf (_("Unknown\n"));
14915 case Tag_ARC_ABI_tls
:
14916 READ_ULEB (val
, p
, end
);
14917 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14920 case Tag_ARC_ABI_enumsize
:
14921 READ_ULEB (val
, p
, end
);
14922 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14926 case Tag_ARC_ABI_exceptions
:
14927 READ_ULEB (val
, p
, end
);
14928 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14932 case Tag_ARC_ABI_double_size
:
14933 READ_ULEB (val
, p
, end
);
14934 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14937 case Tag_ARC_ISA_config
:
14938 printf (" Tag_ARC_ISA_config: ");
14939 p
= display_tag_value (-1, p
, end
);
14942 case Tag_ARC_ISA_apex
:
14943 printf (" Tag_ARC_ISA_apex: ");
14944 p
= display_tag_value (-1, p
, end
);
14947 case Tag_ARC_ISA_mpy_option
:
14948 READ_ULEB (val
, p
, end
);
14949 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14952 case Tag_ARC_ATR_version
:
14953 READ_ULEB (val
, p
, end
);
14954 printf (" Tag_ARC_ATR_version: %d\n", val
);
14958 return display_tag_value (tag
& 1, p
, end
);
14964 /* ARM EABI attributes section. */
14969 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14971 const char ** table
;
14972 } arm_attr_public_tag
;
14974 static const char * arm_attr_tag_CPU_arch
[] =
14975 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14976 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14977 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14978 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14979 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14980 {"No", "Thumb-1", "Thumb-2", "Yes"};
14981 static const char * arm_attr_tag_FP_arch
[] =
14982 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14983 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14984 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14985 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14986 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14987 "NEON for ARMv8.1"};
14988 static const char * arm_attr_tag_PCS_config
[] =
14989 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14990 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14991 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14992 {"V6", "SB", "TLS", "Unused"};
14993 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14994 {"Absolute", "PC-relative", "SB-relative", "None"};
14995 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14996 {"Absolute", "PC-relative", "None"};
14997 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14998 {"None", "direct", "GOT-indirect"};
14999 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15000 {"None", "??? 1", "2", "??? 3", "4"};
15001 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15002 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15003 {"Unused", "Needed", "Sign only"};
15004 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15005 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15006 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15007 {"Unused", "Finite", "RTABI", "IEEE 754"};
15008 static const char * arm_attr_tag_ABI_enum_size
[] =
15009 {"Unused", "small", "int", "forced to int"};
15010 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15011 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15012 static const char * arm_attr_tag_ABI_VFP_args
[] =
15013 {"AAPCS", "VFP registers", "custom", "compatible"};
15014 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15015 {"AAPCS", "WMMX registers", "custom"};
15016 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15017 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15018 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15019 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15020 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15021 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15022 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15023 static const char * arm_attr_tag_FP_HP_extension
[] =
15024 {"Not Allowed", "Allowed"};
15025 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15026 {"None", "IEEE 754", "Alternative Format"};
15027 static const char * arm_attr_tag_DSP_extension
[] =
15028 {"Follow architecture", "Allowed"};
15029 static const char * arm_attr_tag_MPextension_use
[] =
15030 {"Not Allowed", "Allowed"};
15031 static const char * arm_attr_tag_DIV_use
[] =
15032 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15033 "Allowed in v7-A with integer division extension"};
15034 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15035 static const char * arm_attr_tag_Virtualization_use
[] =
15036 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15037 "TrustZone and Virtualization Extensions"};
15038 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15039 {"Not Allowed", "Allowed"};
15041 static const char * arm_attr_tag_MVE_arch
[] =
15042 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15044 #define LOOKUP(id, name) \
15045 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15046 static arm_attr_public_tag arm_attr_public_tags
[] =
15048 {4, "CPU_raw_name", 1, NULL
},
15049 {5, "CPU_name", 1, NULL
},
15050 LOOKUP(6, CPU_arch
),
15051 {7, "CPU_arch_profile", 0, NULL
},
15052 LOOKUP(8, ARM_ISA_use
),
15053 LOOKUP(9, THUMB_ISA_use
),
15054 LOOKUP(10, FP_arch
),
15055 LOOKUP(11, WMMX_arch
),
15056 LOOKUP(12, Advanced_SIMD_arch
),
15057 LOOKUP(13, PCS_config
),
15058 LOOKUP(14, ABI_PCS_R9_use
),
15059 LOOKUP(15, ABI_PCS_RW_data
),
15060 LOOKUP(16, ABI_PCS_RO_data
),
15061 LOOKUP(17, ABI_PCS_GOT_use
),
15062 LOOKUP(18, ABI_PCS_wchar_t
),
15063 LOOKUP(19, ABI_FP_rounding
),
15064 LOOKUP(20, ABI_FP_denormal
),
15065 LOOKUP(21, ABI_FP_exceptions
),
15066 LOOKUP(22, ABI_FP_user_exceptions
),
15067 LOOKUP(23, ABI_FP_number_model
),
15068 {24, "ABI_align_needed", 0, NULL
},
15069 {25, "ABI_align_preserved", 0, NULL
},
15070 LOOKUP(26, ABI_enum_size
),
15071 LOOKUP(27, ABI_HardFP_use
),
15072 LOOKUP(28, ABI_VFP_args
),
15073 LOOKUP(29, ABI_WMMX_args
),
15074 LOOKUP(30, ABI_optimization_goals
),
15075 LOOKUP(31, ABI_FP_optimization_goals
),
15076 {32, "compatibility", 0, NULL
},
15077 LOOKUP(34, CPU_unaligned_access
),
15078 LOOKUP(36, FP_HP_extension
),
15079 LOOKUP(38, ABI_FP_16bit_format
),
15080 LOOKUP(42, MPextension_use
),
15081 LOOKUP(44, DIV_use
),
15082 LOOKUP(46, DSP_extension
),
15083 LOOKUP(48, MVE_arch
),
15084 {64, "nodefaults", 0, NULL
},
15085 {65, "also_compatible_with", 0, NULL
},
15086 LOOKUP(66, T2EE_use
),
15087 {67, "conformance", 1, NULL
},
15088 LOOKUP(68, Virtualization_use
),
15089 LOOKUP(70, MPextension_use_legacy
)
15093 static unsigned char *
15094 display_arm_attribute (unsigned char * p
,
15095 const unsigned char * const end
)
15099 arm_attr_public_tag
* attr
;
15103 READ_ULEB (tag
, p
, end
);
15105 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15107 if (arm_attr_public_tags
[i
].tag
== tag
)
15109 attr
= &arm_attr_public_tags
[i
];
15116 printf (" Tag_%s: ", attr
->name
);
15117 switch (attr
->type
)
15122 case 7: /* Tag_CPU_arch_profile. */
15123 READ_ULEB (val
, p
, end
);
15126 case 0: printf (_("None\n")); break;
15127 case 'A': printf (_("Application\n")); break;
15128 case 'R': printf (_("Realtime\n")); break;
15129 case 'M': printf (_("Microcontroller\n")); break;
15130 case 'S': printf (_("Application or Realtime\n")); break;
15131 default: printf ("??? (%d)\n", val
); break;
15135 case 24: /* Tag_align_needed. */
15136 READ_ULEB (val
, p
, end
);
15139 case 0: printf (_("None\n")); break;
15140 case 1: printf (_("8-byte\n")); break;
15141 case 2: printf (_("4-byte\n")); break;
15142 case 3: printf ("??? 3\n"); break;
15145 printf (_("8-byte and up to %d-byte extended\n"),
15148 printf ("??? (%d)\n", val
);
15153 case 25: /* Tag_align_preserved. */
15154 READ_ULEB (val
, p
, end
);
15157 case 0: printf (_("None\n")); break;
15158 case 1: printf (_("8-byte, except leaf SP\n")); break;
15159 case 2: printf (_("8-byte\n")); break;
15160 case 3: printf ("??? 3\n"); break;
15163 printf (_("8-byte and up to %d-byte extended\n"),
15166 printf ("??? (%d)\n", val
);
15171 case 32: /* Tag_compatibility. */
15173 READ_ULEB (val
, p
, end
);
15174 printf (_("flag = %d, vendor = "), val
);
15177 size_t maxlen
= (end
- p
) - 1;
15179 print_symbol ((int) maxlen
, (const char *) p
);
15180 p
+= strnlen ((char *) p
, maxlen
) + 1;
15184 printf (_("<corrupt>"));
15185 p
= (unsigned char *) end
;
15191 case 64: /* Tag_nodefaults. */
15192 /* PR 17531: file: 001-505008-0.01. */
15195 printf (_("True\n"));
15198 case 65: /* Tag_also_compatible_with. */
15199 READ_ULEB (val
, p
, end
);
15200 if (val
== 6 /* Tag_CPU_arch. */)
15202 READ_ULEB (val
, p
, end
);
15203 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15204 printf ("??? (%d)\n", val
);
15206 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15210 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15215 printf (_("<unknown: %d>\n"), tag
);
15221 return display_tag_value (-1, p
, end
);
15223 return display_tag_value (0, p
, end
);
15226 assert (attr
->type
& 0x80);
15227 READ_ULEB (val
, p
, end
);
15228 type
= attr
->type
& 0x7f;
15230 printf ("??? (%d)\n", val
);
15232 printf ("%s\n", attr
->table
[val
]);
15237 return display_tag_value (tag
, p
, end
);
15240 static unsigned char *
15241 display_gnu_attribute (unsigned char * p
,
15242 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15243 const unsigned char * const end
)
15248 READ_ULEB (tag
, p
, end
);
15250 /* Tag_compatibility is the only generic GNU attribute defined at
15254 READ_ULEB (val
, p
, end
);
15256 printf (_("flag = %d, vendor = "), val
);
15259 printf (_("<corrupt>\n"));
15260 warn (_("corrupt vendor attribute\n"));
15266 size_t maxlen
= (end
- p
) - 1;
15268 print_symbol ((int) maxlen
, (const char *) p
);
15269 p
+= strnlen ((char *) p
, maxlen
) + 1;
15273 printf (_("<corrupt>"));
15274 p
= (unsigned char *) end
;
15281 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15282 return display_proc_gnu_attribute (p
, tag
, end
);
15284 return display_tag_value (tag
, p
, end
);
15287 static unsigned char *
15288 display_power_gnu_attribute (unsigned char * p
,
15290 const unsigned char * const end
)
15294 if (tag
== Tag_GNU_Power_ABI_FP
)
15296 printf (" Tag_GNU_Power_ABI_FP: ");
15299 printf (_("<corrupt>\n"));
15302 READ_ULEB (val
, p
, end
);
15305 printf ("(%#x), ", val
);
15310 printf (_("unspecified hard/soft float, "));
15313 printf (_("hard float, "));
15316 printf (_("soft float, "));
15319 printf (_("single-precision hard float, "));
15326 printf (_("unspecified long double\n"));
15329 printf (_("128-bit IBM long double\n"));
15332 printf (_("64-bit long double\n"));
15335 printf (_("128-bit IEEE long double\n"));
15341 if (tag
== Tag_GNU_Power_ABI_Vector
)
15343 printf (" Tag_GNU_Power_ABI_Vector: ");
15346 printf (_("<corrupt>\n"));
15349 READ_ULEB (val
, p
, end
);
15352 printf ("(%#x), ", val
);
15357 printf (_("unspecified\n"));
15360 printf (_("generic\n"));
15363 printf ("AltiVec\n");
15372 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15374 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15377 printf (_("<corrupt>\n"));
15380 READ_ULEB (val
, p
, end
);
15383 printf ("(%#x), ", val
);
15388 printf (_("unspecified\n"));
15391 printf ("r3/r4\n");
15394 printf (_("memory\n"));
15403 return display_tag_value (tag
& 1, p
, end
);
15406 static unsigned char *
15407 display_s390_gnu_attribute (unsigned char * p
,
15409 const unsigned char * const end
)
15413 if (tag
== Tag_GNU_S390_ABI_Vector
)
15415 printf (" Tag_GNU_S390_ABI_Vector: ");
15416 READ_ULEB (val
, p
, end
);
15421 printf (_("any\n"));
15424 printf (_("software\n"));
15427 printf (_("hardware\n"));
15430 printf ("??? (%d)\n", val
);
15436 return display_tag_value (tag
& 1, p
, end
);
15440 display_sparc_hwcaps (unsigned int mask
)
15444 bfd_boolean first
= TRUE
;
15446 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15447 fputs ("mul32", stdout
), first
= FALSE
;
15448 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15449 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15450 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15451 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15452 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15453 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15454 if (mask
& ELF_SPARC_HWCAP_POPC
)
15455 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15456 if (mask
& ELF_SPARC_HWCAP_VIS
)
15457 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15458 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15459 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15460 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15461 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15462 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15463 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15464 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15465 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15466 if (mask
& ELF_SPARC_HWCAP_HPC
)
15467 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15468 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15469 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15470 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15471 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15472 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15473 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15474 if (mask
& ELF_SPARC_HWCAP_IMA
)
15475 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15476 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15477 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15480 fputc ('0', stdout
);
15481 fputc ('\n', stdout
);
15485 display_sparc_hwcaps2 (unsigned int mask
)
15489 bfd_boolean first
= TRUE
;
15491 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15492 fputs ("fjathplus", stdout
), first
= FALSE
;
15493 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15494 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15495 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15496 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15497 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15498 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15499 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15500 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15501 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15502 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15503 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15504 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15505 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15506 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15507 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15508 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15509 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15510 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15511 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15512 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15515 fputc ('0', stdout
);
15516 fputc ('\n', stdout
);
15519 static unsigned char *
15520 display_sparc_gnu_attribute (unsigned char * p
,
15522 const unsigned char * const end
)
15526 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15528 READ_ULEB (val
, p
, end
);
15529 printf (" Tag_GNU_Sparc_HWCAPS: ");
15530 display_sparc_hwcaps (val
);
15533 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15535 READ_ULEB (val
, p
, end
);
15536 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15537 display_sparc_hwcaps2 (val
);
15541 return display_tag_value (tag
, p
, end
);
15545 print_mips_fp_abi_value (unsigned int val
)
15549 case Val_GNU_MIPS_ABI_FP_ANY
:
15550 printf (_("Hard or soft float\n"));
15552 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15553 printf (_("Hard float (double precision)\n"));
15555 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15556 printf (_("Hard float (single precision)\n"));
15558 case Val_GNU_MIPS_ABI_FP_SOFT
:
15559 printf (_("Soft float\n"));
15561 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15562 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15564 case Val_GNU_MIPS_ABI_FP_XX
:
15565 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15567 case Val_GNU_MIPS_ABI_FP_64
:
15568 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15570 case Val_GNU_MIPS_ABI_FP_64A
:
15571 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15573 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15574 printf (_("NaN 2008 compatibility\n"));
15577 printf ("??? (%d)\n", val
);
15582 static unsigned char *
15583 display_mips_gnu_attribute (unsigned char * p
,
15585 const unsigned char * const end
)
15587 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15591 printf (" Tag_GNU_MIPS_ABI_FP: ");
15592 READ_ULEB (val
, p
, end
);
15593 print_mips_fp_abi_value (val
);
15597 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15601 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15602 READ_ULEB (val
, p
, end
);
15606 case Val_GNU_MIPS_ABI_MSA_ANY
:
15607 printf (_("Any MSA or not\n"));
15609 case Val_GNU_MIPS_ABI_MSA_128
:
15610 printf (_("128-bit MSA\n"));
15613 printf ("??? (%d)\n", val
);
15619 return display_tag_value (tag
& 1, p
, end
);
15622 static unsigned char *
15623 display_tic6x_attribute (unsigned char * p
,
15624 const unsigned char * const end
)
15629 READ_ULEB (tag
, p
, end
);
15634 printf (" Tag_ISA: ");
15635 READ_ULEB (val
, p
, end
);
15639 case C6XABI_Tag_ISA_none
:
15640 printf (_("None\n"));
15642 case C6XABI_Tag_ISA_C62X
:
15645 case C6XABI_Tag_ISA_C67X
:
15648 case C6XABI_Tag_ISA_C67XP
:
15649 printf ("C67x+\n");
15651 case C6XABI_Tag_ISA_C64X
:
15654 case C6XABI_Tag_ISA_C64XP
:
15655 printf ("C64x+\n");
15657 case C6XABI_Tag_ISA_C674X
:
15658 printf ("C674x\n");
15661 printf ("??? (%d)\n", val
);
15666 case Tag_ABI_wchar_t
:
15667 printf (" Tag_ABI_wchar_t: ");
15668 READ_ULEB (val
, p
, end
);
15672 printf (_("Not used\n"));
15675 printf (_("2 bytes\n"));
15678 printf (_("4 bytes\n"));
15681 printf ("??? (%d)\n", val
);
15686 case Tag_ABI_stack_align_needed
:
15687 printf (" Tag_ABI_stack_align_needed: ");
15688 READ_ULEB (val
, p
, end
);
15692 printf (_("8-byte\n"));
15695 printf (_("16-byte\n"));
15698 printf ("??? (%d)\n", val
);
15703 case Tag_ABI_stack_align_preserved
:
15704 READ_ULEB (val
, p
, end
);
15705 printf (" Tag_ABI_stack_align_preserved: ");
15709 printf (_("8-byte\n"));
15712 printf (_("16-byte\n"));
15715 printf ("??? (%d)\n", val
);
15721 READ_ULEB (val
, p
, end
);
15722 printf (" Tag_ABI_DSBT: ");
15726 printf (_("DSBT addressing not used\n"));
15729 printf (_("DSBT addressing used\n"));
15732 printf ("??? (%d)\n", val
);
15738 READ_ULEB (val
, p
, end
);
15739 printf (" Tag_ABI_PID: ");
15743 printf (_("Data addressing position-dependent\n"));
15746 printf (_("Data addressing position-independent, GOT near DP\n"));
15749 printf (_("Data addressing position-independent, GOT far from DP\n"));
15752 printf ("??? (%d)\n", val
);
15758 READ_ULEB (val
, p
, end
);
15759 printf (" Tag_ABI_PIC: ");
15763 printf (_("Code addressing position-dependent\n"));
15766 printf (_("Code addressing position-independent\n"));
15769 printf ("??? (%d)\n", val
);
15774 case Tag_ABI_array_object_alignment
:
15775 READ_ULEB (val
, p
, end
);
15776 printf (" Tag_ABI_array_object_alignment: ");
15780 printf (_("8-byte\n"));
15783 printf (_("4-byte\n"));
15786 printf (_("16-byte\n"));
15789 printf ("??? (%d)\n", val
);
15794 case Tag_ABI_array_object_align_expected
:
15795 READ_ULEB (val
, p
, end
);
15796 printf (" Tag_ABI_array_object_align_expected: ");
15800 printf (_("8-byte\n"));
15803 printf (_("4-byte\n"));
15806 printf (_("16-byte\n"));
15809 printf ("??? (%d)\n", val
);
15814 case Tag_ABI_compatibility
:
15816 READ_ULEB (val
, p
, end
);
15817 printf (" Tag_ABI_compatibility: ");
15818 printf (_("flag = %d, vendor = "), val
);
15821 size_t maxlen
= (end
- p
) - 1;
15823 print_symbol ((int) maxlen
, (const char *) p
);
15824 p
+= strnlen ((char *) p
, maxlen
) + 1;
15828 printf (_("<corrupt>"));
15829 p
= (unsigned char *) end
;
15835 case Tag_ABI_conformance
:
15837 printf (" Tag_ABI_conformance: \"");
15840 size_t maxlen
= (end
- p
) - 1;
15842 print_symbol ((int) maxlen
, (const char *) p
);
15843 p
+= strnlen ((char *) p
, maxlen
) + 1;
15847 printf (_("<corrupt>"));
15848 p
= (unsigned char *) end
;
15855 return display_tag_value (tag
, p
, end
);
15859 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15861 unsigned long addr
= 0;
15862 size_t bytes
= end
- p
;
15869 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15871 printf (" 0x%8.8lx ", addr
);
15873 for (j
= 0; j
< 16; j
++)
15876 printf ("%2.2x", p
[j
]);
15884 for (j
= 0; j
< lbytes
; j
++)
15887 if (k
>= ' ' && k
< 0x7f)
15903 static unsigned char *
15904 display_msp430x_attribute (unsigned char * p
,
15905 const unsigned char * const end
)
15910 READ_ULEB (tag
, p
, end
);
15914 case OFBA_MSPABI_Tag_ISA
:
15915 printf (" Tag_ISA: ");
15916 READ_ULEB (val
, p
, end
);
15919 case 0: printf (_("None\n")); break;
15920 case 1: printf (_("MSP430\n")); break;
15921 case 2: printf (_("MSP430X\n")); break;
15922 default: printf ("??? (%d)\n", val
); break;
15926 case OFBA_MSPABI_Tag_Code_Model
:
15927 printf (" Tag_Code_Model: ");
15928 READ_ULEB (val
, p
, end
);
15931 case 0: printf (_("None\n")); break;
15932 case 1: printf (_("Small\n")); break;
15933 case 2: printf (_("Large\n")); break;
15934 default: printf ("??? (%d)\n", val
); break;
15938 case OFBA_MSPABI_Tag_Data_Model
:
15939 printf (" Tag_Data_Model: ");
15940 READ_ULEB (val
, p
, end
);
15943 case 0: printf (_("None\n")); break;
15944 case 1: printf (_("Small\n")); break;
15945 case 2: printf (_("Large\n")); break;
15946 case 3: printf (_("Restricted Large\n")); break;
15947 default: printf ("??? (%d)\n", val
); break;
15952 printf (_(" <unknown tag %d>: "), tag
);
15959 size_t maxlen
= (end
- p
) - 1;
15961 print_symbol ((int) maxlen
, (const char *) p
);
15962 p
+= strnlen ((char *) p
, maxlen
) + 1;
15966 printf (_("<corrupt>"));
15967 p
= (unsigned char *) end
;
15973 READ_ULEB (val
, p
, end
);
15974 printf ("%d (0x%x)\n", val
, val
);
15983 static unsigned char *
15984 display_msp430_gnu_attribute (unsigned char * p
,
15986 const unsigned char * const end
)
15988 if (tag
== Tag_GNU_MSP430_Data_Region
)
15992 printf (" Tag_GNU_MSP430_Data_Region: ");
15993 READ_ULEB (val
, p
, end
);
15997 case Val_GNU_MSP430_Data_Region_Any
:
15998 printf (_("Any Region\n"));
16000 case Val_GNU_MSP430_Data_Region_Lower
:
16001 printf (_("Lower Region Only\n"));
16004 printf ("??? (%u)\n", val
);
16008 return display_tag_value (tag
& 1, p
, end
);
16011 struct riscv_attr_tag_t
{
16016 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16018 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16021 T(priv_spec_minor
),
16022 T(priv_spec_revision
),
16023 T(unaligned_access
),
16028 static unsigned char *
16029 display_riscv_attribute (unsigned char *p
,
16030 const unsigned char * const end
)
16034 struct riscv_attr_tag_t
*attr
= NULL
;
16037 READ_ULEB (tag
, p
, end
);
16039 /* Find the name of attribute. */
16040 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16042 if (riscv_attr_tag
[i
].tag
== tag
)
16044 attr
= &riscv_attr_tag
[i
];
16050 printf (" %s: ", attr
->name
);
16052 return display_tag_value (tag
, p
, end
);
16056 case Tag_RISCV_priv_spec
:
16057 case Tag_RISCV_priv_spec_minor
:
16058 case Tag_RISCV_priv_spec_revision
:
16059 READ_ULEB (val
, p
, end
);
16060 printf (_("%u\n"), val
);
16062 case Tag_RISCV_unaligned_access
:
16063 READ_ULEB (val
, p
, end
);
16067 printf (_("No unaligned access\n"));
16070 printf (_("Unaligned access\n"));
16074 case Tag_RISCV_stack_align
:
16075 READ_ULEB (val
, p
, end
);
16076 printf (_("%u-bytes\n"), val
);
16078 case Tag_RISCV_arch
:
16079 p
= display_tag_value (-1, p
, end
);
16082 return display_tag_value (tag
, p
, end
);
16089 process_attributes (Filedata
* filedata
,
16090 const char * public_name
,
16091 unsigned int proc_type
,
16092 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16093 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16095 Elf_Internal_Shdr
* sect
;
16097 bfd_boolean res
= TRUE
;
16099 /* Find the section header so that we get the size. */
16100 for (i
= 0, sect
= filedata
->section_headers
;
16101 i
< filedata
->file_header
.e_shnum
;
16104 unsigned char * contents
;
16107 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16110 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16111 sect
->sh_size
, _("attributes"));
16112 if (contents
== NULL
)
16119 /* The first character is the version of the attributes.
16120 Currently only version 1, (aka 'A') is recognised here. */
16123 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16128 bfd_vma section_len
;
16130 section_len
= sect
->sh_size
- 1;
16133 while (section_len
> 0)
16136 unsigned int namelen
;
16137 bfd_boolean public_section
;
16138 bfd_boolean gnu_section
;
16140 if (section_len
<= 4)
16142 error (_("Tag section ends prematurely\n"));
16146 attr_len
= byte_get (p
, 4);
16149 if (attr_len
> section_len
)
16151 error (_("Bad attribute length (%u > %u)\n"),
16152 (unsigned) attr_len
, (unsigned) section_len
);
16153 attr_len
= section_len
;
16156 /* PR 17531: file: 001-101425-0.004 */
16157 else if (attr_len
< 5)
16159 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16164 section_len
-= attr_len
;
16167 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16168 if (namelen
== 0 || namelen
>= attr_len
)
16170 error (_("Corrupt attribute section name\n"));
16175 printf (_("Attribute Section: "));
16176 print_symbol (INT_MAX
, (const char *) p
);
16179 if (public_name
&& streq ((char *) p
, public_name
))
16180 public_section
= TRUE
;
16182 public_section
= FALSE
;
16184 if (streq ((char *) p
, "gnu"))
16185 gnu_section
= TRUE
;
16187 gnu_section
= FALSE
;
16190 attr_len
-= namelen
;
16192 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16197 unsigned char * end
;
16199 /* PR binutils/17531: Safe handling of corrupt files. */
16202 error (_("Unused bytes at end of section\n"));
16209 size
= byte_get (p
, 4);
16210 if (size
> attr_len
)
16212 error (_("Bad subsection length (%u > %u)\n"),
16213 (unsigned) size
, (unsigned) attr_len
);
16217 /* PR binutils/17531: Safe handling of corrupt files. */
16220 error (_("Bad subsection length (%u < 6)\n"),
16228 end
= p
+ size
- 1;
16229 assert (end
<= contents
+ sect
->sh_size
);
16235 printf (_("File Attributes\n"));
16238 printf (_("Section Attributes:"));
16241 printf (_("Symbol Attributes:"));
16242 /* Fall through. */
16246 READ_ULEB (val
, p
, end
);
16249 printf (" %d", val
);
16254 printf (_("Unknown tag: %d\n"), tag
);
16255 public_section
= FALSE
;
16259 if (public_section
&& display_pub_attribute
!= NULL
)
16262 p
= display_pub_attribute (p
, end
);
16265 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16268 p
= display_gnu_attribute (p
,
16269 display_proc_gnu_attribute
,
16275 printf (_(" Unknown attribute:\n"));
16276 display_raw_attribute (p
, end
);
16291 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16292 Print the Address, Access and Initial fields of an entry at VMA ADDR
16293 and return the VMA of the next entry, or -1 if there was a problem.
16294 Does not read from DATA_END or beyond. */
16297 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16298 unsigned char * data_end
)
16301 print_vma (addr
, LONG_HEX
);
16303 if (addr
< pltgot
+ 0xfff0)
16304 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16306 printf ("%10s", "");
16309 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16313 unsigned char * from
= data
+ addr
- pltgot
;
16315 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16317 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16318 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16319 return (bfd_vma
) -1;
16323 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16324 print_vma (entry
, LONG_HEX
);
16327 return addr
+ (is_32bit_elf
? 4 : 8);
16330 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16331 PLTGOT. Print the Address and Initial fields of an entry at VMA
16332 ADDR and return the VMA of the next entry. */
16335 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16338 print_vma (addr
, LONG_HEX
);
16341 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16346 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16347 print_vma (entry
, LONG_HEX
);
16349 return addr
+ (is_32bit_elf
? 4 : 8);
16353 print_mips_ases (unsigned int mask
)
16355 if (mask
& AFL_ASE_DSP
)
16356 fputs ("\n\tDSP ASE", stdout
);
16357 if (mask
& AFL_ASE_DSPR2
)
16358 fputs ("\n\tDSP R2 ASE", stdout
);
16359 if (mask
& AFL_ASE_DSPR3
)
16360 fputs ("\n\tDSP R3 ASE", stdout
);
16361 if (mask
& AFL_ASE_EVA
)
16362 fputs ("\n\tEnhanced VA Scheme", stdout
);
16363 if (mask
& AFL_ASE_MCU
)
16364 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16365 if (mask
& AFL_ASE_MDMX
)
16366 fputs ("\n\tMDMX ASE", stdout
);
16367 if (mask
& AFL_ASE_MIPS3D
)
16368 fputs ("\n\tMIPS-3D ASE", stdout
);
16369 if (mask
& AFL_ASE_MT
)
16370 fputs ("\n\tMT ASE", stdout
);
16371 if (mask
& AFL_ASE_SMARTMIPS
)
16372 fputs ("\n\tSmartMIPS ASE", stdout
);
16373 if (mask
& AFL_ASE_VIRT
)
16374 fputs ("\n\tVZ ASE", stdout
);
16375 if (mask
& AFL_ASE_MSA
)
16376 fputs ("\n\tMSA ASE", stdout
);
16377 if (mask
& AFL_ASE_MIPS16
)
16378 fputs ("\n\tMIPS16 ASE", stdout
);
16379 if (mask
& AFL_ASE_MICROMIPS
)
16380 fputs ("\n\tMICROMIPS ASE", stdout
);
16381 if (mask
& AFL_ASE_XPA
)
16382 fputs ("\n\tXPA ASE", stdout
);
16383 if (mask
& AFL_ASE_MIPS16E2
)
16384 fputs ("\n\tMIPS16e2 ASE", stdout
);
16385 if (mask
& AFL_ASE_CRC
)
16386 fputs ("\n\tCRC ASE", stdout
);
16387 if (mask
& AFL_ASE_GINV
)
16388 fputs ("\n\tGINV ASE", stdout
);
16389 if (mask
& AFL_ASE_LOONGSON_MMI
)
16390 fputs ("\n\tLoongson MMI ASE", stdout
);
16391 if (mask
& AFL_ASE_LOONGSON_CAM
)
16392 fputs ("\n\tLoongson CAM ASE", stdout
);
16393 if (mask
& AFL_ASE_LOONGSON_EXT
)
16394 fputs ("\n\tLoongson EXT ASE", stdout
);
16395 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16396 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16398 fprintf (stdout
, "\n\t%s", _("None"));
16399 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16400 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16404 print_mips_isa_ext (unsigned int isa_ext
)
16409 fputs (_("None"), stdout
);
16412 fputs ("RMI XLR", stdout
);
16414 case AFL_EXT_OCTEON3
:
16415 fputs ("Cavium Networks Octeon3", stdout
);
16417 case AFL_EXT_OCTEON2
:
16418 fputs ("Cavium Networks Octeon2", stdout
);
16420 case AFL_EXT_OCTEONP
:
16421 fputs ("Cavium Networks OcteonP", stdout
);
16423 case AFL_EXT_OCTEON
:
16424 fputs ("Cavium Networks Octeon", stdout
);
16427 fputs ("Toshiba R5900", stdout
);
16430 fputs ("MIPS R4650", stdout
);
16433 fputs ("LSI R4010", stdout
);
16436 fputs ("NEC VR4100", stdout
);
16439 fputs ("Toshiba R3900", stdout
);
16441 case AFL_EXT_10000
:
16442 fputs ("MIPS R10000", stdout
);
16445 fputs ("Broadcom SB-1", stdout
);
16448 fputs ("NEC VR4111/VR4181", stdout
);
16451 fputs ("NEC VR4120", stdout
);
16454 fputs ("NEC VR5400", stdout
);
16457 fputs ("NEC VR5500", stdout
);
16459 case AFL_EXT_LOONGSON_2E
:
16460 fputs ("ST Microelectronics Loongson 2E", stdout
);
16462 case AFL_EXT_LOONGSON_2F
:
16463 fputs ("ST Microelectronics Loongson 2F", stdout
);
16465 case AFL_EXT_INTERAPTIV_MR2
:
16466 fputs ("Imagination interAptiv MR2", stdout
);
16469 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16474 get_mips_reg_size (int reg_size
)
16476 return (reg_size
== AFL_REG_NONE
) ? 0
16477 : (reg_size
== AFL_REG_32
) ? 32
16478 : (reg_size
== AFL_REG_64
) ? 64
16479 : (reg_size
== AFL_REG_128
) ? 128
16484 process_mips_specific (Filedata
* filedata
)
16486 Elf_Internal_Dyn
* entry
;
16487 Elf_Internal_Shdr
*sect
= NULL
;
16488 size_t liblist_offset
= 0;
16489 size_t liblistno
= 0;
16490 size_t conflictsno
= 0;
16491 size_t options_offset
= 0;
16492 size_t conflicts_offset
= 0;
16493 size_t pltrelsz
= 0;
16495 bfd_vma pltgot
= 0;
16496 bfd_vma mips_pltgot
= 0;
16497 bfd_vma jmprel
= 0;
16498 bfd_vma local_gotno
= 0;
16499 bfd_vma gotsym
= 0;
16500 bfd_vma symtabno
= 0;
16501 bfd_boolean res
= TRUE
;
16503 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16504 display_mips_gnu_attribute
))
16507 sect
= find_section (filedata
, ".MIPS.abiflags");
16511 Elf_External_ABIFlags_v0
*abiflags_ext
;
16512 Elf_Internal_ABIFlags_v0 abiflags_in
;
16514 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16516 error (_("Corrupt MIPS ABI Flags section.\n"));
16521 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16522 sect
->sh_size
, _("MIPS ABI Flags section"));
16525 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16526 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16527 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16528 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16529 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16530 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16531 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16532 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16533 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16534 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16535 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16537 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16538 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16539 if (abiflags_in
.isa_rev
> 1)
16540 printf ("r%d", abiflags_in
.isa_rev
);
16541 printf ("\nGPR size: %d",
16542 get_mips_reg_size (abiflags_in
.gpr_size
));
16543 printf ("\nCPR1 size: %d",
16544 get_mips_reg_size (abiflags_in
.cpr1_size
));
16545 printf ("\nCPR2 size: %d",
16546 get_mips_reg_size (abiflags_in
.cpr2_size
));
16547 fputs ("\nFP ABI: ", stdout
);
16548 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16549 fputs ("ISA Extension: ", stdout
);
16550 print_mips_isa_ext (abiflags_in
.isa_ext
);
16551 fputs ("\nASEs:", stdout
);
16552 print_mips_ases (abiflags_in
.ases
);
16553 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16554 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16555 fputc ('\n', stdout
);
16556 free (abiflags_ext
);
16561 /* We have a lot of special sections. Thanks SGI! */
16562 if (dynamic_section
== NULL
)
16564 /* No dynamic information available. See if there is static GOT. */
16565 sect
= find_section (filedata
, ".got");
16568 unsigned char *data_end
;
16569 unsigned char *data
;
16573 pltgot
= sect
->sh_addr
;
16576 addr_size
= (is_32bit_elf
? 4 : 8);
16577 end
= pltgot
+ sect
->sh_size
;
16579 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16581 _("Global Offset Table data"));
16582 /* PR 12855: Null data is handled gracefully throughout. */
16583 data_end
= data
+ (end
- pltgot
);
16585 printf (_("\nStatic GOT:\n"));
16586 printf (_(" Canonical gp value: "));
16587 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16590 /* In a dynamic binary GOT[0] is reserved for the dynamic
16591 loader to store the lazy resolver pointer, however in
16592 a static binary it may well have been omitted and GOT
16593 reduced to a table of addresses.
16594 PR 21344: Check for the entry being fully available
16595 before fetching it. */
16597 && data
+ ent
- pltgot
+ addr_size
<= data_end
16598 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16600 printf (_(" Reserved entries:\n"));
16601 printf (_(" %*s %10s %*s\n"),
16602 addr_size
* 2, _("Address"), _("Access"),
16603 addr_size
* 2, _("Value"));
16604 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16606 if (ent
== (bfd_vma
) -1)
16607 goto sgot_print_fail
;
16609 /* Check for the MSB of GOT[1] being set, identifying a
16610 GNU object. This entry will be used by some runtime
16611 loaders, to store the module pointer. Otherwise this
16612 is an ordinary local entry.
16613 PR 21344: Check for the entry being fully available
16614 before fetching it. */
16616 && data
+ ent
- pltgot
+ addr_size
<= data_end
16617 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16618 >> (addr_size
* 8 - 1)) != 0)
16620 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16622 if (ent
== (bfd_vma
) -1)
16623 goto sgot_print_fail
;
16628 if (data
!= NULL
&& ent
< end
)
16630 printf (_(" Local entries:\n"));
16631 printf (" %*s %10s %*s\n",
16632 addr_size
* 2, _("Address"), _("Access"),
16633 addr_size
* 2, _("Value"));
16636 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16638 if (ent
== (bfd_vma
) -1)
16639 goto sgot_print_fail
;
16651 for (entry
= dynamic_section
;
16652 /* PR 17531 file: 012-50589-0.004. */
16653 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16655 switch (entry
->d_tag
)
16657 case DT_MIPS_LIBLIST
:
16659 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16660 liblistno
* sizeof (Elf32_External_Lib
));
16662 case DT_MIPS_LIBLISTNO
:
16663 liblistno
= entry
->d_un
.d_val
;
16665 case DT_MIPS_OPTIONS
:
16666 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16668 case DT_MIPS_CONFLICT
:
16670 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16671 conflictsno
* sizeof (Elf32_External_Conflict
));
16673 case DT_MIPS_CONFLICTNO
:
16674 conflictsno
= entry
->d_un
.d_val
;
16677 pltgot
= entry
->d_un
.d_ptr
;
16679 case DT_MIPS_LOCAL_GOTNO
:
16680 local_gotno
= entry
->d_un
.d_val
;
16682 case DT_MIPS_GOTSYM
:
16683 gotsym
= entry
->d_un
.d_val
;
16685 case DT_MIPS_SYMTABNO
:
16686 symtabno
= entry
->d_un
.d_val
;
16688 case DT_MIPS_PLTGOT
:
16689 mips_pltgot
= entry
->d_un
.d_ptr
;
16692 pltrel
= entry
->d_un
.d_val
;
16695 pltrelsz
= entry
->d_un
.d_val
;
16698 jmprel
= entry
->d_un
.d_ptr
;
16704 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16706 Elf32_External_Lib
* elib
;
16709 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16710 sizeof (Elf32_External_Lib
),
16712 _("liblist section data"));
16715 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16716 "\nSection '.liblist' contains %lu entries:\n",
16717 (unsigned long) liblistno
),
16718 (unsigned long) liblistno
);
16719 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16722 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16729 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16730 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16731 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16732 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16733 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16735 tmp
= gmtime (&atime
);
16736 snprintf (timebuf
, sizeof (timebuf
),
16737 "%04u-%02u-%02uT%02u:%02u:%02u",
16738 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16739 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16741 printf ("%3lu: ", (unsigned long) cnt
);
16742 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16743 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16745 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16746 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16747 liblist
.l_version
);
16749 if (liblist
.l_flags
== 0)
16753 static const struct
16760 { " EXACT_MATCH", LL_EXACT_MATCH
},
16761 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16762 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16763 { " EXPORTS", LL_EXPORTS
},
16764 { " DELAY_LOAD", LL_DELAY_LOAD
},
16765 { " DELTA", LL_DELTA
}
16767 int flags
= liblist
.l_flags
;
16770 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16771 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16773 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16774 flags
^= l_flags_vals
[fcnt
].bit
;
16777 printf (" %#x", (unsigned int) flags
);
16789 if (options_offset
!= 0)
16791 Elf_External_Options
* eopt
;
16794 sect
= filedata
->section_headers
;
16796 /* Find the section header so that we get the size. */
16797 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16798 /* PR 17533 file: 012-277276-0.004. */
16801 error (_("No MIPS_OPTIONS header found\n"));
16805 if (sect
->sh_size
< sizeof (* eopt
))
16807 error (_("The MIPS options section is too small.\n"));
16811 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16812 sect
->sh_size
, _("options"));
16815 Elf_Internal_Options
* iopt
;
16816 Elf_Internal_Options
* option
;
16817 Elf_Internal_Options
* iopt_end
;
16819 iopt
= (Elf_Internal_Options
*)
16820 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16823 error (_("Out of memory allocating space for MIPS options\n"));
16830 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16832 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16834 Elf_External_Options
* eoption
;
16836 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16838 option
->kind
= BYTE_GET (eoption
->kind
);
16839 option
->size
= BYTE_GET (eoption
->size
);
16840 option
->section
= BYTE_GET (eoption
->section
);
16841 option
->info
= BYTE_GET (eoption
->info
);
16843 /* PR 17531: file: ffa0fa3b. */
16844 if (option
->size
< sizeof (* eopt
)
16845 || offset
+ option
->size
> sect
->sh_size
)
16847 error (_("Invalid size (%u) for MIPS option\n"),
16853 offset
+= option
->size
;
16859 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16860 "\nSection '%s' contains %d entries:\n",
16862 printable_section_name (filedata
, sect
), cnt
);
16871 switch (option
->kind
)
16874 /* This shouldn't happen. */
16875 printf (" NULL %d %lx", option
->section
, option
->info
);
16879 printf (" REGINFO ");
16880 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16882 Elf32_External_RegInfo
* ereg
;
16883 Elf32_RegInfo reginfo
;
16886 if (option
+ 2 > iopt_end
)
16888 printf (_("<corrupt>\n"));
16889 error (_("Truncated MIPS REGINFO option\n"));
16894 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16896 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16897 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16898 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16899 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16900 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16901 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16903 printf ("GPR %08lx GP 0x%lx\n",
16904 reginfo
.ri_gprmask
,
16905 (unsigned long) reginfo
.ri_gp_value
);
16906 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16907 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16908 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16913 Elf64_External_RegInfo
* ereg
;
16914 Elf64_Internal_RegInfo reginfo
;
16916 if (option
+ 2 > iopt_end
)
16918 printf (_("<corrupt>\n"));
16919 error (_("Truncated MIPS REGINFO option\n"));
16924 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16925 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16926 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16927 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16928 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16929 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16930 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16932 printf ("GPR %08lx GP 0x",
16933 reginfo
.ri_gprmask
);
16934 printf_vma (reginfo
.ri_gp_value
);
16937 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16938 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16939 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16944 case ODK_EXCEPTIONS
:
16945 fputs (" EXCEPTIONS fpe_min(", stdout
);
16946 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16947 fputs (") fpe_max(", stdout
);
16948 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16949 fputs (")", stdout
);
16951 if (option
->info
& OEX_PAGE0
)
16952 fputs (" PAGE0", stdout
);
16953 if (option
->info
& OEX_SMM
)
16954 fputs (" SMM", stdout
);
16955 if (option
->info
& OEX_FPDBUG
)
16956 fputs (" FPDBUG", stdout
);
16957 if (option
->info
& OEX_DISMISS
)
16958 fputs (" DISMISS", stdout
);
16962 fputs (" PAD ", stdout
);
16963 if (option
->info
& OPAD_PREFIX
)
16964 fputs (" PREFIX", stdout
);
16965 if (option
->info
& OPAD_POSTFIX
)
16966 fputs (" POSTFIX", stdout
);
16967 if (option
->info
& OPAD_SYMBOL
)
16968 fputs (" SYMBOL", stdout
);
16972 fputs (" HWPATCH ", stdout
);
16973 if (option
->info
& OHW_R4KEOP
)
16974 fputs (" R4KEOP", stdout
);
16975 if (option
->info
& OHW_R8KPFETCH
)
16976 fputs (" R8KPFETCH", stdout
);
16977 if (option
->info
& OHW_R5KEOP
)
16978 fputs (" R5KEOP", stdout
);
16979 if (option
->info
& OHW_R5KCVTL
)
16980 fputs (" R5KCVTL", stdout
);
16984 fputs (" FILL ", stdout
);
16985 /* XXX Print content of info word? */
16989 fputs (" TAGS ", stdout
);
16990 /* XXX Print content of info word? */
16994 fputs (" HWAND ", stdout
);
16995 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16996 fputs (" R4KEOP_CHECKED", stdout
);
16997 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16998 fputs (" R4KEOP_CLEAN", stdout
);
17002 fputs (" HWOR ", stdout
);
17003 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17004 fputs (" R4KEOP_CHECKED", stdout
);
17005 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17006 fputs (" R4KEOP_CLEAN", stdout
);
17010 printf (" GP_GROUP %#06lx self-contained %#06lx",
17011 option
->info
& OGP_GROUP
,
17012 (option
->info
& OGP_SELF
) >> 16);
17016 printf (" IDENT %#06lx self-contained %#06lx",
17017 option
->info
& OGP_GROUP
,
17018 (option
->info
& OGP_SELF
) >> 16);
17022 /* This shouldn't happen. */
17023 printf (" %3d ??? %d %lx",
17024 option
->kind
, option
->section
, option
->info
);
17028 len
= sizeof (* eopt
);
17029 while (len
< option
->size
)
17031 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17033 if (ISPRINT (datum
))
17034 printf ("%c", datum
);
17036 printf ("\\%03o", datum
);
17039 fputs ("\n", stdout
);
17041 offset
+= option
->size
;
17051 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17053 Elf32_Conflict
* iconf
;
17056 if (dynamic_symbols
== NULL
)
17058 error (_("conflict list found without a dynamic symbol table\n"));
17062 /* PR 21345 - print a slightly more helpful error message
17063 if we are sure that the cmalloc will fail. */
17064 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17066 error (_("Overlarge number of conflicts detected: %lx\n"),
17067 (long) conflictsno
);
17071 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17074 error (_("Out of memory allocating space for dynamic conflicts\n"));
17080 Elf32_External_Conflict
* econf32
;
17082 econf32
= (Elf32_External_Conflict
*)
17083 get_data (NULL
, filedata
, conflicts_offset
,
17084 sizeof (*econf32
), conflictsno
, _("conflict"));
17091 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17092 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17098 Elf64_External_Conflict
* econf64
;
17100 econf64
= (Elf64_External_Conflict
*)
17101 get_data (NULL
, filedata
, conflicts_offset
,
17102 sizeof (*econf64
), conflictsno
, _("conflict"));
17109 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17110 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17115 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17116 "\nSection '.conflict' contains %lu entries:\n",
17117 (unsigned long) conflictsno
),
17118 (unsigned long) conflictsno
);
17119 puts (_(" Num: Index Value Name"));
17121 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17123 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17125 if (iconf
[cnt
] >= num_dynamic_syms
)
17126 printf (_("<corrupt symbol index>"));
17129 Elf_Internal_Sym
* psym
;
17131 psym
= & dynamic_symbols
[iconf
[cnt
]];
17132 print_vma (psym
->st_value
, FULL_HEX
);
17134 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17135 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17137 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17145 if (pltgot
!= 0 && local_gotno
!= 0)
17147 bfd_vma ent
, local_end
, global_end
;
17149 unsigned char * data
;
17150 unsigned char * data_end
;
17154 addr_size
= (is_32bit_elf
? 4 : 8);
17155 local_end
= pltgot
+ local_gotno
* addr_size
;
17157 /* PR binutils/17533 file: 012-111227-0.004 */
17158 if (symtabno
< gotsym
)
17160 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17161 (unsigned long) gotsym
, (unsigned long) symtabno
);
17165 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17166 /* PR 17531: file: 54c91a34. */
17167 if (global_end
< local_end
)
17169 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17173 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17174 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17175 global_end
- pltgot
, 1,
17176 _("Global Offset Table data"));
17177 /* PR 12855: Null data is handled gracefully throughout. */
17178 data_end
= data
+ (global_end
- pltgot
);
17180 printf (_("\nPrimary GOT:\n"));
17181 printf (_(" Canonical gp value: "));
17182 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17185 printf (_(" Reserved entries:\n"));
17186 printf (_(" %*s %10s %*s Purpose\n"),
17187 addr_size
* 2, _("Address"), _("Access"),
17188 addr_size
* 2, _("Initial"));
17189 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17190 printf (_(" Lazy resolver\n"));
17191 if (ent
== (bfd_vma
) -1)
17192 goto got_print_fail
;
17194 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17195 This entry will be used by some runtime loaders, to store the
17196 module pointer. Otherwise this is an ordinary local entry.
17197 PR 21344: Check for the entry being fully available before
17200 && data
+ ent
- pltgot
+ addr_size
<= data_end
17201 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17202 >> (addr_size
* 8 - 1)) != 0)
17204 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17205 printf (_(" Module pointer (GNU extension)\n"));
17206 if (ent
== (bfd_vma
) -1)
17207 goto got_print_fail
;
17211 if (data
!= NULL
&& ent
< local_end
)
17213 printf (_(" Local entries:\n"));
17214 printf (" %*s %10s %*s\n",
17215 addr_size
* 2, _("Address"), _("Access"),
17216 addr_size
* 2, _("Initial"));
17217 while (ent
< local_end
)
17219 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17221 if (ent
== (bfd_vma
) -1)
17222 goto got_print_fail
;
17227 if (data
!= NULL
&& gotsym
< symtabno
)
17231 printf (_(" Global entries:\n"));
17232 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17233 addr_size
* 2, _("Address"),
17235 addr_size
* 2, _("Initial"),
17236 addr_size
* 2, _("Sym.Val."),
17238 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17239 _("Ndx"), _("Name"));
17241 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17243 for (i
= gotsym
; i
< symtabno
; i
++)
17245 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17248 if (dynamic_symbols
== NULL
)
17249 printf (_("<no dynamic symbols>"));
17250 else if (i
< num_dynamic_syms
)
17252 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17254 print_vma (psym
->st_value
, LONG_HEX
);
17255 printf (" %-7s %3s ",
17256 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17257 get_symbol_index_type (filedata
, psym
->st_shndx
));
17259 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17260 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17262 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17265 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17266 (unsigned long) i
);
17269 if (ent
== (bfd_vma
) -1)
17280 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17283 size_t offset
, rel_offset
;
17284 unsigned long count
, i
;
17285 unsigned char * data
;
17286 int addr_size
, sym_width
;
17287 Elf_Internal_Rela
* rels
;
17289 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17290 if (pltrel
== DT_RELA
)
17292 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17297 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17302 addr_size
= (is_32bit_elf
? 4 : 8);
17303 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17305 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17306 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17307 1, _("Procedure Linkage Table data"));
17311 printf ("\nPLT GOT:\n\n");
17312 printf (_(" Reserved entries:\n"));
17313 printf (_(" %*s %*s Purpose\n"),
17314 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17315 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17316 printf (_(" PLT lazy resolver\n"));
17317 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17318 printf (_(" Module pointer\n"));
17321 printf (_(" Entries:\n"));
17322 printf (" %*s %*s %*s %-7s %3s %s\n",
17323 addr_size
* 2, _("Address"),
17324 addr_size
* 2, _("Initial"),
17325 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17326 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17327 for (i
= 0; i
< count
; i
++)
17329 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17331 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17334 if (idx
>= num_dynamic_syms
)
17335 printf (_("<corrupt symbol index: %lu>"), idx
);
17338 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17340 print_vma (psym
->st_value
, LONG_HEX
);
17341 printf (" %-7s %3s ",
17342 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17343 get_symbol_index_type (filedata
, psym
->st_shndx
));
17344 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17345 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17347 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17362 process_nds32_specific (Filedata
* filedata
)
17364 Elf_Internal_Shdr
*sect
= NULL
;
17366 sect
= find_section (filedata
, ".nds32_e_flags");
17369 unsigned int *flag
;
17371 printf ("\nNDS32 elf flags section:\n");
17372 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17373 sect
->sh_size
, _("NDS32 elf flags section"));
17378 switch ((*flag
) & 0x3)
17381 printf ("(VEC_SIZE):\tNo entry.\n");
17384 printf ("(VEC_SIZE):\t4 bytes\n");
17387 printf ("(VEC_SIZE):\t16 bytes\n");
17390 printf ("(VEC_SIZE):\treserved\n");
17399 process_gnu_liblist (Filedata
* filedata
)
17401 Elf_Internal_Shdr
* section
;
17402 Elf_Internal_Shdr
* string_sec
;
17403 Elf32_External_Lib
* elib
;
17405 size_t strtab_size
;
17407 unsigned long num_liblist
;
17409 bfd_boolean res
= TRUE
;
17414 for (i
= 0, section
= filedata
->section_headers
;
17415 i
< filedata
->file_header
.e_shnum
;
17418 switch (section
->sh_type
)
17420 case SHT_GNU_LIBLIST
:
17421 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17424 elib
= (Elf32_External_Lib
*)
17425 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17426 _("liblist section data"));
17434 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17435 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17436 string_sec
->sh_size
,
17437 _("liblist string table"));
17439 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17446 strtab_size
= string_sec
->sh_size
;
17448 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17449 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17450 "\nLibrary list section '%s' contains %lu entries:\n",
17452 printable_section_name (filedata
, section
),
17455 puts (_(" Library Time Stamp Checksum Version Flags"));
17457 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17465 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17466 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17467 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17468 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17469 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17471 tmp
= gmtime (&atime
);
17472 snprintf (timebuf
, sizeof (timebuf
),
17473 "%04u-%02u-%02uT%02u:%02u:%02u",
17474 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17475 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17477 printf ("%3lu: ", (unsigned long) cnt
);
17479 printf ("%-20s", liblist
.l_name
< strtab_size
17480 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17482 printf ("%-20.20s", liblist
.l_name
< strtab_size
17483 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17484 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17485 liblist
.l_version
, liblist
.l_flags
);
17496 static const char *
17497 get_note_type (Filedata
* filedata
, unsigned e_type
)
17499 static char buff
[64];
17501 if (filedata
->file_header
.e_type
== ET_CORE
)
17505 return _("NT_AUXV (auxiliary vector)");
17507 return _("NT_PRSTATUS (prstatus structure)");
17509 return _("NT_FPREGSET (floating point registers)");
17511 return _("NT_PRPSINFO (prpsinfo structure)");
17512 case NT_TASKSTRUCT
:
17513 return _("NT_TASKSTRUCT (task structure)");
17515 return _("NT_PRXFPREG (user_xfpregs structure)");
17517 return _("NT_PPC_VMX (ppc Altivec registers)");
17519 return _("NT_PPC_VSX (ppc VSX registers)");
17521 return _("NT_PPC_TAR (ppc TAR register)");
17523 return _("NT_PPC_PPR (ppc PPR register)");
17525 return _("NT_PPC_DSCR (ppc DSCR register)");
17527 return _("NT_PPC_EBB (ppc EBB registers)");
17529 return _("NT_PPC_PMU (ppc PMU registers)");
17530 case NT_PPC_TM_CGPR
:
17531 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17532 case NT_PPC_TM_CFPR
:
17533 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17534 case NT_PPC_TM_CVMX
:
17535 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17536 case NT_PPC_TM_CVSX
:
17537 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17538 case NT_PPC_TM_SPR
:
17539 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17540 case NT_PPC_TM_CTAR
:
17541 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17542 case NT_PPC_TM_CPPR
:
17543 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17544 case NT_PPC_TM_CDSCR
:
17545 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17547 return _("NT_386_TLS (x86 TLS information)");
17548 case NT_386_IOPERM
:
17549 return _("NT_386_IOPERM (x86 I/O permissions)");
17550 case NT_X86_XSTATE
:
17551 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17552 case NT_S390_HIGH_GPRS
:
17553 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17554 case NT_S390_TIMER
:
17555 return _("NT_S390_TIMER (s390 timer register)");
17556 case NT_S390_TODCMP
:
17557 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17558 case NT_S390_TODPREG
:
17559 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17561 return _("NT_S390_CTRS (s390 control registers)");
17562 case NT_S390_PREFIX
:
17563 return _("NT_S390_PREFIX (s390 prefix register)");
17564 case NT_S390_LAST_BREAK
:
17565 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17566 case NT_S390_SYSTEM_CALL
:
17567 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17569 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17570 case NT_S390_VXRS_LOW
:
17571 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17572 case NT_S390_VXRS_HIGH
:
17573 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17574 case NT_S390_GS_CB
:
17575 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17576 case NT_S390_GS_BC
:
17577 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17579 return _("NT_ARM_VFP (arm VFP registers)");
17581 return _("NT_ARM_TLS (AArch TLS registers)");
17582 case NT_ARM_HW_BREAK
:
17583 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17584 case NT_ARM_HW_WATCH
:
17585 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17587 return _("NT_PSTATUS (pstatus structure)");
17589 return _("NT_FPREGS (floating point registers)");
17591 return _("NT_PSINFO (psinfo structure)");
17593 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17595 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17596 case NT_WIN32PSTATUS
:
17597 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17599 return _("NT_SIGINFO (siginfo_t data)");
17601 return _("NT_FILE (mapped files)");
17609 return _("NT_VERSION (version)");
17611 return _("NT_ARCH (architecture)");
17612 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17614 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17620 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17625 print_core_note (Elf_Internal_Note
*pnote
)
17627 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17628 bfd_vma count
, page_size
;
17629 unsigned char *descdata
, *filenames
, *descend
;
17631 if (pnote
->type
!= NT_FILE
)
17641 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17642 /* Still "successful". */
17647 if (pnote
->descsz
< 2 * addr_size
)
17649 error (_(" Malformed note - too short for header\n"));
17653 descdata
= (unsigned char *) pnote
->descdata
;
17654 descend
= descdata
+ pnote
->descsz
;
17656 if (descdata
[pnote
->descsz
- 1] != '\0')
17658 error (_(" Malformed note - does not end with \\0\n"));
17662 count
= byte_get (descdata
, addr_size
);
17663 descdata
+= addr_size
;
17665 page_size
= byte_get (descdata
, addr_size
);
17666 descdata
+= addr_size
;
17668 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17669 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17671 error (_(" Malformed note - too short for supplied file count\n"));
17675 printf (_(" Page size: "));
17676 print_vma (page_size
, DEC
);
17679 printf (_(" %*s%*s%*s\n"),
17680 (int) (2 + 2 * addr_size
), _("Start"),
17681 (int) (4 + 2 * addr_size
), _("End"),
17682 (int) (4 + 2 * addr_size
), _("Page Offset"));
17683 filenames
= descdata
+ count
* 3 * addr_size
;
17684 while (count
-- > 0)
17686 bfd_vma start
, end
, file_ofs
;
17688 if (filenames
== descend
)
17690 error (_(" Malformed note - filenames end too early\n"));
17694 start
= byte_get (descdata
, addr_size
);
17695 descdata
+= addr_size
;
17696 end
= byte_get (descdata
, addr_size
);
17697 descdata
+= addr_size
;
17698 file_ofs
= byte_get (descdata
, addr_size
);
17699 descdata
+= addr_size
;
17702 print_vma (start
, FULL_HEX
);
17704 print_vma (end
, FULL_HEX
);
17706 print_vma (file_ofs
, FULL_HEX
);
17707 printf ("\n %s\n", filenames
);
17709 filenames
+= 1 + strlen ((char *) filenames
);
17715 static const char *
17716 get_gnu_elf_note_type (unsigned e_type
)
17718 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17721 case NT_GNU_ABI_TAG
:
17722 return _("NT_GNU_ABI_TAG (ABI version tag)");
17724 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17725 case NT_GNU_BUILD_ID
:
17726 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17727 case NT_GNU_GOLD_VERSION
:
17728 return _("NT_GNU_GOLD_VERSION (gold version)");
17729 case NT_GNU_PROPERTY_TYPE_0
:
17730 return _("NT_GNU_PROPERTY_TYPE_0");
17731 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17732 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17733 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17734 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17737 static char buff
[64];
17739 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17746 decode_x86_compat_isa (unsigned int bitmask
)
17750 unsigned int bit
= bitmask
& (- bitmask
);
17755 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17758 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17761 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17764 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17767 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17770 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17773 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17776 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17779 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17782 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17785 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17788 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17789 printf ("AVX512F");
17791 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17792 printf ("AVX512CD");
17794 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17795 printf ("AVX512ER");
17797 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17798 printf ("AVX512PF");
17800 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17801 printf ("AVX512VL");
17803 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17804 printf ("AVX512DQ");
17806 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17807 printf ("AVX512BW");
17810 printf (_("<unknown: %x>"), bit
);
17819 decode_x86_isa (unsigned int bitmask
)
17823 printf (_("<None>"));
17829 unsigned int bit
= bitmask
& (- bitmask
);
17834 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17837 case GNU_PROPERTY_X86_ISA_1_SSE
:
17840 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17843 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17846 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17849 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17852 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17855 case GNU_PROPERTY_X86_ISA_1_AVX
:
17858 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17861 case GNU_PROPERTY_X86_ISA_1_FMA
:
17864 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17865 printf ("AVX512F");
17867 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17868 printf ("AVX512CD");
17870 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17871 printf ("AVX512ER");
17873 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17874 printf ("AVX512PF");
17876 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17877 printf ("AVX512VL");
17879 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17880 printf ("AVX512DQ");
17882 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17883 printf ("AVX512BW");
17885 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17886 printf ("AVX512_4FMAPS");
17888 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17889 printf ("AVX512_4VNNIW");
17891 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17892 printf ("AVX512_BITALG");
17894 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17895 printf ("AVX512_IFMA");
17897 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17898 printf ("AVX512_VBMI");
17900 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17901 printf ("AVX512_VBMI2");
17903 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17904 printf ("AVX512_VNNI");
17906 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17907 printf ("AVX512_BF16");
17910 printf (_("<unknown: %x>"), bit
);
17919 decode_x86_feature_1 (unsigned int bitmask
)
17923 printf (_("<None>"));
17929 unsigned int bit
= bitmask
& (- bitmask
);
17934 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17937 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17941 printf (_("<unknown: %x>"), bit
);
17950 decode_x86_feature_2 (unsigned int bitmask
)
17954 printf (_("<None>"));
17960 unsigned int bit
= bitmask
& (- bitmask
);
17965 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17968 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17971 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17974 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17977 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17980 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17983 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17986 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17989 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17990 printf ("XSAVEOPT");
17992 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17996 printf (_("<unknown: %x>"), bit
);
18005 decode_aarch64_feature_1_and (unsigned int bitmask
)
18009 unsigned int bit
= bitmask
& (- bitmask
);
18014 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18018 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18023 printf (_("<unknown: %x>"), bit
);
18032 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18034 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18035 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18036 unsigned int size
= is_32bit_elf
? 4 : 8;
18038 printf (_(" Properties: "));
18040 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18042 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18046 while (ptr
< ptr_end
)
18050 unsigned int datasz
;
18052 if ((size_t) (ptr_end
- ptr
) < 8)
18054 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18058 type
= byte_get (ptr
, 4);
18059 datasz
= byte_get (ptr
+ 4, 4);
18063 if (datasz
> (size_t) (ptr_end
- ptr
))
18065 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18070 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18072 if (filedata
->file_header
.e_machine
== EM_X86_64
18073 || filedata
->file_header
.e_machine
== EM_IAMCU
18074 || filedata
->file_header
.e_machine
== EM_386
)
18076 unsigned int bitmask
;
18079 bitmask
= byte_get (ptr
, 4);
18085 case GNU_PROPERTY_X86_ISA_1_USED
:
18087 printf (_("x86 ISA used: <corrupt length: %#x> "),
18091 printf ("x86 ISA used: ");
18092 decode_x86_isa (bitmask
);
18096 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18098 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18102 printf ("x86 ISA needed: ");
18103 decode_x86_isa (bitmask
);
18107 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18109 printf (_("x86 feature: <corrupt length: %#x> "),
18113 printf ("x86 feature: ");
18114 decode_x86_feature_1 (bitmask
);
18118 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18120 printf (_("x86 feature used: <corrupt length: %#x> "),
18124 printf ("x86 feature used: ");
18125 decode_x86_feature_2 (bitmask
);
18129 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18131 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18134 printf ("x86 feature needed: ");
18135 decode_x86_feature_2 (bitmask
);
18139 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18141 printf (_("x86 ISA used: <corrupt length: %#x> "),
18145 printf ("x86 ISA used: ");
18146 decode_x86_compat_isa (bitmask
);
18150 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18152 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18156 printf ("x86 ISA needed: ");
18157 decode_x86_compat_isa (bitmask
);
18165 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18167 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18169 printf ("AArch64 feature: ");
18171 printf (_("<corrupt length: %#x> "), datasz
);
18173 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18182 case GNU_PROPERTY_STACK_SIZE
:
18183 printf (_("stack size: "));
18184 if (datasz
!= size
)
18185 printf (_("<corrupt length: %#x> "), datasz
);
18187 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18190 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18191 printf ("no copy on protected ");
18193 printf (_("<corrupt length: %#x> "), datasz
);
18201 if (type
< GNU_PROPERTY_LOPROC
)
18202 printf (_("<unknown type %#x data: "), type
);
18203 else if (type
< GNU_PROPERTY_LOUSER
)
18204 printf (_("<procesor-specific type %#x data: "), type
);
18206 printf (_("<application-specific type %#x data: "), type
);
18207 for (j
= 0; j
< datasz
; ++j
)
18208 printf ("%02x ", ptr
[j
] & 0xff);
18212 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18213 if (ptr
== ptr_end
)
18226 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18228 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18229 switch (pnote
->type
)
18231 case NT_GNU_BUILD_ID
:
18235 printf (_(" Build ID: "));
18236 for (i
= 0; i
< pnote
->descsz
; ++i
)
18237 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18242 case NT_GNU_ABI_TAG
:
18244 unsigned long os
, major
, minor
, subminor
;
18245 const char *osname
;
18247 /* PR 17531: file: 030-599401-0.004. */
18248 if (pnote
->descsz
< 16)
18250 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18254 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18255 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18256 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18257 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18261 case GNU_ABI_TAG_LINUX
:
18264 case GNU_ABI_TAG_HURD
:
18267 case GNU_ABI_TAG_SOLARIS
:
18268 osname
= "Solaris";
18270 case GNU_ABI_TAG_FREEBSD
:
18271 osname
= "FreeBSD";
18273 case GNU_ABI_TAG_NETBSD
:
18276 case GNU_ABI_TAG_SYLLABLE
:
18277 osname
= "Syllable";
18279 case GNU_ABI_TAG_NACL
:
18283 osname
= "Unknown";
18287 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18288 major
, minor
, subminor
);
18292 case NT_GNU_GOLD_VERSION
:
18296 printf (_(" Version: "));
18297 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18298 printf ("%c", pnote
->descdata
[i
]);
18305 unsigned long num_entries
, mask
;
18307 /* Hardware capabilities information. Word 0 is the number of entries.
18308 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18309 is a series of entries, where each entry is a single byte followed
18310 by a nul terminated string. The byte gives the bit number to test
18311 if enabled in the bitmask. */
18312 printf (_(" Hardware Capabilities: "));
18313 if (pnote
->descsz
< 8)
18315 error (_("<corrupt GNU_HWCAP>\n"));
18318 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18319 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18320 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18321 /* FIXME: Add code to display the entries... */
18325 case NT_GNU_PROPERTY_TYPE_0
:
18326 print_gnu_property_note (filedata
, pnote
);
18330 /* Handle unrecognised types. An error message should have already been
18331 created by get_gnu_elf_note_type(), so all that we need to do is to
18332 display the data. */
18336 printf (_(" Description data: "));
18337 for (i
= 0; i
< pnote
->descsz
; ++i
)
18338 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18347 static const char *
18348 get_v850_elf_note_type (enum v850_notes n_type
)
18350 static char buff
[64];
18354 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18355 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18356 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18357 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18358 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18359 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18361 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18367 print_v850_note (Elf_Internal_Note
* pnote
)
18371 if (pnote
->descsz
!= 4)
18374 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18378 printf (_("not set\n"));
18382 switch (pnote
->type
)
18384 case V850_NOTE_ALIGNMENT
:
18387 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18388 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18392 case V850_NOTE_DATA_SIZE
:
18395 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18396 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18400 case V850_NOTE_FPU_INFO
:
18403 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18404 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18408 case V850_NOTE_MMU_INFO
:
18409 case V850_NOTE_CACHE_INFO
:
18410 case V850_NOTE_SIMD_INFO
:
18411 if (val
== EF_RH850_SIMD
)
18413 printf (_("yes\n"));
18419 /* An 'unknown note type' message will already have been displayed. */
18423 printf (_("unknown value: %x\n"), val
);
18428 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18430 unsigned int version
;
18432 switch (pnote
->type
)
18434 case NT_NETBSD_IDENT
:
18435 if (pnote
->descsz
< 1)
18437 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18438 if ((version
/ 10000) % 100)
18439 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18440 version
, version
/ 100000000, (version
/ 1000000) % 100,
18441 (version
/ 10000) % 100 > 26 ? "Z" : "",
18442 'A' + (version
/ 10000) % 26);
18444 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18445 version
, version
/ 100000000, (version
/ 1000000) % 100,
18446 (version
/ 100) % 100);
18449 case NT_NETBSD_MARCH
:
18450 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18454 #ifdef NT_NETBSD_PAX
18455 case NT_NETBSD_PAX
:
18456 if (pnote
->descsz
< 1)
18458 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18459 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18460 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18461 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18462 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18463 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18464 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18465 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18470 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18471 pnote
->descsz
, pnote
->type
);
18475 static const char *
18476 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18480 case NT_FREEBSD_THRMISC
:
18481 return _("NT_THRMISC (thrmisc structure)");
18482 case NT_FREEBSD_PROCSTAT_PROC
:
18483 return _("NT_PROCSTAT_PROC (proc data)");
18484 case NT_FREEBSD_PROCSTAT_FILES
:
18485 return _("NT_PROCSTAT_FILES (files data)");
18486 case NT_FREEBSD_PROCSTAT_VMMAP
:
18487 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18488 case NT_FREEBSD_PROCSTAT_GROUPS
:
18489 return _("NT_PROCSTAT_GROUPS (groups data)");
18490 case NT_FREEBSD_PROCSTAT_UMASK
:
18491 return _("NT_PROCSTAT_UMASK (umask data)");
18492 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18493 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18494 case NT_FREEBSD_PROCSTAT_OSREL
:
18495 return _("NT_PROCSTAT_OSREL (osreldate data)");
18496 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18497 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18498 case NT_FREEBSD_PROCSTAT_AUXV
:
18499 return _("NT_PROCSTAT_AUXV (auxv data)");
18500 case NT_FREEBSD_PTLWPINFO
:
18501 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18503 return get_note_type (filedata
, e_type
);
18506 static const char *
18507 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18509 static char buff
[64];
18513 case NT_NETBSDCORE_PROCINFO
:
18514 /* NetBSD core "procinfo" structure. */
18515 return _("NetBSD procinfo structure");
18517 #ifdef NT_NETBSDCORE_AUXV
18518 case NT_NETBSDCORE_AUXV
:
18519 return _("NetBSD ELF auxiliary vector data");
18522 #ifdef NT_NETBSDCORE_LWPSTATUS
18523 case NT_NETBSDCORE_LWPSTATUS
:
18524 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18528 /* As of Jan 2020 there are no other machine-independent notes
18529 defined for NetBSD core files. If the note type is less
18530 than the start of the machine-dependent note types, we don't
18533 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18535 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18541 switch (filedata
->file_header
.e_machine
)
18543 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18544 and PT_GETFPREGS == mach+2. */
18549 case EM_SPARC32PLUS
:
18553 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18554 return _("PT_GETREGS (reg structure)");
18555 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18556 return _("PT_GETFPREGS (fpreg structure)");
18562 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18563 There's also old PT___GETREGS40 == mach + 1 for old reg
18564 structure which lacks GBR. */
18568 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18569 return _("PT___GETREGS40 (old reg structure)");
18570 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18571 return _("PT_GETREGS (reg structure)");
18572 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18573 return _("PT_GETFPREGS (fpreg structure)");
18579 /* On all other arch's, PT_GETREGS == mach+1 and
18580 PT_GETFPREGS == mach+3. */
18584 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18585 return _("PT_GETREGS (reg structure)");
18586 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18587 return _("PT_GETFPREGS (fpreg structure)");
18593 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18594 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18598 static const char *
18599 get_stapsdt_note_type (unsigned e_type
)
18601 static char buff
[64];
18606 return _("NT_STAPSDT (SystemTap probe descriptors)");
18612 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18617 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18619 size_t len
, maxlen
;
18620 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18621 char *data
= pnote
->descdata
;
18622 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18623 bfd_vma pc
, base_addr
, semaphore
;
18624 char *provider
, *probe
, *arg_fmt
;
18626 if (pnote
->descsz
< (addr_size
* 3))
18627 goto stapdt_note_too_small
;
18629 pc
= byte_get ((unsigned char *) data
, addr_size
);
18632 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18635 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18638 if (data
>= data_end
)
18639 goto stapdt_note_too_small
;
18640 maxlen
= data_end
- data
;
18641 len
= strnlen (data
, maxlen
);
18648 goto stapdt_note_too_small
;
18650 if (data
>= data_end
)
18651 goto stapdt_note_too_small
;
18652 maxlen
= data_end
- data
;
18653 len
= strnlen (data
, maxlen
);
18660 goto stapdt_note_too_small
;
18662 if (data
>= data_end
)
18663 goto stapdt_note_too_small
;
18664 maxlen
= data_end
- data
;
18665 len
= strnlen (data
, maxlen
);
18672 goto stapdt_note_too_small
;
18674 printf (_(" Provider: %s\n"), provider
);
18675 printf (_(" Name: %s\n"), probe
);
18676 printf (_(" Location: "));
18677 print_vma (pc
, FULL_HEX
);
18678 printf (_(", Base: "));
18679 print_vma (base_addr
, FULL_HEX
);
18680 printf (_(", Semaphore: "));
18681 print_vma (semaphore
, FULL_HEX
);
18683 printf (_(" Arguments: %s\n"), arg_fmt
);
18685 return data
== data_end
;
18687 stapdt_note_too_small
:
18688 printf (_(" <corrupt - note is too small>\n"));
18689 error (_("corrupt stapdt note - the data size is too small\n"));
18693 static const char *
18694 get_ia64_vms_note_type (unsigned e_type
)
18696 static char buff
[64];
18701 return _("NT_VMS_MHD (module header)");
18703 return _("NT_VMS_LNM (language name)");
18705 return _("NT_VMS_SRC (source files)");
18707 return "NT_VMS_TITLE";
18709 return _("NT_VMS_EIDC (consistency check)");
18710 case NT_VMS_FPMODE
:
18711 return _("NT_VMS_FPMODE (FP mode)");
18712 case NT_VMS_LINKTIME
:
18713 return "NT_VMS_LINKTIME";
18714 case NT_VMS_IMGNAM
:
18715 return _("NT_VMS_IMGNAM (image name)");
18717 return _("NT_VMS_IMGID (image id)");
18718 case NT_VMS_LINKID
:
18719 return _("NT_VMS_LINKID (link id)");
18720 case NT_VMS_IMGBID
:
18721 return _("NT_VMS_IMGBID (build id)");
18722 case NT_VMS_GSTNAM
:
18723 return _("NT_VMS_GSTNAM (sym table name)");
18724 case NT_VMS_ORIG_DYN
:
18725 return "NT_VMS_ORIG_DYN";
18726 case NT_VMS_PATCHTIME
:
18727 return "NT_VMS_PATCHTIME";
18729 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18735 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18737 int maxlen
= pnote
->descsz
;
18739 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18740 goto desc_size_fail
;
18742 switch (pnote
->type
)
18746 goto desc_size_fail
;
18748 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18750 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18751 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18752 if (l
+ 34 < maxlen
)
18754 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18755 if (l
+ 35 < maxlen
)
18756 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18758 printf (_(" Module version : <missing>\n"));
18762 printf (_(" Module name : <missing>\n"));
18763 printf (_(" Module version : <missing>\n"));
18768 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18772 case NT_VMS_FPMODE
:
18773 printf (_(" Floating Point mode: "));
18775 goto desc_size_fail
;
18776 /* FIXME: Generate an error if descsz > 8 ? */
18778 printf ("0x%016" BFD_VMA_FMT
"x\n",
18779 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18782 case NT_VMS_LINKTIME
:
18783 printf (_(" Link time: "));
18785 goto desc_size_fail
;
18786 /* FIXME: Generate an error if descsz > 8 ? */
18789 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18793 case NT_VMS_PATCHTIME
:
18794 printf (_(" Patch time: "));
18796 goto desc_size_fail
;
18797 /* FIXME: Generate an error if descsz > 8 ? */
18800 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18804 case NT_VMS_ORIG_DYN
:
18806 goto desc_size_fail
;
18808 printf (_(" Major id: %u, minor id: %u\n"),
18809 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18810 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18811 printf (_(" Last modified : "));
18813 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18814 printf (_("\n Link flags : "));
18815 printf ("0x%016" BFD_VMA_FMT
"x\n",
18816 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18817 printf (_(" Header flags: 0x%08x\n"),
18818 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18819 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18823 case NT_VMS_IMGNAM
:
18824 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18827 case NT_VMS_GSTNAM
:
18828 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18832 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18835 case NT_VMS_LINKID
:
18836 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18846 printf (_(" <corrupt - data size is too small>\n"));
18847 error (_("corrupt IA64 note: data size is too small\n"));
18851 struct build_attr_cache
{
18852 Filedata
*filedata
;
18854 unsigned long strtablen
;
18855 Elf_Internal_Sym
*symtab
;
18856 unsigned long nsyms
;
18859 /* Find the symbol associated with a build attribute that is attached
18860 to address OFFSET. If PNAME is non-NULL then store the name of
18861 the symbol (if found) in the provided pointer, Returns NULL if a
18862 symbol could not be found. */
18864 static Elf_Internal_Sym
*
18865 get_symbol_for_build_attribute (Filedata
* filedata
,
18866 unsigned long offset
,
18867 bfd_boolean is_open_attr
,
18868 const char ** pname
)
18870 Elf_Internal_Sym
*saved_sym
= NULL
;
18871 Elf_Internal_Sym
*sym
;
18873 if (filedata
->section_headers
!= NULL
18874 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18876 Elf_Internal_Shdr
* symsec
;
18878 free (ba_cache
.strtab
);
18879 ba_cache
.strtab
= NULL
;
18880 free (ba_cache
.symtab
);
18881 ba_cache
.symtab
= NULL
;
18883 /* Load the symbol and string sections. */
18884 for (symsec
= filedata
->section_headers
;
18885 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18888 if (symsec
->sh_type
== SHT_SYMTAB
18889 && get_symtab (filedata
, symsec
,
18890 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18891 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18894 ba_cache
.filedata
= filedata
;
18897 if (ba_cache
.symtab
== NULL
)
18900 /* Find a symbol whose value matches offset. */
18901 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18902 if (sym
->st_value
== offset
)
18904 if (sym
->st_name
>= ba_cache
.strtablen
)
18905 /* Huh ? This should not happen. */
18908 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18911 /* The AArch64 and ARM architectures define mapping symbols
18912 (eg $d, $x, $t) which we want to ignore. */
18913 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18914 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18915 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18920 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18921 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18922 FUNC symbols entirely. */
18923 switch (ELF_ST_TYPE (sym
->st_info
))
18930 /* If the symbol has a size associated
18931 with it then we can stop searching. */
18932 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18937 /* Ignore function symbols. */
18944 switch (ELF_ST_BIND (sym
->st_info
))
18947 if (saved_sym
== NULL
18948 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18953 if (saved_sym
== NULL
)
18963 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18971 if (saved_sym
&& pname
)
18972 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
18977 /* Returns true iff addr1 and addr2 are in the same section. */
18980 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18982 Elf_Internal_Shdr
* a1
;
18983 Elf_Internal_Shdr
* a2
;
18985 a1
= find_section_by_address (filedata
, addr1
);
18986 a2
= find_section_by_address (filedata
, addr2
);
18988 return a1
== a2
&& a1
!= NULL
;
18992 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18993 Filedata
* filedata
)
18995 static unsigned long global_offset
= 0;
18996 static unsigned long global_end
= 0;
18997 static unsigned long func_offset
= 0;
18998 static unsigned long func_end
= 0;
19000 Elf_Internal_Sym
* sym
;
19002 unsigned long start
;
19004 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19006 switch (pnote
->descsz
)
19009 /* A zero-length description means that the range of
19010 the previous note of the same type should be used. */
19013 if (global_end
> global_offset
)
19014 printf (_(" Applies to region from %#lx to %#lx\n"),
19015 global_offset
, global_end
);
19017 printf (_(" Applies to region from %#lx\n"), global_offset
);
19021 if (func_end
> func_offset
)
19022 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19024 printf (_(" Applies to region from %#lx\n"), func_offset
);
19029 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19036 /* FIXME: We should check that version 3+ notes are being used here... */
19037 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19038 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19042 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19048 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19049 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19053 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19054 printf (_(" <invalid descsz>"));
19059 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19060 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19061 in order to avoid them being confused with the start address of the
19062 first function in the file... */
19063 if (sym
== NULL
&& is_open_attr
)
19064 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19067 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19068 end
= start
+ sym
->st_size
;
19072 /* FIXME: Need to properly allow for section alignment.
19073 16 is just the alignment used on x86_64. */
19075 && start
> BFD_ALIGN (global_end
, 16)
19076 /* Build notes are not guaranteed to be organised in order of
19077 increasing address, but we should find the all of the notes
19078 for one section in the same place. */
19079 && same_section (filedata
, start
, global_end
))
19080 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19081 global_end
+ 1, start
- 1);
19083 printf (_(" Applies to region from %#lx"), start
);
19084 global_offset
= start
;
19088 printf (_(" to %#lx"), end
);
19094 printf (_(" Applies to region from %#lx"), start
);
19095 func_offset
= start
;
19099 printf (_(" to %#lx"), end
);
19105 printf (_(" (%s)"), name
);
19112 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19114 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19115 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19116 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19118 char name_attribute
;
19119 const char * expected_types
;
19120 const char * name
= pnote
->namedata
;
19124 if (name
== NULL
|| pnote
->namesz
< 2)
19126 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19127 print_symbol (-20, _(" <corrupt name>"));
19136 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19137 if (name
[0] == 'G' && name
[1] == 'A')
19139 if (pnote
->namesz
< 4)
19141 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19142 print_symbol (-20, _(" <corrupt name>"));
19151 switch ((name_type
= * name
))
19153 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19154 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19155 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19156 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19157 printf ("%c", * name
);
19161 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19162 print_symbol (-20, _("<unknown name type>"));
19169 switch ((name_attribute
= * name
))
19171 case GNU_BUILD_ATTRIBUTE_VERSION
:
19172 text
= _("<version>");
19173 expected_types
= string_expected
;
19176 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19177 text
= _("<stack prot>");
19178 expected_types
= "!+*";
19181 case GNU_BUILD_ATTRIBUTE_RELRO
:
19182 text
= _("<relro>");
19183 expected_types
= bool_expected
;
19186 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19187 text
= _("<stack size>");
19188 expected_types
= number_expected
;
19191 case GNU_BUILD_ATTRIBUTE_TOOL
:
19192 text
= _("<tool>");
19193 expected_types
= string_expected
;
19196 case GNU_BUILD_ATTRIBUTE_ABI
:
19198 expected_types
= "$*";
19201 case GNU_BUILD_ATTRIBUTE_PIC
:
19203 expected_types
= number_expected
;
19206 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19207 text
= _("<short enum>");
19208 expected_types
= bool_expected
;
19212 if (ISPRINT (* name
))
19214 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19216 if (len
> left
&& ! do_wide
)
19218 printf ("%.*s:", len
, name
);
19224 static char tmpbuf
[128];
19226 error (_("unrecognised byte in name field: %d\n"), * name
);
19227 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19231 expected_types
= "*$!+";
19236 left
-= printf ("%s", text
);
19238 if (strchr (expected_types
, name_type
) == NULL
)
19239 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19241 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19243 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19244 (unsigned long) pnote
->namesz
,
19245 (long) (name
- pnote
->namedata
));
19249 if (left
< 1 && ! do_wide
)
19254 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19256 unsigned int bytes
;
19257 unsigned long long val
= 0;
19258 unsigned int shift
= 0;
19259 char * decoded
= NULL
;
19261 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19263 /* The -1 is because the name field is always 0 terminated, and we
19264 want to be able to ensure that the shift in the while loop below
19265 will not overflow. */
19268 if (bytes
> sizeof (val
))
19270 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19272 bytes
= sizeof (val
);
19274 /* We do not bother to warn if bytes == 0 as this can
19275 happen with some early versions of the gcc plugin. */
19279 unsigned long byte
= (* name
++) & 0xff;
19281 val
|= byte
<< shift
;
19285 switch (name_attribute
)
19287 case GNU_BUILD_ATTRIBUTE_PIC
:
19290 case 0: decoded
= "static"; break;
19291 case 1: decoded
= "pic"; break;
19292 case 2: decoded
= "PIC"; break;
19293 case 3: decoded
= "pie"; break;
19294 case 4: decoded
= "PIE"; break;
19298 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19301 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19302 case 0: decoded
= "off"; break;
19303 case 1: decoded
= "on"; break;
19304 case 2: decoded
= "all"; break;
19305 case 3: decoded
= "strong"; break;
19306 case 4: decoded
= "explicit"; break;
19314 if (decoded
!= NULL
)
19316 print_symbol (-left
, decoded
);
19327 left
-= printf ("0x%llx", val
);
19329 left
-= printf ("0x%-.*llx", left
, val
);
19333 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19334 left
-= print_symbol (- left
, name
);
19336 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19337 left
-= print_symbol (- left
, "true");
19339 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19340 left
-= print_symbol (- left
, "false");
19344 if (do_wide
&& left
> 0)
19345 printf ("%-*s", left
, " ");
19350 /* Note that by the ELF standard, the name field is already null byte
19351 terminated, and namesz includes the terminating null byte.
19352 I.E. the value of namesz for the name "FSF" is 4.
19354 If the value of namesz is zero, there is no name present. */
19357 process_note (Elf_Internal_Note
* pnote
,
19358 Filedata
* filedata
)
19360 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19363 if (pnote
->namesz
== 0)
19364 /* If there is no note name, then use the default set of
19365 note type strings. */
19366 nt
= get_note_type (filedata
, pnote
->type
);
19368 else if (const_strneq (pnote
->namedata
, "GNU"))
19369 /* GNU-specific object file notes. */
19370 nt
= get_gnu_elf_note_type (pnote
->type
);
19372 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19373 /* FreeBSD-specific core file notes. */
19374 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19376 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19377 /* NetBSD-specific core file notes. */
19378 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19380 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19381 /* NetBSD-specific core file notes. */
19382 return process_netbsd_elf_note (pnote
);
19384 else if (const_strneq (pnote
->namedata
, "PaX"))
19385 /* NetBSD-specific core file notes. */
19386 return process_netbsd_elf_note (pnote
);
19388 else if (strneq (pnote
->namedata
, "SPU/", 4))
19390 /* SPU-specific core file notes. */
19391 nt
= pnote
->namedata
+ 4;
19395 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19396 /* VMS/ia64-specific file notes. */
19397 nt
= get_ia64_vms_note_type (pnote
->type
);
19399 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19400 nt
= get_stapsdt_note_type (pnote
->type
);
19403 /* Don't recognize this note name; just use the default set of
19404 note type strings. */
19405 nt
= get_note_type (filedata
, pnote
->type
);
19409 if (((const_strneq (pnote
->namedata
, "GA")
19410 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19411 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19412 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19413 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19414 print_gnu_build_attribute_name (pnote
);
19416 print_symbol (-20, name
);
19419 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19421 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19423 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19424 return print_ia64_vms_note (pnote
);
19425 else if (const_strneq (pnote
->namedata
, "GNU"))
19426 return print_gnu_note (filedata
, pnote
);
19427 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19428 return print_stapsdt_note (pnote
);
19429 else if (const_strneq (pnote
->namedata
, "CORE"))
19430 return print_core_note (pnote
);
19431 else if (((const_strneq (pnote
->namedata
, "GA")
19432 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19433 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19434 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19435 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19436 return print_gnu_build_attribute_description (pnote
, filedata
);
19442 printf (_(" description data: "));
19443 for (i
= 0; i
< pnote
->descsz
; i
++)
19444 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19456 process_notes_at (Filedata
* filedata
,
19457 Elf_Internal_Shdr
* section
,
19462 Elf_External_Note
* pnotes
;
19463 Elf_External_Note
* external
;
19465 bfd_boolean res
= TRUE
;
19472 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19475 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19483 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19486 if (pnotes
== NULL
)
19492 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19494 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19495 (unsigned long) offset
, (unsigned long) length
);
19497 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19498 specifies that notes should be aligned to 4 bytes in 32-bit
19499 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19500 we also support 4 byte alignment in 64-bit objects. If section
19501 alignment is less than 4, we treate alignment as 4 bytes. */
19504 else if (align
!= 4 && align
!= 8)
19506 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19512 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19514 end
= (char *) pnotes
+ length
;
19515 while ((char *) external
< end
)
19517 Elf_Internal_Note inote
;
19520 char * temp
= NULL
;
19521 size_t data_remaining
= end
- (char *) external
;
19523 if (!is_ia64_vms (filedata
))
19525 /* PR binutils/15191
19526 Make sure that there is enough data to read. */
19527 min_notesz
= offsetof (Elf_External_Note
, name
);
19528 if (data_remaining
< min_notesz
)
19530 warn (ngettext ("Corrupt note: only %ld byte remains, "
19531 "not enough for a full note\n",
19532 "Corrupt note: only %ld bytes remain, "
19533 "not enough for a full note\n",
19535 (long) data_remaining
);
19538 data_remaining
-= min_notesz
;
19540 inote
.type
= BYTE_GET (external
->type
);
19541 inote
.namesz
= BYTE_GET (external
->namesz
);
19542 inote
.namedata
= external
->name
;
19543 inote
.descsz
= BYTE_GET (external
->descsz
);
19544 inote
.descdata
= ((char *) external
19545 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19546 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19547 next
= ((char *) external
19548 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19552 Elf64_External_VMS_Note
*vms_external
;
19554 /* PR binutils/15191
19555 Make sure that there is enough data to read. */
19556 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19557 if (data_remaining
< min_notesz
)
19559 warn (ngettext ("Corrupt note: only %ld byte remains, "
19560 "not enough for a full note\n",
19561 "Corrupt note: only %ld bytes remain, "
19562 "not enough for a full note\n",
19564 (long) data_remaining
);
19567 data_remaining
-= min_notesz
;
19569 vms_external
= (Elf64_External_VMS_Note
*) external
;
19570 inote
.type
= BYTE_GET (vms_external
->type
);
19571 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19572 inote
.namedata
= vms_external
->name
;
19573 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19574 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19575 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19576 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19579 /* PR 17531: file: 3443835e. */
19580 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19581 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19582 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19583 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19584 || ((size_t) (next
- inote
.descdata
)
19585 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19587 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19588 (unsigned long) ((char *) external
- (char *) pnotes
));
19589 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19590 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19594 external
= (Elf_External_Note
*) next
;
19596 /* Verify that name is null terminated. It appears that at least
19597 one version of Linux (RedHat 6.0) generates corefiles that don't
19598 comply with the ELF spec by failing to include the null byte in
19600 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19602 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19604 temp
= (char *) malloc (inote
.namesz
+ 1);
19607 error (_("Out of memory allocating space for inote name\n"));
19612 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19613 inote
.namedata
= temp
;
19615 inote
.namedata
[inote
.namesz
] = 0;
19618 if (! process_note (& inote
, filedata
))
19634 process_corefile_note_segments (Filedata
* filedata
)
19636 Elf_Internal_Phdr
* segment
;
19638 bfd_boolean res
= TRUE
;
19640 if (! get_program_headers (filedata
))
19643 for (i
= 0, segment
= filedata
->program_headers
;
19644 i
< filedata
->file_header
.e_phnum
;
19647 if (segment
->p_type
== PT_NOTE
)
19648 if (! process_notes_at (filedata
, NULL
,
19649 (bfd_vma
) segment
->p_offset
,
19650 (bfd_vma
) segment
->p_filesz
,
19651 (bfd_vma
) segment
->p_align
))
19659 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19661 Elf_External_Note
* pnotes
;
19662 Elf_External_Note
* external
;
19664 bfd_boolean res
= TRUE
;
19669 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19671 if (pnotes
== NULL
)
19675 end
= (char*) pnotes
+ length
;
19677 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19678 (unsigned long) offset
, (unsigned long) length
);
19680 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19682 Elf_External_Note
* next
;
19683 Elf_Internal_Note inote
;
19685 inote
.type
= BYTE_GET (external
->type
);
19686 inote
.namesz
= BYTE_GET (external
->namesz
);
19687 inote
.namedata
= external
->name
;
19688 inote
.descsz
= BYTE_GET (external
->descsz
);
19689 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19690 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19692 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19694 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19695 inote
.descdata
= inote
.namedata
;
19699 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19701 if ( ((char *) next
> end
)
19702 || ((char *) next
< (char *) pnotes
))
19704 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19705 (unsigned long) ((char *) external
- (char *) pnotes
));
19706 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19707 inote
.type
, inote
.namesz
, inote
.descsz
);
19713 /* Prevent out-of-bounds indexing. */
19714 if ( inote
.namedata
+ inote
.namesz
> end
19715 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19717 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19718 (unsigned long) ((char *) external
- (char *) pnotes
));
19719 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19720 inote
.type
, inote
.namesz
, inote
.descsz
);
19724 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19726 if (! print_v850_note (& inote
))
19729 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19730 inote
.namesz
, inote
.descsz
);
19740 process_note_sections (Filedata
* filedata
)
19742 Elf_Internal_Shdr
* section
;
19744 unsigned int n
= 0;
19745 bfd_boolean res
= TRUE
;
19747 for (i
= 0, section
= filedata
->section_headers
;
19748 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19751 if (section
->sh_type
== SHT_NOTE
)
19753 if (! process_notes_at (filedata
, section
,
19754 (bfd_vma
) section
->sh_offset
,
19755 (bfd_vma
) section
->sh_size
,
19756 (bfd_vma
) section
->sh_addralign
))
19761 if (( filedata
->file_header
.e_machine
== EM_V800
19762 || filedata
->file_header
.e_machine
== EM_V850
19763 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19764 && section
->sh_type
== SHT_RENESAS_INFO
)
19766 if (! process_v850_notes (filedata
,
19767 (bfd_vma
) section
->sh_offset
,
19768 (bfd_vma
) section
->sh_size
))
19775 /* Try processing NOTE segments instead. */
19776 return process_corefile_note_segments (filedata
);
19782 process_notes (Filedata
* filedata
)
19784 /* If we have not been asked to display the notes then do nothing. */
19788 if (filedata
->file_header
.e_type
!= ET_CORE
)
19789 return process_note_sections (filedata
);
19791 /* No program headers means no NOTE segment. */
19792 if (filedata
->file_header
.e_phnum
> 0)
19793 return process_corefile_note_segments (filedata
);
19795 printf (_("No note segments present in the core file.\n"));
19799 static unsigned char *
19800 display_public_gnu_attributes (unsigned char * start
,
19801 const unsigned char * const end
)
19803 printf (_(" Unknown GNU attribute: %s\n"), start
);
19805 start
+= strnlen ((char *) start
, end
- start
);
19806 display_raw_attribute (start
, end
);
19808 return (unsigned char *) end
;
19811 static unsigned char *
19812 display_generic_attribute (unsigned char * start
,
19814 const unsigned char * const end
)
19817 return (unsigned char *) end
;
19819 return display_tag_value (tag
, start
, end
);
19823 process_arch_specific (Filedata
* filedata
)
19828 switch (filedata
->file_header
.e_machine
)
19831 case EM_ARC_COMPACT
:
19832 case EM_ARC_COMPACT2
:
19833 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19834 display_arc_attribute
,
19835 display_generic_attribute
);
19837 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19838 display_arm_attribute
,
19839 display_generic_attribute
);
19842 case EM_MIPS_RS3_LE
:
19843 return process_mips_specific (filedata
);
19846 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19847 display_msp430x_attribute
,
19848 display_msp430_gnu_attribute
);
19851 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19852 display_riscv_attribute
,
19853 display_generic_attribute
);
19856 return process_nds32_specific (filedata
);
19860 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19861 display_power_gnu_attribute
);
19865 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19866 display_s390_gnu_attribute
);
19869 case EM_SPARC32PLUS
:
19871 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19872 display_sparc_gnu_attribute
);
19875 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19876 display_tic6x_attribute
,
19877 display_generic_attribute
);
19880 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19881 display_public_gnu_attributes
,
19882 display_generic_attribute
);
19887 get_file_header (Filedata
* filedata
)
19889 /* Read in the identity array. */
19890 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19893 /* Determine how to read the rest of the header. */
19894 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19899 byte_get
= byte_get_little_endian
;
19900 byte_put
= byte_put_little_endian
;
19903 byte_get
= byte_get_big_endian
;
19904 byte_put
= byte_put_big_endian
;
19908 /* For now we only support 32 bit and 64 bit ELF files. */
19909 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19911 /* Read in the rest of the header. */
19914 Elf32_External_Ehdr ehdr32
;
19916 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19919 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19920 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19921 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19922 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19923 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19924 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19925 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19926 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19927 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19928 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19929 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19930 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19931 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19935 Elf64_External_Ehdr ehdr64
;
19937 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19938 we will not be able to cope with the 64bit data found in
19939 64 ELF files. Detect this now and abort before we start
19940 overwriting things. */
19941 if (sizeof (bfd_vma
) < 8)
19943 error (_("This instance of readelf has been built without support for a\n\
19944 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19948 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19951 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19952 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19953 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19954 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19955 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19956 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19957 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19958 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19959 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19960 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19961 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19962 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19963 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19966 if (filedata
->file_header
.e_shoff
)
19968 /* There may be some extensions in the first section header. Don't
19969 bomb if we can't read it. */
19971 get_32bit_section_headers (filedata
, TRUE
);
19973 get_64bit_section_headers (filedata
, TRUE
);
19980 close_file (Filedata
* filedata
)
19984 if (filedata
->handle
)
19985 fclose (filedata
->handle
);
19991 close_debug_file (void * data
)
19993 close_file ((Filedata
*) data
);
19997 open_file (const char * pathname
)
19999 struct stat statbuf
;
20000 Filedata
* filedata
= NULL
;
20002 if (stat (pathname
, & statbuf
) < 0
20003 || ! S_ISREG (statbuf
.st_mode
))
20006 filedata
= calloc (1, sizeof * filedata
);
20007 if (filedata
== NULL
)
20010 filedata
->handle
= fopen (pathname
, "rb");
20011 if (filedata
->handle
== NULL
)
20014 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20015 filedata
->file_name
= pathname
;
20017 if (! get_file_header (filedata
))
20020 if (filedata
->file_header
.e_shoff
)
20024 /* Read the section headers again, this time for real. */
20026 res
= get_32bit_section_headers (filedata
, FALSE
);
20028 res
= get_64bit_section_headers (filedata
, FALSE
);
20039 if (filedata
->handle
)
20040 fclose (filedata
->handle
);
20047 open_debug_file (const char * pathname
)
20049 return open_file (pathname
);
20052 /* Process one ELF object file according to the command line options.
20053 This file may actually be stored in an archive. The file is
20054 positioned at the start of the ELF object. Returns TRUE if no
20055 problems were encountered, FALSE otherwise. */
20058 process_object (Filedata
* filedata
)
20060 bfd_boolean have_separate_files
;
20062 bfd_boolean res
= TRUE
;
20064 if (! get_file_header (filedata
))
20066 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20070 /* Initialise per file variables. */
20071 for (i
= ARRAY_SIZE (version_info
); i
--;)
20072 version_info
[i
] = 0;
20074 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
20075 dynamic_info
[i
] = 0;
20076 dynamic_info_DT_GNU_HASH
= 0;
20077 dynamic_info_DT_MIPS_XHASH
= 0;
20079 /* Process the file. */
20081 printf (_("\nFile: %s\n"), filedata
->file_name
);
20083 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20084 Note we do this even if cmdline_dump_sects is empty because we
20085 must make sure that the dump_sets array is zeroed out before each
20086 object file is processed. */
20087 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
20088 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
20090 if (cmdline
.num_dump_sects
> 0)
20092 if (filedata
->num_dump_sects
== 0)
20093 /* A sneaky way of allocating the dump_sects array. */
20094 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
20096 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
20097 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
20098 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
20101 if (! process_file_header (filedata
))
20104 if (! process_section_headers (filedata
))
20106 /* Without loaded section headers we cannot process lots of things. */
20107 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20109 if (! do_using_dynamic
)
20110 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20113 if (! process_section_groups (filedata
))
20114 /* Without loaded section groups we cannot process unwind. */
20117 if (process_program_headers (filedata
))
20118 process_dynamic_section (filedata
);
20122 if (! process_relocs (filedata
))
20125 if (! process_unwind (filedata
))
20128 if (! process_symbol_table (filedata
))
20131 if (! process_syminfo (filedata
))
20134 if (! process_version_sections (filedata
))
20137 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20138 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20140 have_separate_files
= FALSE
;
20142 if (! process_section_contents (filedata
))
20145 if (have_separate_files
)
20149 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20151 if (! process_section_headers (d
->handle
))
20153 else if (! process_section_contents (d
->handle
))
20157 /* The file handles are closed by the call to free_debug_memory() below. */
20160 if (! process_notes (filedata
))
20163 if (! process_gnu_liblist (filedata
))
20166 if (! process_arch_specific (filedata
))
20169 free (filedata
->program_headers
);
20170 filedata
->program_headers
= NULL
;
20172 free (filedata
->section_headers
);
20173 filedata
->section_headers
= NULL
;
20175 free (filedata
->string_table
);
20176 filedata
->string_table
= NULL
;
20177 filedata
->string_table_length
= 0;
20179 if (filedata
->dump_sects
!= NULL
)
20181 free (filedata
->dump_sects
);
20182 filedata
->dump_sects
= NULL
;
20183 filedata
->num_dump_sects
= 0;
20186 if (dynamic_strings
)
20188 free (dynamic_strings
);
20189 dynamic_strings
= NULL
;
20190 dynamic_strings_length
= 0;
20193 if (dynamic_symbols
)
20195 free (dynamic_symbols
);
20196 dynamic_symbols
= NULL
;
20197 num_dynamic_syms
= 0;
20200 if (dynamic_syminfo
)
20202 free (dynamic_syminfo
);
20203 dynamic_syminfo
= NULL
;
20206 if (dynamic_section
)
20208 free (dynamic_section
);
20209 dynamic_section
= NULL
;
20212 while (symtab_shndx_list
!= NULL
)
20214 elf_section_list
*next
= symtab_shndx_list
->next
;
20215 free (symtab_shndx_list
);
20216 symtab_shndx_list
= next
;
20219 if (section_headers_groups
)
20221 free (section_headers_groups
);
20222 section_headers_groups
= NULL
;
20225 if (section_groups
)
20227 struct group_list
* g
;
20228 struct group_list
* next
;
20230 for (i
= 0; i
< group_count
; i
++)
20232 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20239 free (section_groups
);
20240 section_groups
= NULL
;
20243 free_debug_memory ();
20248 /* Process an ELF archive.
20249 On entry the file is positioned just after the ARMAG string.
20250 Returns TRUE upon success, FALSE otherwise. */
20253 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20255 struct archive_info arch
;
20256 struct archive_info nested_arch
;
20258 bfd_boolean ret
= TRUE
;
20262 /* The ARCH structure is used to hold information about this archive. */
20263 arch
.file_name
= NULL
;
20265 arch
.index_array
= NULL
;
20266 arch
.sym_table
= NULL
;
20267 arch
.longnames
= NULL
;
20269 /* The NESTED_ARCH structure is used as a single-item cache of information
20270 about a nested archive (when members of a thin archive reside within
20271 another regular archive file). */
20272 nested_arch
.file_name
= NULL
;
20273 nested_arch
.file
= NULL
;
20274 nested_arch
.index_array
= NULL
;
20275 nested_arch
.sym_table
= NULL
;
20276 nested_arch
.longnames
= NULL
;
20278 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20279 filedata
->file_size
, is_thin_archive
,
20280 do_archive_index
) != 0)
20286 if (do_archive_index
)
20288 if (arch
.sym_table
== NULL
)
20289 error (_("%s: unable to dump the index as none was found\n"),
20290 filedata
->file_name
);
20293 unsigned long i
, l
;
20294 unsigned long current_pos
;
20296 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20297 "in the symbol table)\n"),
20298 filedata
->file_name
, (unsigned long) arch
.index_num
,
20301 current_pos
= ftell (filedata
->handle
);
20303 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20306 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20309 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20312 if (member_name
!= NULL
)
20314 char * qualified_name
20315 = make_qualified_name (&arch
, &nested_arch
,
20318 if (qualified_name
!= NULL
)
20320 printf (_("Contents of binary %s at offset "),
20322 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20324 free (qualified_name
);
20326 free (member_name
);
20330 if (l
>= arch
.sym_size
)
20332 error (_("%s: end of the symbol table reached "
20333 "before the end of the index\n"),
20334 filedata
->file_name
);
20338 /* PR 17531: file: 0b6630b2. */
20339 printf ("\t%.*s\n",
20340 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20341 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20344 if (arch
.uses_64bit_indices
)
20349 if (l
< arch
.sym_size
)
20351 error (ngettext ("%s: %ld byte remains in the symbol table, "
20352 "but without corresponding entries in "
20353 "the index table\n",
20354 "%s: %ld bytes remain in the symbol table, "
20355 "but without corresponding entries in "
20356 "the index table\n",
20357 arch
.sym_size
- l
),
20358 filedata
->file_name
, arch
.sym_size
- l
);
20362 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20364 error (_("%s: failed to seek back to start of object files "
20365 "in the archive\n"),
20366 filedata
->file_name
);
20372 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20373 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20374 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20375 && !do_section_groups
&& !do_dyn_syms
)
20377 ret
= TRUE
; /* Archive index only. */
20386 char * qualified_name
;
20388 /* Read the next archive header. */
20389 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20391 error (_("%s: failed to seek to next archive header\n"),
20396 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20397 if (got
!= sizeof arch
.arhdr
)
20401 /* PR 24049 - we cannot use filedata->file_name as this will
20402 have already been freed. */
20403 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20408 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20410 error (_("%s: did not find a valid archive header\n"),
20416 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20418 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20419 if (archive_file_size
& 01)
20420 ++archive_file_size
;
20422 name
= get_archive_member_name (&arch
, &nested_arch
);
20425 error (_("%s: bad archive file name\n"), arch
.file_name
);
20429 namelen
= strlen (name
);
20431 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20432 if (qualified_name
== NULL
)
20434 error (_("%s: bad archive file name\n"), arch
.file_name
);
20440 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20442 /* This is a proxy for an external member of a thin archive. */
20443 Filedata
* member_filedata
;
20444 char * member_file_name
= adjust_relative_path
20445 (filedata
->file_name
, name
, namelen
);
20448 if (member_file_name
== NULL
)
20450 free (qualified_name
);
20455 member_filedata
= open_file (member_file_name
);
20456 if (member_filedata
== NULL
)
20458 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20459 free (member_file_name
);
20460 free (qualified_name
);
20465 archive_file_offset
= arch
.nested_member_origin
;
20466 member_filedata
->file_name
= qualified_name
;
20468 if (! process_object (member_filedata
))
20471 close_file (member_filedata
);
20472 free (member_file_name
);
20474 else if (is_thin_archive
)
20476 Filedata thin_filedata
;
20478 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20480 /* PR 15140: Allow for corrupt thin archives. */
20481 if (nested_arch
.file
== NULL
)
20483 error (_("%s: contains corrupt thin archive: %s\n"),
20484 qualified_name
, name
);
20485 free (qualified_name
);
20492 /* This is a proxy for a member of a nested archive. */
20493 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20495 /* The nested archive file will have been opened and setup by
20496 get_archive_member_name. */
20497 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20499 error (_("%s: failed to seek to archive member.\n"),
20500 nested_arch
.file_name
);
20501 free (qualified_name
);
20506 thin_filedata
.handle
= nested_arch
.file
;
20507 thin_filedata
.file_name
= qualified_name
;
20509 if (! process_object (& thin_filedata
))
20515 archive_file_offset
= arch
.next_arhdr_offset
;
20516 filedata
->file_name
= qualified_name
;
20517 if (! process_object (filedata
))
20519 arch
.next_arhdr_offset
+= archive_file_size
;
20520 /* Stop looping with "negative" archive_file_size. */
20521 if (arch
.next_arhdr_offset
< archive_file_size
)
20522 arch
.next_arhdr_offset
= -1ul;
20525 free (qualified_name
);
20529 if (nested_arch
.file
!= NULL
)
20530 fclose (nested_arch
.file
);
20531 release_archive (&nested_arch
);
20532 release_archive (&arch
);
20538 process_file (char * file_name
)
20540 Filedata
* filedata
= NULL
;
20541 struct stat statbuf
;
20542 char armag
[SARMAG
];
20543 bfd_boolean ret
= TRUE
;
20545 if (stat (file_name
, &statbuf
) < 0)
20547 if (errno
== ENOENT
)
20548 error (_("'%s': No such file\n"), file_name
);
20550 error (_("Could not locate '%s'. System error message: %s\n"),
20551 file_name
, strerror (errno
));
20555 if (! S_ISREG (statbuf
.st_mode
))
20557 error (_("'%s' is not an ordinary file\n"), file_name
);
20561 filedata
= calloc (1, sizeof * filedata
);
20562 if (filedata
== NULL
)
20564 error (_("Out of memory allocating file data structure\n"));
20568 filedata
->file_name
= file_name
;
20569 filedata
->handle
= fopen (file_name
, "rb");
20570 if (filedata
->handle
== NULL
)
20572 error (_("Input file '%s' is not readable.\n"), file_name
);
20577 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20579 error (_("%s: Failed to read file's magic number\n"), file_name
);
20580 fclose (filedata
->handle
);
20585 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20587 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20589 if (! process_archive (filedata
, FALSE
))
20592 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20594 if ( ! process_archive (filedata
, TRUE
))
20599 if (do_archive_index
)
20600 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20603 rewind (filedata
->handle
);
20604 archive_file_size
= archive_file_offset
= 0;
20606 if (! process_object (filedata
))
20610 fclose (filedata
->handle
);
20611 free (filedata
->section_headers
);
20612 free (filedata
->program_headers
);
20613 free (filedata
->string_table
);
20614 free (filedata
->dump_sects
);
20617 free (ba_cache
.strtab
);
20618 ba_cache
.strtab
= NULL
;
20619 free (ba_cache
.symtab
);
20620 ba_cache
.symtab
= NULL
;
20621 ba_cache
.filedata
= NULL
;
20626 #ifdef SUPPORT_DISASSEMBLY
20627 /* Needed by the i386 disassembler. For extra credit, someone could
20628 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20632 print_address (unsigned int addr
, FILE * outfile
)
20634 fprintf (outfile
,"0x%8.8x", addr
);
20637 /* Needed by the i386 disassembler. */
20640 db_task_printsym (unsigned int addr
)
20642 print_address (addr
, stderr
);
20647 main (int argc
, char ** argv
)
20651 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20652 setlocale (LC_MESSAGES
, "");
20654 #if defined (HAVE_SETLOCALE)
20655 setlocale (LC_CTYPE
, "");
20657 bindtextdomain (PACKAGE
, LOCALEDIR
);
20658 textdomain (PACKAGE
);
20660 expandargv (&argc
, &argv
);
20662 cmdline
.file_name
= "<cmdline>";
20663 parse_args (& cmdline
, argc
, argv
);
20665 if (optind
< (argc
- 1))
20667 else if (optind
>= argc
)
20669 warn (_("Nothing to do.\n"));
20674 while (optind
< argc
)
20675 if (! process_file (argv
[optind
++]))
20678 if (cmdline
.dump_sects
!= NULL
)
20679 free (cmdline
.dump_sects
);
20681 free (dump_ctf_symtab_name
);
20682 free (dump_ctf_strtab_name
);
20683 free (dump_ctf_parent_name
);
20685 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;