1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2023 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 #if defined HAVE_MSGPACK
56 /* Define BFD64 here, even if our default architecture is 32 bit ELF
57 as this will allow us to read in and parse 64bit and 32bit ELF files. */
63 #include "demanguse.h"
66 #include "sframe-api.h"
69 #include "elf/common.h"
70 #include "elf/external.h"
71 #include "elf/internal.h"
74 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
75 we can obtain the H8 reloc numbers. We need these for the
76 get_reloc_size() function. We include h8.h again after defining
77 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
82 /* Undo the effects of #including reloc-macros.h. */
84 #undef START_RELOC_NUMBERS
88 #undef END_RELOC_NUMBERS
89 #undef _RELOC_MACROS_H
91 /* The following headers use the elf/reloc-macros.h file to
92 automatically generate relocation recognition functions
93 such as elf_mips_reloc_type() */
95 #define RELOC_MACROS_GEN_FUNC
97 #include "elf/aarch64.h"
98 #include "elf/alpha.h"
99 #include "elf/amdgpu.h"
103 #include "elf/bfin.h"
104 #include "elf/cr16.h"
105 #include "elf/cris.h"
107 #include "elf/csky.h"
108 #include "elf/d10v.h"
109 #include "elf/d30v.h"
112 #include "elf/epiphany.h"
113 #include "elf/fr30.h"
115 #include "elf/ft32.h"
117 #include "elf/hppa.h"
118 #include "elf/i386.h"
119 #include "elf/i370.h"
120 #include "elf/i860.h"
121 #include "elf/i960.h"
122 #include "elf/ia64.h"
123 #include "elf/ip2k.h"
125 #include "elf/lm32.h"
126 #include "elf/iq2000.h"
127 #include "elf/m32c.h"
128 #include "elf/m32r.h"
129 #include "elf/m68k.h"
130 #include "elf/m68hc11.h"
131 #include "elf/s12z.h"
132 #include "elf/mcore.h"
134 #include "elf/metag.h"
135 #include "elf/microblaze.h"
136 #include "elf/mips.h"
137 #include "elf/mmix.h"
138 #include "elf/mn10200.h"
139 #include "elf/mn10300.h"
140 #include "elf/moxie.h"
142 #include "elf/msp430.h"
143 #include "elf/nds32.h"
145 #include "elf/nios2.h"
146 #include "elf/or1k.h"
149 #include "elf/ppc64.h"
151 #include "elf/riscv.h"
152 #include "elf/rl78.h"
154 #include "elf/s390.h"
155 #include "elf/score.h"
157 #include "elf/sparc.h"
159 #include "elf/tic6x.h"
160 #include "elf/tilegx.h"
161 #include "elf/tilepro.h"
162 #include "elf/v850.h"
164 #include "elf/visium.h"
165 #include "elf/wasm32.h"
166 #include "elf/x86-64.h"
167 #include "elf/xgate.h"
168 #include "elf/xstormy16.h"
169 #include "elf/xtensa.h"
171 #include "elf/loongarch.h"
175 #include "libiberty.h"
176 #include "safe-ctype.h"
177 #include "filenames.h"
180 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
183 typedef struct elf_section_list
185 Elf_Internal_Shdr
* hdr
;
186 struct elf_section_list
* next
;
189 /* Flag bits indicating particular types of dump. */
190 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
191 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
192 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
193 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
194 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
195 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
196 #define SFRAME_DUMP (1 << 6) /* The --sframe command line switch. */
198 typedef unsigned char dump_type
;
200 /* A linked list of the section names for which dumps were requested. */
201 struct dump_list_entry
205 struct dump_list_entry
* next
;
208 /* A dynamic array of flags indicating for which sections a dump
209 has been requested via command line switches. */
212 dump_type
* dump_sects
;
213 unsigned int num_dump_sects
;
216 static struct dump_data cmdline
;
218 static struct dump_list_entry
* dump_sects_byname
;
220 char * program_name
= "readelf";
222 static bool show_name
= false;
223 static bool do_dynamic
= false;
224 static bool do_syms
= false;
225 static bool do_dyn_syms
= false;
226 static bool do_lto_syms
= false;
227 static bool do_reloc
= false;
228 static bool do_sections
= false;
229 static bool do_section_groups
= false;
230 static bool do_section_details
= false;
231 static bool do_segments
= false;
232 static bool do_unwind
= false;
233 static bool do_using_dynamic
= false;
234 static bool do_header
= false;
235 static bool do_dump
= false;
236 static bool do_version
= false;
237 static bool do_histogram
= false;
238 static bool do_debugging
= false;
239 static bool do_ctf
= false;
240 static bool do_sframe
= false;
241 static bool do_arch
= false;
242 static bool do_notes
= false;
243 static bool do_archive_index
= false;
244 static bool check_all
= false;
245 static bool is_32bit_elf
= false;
246 static bool decompress_dumps
= false;
247 static bool do_not_show_symbol_truncation
= false;
248 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
249 static bool process_links
= false;
250 static bool dump_any_debugging
= false;
251 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
252 static int sym_base
= 0;
254 static char *dump_ctf_parent_name
;
255 static char *dump_ctf_symtab_name
;
256 static char *dump_ctf_strtab_name
;
260 struct group_list
* next
;
261 unsigned int section_index
;
266 struct group_list
* root
;
267 unsigned int group_index
;
270 typedef struct filedata
272 const char * file_name
;
276 Elf_Internal_Ehdr file_header
;
277 uint64_t archive_file_offset
;
278 uint64_t archive_file_size
;
279 /* Everything below this point is cleared out by free_filedata. */
280 Elf_Internal_Shdr
* section_headers
;
281 Elf_Internal_Phdr
* program_headers
;
283 uint64_t string_table_length
;
284 uint64_t dynamic_addr
;
285 uint64_t dynamic_size
;
286 uint64_t dynamic_nent
;
287 Elf_Internal_Dyn
* dynamic_section
;
288 Elf_Internal_Shdr
* dynamic_strtab_section
;
289 char * dynamic_strings
;
290 uint64_t dynamic_strings_length
;
291 Elf_Internal_Shdr
* dynamic_symtab_section
;
292 uint64_t num_dynamic_syms
;
293 Elf_Internal_Sym
* dynamic_symbols
;
294 uint64_t version_info
[16];
295 unsigned int dynamic_syminfo_nent
;
296 Elf_Internal_Syminfo
* dynamic_syminfo
;
297 uint64_t dynamic_syminfo_offset
;
302 uint64_t ngnubuckets
;
304 uint64_t * gnubuckets
;
305 uint64_t * gnuchains
;
308 char * program_interpreter
;
309 uint64_t dynamic_info
[DT_RELRENT
+ 1];
310 uint64_t dynamic_info_DT_GNU_HASH
;
311 uint64_t dynamic_info_DT_MIPS_XHASH
;
312 elf_section_list
* symtab_shndx_list
;
314 struct group
* section_groups
;
315 struct group
** section_headers_groups
;
316 /* A dynamic array of flags indicating for which sections a dump of
317 some kind has been requested. It is reset on a per-object file
318 basis and then initialised from the cmdline_dump_sects array,
319 the results of interpreting the -w switch, and the
320 dump_sects_byname list. */
321 struct dump_data dump
;
324 /* How to print a vma value. */
325 typedef enum print_mode
342 typedef enum unicode_display_type
350 } unicode_display_type
;
352 static unicode_display_type unicode_display
= unicode_default
;
362 /* Versioned symbol info. */
363 enum versioned_symbol_info
371 fseek64 (FILE *stream
, int64_t offset
, int whence
)
373 #if defined (HAVE_FSEEKO64)
380 return fseeko64 (stream
, o
, whence
);
381 #elif defined (HAVE_FSEEKO)
388 return fseeko (stream
, o
, whence
);
396 return fseek (stream
, o
, whence
);
400 static const char * get_symbol_version_string
401 (Filedata
*, bool, const char *, size_t, unsigned,
402 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
406 static inline const char *
407 section_name (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
409 return filedata
->string_table
+ hdr
->sh_name
;
413 section_name_valid (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
416 && filedata
->string_table
!= NULL
417 && hdr
->sh_name
< filedata
->string_table_length
);
420 static inline const char *
421 section_name_print (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
425 if (filedata
->string_table
== NULL
)
426 return _("<no-strings>");
427 if (hdr
->sh_name
>= filedata
->string_table_length
)
428 return _("<corrupt>");
429 return section_name (filedata
, hdr
);
432 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
435 valid_symbol_name (const char *strtab
, size_t strtab_size
, uint64_t offset
)
437 return strtab
!= NULL
&& offset
< strtab_size
;
441 valid_dynamic_name (const Filedata
*filedata
, uint64_t offset
)
443 return valid_symbol_name (filedata
->dynamic_strings
,
444 filedata
->dynamic_strings_length
, offset
);
447 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
448 already been called and verified that the string exists. */
449 static inline const char *
450 get_dynamic_name (const Filedata
*filedata
, size_t offset
)
452 return filedata
->dynamic_strings
+ offset
;
455 #define REMOVE_ARCH_BITS(ADDR) \
458 if (filedata->file_header.e_machine == EM_ARM) \
463 /* Get the correct GNU hash section name. */
464 #define GNU_HASH_SECTION_NAME(filedata) \
465 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
467 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
468 OFFSET + the offset of the current archive member, if we are examining an
469 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
470 allocate a buffer using malloc and fill that. In either case return the
471 pointer to the start of the retrieved data or NULL if something went wrong.
472 If something does go wrong and REASON is not NULL then emit an error
473 message using REASON as part of the context. */
484 uint64_t amt
= size
* nmemb
;
486 if (size
== 0 || nmemb
== 0)
489 /* If size_t is smaller than uint64_t, eg because you are building
490 on a 32-bit host, then make sure that when the sizes are cast to
491 size_t no information is lost. */
492 if ((size_t) size
!= size
493 || (size_t) nmemb
!= nmemb
494 || (size_t) amt
!= amt
495 || amt
/ size
!= nmemb
496 || (size_t) amt
+ 1 == 0)
499 error (_("Size overflow prevents reading %" PRIu64
500 " elements of size %" PRIu64
" for %s\n"),
501 nmemb
, size
, reason
);
505 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
506 attempting to allocate memory when the read is bound to fail. */
507 if (filedata
->archive_file_offset
> filedata
->file_size
508 || offset
> filedata
->file_size
- filedata
->archive_file_offset
509 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
512 error (_("Reading %" PRIu64
" bytes extends past end of file for %s\n"),
517 if (fseek64 (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
521 error (_("Unable to seek to %#" PRIx64
" for %s\n"),
522 filedata
->archive_file_offset
+ offset
, reason
);
529 /* + 1 so that we can '\0' terminate invalid string table sections. */
530 mvar
= malloc ((size_t) amt
+ 1);
535 error (_("Out of memory allocating %" PRIu64
" bytes for %s\n"),
540 ((char *) mvar
)[amt
] = '\0';
543 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
546 error (_("Unable to read in %" PRIu64
" bytes of %s\n"),
556 /* Print a VMA value in the MODE specified.
557 Returns the number of characters displayed. */
560 print_vma (uint64_t vma
, print_mode mode
)
571 return nc
+ printf ("%16.16" PRIx64
, vma
);
572 return nc
+ printf ("%8.8" PRIx64
, vma
);
576 return printf ("%5" PRId64
, vma
);
582 return nc
+ printf ("%" PRIx64
, vma
);
588 return nc
+ printf ("%05" PRIx64
, vma
);
591 return printf ("%" PRId64
, vma
);
594 return printf ("%" PRIu64
, vma
);
597 return printf ("%5" PRIu64
, vma
);
600 return printf ("%" PRIo64
, vma
);
603 return printf ("%5" PRIo64
, vma
);
606 /* FIXME: Report unrecognised mode ? */
612 /* Display a symbol on stdout. Handles the display of control characters and
613 multibye characters (assuming the host environment supports them).
615 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
617 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
618 abs(WIDTH) - 5 characters followed by "[...]".
620 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
621 padding as necessary.
623 Returns the number of emitted characters. */
626 print_symbol (signed int width
, const char * symbol
)
628 bool extra_padding
= false;
629 bool do_dots
= false;
630 signed int num_printed
= 0;
631 #ifdef HAVE_MBSTATE_T
634 unsigned int width_remaining
;
635 const void * alloced_symbol
= NULL
;
639 /* Keep the width positive. This helps the code below. */
641 extra_padding
= true;
647 /* Set the remaining width to a very large value.
648 This simplifies the code below. */
649 width_remaining
= INT_MAX
;
652 width_remaining
= width
;
653 if (! do_not_show_symbol_truncation
654 && (int) strlen (symbol
) > width
)
656 width_remaining
-= 5;
657 if ((int) width_remaining
< 0)
663 #ifdef HAVE_MBSTATE_T
664 /* Initialise the multibyte conversion state. */
665 memset (& state
, 0, sizeof (state
));
668 if (do_demangle
&& *symbol
)
670 const char * res
= cplus_demangle (symbol
, demangle_flags
);
673 alloced_symbol
= symbol
= res
;
676 while (width_remaining
)
679 const char c
= *symbol
++;
690 else if (ISCNTRL (c
))
692 /* Do not print control characters directly as they can affect terminal
693 settings. Such characters usually appear in the names generated
694 by the assembler for local labels. */
696 if (width_remaining
< 2)
699 printf ("^%c", c
+ 0x40);
700 width_remaining
-= 2;
705 if (width_remaining
< 5)
708 width_remaining
-= 5;
711 else if (unicode_display
!= unicode_locale
712 && unicode_display
!= unicode_default
)
714 /* Display unicode characters as something else. */
715 unsigned char bytes
[4];
728 bytes
[1] = *symbol
++;
730 if ((bytes
[1] & 0xc0) != 0x80)
733 /* Do not consume this character. It may only
734 be the first byte in the sequence that was
739 else if ((bytes
[0] & 0x20) == 0)
746 bytes
[2] = *symbol
++;
748 if ((bytes
[2] & 0xc0) != 0x80)
754 else if ((bytes
[0] & 0x10) == 0)
761 bytes
[3] = *symbol
++;
765 if ((bytes
[3] & 0xc0) != 0x80)
777 if (unicode_display
== unicode_invalid
)
780 if (unicode_display
== unicode_hex
|| ! is_utf8
)
784 if (width_remaining
< (nbytes
* 2) + 2)
787 putchar (is_utf8
? '<' : '{');
789 for (i
= 0; i
< nbytes
; i
++)
790 printf ("%02x", bytes
[i
]);
791 putchar (is_utf8
? '>' : '}');
795 if (unicode_display
== unicode_highlight
&& isatty (1))
796 printf ("\x1B[31;47m"); /* Red. */
801 if (width_remaining
< 6)
803 printf ("\\u%02x%02x",
804 (bytes
[0] & 0x1c) >> 2,
805 ((bytes
[0] & 0x03) << 6) | (bytes
[1] & 0x3f));
808 if (width_remaining
< 6)
810 printf ("\\u%02x%02x",
811 ((bytes
[0] & 0x0f) << 4) | ((bytes
[1] & 0x3c) >> 2),
812 ((bytes
[1] & 0x03) << 6) | (bytes
[2] & 0x3f));
815 if (width_remaining
< 8)
817 printf ("\\u%02x%02x%02x",
818 ((bytes
[0] & 0x07) << 6) | ((bytes
[1] & 0x3c) >> 2),
819 ((bytes
[1] & 0x03) << 6) | ((bytes
[2] & 0x3c) >> 2),
820 ((bytes
[2] & 0x03) << 6) | (bytes
[3] & 0x3f));
828 if (unicode_display
== unicode_highlight
&& isatty (1))
829 printf ("\033[0m"); /* Default colour. */
832 if (bytes
[nbytes
- 1] == 0)
837 #ifdef HAVE_MBSTATE_T
840 /* Let printf do the hard work of displaying multibyte characters. */
841 printf ("%.1s", symbol
- 1);
845 #ifdef HAVE_MBSTATE_T
846 /* Try to find out how many bytes made up the character that was
847 just printed. Advance the symbol pointer past the bytes that
849 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
853 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
859 num_printed
+= printf ("[...]");
861 if (extra_padding
&& num_printed
< width
)
863 /* Fill in the remaining spaces. */
864 printf ("%-*s", width
- num_printed
, " ");
868 free ((void *) alloced_symbol
);
872 /* Returns a pointer to a static buffer containing a printable version of
873 the given section's name. Like print_symbol, except that it does not try
874 to print multibyte characters, it just interprets them as hex values. */
877 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
879 #define MAX_PRINT_SEC_NAME_LEN 256
880 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
881 const char * name
= section_name_print (filedata
, sec
);
882 char * buf
= sec_name_buf
;
884 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
886 while ((c
= * name
++) != 0)
897 else if (ISPRINT (c
))
904 static char hex
[17] = "0123456789ABCDEF";
909 * buf
++ = hex
[(c
& 0xf0) >> 4];
910 * buf
++ = hex
[c
& 0x0f];
924 printable_section_name_from_index (Filedata
*filedata
, size_t ndx
)
926 if (ndx
>= filedata
->file_header
.e_shnum
)
927 return _("<corrupt>");
929 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
932 /* Return a pointer to section NAME, or NULL if no such section exists. */
934 static Elf_Internal_Shdr
*
935 find_section (Filedata
* filedata
, const char * name
)
939 if (filedata
->section_headers
== NULL
)
942 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
943 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
944 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
946 return filedata
->section_headers
+ i
;
951 /* Return a pointer to a section containing ADDR, or NULL if no such
954 static Elf_Internal_Shdr
*
955 find_section_by_address (Filedata
* filedata
, uint64_t addr
)
959 if (filedata
->section_headers
== NULL
)
962 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
964 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
966 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
973 static Elf_Internal_Shdr
*
974 find_section_by_type (Filedata
* filedata
, unsigned int type
)
978 if (filedata
->section_headers
== NULL
)
981 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
983 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
985 if (sec
->sh_type
== type
)
992 /* Return a pointer to section NAME, or NULL if no such section exists,
993 restricted to the list of sections given in SET. */
995 static Elf_Internal_Shdr
*
996 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
1000 if (filedata
->section_headers
== NULL
)
1005 while ((i
= *set
++) > 0)
1007 /* See PR 21156 for a reproducer. */
1008 if (i
>= filedata
->file_header
.e_shnum
)
1009 continue; /* FIXME: Should we issue an error message ? */
1011 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1012 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1014 return filedata
->section_headers
+ i
;
1018 return find_section (filedata
, name
);
1021 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
1022 This OS has so many departures from the ELF standard that we test it at
1026 is_ia64_vms (Filedata
* filedata
)
1028 return filedata
->file_header
.e_machine
== EM_IA_64
1029 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
1032 /* Guess the relocation size commonly used by the specific machines. */
1035 guess_is_rela (unsigned int e_machine
)
1039 /* Targets that use REL relocations. */
1045 case EM_CYGNUS_D10V
:
1048 case EM_MIPS_RS3_LE
:
1049 case EM_CYGNUS_M32R
:
1056 /* Targets that use RELA relocations. */
1060 case EM_ADAPTEVA_EPIPHANY
:
1062 case EM_ALTERA_NIOS2
:
1064 case EM_ARC_COMPACT
:
1065 case EM_ARC_COMPACT2
:
1066 case EM_ARC_COMPACT3
:
1067 case EM_ARC_COMPACT3_64
:
1076 case EM_CYGNUS_D30V
:
1079 case EM_CYGNUS_FR30
:
1089 case EM_LATTICEMICO32
:
1098 case EM_CYGNUS_MN10200
:
1100 case EM_CYGNUS_MN10300
:
1118 case EM_SPARC32PLUS
:
1126 case EM_CYGNUS_V850
:
1136 case EM_MICROBLAZE_OLD
:
1137 case EM_WEBASSEMBLY
:
1158 warn (_("Don't know about relocations on this machine architecture\n"));
1163 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1164 Returns TRUE upon success, FALSE otherwise. If successful then a
1165 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
1166 and the number of relocs loaded is placed in *NRELASP. It is the caller's
1167 responsibility to free the allocated buffer. */
1170 slurp_rela_relocs (Filedata
*filedata
,
1171 uint64_t rel_offset
,
1173 Elf_Internal_Rela
**relasp
,
1176 Elf_Internal_Rela
* relas
;
1182 Elf32_External_Rela
* erelas
;
1184 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1185 rel_size
, _("32-bit relocation data"));
1189 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1191 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1192 sizeof (Elf_Internal_Rela
));
1197 error (_("out of memory parsing relocs\n"));
1201 for (i
= 0; i
< nrelas
; i
++)
1203 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1204 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1205 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1212 Elf64_External_Rela
* erelas
;
1214 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1215 rel_size
, _("64-bit relocation data"));
1219 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1221 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1222 sizeof (Elf_Internal_Rela
));
1227 error (_("out of memory parsing relocs\n"));
1231 for (i
= 0; i
< nrelas
; i
++)
1233 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1234 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1235 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1237 if (filedata
->file_header
.e_machine
== EM_MIPS
1238 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1240 /* In little-endian objects, r_info isn't really a
1241 64-bit little-endian value: it has a 32-bit
1242 little-endian symbol index followed by four
1243 individual byte fields. Reorder INFO
1245 uint64_t inf
= relas
[i
].r_info
;
1246 inf
= (((inf
& 0xffffffff) << 32)
1247 | ((inf
>> 56) & 0xff)
1248 | ((inf
>> 40) & 0xff00)
1249 | ((inf
>> 24) & 0xff0000)
1250 | ((inf
>> 8) & 0xff000000));
1251 relas
[i
].r_info
= inf
;
1263 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1264 Returns TRUE upon success, FALSE otherwise. If successful then a
1265 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1266 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1267 responsibility to free the allocated buffer. */
1270 slurp_rel_relocs (Filedata
*filedata
,
1271 uint64_t rel_offset
,
1273 Elf_Internal_Rela
**relsp
,
1276 Elf_Internal_Rela
* rels
;
1282 Elf32_External_Rel
* erels
;
1284 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1285 rel_size
, _("32-bit relocation data"));
1289 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1291 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1296 error (_("out of memory parsing relocs\n"));
1300 for (i
= 0; i
< nrels
; i
++)
1302 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1303 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1304 rels
[i
].r_addend
= 0;
1311 Elf64_External_Rel
* erels
;
1313 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1314 rel_size
, _("64-bit relocation data"));
1318 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1320 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1325 error (_("out of memory parsing relocs\n"));
1329 for (i
= 0; i
< nrels
; i
++)
1331 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1332 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1333 rels
[i
].r_addend
= 0;
1335 if (filedata
->file_header
.e_machine
== EM_MIPS
1336 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1338 /* In little-endian objects, r_info isn't really a
1339 64-bit little-endian value: it has a 32-bit
1340 little-endian symbol index followed by four
1341 individual byte fields. Reorder INFO
1343 uint64_t inf
= rels
[i
].r_info
;
1344 inf
= (((inf
& 0xffffffff) << 32)
1345 | ((inf
>> 56) & 0xff)
1346 | ((inf
>> 40) & 0xff00)
1347 | ((inf
>> 24) & 0xff0000)
1348 | ((inf
>> 8) & 0xff000000));
1349 rels
[i
].r_info
= inf
;
1362 slurp_relr_relocs (Filedata
*filedata
,
1363 uint64_t relr_offset
,
1369 size_t size
= 0, nentries
, i
;
1370 uint64_t base
= 0, addr
, entry
;
1372 relrs
= get_data (NULL
, filedata
, relr_offset
, 1, relr_size
,
1373 _("RELR relocation data"));
1378 nentries
= relr_size
/ sizeof (Elf32_External_Relr
);
1380 nentries
= relr_size
/ sizeof (Elf64_External_Relr
);
1381 for (i
= 0; i
< nentries
; i
++)
1384 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1386 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1387 if ((entry
& 1) == 0)
1390 while ((entry
>>= 1) != 0)
1391 if ((entry
& 1) == 1)
1395 *relrsp
= malloc (size
* sizeof (**relrsp
));
1396 if (*relrsp
== NULL
)
1399 error (_("out of memory parsing relocs\n"));
1404 for (i
= 0; i
< nentries
; i
++)
1406 const uint64_t entry_bytes
= is_32bit_elf
? 4 : 8;
1409 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1411 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1412 if ((entry
& 1) == 0)
1414 (*relrsp
)[size
++] = entry
;
1415 base
= entry
+ entry_bytes
;
1419 for (addr
= base
; (entry
>>= 1) != 0; addr
+= entry_bytes
)
1420 if ((entry
& 1) != 0)
1421 (*relrsp
)[size
++] = addr
;
1422 base
+= entry_bytes
* (entry_bytes
* CHAR_BIT
- 1);
1431 /* Returns the reloc type extracted from the reloc info field. */
1434 get_reloc_type (Filedata
* filedata
, uint64_t reloc_info
)
1437 return ELF32_R_TYPE (reloc_info
);
1439 switch (filedata
->file_header
.e_machine
)
1442 /* Note: We assume that reloc_info has already been adjusted for us. */
1443 return ELF64_MIPS_R_TYPE (reloc_info
);
1446 return ELF64_R_TYPE_ID (reloc_info
);
1449 return ELF64_R_TYPE (reloc_info
);
1453 /* Return the symbol index extracted from the reloc info field. */
1456 get_reloc_symindex (uint64_t reloc_info
)
1458 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1462 uses_msp430x_relocs (Filedata
* filedata
)
1465 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1466 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1467 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1468 /* TI compiler uses ELFOSABI_NONE. */
1469 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1472 /* Display the contents of the relocation data found at the specified
1476 dump_relocations (Filedata
*filedata
,
1477 uint64_t rel_offset
,
1479 Elf_Internal_Sym
*symtab
,
1483 relocation_type rel_type
,
1487 Elf_Internal_Rela
* rels
;
1490 if (rel_type
== reltype_unknown
)
1491 rel_type
= guess_is_rela (filedata
->file_header
.e_machine
) ? reltype_rela
: reltype_rel
;
1493 if (rel_type
== reltype_rela
)
1495 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1498 else if (rel_type
== reltype_rel
)
1500 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1503 else if (rel_type
== reltype_relr
)
1507 = is_32bit_elf
? "%08" PRIx64
"\n" : "%016" PRIx64
"\n";
1509 if (!slurp_relr_relocs (filedata
, rel_offset
, rel_size
, &relrs
,
1513 printf (ngettext (" %" PRIu64
" offset\n",
1514 " %" PRIu64
" offsets\n", rel_size
),
1516 for (i
= 0; i
< rel_size
; i
++)
1517 printf (format
, relrs
[i
]);
1524 if (rel_type
== reltype_rela
)
1527 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1529 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1534 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1536 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1541 if (rel_type
== reltype_rela
)
1544 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1546 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1551 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1553 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1557 for (i
= 0; i
< rel_size
; i
++)
1562 uint64_t symtab_index
;
1565 offset
= rels
[i
].r_offset
;
1566 inf
= rels
[i
].r_info
;
1568 type
= get_reloc_type (filedata
, inf
);
1569 symtab_index
= get_reloc_symindex (inf
);
1573 printf ("%8.8lx %8.8lx ",
1574 (unsigned long) offset
& 0xffffffff,
1575 (unsigned long) inf
& 0xffffffff);
1580 ? "%16.16" PRIx64
" %16.16" PRIx64
" "
1581 : "%12.12" PRIx64
" %12.12" PRIx64
" ",
1585 switch (filedata
->file_header
.e_machine
)
1592 rtype
= elf_aarch64_reloc_type (type
);
1596 case EM_CYGNUS_M32R
:
1597 rtype
= elf_m32r_reloc_type (type
);
1602 rtype
= elf_i386_reloc_type (type
);
1607 rtype
= elf_m68hc11_reloc_type (type
);
1611 rtype
= elf_s12z_reloc_type (type
);
1615 rtype
= elf_m68k_reloc_type (type
);
1619 rtype
= elf_i960_reloc_type (type
);
1624 rtype
= elf_avr_reloc_type (type
);
1627 case EM_OLD_SPARCV9
:
1628 case EM_SPARC32PLUS
:
1631 rtype
= elf_sparc_reloc_type (type
);
1635 rtype
= elf_spu_reloc_type (type
);
1639 rtype
= v800_reloc_type (type
);
1642 case EM_CYGNUS_V850
:
1643 rtype
= v850_reloc_type (type
);
1647 case EM_CYGNUS_D10V
:
1648 rtype
= elf_d10v_reloc_type (type
);
1652 case EM_CYGNUS_D30V
:
1653 rtype
= elf_d30v_reloc_type (type
);
1657 rtype
= elf_dlx_reloc_type (type
);
1661 rtype
= elf_sh_reloc_type (type
);
1665 case EM_CYGNUS_MN10300
:
1666 rtype
= elf_mn10300_reloc_type (type
);
1670 case EM_CYGNUS_MN10200
:
1671 rtype
= elf_mn10200_reloc_type (type
);
1675 case EM_CYGNUS_FR30
:
1676 rtype
= elf_fr30_reloc_type (type
);
1680 rtype
= elf_frv_reloc_type (type
);
1684 rtype
= elf_csky_reloc_type (type
);
1688 rtype
= elf_ft32_reloc_type (type
);
1692 rtype
= elf_mcore_reloc_type (type
);
1696 rtype
= elf_mmix_reloc_type (type
);
1700 rtype
= elf_moxie_reloc_type (type
);
1704 if (uses_msp430x_relocs (filedata
))
1706 rtype
= elf_msp430x_reloc_type (type
);
1711 rtype
= elf_msp430_reloc_type (type
);
1715 rtype
= elf_nds32_reloc_type (type
);
1719 rtype
= elf_ppc_reloc_type (type
);
1723 rtype
= elf_ppc64_reloc_type (type
);
1727 case EM_MIPS_RS3_LE
:
1728 rtype
= elf_mips_reloc_type (type
);
1732 rtype
= elf_riscv_reloc_type (type
);
1736 rtype
= elf_alpha_reloc_type (type
);
1740 rtype
= elf_arm_reloc_type (type
);
1744 case EM_ARC_COMPACT
:
1745 case EM_ARC_COMPACT2
:
1746 case EM_ARC_COMPACT3
:
1747 case EM_ARC_COMPACT3_64
:
1748 rtype
= elf_arc_reloc_type (type
);
1752 rtype
= elf_hppa_reloc_type (type
);
1758 rtype
= elf_h8_reloc_type (type
);
1762 rtype
= elf_or1k_reloc_type (type
);
1767 rtype
= elf_pj_reloc_type (type
);
1770 rtype
= elf_ia64_reloc_type (type
);
1774 rtype
= elf_kvx_reloc_type (type
);
1778 rtype
= elf_cris_reloc_type (type
);
1782 rtype
= elf_i860_reloc_type (type
);
1788 rtype
= elf_x86_64_reloc_type (type
);
1792 rtype
= i370_reloc_type (type
);
1797 rtype
= elf_s390_reloc_type (type
);
1801 rtype
= elf_score_reloc_type (type
);
1805 rtype
= elf_xstormy16_reloc_type (type
);
1809 rtype
= elf_crx_reloc_type (type
);
1813 rtype
= elf_vax_reloc_type (type
);
1817 rtype
= elf_visium_reloc_type (type
);
1821 rtype
= elf_bpf_reloc_type (type
);
1824 case EM_ADAPTEVA_EPIPHANY
:
1825 rtype
= elf_epiphany_reloc_type (type
);
1830 rtype
= elf_ip2k_reloc_type (type
);
1834 rtype
= elf_iq2000_reloc_type (type
);
1839 rtype
= elf_xtensa_reloc_type (type
);
1842 case EM_LATTICEMICO32
:
1843 rtype
= elf_lm32_reloc_type (type
);
1848 rtype
= elf_m32c_reloc_type (type
);
1852 rtype
= elf_mt_reloc_type (type
);
1856 rtype
= elf_bfin_reloc_type (type
);
1860 rtype
= elf_mep_reloc_type (type
);
1864 rtype
= elf_cr16_reloc_type (type
);
1868 case EM_MICROBLAZE_OLD
:
1869 rtype
= elf_microblaze_reloc_type (type
);
1873 rtype
= elf_rl78_reloc_type (type
);
1877 rtype
= elf_rx_reloc_type (type
);
1881 rtype
= elf_metag_reloc_type (type
);
1885 rtype
= elf_tic6x_reloc_type (type
);
1889 rtype
= elf_tilegx_reloc_type (type
);
1893 rtype
= elf_tilepro_reloc_type (type
);
1896 case EM_WEBASSEMBLY
:
1897 rtype
= elf_wasm32_reloc_type (type
);
1901 rtype
= elf_xgate_reloc_type (type
);
1904 case EM_ALTERA_NIOS2
:
1905 rtype
= elf_nios2_reloc_type (type
);
1909 rtype
= elf_pru_reloc_type (type
);
1913 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1914 rtype
= elf_nfp3200_reloc_type (type
);
1916 rtype
= elf_nfp_reloc_type (type
);
1920 rtype
= elf_z80_reloc_type (type
);
1924 rtype
= elf_loongarch_reloc_type (type
);
1928 rtype
= elf_amdgpu_reloc_type (type
);
1933 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1935 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1937 if (filedata
->file_header
.e_machine
== EM_ALPHA
1939 && streq (rtype
, "R_ALPHA_LITUSE")
1940 && rel_type
== reltype_rela
)
1942 switch (rels
[i
].r_addend
)
1944 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1945 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1946 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1947 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1948 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1949 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1950 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1951 default: rtype
= NULL
;
1955 printf (" (%s)", rtype
);
1959 printf (_("<unknown addend: %" PRIx64
">"),
1964 else if (symtab_index
)
1966 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1968 error (_(" bad symbol index: %08lx in reloc\n"),
1969 (unsigned long) symtab_index
);
1974 Elf_Internal_Sym
* psym
;
1975 const char * version_string
;
1976 enum versioned_symbol_info sym_info
;
1977 unsigned short vna_other
;
1979 psym
= symtab
+ symtab_index
;
1982 = get_symbol_version_string (filedata
, is_dynsym
,
1991 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1995 unsigned int width
= is_32bit_elf
? 8 : 14;
1997 /* Relocations against GNU_IFUNC symbols do not use the value
1998 of the symbol as the address to relocate against. Instead
1999 they invoke the function named by the symbol and use its
2000 result as the address for relocation.
2002 To indicate this to the user, do not display the value of
2003 the symbol in the "Symbols's Value" field. Instead show
2004 its name followed by () as a hint that the symbol is
2008 || psym
->st_name
== 0
2009 || psym
->st_name
>= strtablen
)
2012 name
= strtab
+ psym
->st_name
;
2014 len
= print_symbol (width
, name
);
2016 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2018 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
2022 print_vma (psym
->st_value
, LONG_HEX
);
2024 printf (is_32bit_elf
? " " : " ");
2027 if (psym
->st_name
== 0)
2029 const char * sec_name
= "<null>";
2032 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
2034 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
2035 && filedata
->section_headers
!= NULL
)
2036 sec_name
= section_name_print (filedata
,
2037 filedata
->section_headers
2039 else if (psym
->st_shndx
== SHN_ABS
)
2041 else if (psym
->st_shndx
== SHN_COMMON
)
2042 sec_name
= "COMMON";
2043 else if ((filedata
->file_header
.e_machine
== EM_MIPS
2044 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
2045 || (filedata
->file_header
.e_machine
== EM_TI_C6000
2046 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
2047 sec_name
= "SCOMMON";
2048 else if (filedata
->file_header
.e_machine
== EM_MIPS
2049 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
2050 sec_name
= "SUNDEF";
2051 else if ((filedata
->file_header
.e_machine
== EM_X86_64
2052 || filedata
->file_header
.e_machine
== EM_L1OM
2053 || filedata
->file_header
.e_machine
== EM_K1OM
)
2054 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
2055 sec_name
= "LARGE_COMMON";
2056 else if (filedata
->file_header
.e_machine
== EM_IA_64
2057 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
2058 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
2059 sec_name
= "ANSI_COM";
2060 else if (is_ia64_vms (filedata
)
2061 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
2062 sec_name
= "VMS_SYMVEC";
2065 sprintf (name_buf
, "<section 0x%x>",
2066 (unsigned int) psym
->st_shndx
);
2067 sec_name
= name_buf
;
2070 print_symbol (22, sec_name
);
2072 else if (strtab
== NULL
)
2073 printf (_("<string table index: %3ld>"), psym
->st_name
);
2074 else if (psym
->st_name
>= strtablen
)
2076 error (_("<corrupt string table index: %3ld>\n"),
2082 print_symbol (22, strtab
+ psym
->st_name
);
2084 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2088 if (rel_type
== reltype_rela
)
2090 uint64_t off
= rels
[i
].r_addend
;
2092 if ((int64_t) off
< 0)
2093 printf (" - %" PRIx64
, -off
);
2095 printf (" + %" PRIx64
, off
);
2099 else if (rel_type
== reltype_rela
)
2101 uint64_t off
= rels
[i
].r_addend
;
2103 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
2104 if ((int64_t) off
< 0)
2105 printf ("-%" PRIx64
, -off
);
2107 printf ("%" PRIx64
, off
);
2110 if (filedata
->file_header
.e_machine
== EM_SPARCV9
2112 && streq (rtype
, "R_SPARC_OLO10"))
2113 printf (" + %" PRIx64
, ELF64_R_TYPE_DATA (inf
));
2117 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
2119 uint64_t type2
= ELF64_MIPS_R_TYPE2 (inf
);
2120 uint64_t type3
= ELF64_MIPS_R_TYPE3 (inf
);
2121 const char * rtype2
= elf_mips_reloc_type (type2
);
2122 const char * rtype3
= elf_mips_reloc_type (type3
);
2124 printf (" Type2: ");
2127 printf (_("unrecognized: %-7lx"),
2128 (unsigned long) type2
& 0xffffffff);
2130 printf ("%-17.17s", rtype2
);
2132 printf ("\n Type3: ");
2135 printf (_("unrecognized: %-7lx"),
2136 (unsigned long) type3
& 0xffffffff);
2138 printf ("%-17.17s", rtype3
);
2150 get_aarch64_dynamic_type (unsigned long type
)
2154 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
2155 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
2156 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
2163 get_mips_dynamic_type (unsigned long type
)
2167 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
2168 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
2169 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
2170 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
2171 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
2172 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
2173 case DT_MIPS_MSYM
: return "MIPS_MSYM";
2174 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2175 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2176 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
2177 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
2178 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
2179 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
2180 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
2181 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
2182 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
2183 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
2184 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
2185 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
2186 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
2187 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
2188 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
2189 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
2190 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
2191 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
2192 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
2193 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
2194 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
2195 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
2196 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
2197 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2198 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
2199 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
2200 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
2201 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
2202 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2203 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
2204 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
2205 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
2206 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
2207 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
2208 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
2209 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
2210 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
2211 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
2212 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
2213 case DT_MIPS_XHASH
: return "MIPS_XHASH";
2220 get_sparc64_dynamic_type (unsigned long type
)
2224 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
2231 get_ppc_dynamic_type (unsigned long type
)
2235 case DT_PPC_GOT
: return "PPC_GOT";
2236 case DT_PPC_OPT
: return "PPC_OPT";
2243 get_ppc64_dynamic_type (unsigned long type
)
2247 case DT_PPC64_GLINK
: return "PPC64_GLINK";
2248 case DT_PPC64_OPD
: return "PPC64_OPD";
2249 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
2250 case DT_PPC64_OPT
: return "PPC64_OPT";
2257 get_parisc_dynamic_type (unsigned long type
)
2261 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
2262 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
2263 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
2264 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
2265 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
2266 case DT_HP_PREINIT
: return "HP_PREINIT";
2267 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
2268 case DT_HP_NEEDED
: return "HP_NEEDED";
2269 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
2270 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2271 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2272 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2273 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2274 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2275 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2276 case DT_HP_FILTERED
: return "HP_FILTERED";
2277 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2278 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2279 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2280 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2281 case DT_PLT
: return "PLT";
2282 case DT_PLT_SIZE
: return "PLT_SIZE";
2283 case DT_DLT
: return "DLT";
2284 case DT_DLT_SIZE
: return "DLT_SIZE";
2291 get_ia64_dynamic_type (unsigned long type
)
2295 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2296 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2297 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2298 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2299 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2300 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2301 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2302 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2303 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2304 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2305 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2306 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2307 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2308 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2309 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2310 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2311 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2312 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2313 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2314 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2315 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2316 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2317 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2318 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2319 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2320 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2321 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2322 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2323 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2324 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2325 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2332 get_solaris_section_type (unsigned long type
)
2336 case 0x6fffffee: return "SUNW_ancillary";
2337 case 0x6fffffef: return "SUNW_capchain";
2338 case 0x6ffffff0: return "SUNW_capinfo";
2339 case 0x6ffffff1: return "SUNW_symsort";
2340 case 0x6ffffff2: return "SUNW_tlssort";
2341 case 0x6ffffff3: return "SUNW_LDYNSYM";
2342 case 0x6ffffff4: return "SUNW_dof";
2343 case 0x6ffffff5: return "SUNW_cap";
2344 case 0x6ffffff6: return "SUNW_SIGNATURE";
2345 case 0x6ffffff7: return "SUNW_ANNOTATE";
2346 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2347 case 0x6ffffff9: return "SUNW_DEBUG";
2348 case 0x6ffffffa: return "SUNW_move";
2349 case 0x6ffffffb: return "SUNW_COMDAT";
2350 case 0x6ffffffc: return "SUNW_syminfo";
2351 case 0x6ffffffd: return "SUNW_verdef";
2352 case 0x6ffffffe: return "SUNW_verneed";
2353 case 0x6fffffff: return "SUNW_versym";
2354 case 0x70000000: return "SPARC_GOTDATA";
2355 default: return NULL
;
2360 get_alpha_dynamic_type (unsigned long type
)
2364 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2365 default: return NULL
;
2370 get_score_dynamic_type (unsigned long type
)
2374 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2375 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2376 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2377 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2378 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2379 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2380 default: return NULL
;
2385 get_tic6x_dynamic_type (unsigned long type
)
2389 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2390 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2391 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2392 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2393 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2394 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2395 default: return NULL
;
2400 get_nios2_dynamic_type (unsigned long type
)
2404 case DT_NIOS2_GP
: return "NIOS2_GP";
2405 default: return NULL
;
2410 get_solaris_dynamic_type (unsigned long type
)
2414 case 0x6000000d: return "SUNW_AUXILIARY";
2415 case 0x6000000e: return "SUNW_RTLDINF";
2416 case 0x6000000f: return "SUNW_FILTER";
2417 case 0x60000010: return "SUNW_CAP";
2418 case 0x60000011: return "SUNW_SYMTAB";
2419 case 0x60000012: return "SUNW_SYMSZ";
2420 case 0x60000013: return "SUNW_SORTENT";
2421 case 0x60000014: return "SUNW_SYMSORT";
2422 case 0x60000015: return "SUNW_SYMSORTSZ";
2423 case 0x60000016: return "SUNW_TLSSORT";
2424 case 0x60000017: return "SUNW_TLSSORTSZ";
2425 case 0x60000018: return "SUNW_CAPINFO";
2426 case 0x60000019: return "SUNW_STRPAD";
2427 case 0x6000001a: return "SUNW_CAPCHAIN";
2428 case 0x6000001b: return "SUNW_LDMACH";
2429 case 0x6000001d: return "SUNW_CAPCHAINENT";
2430 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2431 case 0x60000021: return "SUNW_PARENT";
2432 case 0x60000023: return "SUNW_ASLR";
2433 case 0x60000025: return "SUNW_RELAX";
2434 case 0x60000029: return "SUNW_NXHEAP";
2435 case 0x6000002b: return "SUNW_NXSTACK";
2437 case 0x70000001: return "SPARC_REGISTER";
2438 case 0x7ffffffd: return "AUXILIARY";
2439 case 0x7ffffffe: return "USED";
2440 case 0x7fffffff: return "FILTER";
2442 default: return NULL
;
2447 get_riscv_dynamic_type (unsigned long type
)
2451 case DT_RISCV_VARIANT_CC
: return "RISCV_VARIANT_CC";
2458 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2460 static char buff
[64];
2464 case DT_NULL
: return "NULL";
2465 case DT_NEEDED
: return "NEEDED";
2466 case DT_PLTRELSZ
: return "PLTRELSZ";
2467 case DT_PLTGOT
: return "PLTGOT";
2468 case DT_HASH
: return "HASH";
2469 case DT_STRTAB
: return "STRTAB";
2470 case DT_SYMTAB
: return "SYMTAB";
2471 case DT_RELA
: return "RELA";
2472 case DT_RELASZ
: return "RELASZ";
2473 case DT_RELAENT
: return "RELAENT";
2474 case DT_STRSZ
: return "STRSZ";
2475 case DT_SYMENT
: return "SYMENT";
2476 case DT_INIT
: return "INIT";
2477 case DT_FINI
: return "FINI";
2478 case DT_SONAME
: return "SONAME";
2479 case DT_RPATH
: return "RPATH";
2480 case DT_SYMBOLIC
: return "SYMBOLIC";
2481 case DT_REL
: return "REL";
2482 case DT_RELSZ
: return "RELSZ";
2483 case DT_RELENT
: return "RELENT";
2484 case DT_RELR
: return "RELR";
2485 case DT_RELRSZ
: return "RELRSZ";
2486 case DT_RELRENT
: return "RELRENT";
2487 case DT_PLTREL
: return "PLTREL";
2488 case DT_DEBUG
: return "DEBUG";
2489 case DT_TEXTREL
: return "TEXTREL";
2490 case DT_JMPREL
: return "JMPREL";
2491 case DT_BIND_NOW
: return "BIND_NOW";
2492 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2493 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2494 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2495 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2496 case DT_RUNPATH
: return "RUNPATH";
2497 case DT_FLAGS
: return "FLAGS";
2499 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2500 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2501 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2503 case DT_CHECKSUM
: return "CHECKSUM";
2504 case DT_PLTPADSZ
: return "PLTPADSZ";
2505 case DT_MOVEENT
: return "MOVEENT";
2506 case DT_MOVESZ
: return "MOVESZ";
2507 case DT_FEATURE
: return "FEATURE";
2508 case DT_POSFLAG_1
: return "POSFLAG_1";
2509 case DT_SYMINSZ
: return "SYMINSZ";
2510 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2512 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2513 case DT_CONFIG
: return "CONFIG";
2514 case DT_DEPAUDIT
: return "DEPAUDIT";
2515 case DT_AUDIT
: return "AUDIT";
2516 case DT_PLTPAD
: return "PLTPAD";
2517 case DT_MOVETAB
: return "MOVETAB";
2518 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2520 case DT_VERSYM
: return "VERSYM";
2522 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2523 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2524 case DT_RELACOUNT
: return "RELACOUNT";
2525 case DT_RELCOUNT
: return "RELCOUNT";
2526 case DT_FLAGS_1
: return "FLAGS_1";
2527 case DT_VERDEF
: return "VERDEF";
2528 case DT_VERDEFNUM
: return "VERDEFNUM";
2529 case DT_VERNEED
: return "VERNEED";
2530 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2532 case DT_AUXILIARY
: return "AUXILIARY";
2533 case DT_USED
: return "USED";
2534 case DT_FILTER
: return "FILTER";
2536 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2537 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2538 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2539 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2540 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2541 case DT_GNU_HASH
: return "GNU_HASH";
2542 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2545 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2547 const char * result
;
2549 switch (filedata
->file_header
.e_machine
)
2552 result
= get_aarch64_dynamic_type (type
);
2555 case EM_MIPS_RS3_LE
:
2556 result
= get_mips_dynamic_type (type
);
2559 result
= get_sparc64_dynamic_type (type
);
2562 result
= get_ppc_dynamic_type (type
);
2565 result
= get_ppc64_dynamic_type (type
);
2568 result
= get_ia64_dynamic_type (type
);
2571 result
= get_alpha_dynamic_type (type
);
2574 result
= get_score_dynamic_type (type
);
2577 result
= get_tic6x_dynamic_type (type
);
2579 case EM_ALTERA_NIOS2
:
2580 result
= get_nios2_dynamic_type (type
);
2583 result
= get_riscv_dynamic_type (type
);
2586 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2587 result
= get_solaris_dynamic_type (type
);
2596 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2598 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2599 || (filedata
->file_header
.e_machine
== EM_PARISC
2600 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2602 const char * result
;
2604 switch (filedata
->file_header
.e_machine
)
2607 result
= get_parisc_dynamic_type (type
);
2610 result
= get_ia64_dynamic_type (type
);
2613 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2614 result
= get_solaris_dynamic_type (type
);
2623 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2627 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2633 static bool get_program_headers (Filedata
*);
2634 static bool get_dynamic_section (Filedata
*);
2637 locate_dynamic_section (Filedata
*filedata
)
2639 uint64_t dynamic_addr
= 0;
2640 uint64_t dynamic_size
= 0;
2642 if (filedata
->file_header
.e_phnum
!= 0
2643 && get_program_headers (filedata
))
2645 Elf_Internal_Phdr
*segment
;
2648 for (i
= 0, segment
= filedata
->program_headers
;
2649 i
< filedata
->file_header
.e_phnum
;
2652 if (segment
->p_type
== PT_DYNAMIC
)
2654 dynamic_addr
= segment
->p_offset
;
2655 dynamic_size
= segment
->p_filesz
;
2657 if (filedata
->section_headers
!= NULL
)
2659 Elf_Internal_Shdr
*sec
;
2661 sec
= find_section (filedata
, ".dynamic");
2664 if (sec
->sh_size
== 0
2665 || sec
->sh_type
== SHT_NOBITS
)
2672 dynamic_addr
= sec
->sh_offset
;
2673 dynamic_size
= sec
->sh_size
;
2678 if (dynamic_addr
> filedata
->file_size
2679 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2688 filedata
->dynamic_addr
= dynamic_addr
;
2689 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2693 is_pie (Filedata
*filedata
)
2695 Elf_Internal_Dyn
*entry
;
2697 if (filedata
->dynamic_size
== 0)
2698 locate_dynamic_section (filedata
);
2699 if (filedata
->dynamic_size
<= 1)
2702 if (!get_dynamic_section (filedata
))
2705 for (entry
= filedata
->dynamic_section
;
2706 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
2709 if (entry
->d_tag
== DT_FLAGS_1
)
2711 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
2720 get_file_type (Filedata
*filedata
)
2722 unsigned e_type
= filedata
->file_header
.e_type
;
2723 static char buff
[64];
2727 case ET_NONE
: return _("NONE (None)");
2728 case ET_REL
: return _("REL (Relocatable file)");
2729 case ET_EXEC
: return _("EXEC (Executable file)");
2731 if (is_pie (filedata
))
2732 return _("DYN (Position-Independent Executable file)");
2734 return _("DYN (Shared object file)");
2735 case ET_CORE
: return _("CORE (Core file)");
2738 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2739 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2740 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2741 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2743 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2749 get_machine_name (unsigned e_machine
)
2751 static char buff
[64]; /* XXX */
2755 /* Please keep this switch table sorted by increasing EM_ value. */
2757 case EM_NONE
: return _("None");
2758 case EM_M32
: return "WE32100";
2759 case EM_SPARC
: return "Sparc";
2760 case EM_386
: return "Intel 80386";
2761 case EM_68K
: return "MC68000";
2762 case EM_88K
: return "MC88000";
2763 case EM_IAMCU
: return "Intel MCU";
2764 case EM_860
: return "Intel 80860";
2765 case EM_MIPS
: return "MIPS R3000";
2766 case EM_S370
: return "IBM System/370";
2768 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2769 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2770 case EM_PARISC
: return "HPPA";
2771 case EM_VPP550
: return "Fujitsu VPP500";
2772 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2773 case EM_960
: return "Intel 80960";
2774 case EM_PPC
: return "PowerPC";
2776 case EM_PPC64
: return "PowerPC64";
2778 case EM_S390
: return "IBM S/390";
2779 case EM_SPU
: return "SPU";
2781 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2782 case EM_FR20
: return "Fujitsu FR20";
2783 case EM_RH32
: return "TRW RH32";
2784 case EM_MCORE
: return "MCORE";
2786 case EM_ARM
: return "ARM";
2787 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2788 case EM_SH
: return "Renesas / SuperH SH";
2789 case EM_SPARCV9
: return "Sparc v9";
2790 case EM_TRICORE
: return "Siemens Tricore";
2791 case EM_ARC
: return "ARC";
2792 case EM_H8_300
: return "Renesas H8/300";
2793 case EM_H8_300H
: return "Renesas H8/300H";
2794 case EM_H8S
: return "Renesas H8S";
2795 case EM_H8_500
: return "Renesas H8/500";
2797 case EM_IA_64
: return "Intel IA-64";
2798 case EM_MIPS_X
: return "Stanford MIPS-X";
2799 case EM_COLDFIRE
: return "Motorola Coldfire";
2800 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2801 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2802 case EM_PCP
: return "Siemens PCP";
2803 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2804 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2805 case EM_STARCORE
: return "Motorola Star*Core processor";
2806 case EM_ME16
: return "Toyota ME16 processor";
2808 case EM_ST100
: return "STMicroelectronics ST100 processor";
2809 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2810 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2811 case EM_PDSP
: return "Sony DSP processor";
2812 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2813 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2814 case EM_FX66
: return "Siemens FX66 microcontroller";
2815 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2816 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2817 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2819 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2820 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2821 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2822 case EM_SVX
: return "Silicon Graphics SVx";
2823 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2824 case EM_VAX
: return "Digital VAX";
2825 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2826 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2827 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2828 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2830 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2831 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2832 case EM_PRISM
: return "Vitesse Prism";
2834 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2835 case EM_CYGNUS_FR30
:
2836 case EM_FR30
: return "Fujitsu FR30";
2837 case EM_CYGNUS_D10V
:
2838 case EM_D10V
: return "d10v";
2839 case EM_CYGNUS_D30V
:
2840 case EM_D30V
: return "d30v";
2841 case EM_CYGNUS_V850
:
2842 case EM_V850
: return "Renesas V850";
2843 case EM_CYGNUS_M32R
:
2844 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2845 case EM_CYGNUS_MN10300
:
2846 case EM_MN10300
: return "mn10300";
2848 case EM_CYGNUS_MN10200
:
2849 case EM_MN10200
: return "mn10200";
2850 case EM_PJ
: return "picoJava";
2851 case EM_OR1K
: return "OpenRISC 1000";
2852 case EM_ARC_COMPACT
: return "ARCompact";
2854 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2855 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2856 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2857 case EM_NS32K
: return "National Semiconductor 32000 series";
2858 case EM_TPC
: return "Tenor Network TPC processor";
2859 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2861 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2863 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2864 case EM_MAX
: return "MAX Processor";
2865 case EM_CR
: return "National Semiconductor CompactRISC";
2866 case EM_F2MC16
: return "Fujitsu F2MC16";
2867 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2868 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2869 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2870 case EM_SEP
: return "Sharp embedded microprocessor";
2871 case EM_ARCA
: return "Arca RISC microprocessor";
2873 case EM_UNICORE
: return "Unicore";
2874 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2875 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2876 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2877 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2878 case EM_XGATE
: return "Motorola XGATE embedded processor";
2880 case EM_XC16X
: return "Infineon Technologies xc16x";
2881 case EM_M16C
: return "Renesas M16C series microprocessors";
2882 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2883 case EM_CE
: return "Freescale Communication Engine RISC core";
2885 case EM_M32C
: return "Renesas M32c";
2887 case EM_TSK3000
: return "Altium TSK3000 core";
2888 case EM_RS08
: return "Freescale RS08 embedded processor";
2889 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2890 case EM_SCORE
: return "SUNPLUS S+Core";
2891 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2892 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2893 case EM_LATTICEMICO32
: return "Lattice Mico32";
2894 case EM_SE_C17
: return "Seiko Epson C17 family";
2896 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2897 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2898 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2899 case EM_TI_PRU
: return "TI PRU I/O processor";
2901 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2902 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2903 case EM_R32C
: return "Renesas R32C series microprocessors";
2904 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2905 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2906 case EM_8051
: return "Intel 8051 and variants";
2907 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2908 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2909 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2910 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2912 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2913 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2914 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2915 case EM_RX
: return "Renesas RX";
2916 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2917 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2918 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2921 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2922 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2923 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2925 case EM_L1OM
: return "Intel L1OM";
2926 case EM_K1OM
: return "Intel K1OM";
2927 case EM_INTEL182
: return "Intel (reserved)";
2928 case EM_AARCH64
: return "AArch64";
2929 case EM_ARM184
: return "ARM (reserved)";
2930 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2931 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2932 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2933 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2935 case EM_CUDA
: return "NVIDIA CUDA architecture";
2936 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2937 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2938 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2939 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2940 case EM_ARC_COMPACT2
: return "ARCv2";
2941 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2942 case EM_RL78
: return "Renesas RL78";
2943 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2944 case EM_78K0R
: return "Renesas 78K0R";
2946 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2947 case EM_BA1
: return "Beyond BA1 CPU architecture";
2948 case EM_BA2
: return "Beyond BA2 CPU architecture";
2949 case EM_XCORE
: return "XMOS xCORE processor family";
2950 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2951 case EM_INTELGT
: return "Intel Graphics Technology";
2953 case EM_KM32
: return "KM211 KM32 32-bit processor";
2954 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2955 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2956 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2957 case EM_KVARC
: return "KM211 KVARC processor";
2958 case EM_CDP
: return "Paneve CDP architecture family";
2959 case EM_COGE
: return "Cognitive Smart Memory Processor";
2960 case EM_COOL
: return "Bluechip Systems CoolEngine";
2961 case EM_NORC
: return "Nanoradio Optimized RISC";
2962 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2964 case EM_Z80
: return "Zilog Z80";
2965 case EM_VISIUM
: return "CDS VISIUMcore processor";
2966 case EM_FT32
: return "FTDI Chip FT32";
2967 case EM_MOXIE
: return "Moxie";
2968 case EM_AMDGPU
: return "AMD GPU";
2969 /* 230 (all reserved) */
2971 case EM_RISCV
: return "RISC-V";
2972 case EM_LANAI
: return "Lanai 32-bit processor";
2973 case EM_CEVA
: return "CEVA Processor Architecture Family";
2974 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2975 case EM_BPF
: return "Linux BPF";
2976 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2977 case EM_IMG1
: return "Imagination Technologies";
2979 case EM_NFP
: return "Netronome Flow Processor";
2980 case EM_VE
: return "NEC Vector Engine";
2981 case EM_CSKY
: return "C-SKY";
2982 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv3 64-bit processor";
2983 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2984 case EM_ARC_COMPACT3
: return "Synopsys ARCv3 32-bit processor";
2985 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2986 case EM_65816
: return "WDC 65816/65C816";
2987 case EM_LOONGARCH
: return "LoongArch";
2988 case EM_KF32
: return "ChipON KungFu32";
2990 /* Large numbers... */
2991 case EM_MT
: return "Morpho Techologies MT processor";
2992 case EM_ALPHA
: return "Alpha";
2993 case EM_WEBASSEMBLY
: return "Web Assembly";
2994 case EM_DLX
: return "OpenDLX";
2995 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2996 case EM_IQ2000
: return "Vitesse IQ2000";
2998 case EM_NIOS32
: return "Altera Nios";
2999 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
3000 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
3001 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
3002 case EM_S12Z
: return "Freescale S12Z";
3005 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
3011 decode_ARC_machine_flags (char *out
, unsigned e_flags
, unsigned e_machine
)
3013 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
3014 other compilers don't specify an architecture type in the e_flags, and
3015 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
3016 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
3019 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
3020 but also sets a specific architecture type in the e_flags field.
3022 However, when decoding the flags we don't worry if we see an
3023 unexpected pairing, for example EM_ARC_COMPACT machine type, with
3024 ARCEM architecture type. */
3026 switch (e_flags
& EF_ARC_MACH_MSK
)
3028 /* We only expect these to occur for EM_ARC_COMPACT2. */
3029 case EF_ARC_CPU_ARCV2EM
:
3030 out
= stpcpy (out
, ", ARC EM");
3032 case EF_ARC_CPU_ARCV2HS
:
3033 out
= stpcpy (out
, ", ARC HS");
3036 /* We only expect these to occur for EM_ARC_COMPACT. */
3037 case E_ARC_MACH_ARC600
:
3038 out
= stpcpy (out
, ", ARC600");
3040 case E_ARC_MACH_ARC601
:
3041 out
= stpcpy (out
, ", ARC601");
3043 case E_ARC_MACH_ARC700
:
3044 out
= stpcpy (out
, ", ARC700");
3047 /* The only times we should end up here are (a) A corrupt ELF, (b) A
3048 new ELF with new architecture being read by an old version of
3049 readelf, or (c) An ELF built with non-GNU compiler that does not
3050 set the architecture in the e_flags. */
3052 if (e_machine
== EM_ARC_COMPACT
)
3053 out
= stpcpy (out
, ", Unknown ARCompact");
3055 out
= stpcpy (out
, ", Unknown ARC");
3059 switch (e_flags
& EF_ARC_OSABI_MSK
)
3061 case E_ARC_OSABI_ORIG
:
3062 out
= stpcpy (out
, ", (ABI:legacy)");
3064 case E_ARC_OSABI_V2
:
3065 out
= stpcpy (out
, ", (ABI:v2)");
3067 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
3068 case E_ARC_OSABI_V3
:
3069 out
= stpcpy (out
, ", v3 no-legacy-syscalls ABI");
3071 case E_ARC_OSABI_V4
:
3072 out
= stpcpy (out
, ", v4 ABI");
3075 out
= stpcpy (out
, ", unrecognised ARC OSABI flag");
3082 decode_ARM_machine_flags (char *out
, unsigned e_flags
)
3085 bool unknown
= false;
3087 eabi
= EF_ARM_EABI_VERSION (e_flags
);
3088 e_flags
&= ~ EF_ARM_EABIMASK
;
3090 /* Handle "generic" ARM flags. */
3091 if (e_flags
& EF_ARM_RELEXEC
)
3093 out
= stpcpy (out
, ", relocatable executable");
3094 e_flags
&= ~ EF_ARM_RELEXEC
;
3097 if (e_flags
& EF_ARM_PIC
)
3099 out
= stpcpy (out
, ", position independent");
3100 e_flags
&= ~ EF_ARM_PIC
;
3103 /* Now handle EABI specific flags. */
3107 out
= stpcpy (out
, ", <unrecognized EABI>");
3112 case EF_ARM_EABI_VER1
:
3113 out
= stpcpy (out
, ", Version1 EABI");
3118 /* Process flags one bit at a time. */
3119 flag
= e_flags
& - e_flags
;
3124 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3125 out
= stpcpy (out
, ", sorted symbol tables");
3135 case EF_ARM_EABI_VER2
:
3136 out
= stpcpy (out
, ", Version2 EABI");
3141 /* Process flags one bit at a time. */
3142 flag
= e_flags
& - e_flags
;
3147 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3148 out
= stpcpy (out
, ", sorted symbol tables");
3151 case EF_ARM_DYNSYMSUSESEGIDX
:
3152 out
= stpcpy (out
, ", dynamic symbols use segment index");
3155 case EF_ARM_MAPSYMSFIRST
:
3156 out
= stpcpy (out
, ", mapping symbols precede others");
3166 case EF_ARM_EABI_VER3
:
3167 out
= stpcpy (out
, ", Version3 EABI");
3170 case EF_ARM_EABI_VER4
:
3171 out
= stpcpy (out
, ", Version4 EABI");
3176 /* Process flags one bit at a time. */
3177 flag
= e_flags
& - e_flags
;
3183 out
= stpcpy (out
, ", BE8");
3187 out
= stpcpy (out
, ", LE8");
3197 case EF_ARM_EABI_VER5
:
3198 out
= stpcpy (out
, ", Version5 EABI");
3203 /* Process flags one bit at a time. */
3204 flag
= e_flags
& - e_flags
;
3210 out
= stpcpy (out
, ", BE8");
3214 out
= stpcpy (out
, ", LE8");
3217 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3218 out
= stpcpy (out
, ", soft-float ABI");
3221 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3222 out
= stpcpy (out
, ", hard-float ABI");
3232 case EF_ARM_EABI_UNKNOWN
:
3233 out
= stpcpy (out
, ", GNU EABI");
3238 /* Process flags one bit at a time. */
3239 flag
= e_flags
& - e_flags
;
3244 case EF_ARM_INTERWORK
:
3245 out
= stpcpy (out
, ", interworking enabled");
3248 case EF_ARM_APCS_26
:
3249 out
= stpcpy (out
, ", uses APCS/26");
3252 case EF_ARM_APCS_FLOAT
:
3253 out
= stpcpy (out
, ", uses APCS/float");
3257 out
= stpcpy (out
, ", position independent");
3261 out
= stpcpy (out
, ", 8 bit structure alignment");
3264 case EF_ARM_NEW_ABI
:
3265 out
= stpcpy (out
, ", uses new ABI");
3268 case EF_ARM_OLD_ABI
:
3269 out
= stpcpy (out
, ", uses old ABI");
3272 case EF_ARM_SOFT_FLOAT
:
3273 out
= stpcpy (out
, ", software FP");
3276 case EF_ARM_VFP_FLOAT
:
3277 out
= stpcpy (out
, ", VFP");
3280 case EF_ARM_MAVERICK_FLOAT
:
3281 out
= stpcpy (out
, ", Maverick FP");
3292 out
= stpcpy (out
,_(", <unknown>"));
3297 decode_AVR_machine_flags (char *out
, unsigned e_flags
)
3299 switch (e_flags
& EF_AVR_MACH
)
3301 case E_AVR_MACH_AVR1
:
3302 out
= stpcpy (out
, ", avr:1");
3304 case E_AVR_MACH_AVR2
:
3305 out
= stpcpy (out
, ", avr:2");
3307 case E_AVR_MACH_AVR25
:
3308 out
= stpcpy (out
, ", avr:25");
3310 case E_AVR_MACH_AVR3
:
3311 out
= stpcpy (out
, ", avr:3");
3313 case E_AVR_MACH_AVR31
:
3314 out
= stpcpy (out
, ", avr:31");
3316 case E_AVR_MACH_AVR35
:
3317 out
= stpcpy (out
, ", avr:35");
3319 case E_AVR_MACH_AVR4
:
3320 out
= stpcpy (out
, ", avr:4");
3322 case E_AVR_MACH_AVR5
:
3323 out
= stpcpy (out
, ", avr:5");
3325 case E_AVR_MACH_AVR51
:
3326 out
= stpcpy (out
, ", avr:51");
3328 case E_AVR_MACH_AVR6
:
3329 out
= stpcpy (out
, ", avr:6");
3331 case E_AVR_MACH_AVRTINY
:
3332 out
= stpcpy (out
, ", avr:100");
3334 case E_AVR_MACH_XMEGA1
:
3335 out
= stpcpy (out
, ", avr:101");
3337 case E_AVR_MACH_XMEGA2
:
3338 out
= stpcpy (out
, ", avr:102");
3340 case E_AVR_MACH_XMEGA3
:
3341 out
= stpcpy (out
, ", avr:103");
3343 case E_AVR_MACH_XMEGA4
:
3344 out
= stpcpy (out
, ", avr:104");
3346 case E_AVR_MACH_XMEGA5
:
3347 out
= stpcpy (out
, ", avr:105");
3349 case E_AVR_MACH_XMEGA6
:
3350 out
= stpcpy (out
, ", avr:106");
3352 case E_AVR_MACH_XMEGA7
:
3353 out
= stpcpy (out
, ", avr:107");
3356 out
= stpcpy (out
, ", avr:<unknown>");
3360 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3361 out
= stpcpy (out
, ", link-relax");
3366 decode_BLACKFIN_machine_flags (char *out
, unsigned e_flags
)
3368 if (e_flags
& EF_BFIN_PIC
)
3369 out
= stpcpy (out
, ", PIC");
3371 if (e_flags
& EF_BFIN_FDPIC
)
3372 out
= stpcpy (out
, ", FDPIC");
3374 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3375 out
= stpcpy (out
, ", code in L1");
3377 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3378 out
= stpcpy (out
, ", data in L1");
3383 decode_FRV_machine_flags (char *out
, unsigned e_flags
)
3385 switch (e_flags
& EF_FRV_CPU_MASK
)
3387 case EF_FRV_CPU_GENERIC
:
3391 out
= stpcpy (out
, ", fr???");
3394 case EF_FRV_CPU_FR300
:
3395 out
= stpcpy (out
, ", fr300");
3398 case EF_FRV_CPU_FR400
:
3399 out
= stpcpy (out
, ", fr400");
3401 case EF_FRV_CPU_FR405
:
3402 out
= stpcpy (out
, ", fr405");
3405 case EF_FRV_CPU_FR450
:
3406 out
= stpcpy (out
, ", fr450");
3409 case EF_FRV_CPU_FR500
:
3410 out
= stpcpy (out
, ", fr500");
3412 case EF_FRV_CPU_FR550
:
3413 out
= stpcpy (out
, ", fr550");
3416 case EF_FRV_CPU_SIMPLE
:
3417 out
= stpcpy (out
, ", simple");
3419 case EF_FRV_CPU_TOMCAT
:
3420 out
= stpcpy (out
, ", tomcat");
3427 decode_IA64_machine_flags (char *out
, unsigned e_flags
, Filedata
*filedata
)
3429 if ((e_flags
& EF_IA_64_ABI64
))
3430 out
= stpcpy (out
, ", 64-bit");
3432 out
= stpcpy (out
, ", 32-bit");
3433 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3434 out
= stpcpy (out
, ", reduced fp model");
3435 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3436 out
= stpcpy (out
, ", no function descriptors, constant gp");
3437 else if ((e_flags
& EF_IA_64_CONS_GP
))
3438 out
= stpcpy (out
, ", constant gp");
3439 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3440 out
= stpcpy (out
, ", absolute");
3441 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3443 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3444 out
= stpcpy (out
, ", vms_linkages");
3445 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3447 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3449 case EF_IA_64_VMS_COMCOD_WARNING
:
3450 out
= stpcpy (out
, ", warning");
3452 case EF_IA_64_VMS_COMCOD_ERROR
:
3453 out
= stpcpy (out
, ", error");
3455 case EF_IA_64_VMS_COMCOD_ABORT
:
3456 out
= stpcpy (out
, ", abort");
3459 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3460 e_flags
& EF_IA_64_VMS_COMCOD
);
3461 out
= stpcpy (out
, ", <unknown>");
3468 decode_LOONGARCH_machine_flags (char *out
, unsigned int e_flags
)
3470 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
3471 out
= stpcpy (out
, ", SOFT-FLOAT");
3472 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
3473 out
= stpcpy (out
, ", SINGLE-FLOAT");
3474 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
3475 out
= stpcpy (out
, ", DOUBLE-FLOAT");
3477 if (EF_LOONGARCH_IS_OBJ_V0 (e_flags
))
3478 out
= stpcpy (out
, ", OBJ-v0");
3479 else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags
))
3480 out
= stpcpy (out
, ", OBJ-v1");
3485 decode_M68K_machine_flags (char *out
, unsigned int e_flags
)
3487 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3488 out
= stpcpy (out
, ", m68000");
3489 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3490 out
= stpcpy (out
, ", cpu32");
3491 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3492 out
= stpcpy (out
, ", fido_a");
3495 char const *isa
= _("unknown");
3496 char const *mac
= _("unknown mac");
3497 char const *additional
= NULL
;
3499 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3501 case EF_M68K_CF_ISA_A_NODIV
:
3503 additional
= ", nodiv";
3505 case EF_M68K_CF_ISA_A
:
3508 case EF_M68K_CF_ISA_A_PLUS
:
3511 case EF_M68K_CF_ISA_B_NOUSP
:
3513 additional
= ", nousp";
3515 case EF_M68K_CF_ISA_B
:
3518 case EF_M68K_CF_ISA_C
:
3521 case EF_M68K_CF_ISA_C_NODIV
:
3523 additional
= ", nodiv";
3526 out
= stpcpy (out
, ", cf, isa ");
3527 out
= stpcpy (out
, isa
);
3529 out
= stpcpy (out
, additional
);
3530 if (e_flags
& EF_M68K_CF_FLOAT
)
3531 out
= stpcpy (out
, ", float");
3532 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3537 case EF_M68K_CF_MAC
:
3540 case EF_M68K_CF_EMAC
:
3543 case EF_M68K_CF_EMAC_B
:
3549 out
= stpcpy (out
, ", ");
3550 out
= stpcpy (out
, mac
);
3557 decode_MeP_machine_flags (char *out
, unsigned int e_flags
)
3559 switch (e_flags
& EF_MEP_CPU_MASK
)
3561 case EF_MEP_CPU_MEP
:
3562 out
= stpcpy (out
, ", generic MeP");
3565 out
= stpcpy (out
, ", MeP C2");
3568 out
= stpcpy (out
, ", MeP C3");
3571 out
= stpcpy (out
, ", MeP C4");
3574 out
= stpcpy (out
, ", MeP C5");
3577 out
= stpcpy (out
, ", MeP H1");
3580 out
= stpcpy (out
, _(", <unknown MeP cpu type>"));
3584 switch (e_flags
& EF_MEP_COP_MASK
)
3586 case EF_MEP_COP_NONE
:
3588 case EF_MEP_COP_AVC
:
3589 out
= stpcpy (out
, ", AVC coprocessor");
3591 case EF_MEP_COP_AVC2
:
3592 out
= stpcpy (out
, ", AVC2 coprocessor");
3594 case EF_MEP_COP_FMAX
:
3595 out
= stpcpy (out
, ", FMAX coprocessor");
3597 case EF_MEP_COP_IVC2
:
3598 out
= stpcpy (out
, ", IVC2 coprocessor");
3601 out
= stpcpy (out
, _("<unknown MeP copro type>"));
3605 if (e_flags
& EF_MEP_LIBRARY
)
3606 out
= stpcpy (out
, ", Built for Library");
3608 if (e_flags
& EF_MEP_INDEX_MASK
)
3609 out
+= sprintf (out
, ", Configuration Index: %#x",
3610 e_flags
& EF_MEP_INDEX_MASK
);
3612 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3613 out
+= sprintf (out
, _(", unknown flags bits: %#x"),
3614 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3619 decode_MIPS_machine_flags (char *out
, unsigned int e_flags
)
3621 if (e_flags
& EF_MIPS_NOREORDER
)
3622 out
= stpcpy (out
, ", noreorder");
3624 if (e_flags
& EF_MIPS_PIC
)
3625 out
= stpcpy (out
, ", pic");
3627 if (e_flags
& EF_MIPS_CPIC
)
3628 out
= stpcpy (out
, ", cpic");
3630 if (e_flags
& EF_MIPS_UCODE
)
3631 out
= stpcpy (out
, ", ugen_reserved");
3633 if (e_flags
& EF_MIPS_ABI2
)
3634 out
= stpcpy (out
, ", abi2");
3636 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3637 out
= stpcpy (out
, ", odk first");
3639 if (e_flags
& EF_MIPS_32BITMODE
)
3640 out
= stpcpy (out
, ", 32bitmode");
3642 if (e_flags
& EF_MIPS_NAN2008
)
3643 out
= stpcpy (out
, ", nan2008");
3645 if (e_flags
& EF_MIPS_FP64
)
3646 out
= stpcpy (out
, ", fp64");
3648 switch ((e_flags
& EF_MIPS_MACH
))
3650 case E_MIPS_MACH_3900
:
3651 out
= stpcpy (out
, ", 3900");
3653 case E_MIPS_MACH_4010
:
3654 out
= stpcpy (out
, ", 4010");
3656 case E_MIPS_MACH_4100
:
3657 out
= stpcpy (out
, ", 4100");
3659 case E_MIPS_MACH_4111
:
3660 out
= stpcpy (out
, ", 4111");
3662 case E_MIPS_MACH_4120
:
3663 out
= stpcpy (out
, ", 4120");
3665 case E_MIPS_MACH_4650
:
3666 out
= stpcpy (out
, ", 4650");
3668 case E_MIPS_MACH_5400
:
3669 out
= stpcpy (out
, ", 5400");
3671 case E_MIPS_MACH_5500
:
3672 out
= stpcpy (out
, ", 5500");
3674 case E_MIPS_MACH_5900
:
3675 out
= stpcpy (out
, ", 5900");
3677 case E_MIPS_MACH_SB1
:
3678 out
= stpcpy (out
, ", sb1");
3680 case E_MIPS_MACH_9000
:
3681 out
= stpcpy (out
, ", 9000");
3683 case E_MIPS_MACH_LS2E
:
3684 out
= stpcpy (out
, ", loongson-2e");
3686 case E_MIPS_MACH_LS2F
:
3687 out
= stpcpy (out
, ", loongson-2f");
3689 case E_MIPS_MACH_GS464
:
3690 out
= stpcpy (out
, ", gs464");
3692 case E_MIPS_MACH_GS464E
:
3693 out
= stpcpy (out
, ", gs464e");
3695 case E_MIPS_MACH_GS264E
:
3696 out
= stpcpy (out
, ", gs264e");
3698 case E_MIPS_MACH_OCTEON
:
3699 out
= stpcpy (out
, ", octeon");
3701 case E_MIPS_MACH_OCTEON2
:
3702 out
= stpcpy (out
, ", octeon2");
3704 case E_MIPS_MACH_OCTEON3
:
3705 out
= stpcpy (out
, ", octeon3");
3707 case E_MIPS_MACH_XLR
:
3708 out
= stpcpy (out
, ", xlr");
3710 case E_MIPS_MACH_IAMR2
:
3711 out
= stpcpy (out
, ", interaptiv-mr2");
3713 case E_MIPS_MACH_ALLEGREX
:
3714 out
= stpcpy (out
, ", allegrex");
3717 /* We simply ignore the field in this case to avoid confusion:
3718 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3722 out
= stpcpy (out
, _(", unknown CPU"));
3726 switch ((e_flags
& EF_MIPS_ABI
))
3728 case E_MIPS_ABI_O32
:
3729 out
= stpcpy (out
, ", o32");
3731 case E_MIPS_ABI_O64
:
3732 out
= stpcpy (out
, ", o64");
3734 case E_MIPS_ABI_EABI32
:
3735 out
= stpcpy (out
, ", eabi32");
3737 case E_MIPS_ABI_EABI64
:
3738 out
= stpcpy (out
, ", eabi64");
3741 /* We simply ignore the field in this case to avoid confusion:
3742 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3743 This means it is likely to be an o32 file, but not for
3747 out
= stpcpy (out
, _(", unknown ABI"));
3751 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3752 out
= stpcpy (out
, ", mdmx");
3754 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3755 out
= stpcpy (out
, ", mips16");
3757 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3758 out
= stpcpy (out
, ", micromips");
3760 switch ((e_flags
& EF_MIPS_ARCH
))
3763 out
= stpcpy (out
, ", mips1");
3766 out
= stpcpy (out
, ", mips2");
3769 out
= stpcpy (out
, ", mips3");
3772 out
= stpcpy (out
, ", mips4");
3775 out
= stpcpy (out
, ", mips5");
3777 case E_MIPS_ARCH_32
:
3778 out
= stpcpy (out
, ", mips32");
3780 case E_MIPS_ARCH_32R2
:
3781 out
= stpcpy (out
, ", mips32r2");
3783 case E_MIPS_ARCH_32R6
:
3784 out
= stpcpy (out
, ", mips32r6");
3786 case E_MIPS_ARCH_64
:
3787 out
= stpcpy (out
, ", mips64");
3789 case E_MIPS_ARCH_64R2
:
3790 out
= stpcpy (out
, ", mips64r2");
3792 case E_MIPS_ARCH_64R6
:
3793 out
= stpcpy (out
, ", mips64r6");
3796 out
= stpcpy (out
, _(", unknown ISA"));
3803 decode_MSP430_machine_flags (char *out
, unsigned e_flags
)
3805 out
= stpcpy (out
, _(": architecture variant: "));
3806 switch (e_flags
& EF_MSP430_MACH
)
3808 case E_MSP430_MACH_MSP430x11
:
3809 out
= stpcpy (out
, "MSP430x11");
3811 case E_MSP430_MACH_MSP430x11x1
:
3812 out
= stpcpy (out
, "MSP430x11x1 ");
3814 case E_MSP430_MACH_MSP430x12
:
3815 out
= stpcpy (out
, "MSP430x12");
3817 case E_MSP430_MACH_MSP430x13
:
3818 out
= stpcpy (out
, "MSP430x13");
3820 case E_MSP430_MACH_MSP430x14
:
3821 out
= stpcpy (out
, "MSP430x14");
3823 case E_MSP430_MACH_MSP430x15
:
3824 out
= stpcpy (out
, "MSP430x15");
3826 case E_MSP430_MACH_MSP430x16
:
3827 out
= stpcpy (out
, "MSP430x16");
3829 case E_MSP430_MACH_MSP430x31
:
3830 out
= stpcpy (out
, "MSP430x31");
3832 case E_MSP430_MACH_MSP430x32
:
3833 out
= stpcpy (out
, "MSP430x32");
3835 case E_MSP430_MACH_MSP430x33
:
3836 out
= stpcpy (out
, "MSP430x33");
3838 case E_MSP430_MACH_MSP430x41
:
3839 out
= stpcpy (out
, "MSP430x41");
3841 case E_MSP430_MACH_MSP430x42
:
3842 out
= stpcpy (out
, "MSP430x42");
3844 case E_MSP430_MACH_MSP430x43
:
3845 out
= stpcpy (out
, "MSP430x43");
3847 case E_MSP430_MACH_MSP430x44
:
3848 out
= stpcpy (out
, "MSP430x44");
3850 case E_MSP430_MACH_MSP430X
:
3851 out
= stpcpy (out
, "MSP430X");
3854 out
= stpcpy (out
, _(": unknown"));
3858 if (e_flags
& ~ EF_MSP430_MACH
)
3859 out
= stpcpy (out
, _(": unknown extra flag bits also present"));
3864 decode_NDS32_machine_flags (char *out
, unsigned e_flags
)
3870 bool has_fpu
= false;
3872 static const char *ABI_STRINGS
[] =
3874 "ABI v0", /* use r5 as return register; only used in N1213HC */
3875 "ABI v1", /* use r0 as return register */
3876 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3877 "ABI v2fp", /* for FPU */
3881 static const char *VER_STRINGS
[] =
3883 "Andes ELF V1.3 or older",
3887 static const char *ARCH_STRINGS
[] =
3896 abi
= EF_NDS_ABI
& e_flags
;
3897 arch
= EF_NDS_ARCH
& e_flags
;
3898 config
= EF_NDS_INST
& e_flags
;
3899 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3906 case E_NDS_ABI_V2FP
:
3907 case E_NDS_ABI_AABI
:
3908 case E_NDS_ABI_V2FP_PLUS
:
3909 /* In case there are holes in the array. */
3910 out
+= sprintf (out
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3914 out
= stpcpy (out
, ", <unrecognized ABI>");
3920 case E_NDS32_ELF_VER_1_2
:
3921 case E_NDS32_ELF_VER_1_3
:
3922 case E_NDS32_ELF_VER_1_4
:
3923 out
+= sprintf (out
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3927 out
= stpcpy (out
, ", <unrecognized ELF version number>");
3931 if (E_NDS_ABI_V0
== abi
)
3933 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3934 out
= stpcpy (out
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3935 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3936 out
= stpcpy (out
, ", 16b"); /* has 16-bit instructions */
3942 case E_NDS_ARCH_STAR_V1_0
:
3943 case E_NDS_ARCH_STAR_V2_0
:
3944 case E_NDS_ARCH_STAR_V3_0
:
3945 case E_NDS_ARCH_STAR_V3_M
:
3946 out
+= sprintf (out
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3950 out
= stpcpy (out
, ", <unrecognized architecture>");
3951 /* ARCH version determines how the e_flags are interpreted.
3952 If it is unknown, we cannot proceed. */
3956 /* Newer ABI; Now handle architecture specific flags. */
3957 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3959 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3960 out
= stpcpy (out
, ", MFUSR_PC");
3962 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3963 out
= stpcpy (out
, ", MAC");
3965 if (config
& E_NDS32_HAS_DIV_INST
)
3966 out
= stpcpy (out
, ", DIV");
3968 if (config
& E_NDS32_HAS_16BIT_INST
)
3969 out
= stpcpy (out
, ", 16b");
3973 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3975 if (version
<= E_NDS32_ELF_VER_1_3
)
3976 out
= stpcpy (out
, ", [B8]");
3978 out
= stpcpy (out
, ", EX9");
3981 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3982 out
= stpcpy (out
, ", MAC_DX");
3984 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3985 out
= stpcpy (out
, ", DIV_DX");
3987 if (config
& E_NDS32_HAS_16BIT_INST
)
3989 if (version
<= E_NDS32_ELF_VER_1_3
)
3990 out
= stpcpy (out
, ", 16b");
3992 out
= stpcpy (out
, ", IFC");
3996 if (config
& E_NDS32_HAS_EXT_INST
)
3997 out
= stpcpy (out
, ", PERF1");
3999 if (config
& E_NDS32_HAS_EXT2_INST
)
4000 out
= stpcpy (out
, ", PERF2");
4002 if (config
& E_NDS32_HAS_FPU_INST
)
4005 out
= stpcpy (out
, ", FPU_SP");
4008 if (config
& E_NDS32_HAS_FPU_DP_INST
)
4011 out
= stpcpy (out
, ", FPU_DP");
4014 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
4017 out
= stpcpy (out
, ", FPU_MAC");
4022 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
4024 case E_NDS32_FPU_REG_8SP_4DP
:
4025 out
= stpcpy (out
, ", FPU_REG:8/4");
4027 case E_NDS32_FPU_REG_16SP_8DP
:
4028 out
= stpcpy (out
, ", FPU_REG:16/8");
4030 case E_NDS32_FPU_REG_32SP_16DP
:
4031 out
= stpcpy (out
, ", FPU_REG:32/16");
4033 case E_NDS32_FPU_REG_32SP_32DP
:
4034 out
= stpcpy (out
, ", FPU_REG:32/32");
4039 if (config
& E_NDS32_HAS_AUDIO_INST
)
4040 out
= stpcpy (out
, ", AUDIO");
4042 if (config
& E_NDS32_HAS_STRING_INST
)
4043 out
= stpcpy (out
, ", STR");
4045 if (config
& E_NDS32_HAS_REDUCED_REGS
)
4046 out
= stpcpy (out
, ", 16REG");
4048 if (config
& E_NDS32_HAS_VIDEO_INST
)
4050 if (version
<= E_NDS32_ELF_VER_1_3
)
4051 out
= stpcpy (out
, ", VIDEO");
4053 out
= stpcpy (out
, ", SATURATION");
4056 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
4057 out
= stpcpy (out
, ", ENCRP");
4059 if (config
& E_NDS32_HAS_L2C_INST
)
4060 out
= stpcpy (out
, ", L2C");
4066 decode_PARISC_machine_flags (char *out
, unsigned e_flags
)
4068 switch (e_flags
& EF_PARISC_ARCH
)
4070 case EFA_PARISC_1_0
:
4071 out
= stpcpy (out
, ", PA-RISC 1.0");
4073 case EFA_PARISC_1_1
:
4074 out
= stpcpy (out
, ", PA-RISC 1.1");
4076 case EFA_PARISC_2_0
:
4077 out
= stpcpy (out
, ", PA-RISC 2.0");
4082 if (e_flags
& EF_PARISC_TRAPNIL
)
4083 out
= stpcpy (out
, ", trapnil");
4084 if (e_flags
& EF_PARISC_EXT
)
4085 out
= stpcpy (out
, ", ext");
4086 if (e_flags
& EF_PARISC_LSB
)
4087 out
= stpcpy (out
, ", lsb");
4088 if (e_flags
& EF_PARISC_WIDE
)
4089 out
= stpcpy (out
, ", wide");
4090 if (e_flags
& EF_PARISC_NO_KABP
)
4091 out
= stpcpy (out
, ", no kabp");
4092 if (e_flags
& EF_PARISC_LAZYSWAP
)
4093 out
= stpcpy (out
, ", lazyswap");
4098 decode_RISCV_machine_flags (char *out
, unsigned e_flags
)
4100 if (e_flags
& EF_RISCV_RVC
)
4101 out
= stpcpy (out
, ", RVC");
4103 if (e_flags
& EF_RISCV_RVE
)
4104 out
= stpcpy (out
, ", RVE");
4106 if (e_flags
& EF_RISCV_TSO
)
4107 out
= stpcpy (out
, ", TSO");
4109 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
4111 case EF_RISCV_FLOAT_ABI_SOFT
:
4112 out
= stpcpy (out
, ", soft-float ABI");
4115 case EF_RISCV_FLOAT_ABI_SINGLE
:
4116 out
= stpcpy (out
, ", single-float ABI");
4119 case EF_RISCV_FLOAT_ABI_DOUBLE
:
4120 out
= stpcpy (out
, ", double-float ABI");
4123 case EF_RISCV_FLOAT_ABI_QUAD
:
4124 out
= stpcpy (out
, ", quad-float ABI");
4131 decode_RL78_machine_flags (char *out
, unsigned e_flags
)
4133 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4135 case E_FLAG_RL78_ANY_CPU
:
4137 case E_FLAG_RL78_G10
:
4138 out
= stpcpy (out
, ", G10");
4140 case E_FLAG_RL78_G13
:
4141 out
= stpcpy (out
, ", G13");
4143 case E_FLAG_RL78_G14
:
4144 out
= stpcpy (out
, ", G14");
4147 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4148 out
= stpcpy (out
, ", 64-bit doubles");
4153 decode_RX_machine_flags (char *out
, unsigned e_flags
)
4155 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4156 out
= stpcpy (out
, ", 64-bit doubles");
4157 if (e_flags
& E_FLAG_RX_DSP
)
4158 out
= stpcpy (out
, ", dsp");
4159 if (e_flags
& E_FLAG_RX_PID
)
4160 out
= stpcpy (out
, ", pid");
4161 if (e_flags
& E_FLAG_RX_ABI
)
4162 out
= stpcpy (out
, ", RX ABI");
4163 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4164 out
= stpcpy (out
, (e_flags
& E_FLAG_RX_SINSNS_YES
4165 ? ", uses String instructions"
4166 : ", bans String instructions"));
4167 if (e_flags
& E_FLAG_RX_V2
)
4168 out
= stpcpy (out
, ", V2");
4169 if (e_flags
& E_FLAG_RX_V3
)
4170 out
= stpcpy (out
, ", V3");
4175 decode_SH_machine_flags (char *out
, unsigned e_flags
)
4177 switch ((e_flags
& EF_SH_MACH_MASK
))
4180 out
= stpcpy (out
, ", sh1");
4183 out
= stpcpy (out
, ", sh2");
4186 out
= stpcpy (out
, ", sh3");
4189 out
= stpcpy (out
, ", sh-dsp");
4192 out
= stpcpy (out
, ", sh3-dsp");
4195 out
= stpcpy (out
, ", sh4al-dsp");
4198 out
= stpcpy (out
, ", sh3e");
4201 out
= stpcpy (out
, ", sh4");
4204 out
= stpcpy (out
, ", sh5");
4207 out
= stpcpy (out
, ", sh2e");
4210 out
= stpcpy (out
, ", sh4a");
4213 out
= stpcpy (out
, ", sh2a");
4216 out
= stpcpy (out
, ", sh4-nofpu");
4219 out
= stpcpy (out
, ", sh4a-nofpu");
4222 out
= stpcpy (out
, ", sh2a-nofpu");
4225 out
= stpcpy (out
, ", sh3-nommu");
4227 case EF_SH4_NOMMU_NOFPU
:
4228 out
= stpcpy (out
, ", sh4-nommu-nofpu");
4230 case EF_SH2A_SH4_NOFPU
:
4231 out
= stpcpy (out
, ", sh2a-nofpu-or-sh4-nommu-nofpu");
4233 case EF_SH2A_SH3_NOFPU
:
4234 out
= stpcpy (out
, ", sh2a-nofpu-or-sh3-nommu");
4237 out
= stpcpy (out
, ", sh2a-or-sh4");
4240 out
= stpcpy (out
, ", sh2a-or-sh3e");
4243 out
= stpcpy (out
, _(", unknown ISA"));
4247 if (e_flags
& EF_SH_PIC
)
4248 out
= stpcpy (out
, ", pic");
4250 if (e_flags
& EF_SH_FDPIC
)
4251 out
= stpcpy (out
, ", fdpic");
4256 decode_SPARC_machine_flags (char *out
, unsigned e_flags
)
4258 if (e_flags
& EF_SPARC_32PLUS
)
4259 out
= stpcpy (out
, ", v8+");
4261 if (e_flags
& EF_SPARC_SUN_US1
)
4262 out
= stpcpy (out
, ", ultrasparcI");
4264 if (e_flags
& EF_SPARC_SUN_US3
)
4265 out
= stpcpy (out
, ", ultrasparcIII");
4267 if (e_flags
& EF_SPARC_HAL_R1
)
4268 out
= stpcpy (out
, ", halr1");
4270 if (e_flags
& EF_SPARC_LEDATA
)
4271 out
= stpcpy (out
, ", ledata");
4273 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
4274 out
= stpcpy (out
, ", tso");
4276 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
4277 out
= stpcpy (out
, ", pso");
4279 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
4280 out
= stpcpy (out
, ", rmo");
4285 decode_V800_machine_flags (char *out
, unsigned int e_flags
)
4287 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
4288 out
= stpcpy (out
, ", RH850 ABI");
4290 if (e_flags
& EF_V800_850E3
)
4291 out
= stpcpy (out
, ", V3 architecture");
4293 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
4294 out
= stpcpy (out
, ", FPU not used");
4296 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
4297 out
= stpcpy (out
, ", regmode: COMMON");
4299 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
4300 out
= stpcpy (out
, ", r4 not used");
4302 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
4303 out
= stpcpy (out
, ", r30 not used");
4305 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
4306 out
= stpcpy (out
, ", r5 not used");
4308 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
4309 out
= stpcpy (out
, ", r2 not used");
4311 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
4313 switch (e_flags
& - e_flags
)
4315 case EF_RH850_FPU_DOUBLE
:
4316 out
= stpcpy (out
, ", double precision FPU");
4318 case EF_RH850_FPU_SINGLE
:
4319 out
= stpcpy (out
, ", single precision FPU");
4321 case EF_RH850_REGMODE22
:
4322 out
= stpcpy (out
, ", regmode:22");
4324 case EF_RH850_REGMODE32
:
4325 out
= stpcpy (out
, ", regmode:23");
4327 case EF_RH850_GP_FIX
:
4328 out
= stpcpy (out
, ", r4 fixed");
4330 case EF_RH850_GP_NOFIX
:
4331 out
= stpcpy (out
, ", r4 free");
4333 case EF_RH850_EP_FIX
:
4334 out
= stpcpy (out
, ", r30 fixed");
4336 case EF_RH850_EP_NOFIX
:
4337 out
= stpcpy (out
, ", r30 free");
4339 case EF_RH850_TP_FIX
:
4340 out
= stpcpy (out
, ", r5 fixed");
4342 case EF_RH850_TP_NOFIX
:
4343 out
= stpcpy (out
, ", r5 free");
4345 case EF_RH850_REG2_RESERVE
:
4346 out
= stpcpy (out
, ", r2 fixed");
4348 case EF_RH850_REG2_NORESERVE
:
4349 out
= stpcpy (out
, ", r2 free");
4359 decode_V850_machine_flags (char *out
, unsigned int e_flags
)
4361 switch (e_flags
& EF_V850_ARCH
)
4363 case E_V850E3V5_ARCH
:
4364 out
= stpcpy (out
, ", v850e3v5");
4366 case E_V850E2V3_ARCH
:
4367 out
= stpcpy (out
, ", v850e2v3");
4370 out
= stpcpy (out
, ", v850e2");
4373 out
= stpcpy (out
, ", v850e1");
4376 out
= stpcpy (out
, ", v850e");
4379 out
= stpcpy (out
, ", v850");
4382 out
= stpcpy (out
, _(", unknown v850 architecture variant"));
4389 decode_Z80_machine_flags (char *out
, unsigned int e_flags
)
4391 switch (e_flags
& EF_Z80_MACH_MSK
)
4393 case EF_Z80_MACH_Z80
:
4394 out
= stpcpy (out
, ", Z80");
4396 case EF_Z80_MACH_Z180
:
4397 out
= stpcpy (out
, ", Z180");
4399 case EF_Z80_MACH_R800
:
4400 out
= stpcpy (out
, ", R800");
4402 case EF_Z80_MACH_EZ80_Z80
:
4403 out
= stpcpy (out
, ", EZ80");
4405 case EF_Z80_MACH_EZ80_ADL
:
4406 out
= stpcpy (out
, ", EZ80, ADL");
4408 case EF_Z80_MACH_GBZ80
:
4409 out
= stpcpy (out
, ", GBZ80");
4411 case EF_Z80_MACH_Z80N
:
4412 out
= stpcpy (out
, ", Z80N");
4415 out
= stpcpy (out
, _(", unknown"));
4422 decode_AMDGPU_machine_flags (char *out
, unsigned int e_flags
, Filedata
*filedata
)
4424 unsigned char *e_ident
= filedata
->file_header
.e_ident
;
4425 unsigned char osabi
= e_ident
[EI_OSABI
];
4426 unsigned char abiversion
= e_ident
[EI_ABIVERSION
];
4429 /* HSA OS ABI v2 used a different encoding, but we don't need to support it,
4430 it has been deprecated for a while.
4432 The PAL, MESA3D and NONE OS ABIs are not properly versioned, at the time
4433 of writing, they use the same flags as HSA v3, so the code below uses that
4435 if (osabi
== ELFOSABI_AMDGPU_HSA
&& abiversion
< ELFABIVERSION_AMDGPU_HSA_V3
)
4438 mach
= e_flags
& EF_AMDGPU_MACH
;
4441 #define AMDGPU_CASE(code, string) \
4442 case code: out = stpcpy (out, ", " string); break;
4443 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600
, "gfx600")
4444 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601
, "gfx601")
4445 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700
, "gfx700")
4446 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX701
, "gfx701")
4447 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX702
, "gfx702")
4448 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX703
, "gfx703")
4449 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX704
, "gfx704")
4450 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX801
, "gfx801")
4451 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX802
, "gfx802")
4452 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX803
, "gfx803")
4453 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX810
, "gfx810")
4454 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX900
, "gfx900")
4455 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX902
, "gfx902")
4456 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX904
, "gfx904")
4457 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX906
, "gfx906")
4458 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX908
, "gfx908")
4459 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX909
, "gfx909")
4460 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90C
, "gfx90c")
4461 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1010
, "gfx1010")
4462 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1011
, "gfx1011")
4463 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1012
, "gfx1012")
4464 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1030
, "gfx1030")
4465 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1031
, "gfx1031")
4466 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1032
, "gfx1032")
4467 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1033
, "gfx1033")
4468 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX602
, "gfx602")
4469 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX705
, "gfx705")
4470 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX805
, "gfx805")
4471 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1035
, "gfx1035")
4472 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1034
, "gfx1034")
4473 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90A
, "gfx90a")
4474 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX940
, "gfx940")
4475 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013
, "gfx1013")
4476 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036
, "gfx1036")
4478 out
+= sprintf (out
, _(", <unknown AMDGPU GPU type: %#x>"), mach
);
4483 e_flags
&= ~EF_AMDGPU_MACH
;
4485 if ((osabi
== ELFOSABI_AMDGPU_HSA
4486 && abiversion
== ELFABIVERSION_AMDGPU_HSA_V3
)
4487 || osabi
!= ELFOSABI_AMDGPU_HSA
)
4489 /* For HSA v3 and other OS ABIs. */
4490 if (e_flags
& EF_AMDGPU_FEATURE_XNACK_V3
)
4492 out
= stpcpy (out
, ", xnack on");
4493 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V3
;
4496 if (e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V3
)
4498 out
= stpcpy (out
, ", sramecc on");
4499 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V3
;
4507 xnack
= e_flags
& EF_AMDGPU_FEATURE_XNACK_V4
;
4510 case EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
:
4513 case EF_AMDGPU_FEATURE_XNACK_ANY_V4
:
4514 out
= stpcpy (out
, ", xnack any");
4517 case EF_AMDGPU_FEATURE_XNACK_OFF_V4
:
4518 out
= stpcpy (out
, ", xnack off");
4521 case EF_AMDGPU_FEATURE_XNACK_ON_V4
:
4522 out
= stpcpy (out
, ", xnack on");
4526 out
+= sprintf (out
, _(", <unknown xnack value: %#x>"), xnack
);
4530 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V4
;
4532 sramecc
= e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V4
;
4535 case EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
:
4538 case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
:
4539 out
= stpcpy (out
, ", sramecc any");
4542 case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
:
4543 out
= stpcpy (out
, ", sramecc off");
4546 case EF_AMDGPU_FEATURE_SRAMECC_ON_V4
:
4547 out
= stpcpy (out
, ", sramecc on");
4551 out
+= sprintf (out
, _(", <unknown sramecc value: %#x>"), sramecc
);
4555 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V4
;
4559 out
+= sprintf (out
, _(", unknown flags bits: %#x"), e_flags
);
4564 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
4566 static char buf
[1024];
4578 case EM_ARC_COMPACT3
:
4579 out
= stpcpy (out
, ", HS5x");
4582 case EM_ARC_COMPACT3_64
:
4583 out
= stpcpy (out
, ", HS6x");
4586 case EM_ARC_COMPACT2
:
4587 case EM_ARC_COMPACT
:
4588 out
= decode_ARC_machine_flags (out
, e_flags
, e_machine
);
4592 out
= decode_ARM_machine_flags (out
, e_flags
);
4596 out
= decode_AVR_machine_flags (out
, e_flags
);
4600 out
= decode_BLACKFIN_machine_flags (out
, e_flags
);
4604 out
= decode_FRV_machine_flags (out
, e_flags
);
4608 out
= decode_M68K_machine_flags (out
, e_flags
);
4612 out
= decode_AMDGPU_machine_flags (out
, e_flags
, filedata
);
4616 out
= decode_MeP_machine_flags (out
, e_flags
);
4620 if (e_flags
& EF_PPC_EMB
)
4621 out
= stpcpy (out
, ", emb");
4623 if (e_flags
& EF_PPC_RELOCATABLE
)
4624 out
= stpcpy (out
, _(", relocatable"));
4626 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
4627 out
= stpcpy (out
, _(", relocatable-lib"));
4631 if (e_flags
& EF_PPC64_ABI
)
4632 out
+= sprintf (out
, ", abiv%d", e_flags
& EF_PPC64_ABI
);
4636 out
= decode_V800_machine_flags (out
, e_flags
);
4640 case EM_CYGNUS_V850
:
4641 out
= decode_V850_machine_flags (out
, e_flags
);
4645 case EM_CYGNUS_M32R
:
4646 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
4647 out
= stpcpy (out
, ", m32r");
4651 case EM_MIPS_RS3_LE
:
4652 out
= decode_MIPS_machine_flags (out
, e_flags
);
4656 out
= decode_NDS32_machine_flags (out
, e_flags
);
4660 switch (EF_NFP_MACH (e_flags
))
4662 case E_NFP_MACH_3200
:
4663 out
= stpcpy (out
, ", NFP-32xx");
4665 case E_NFP_MACH_6000
:
4666 out
= stpcpy (out
, ", NFP-6xxx");
4672 out
= decode_RISCV_machine_flags (out
, e_flags
);
4676 out
= decode_SH_machine_flags (out
, e_flags
);
4680 if (e_flags
& EF_OR1K_NODELAY
)
4681 out
= stpcpy (out
, ", no delay");
4685 out
+= sprintf (out
, ", CPU Version: %u", e_flags
& EF_BPF_CPUVER
);
4689 out
= decode_SPARC_machine_flags (out
, e_flags
);
4693 out
= decode_PARISC_machine_flags (out
, e_flags
);
4698 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
4699 out
= stpcpy (out
, ", new calling convention");
4701 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
4702 out
= stpcpy (out
, ", gnu calling convention");
4706 out
= decode_IA64_machine_flags (out
, e_flags
, filedata
);
4710 if ((e_flags
& EF_VAX_NONPIC
))
4711 out
= stpcpy (out
, ", non-PIC");
4712 if ((e_flags
& EF_VAX_DFLOAT
))
4713 out
= stpcpy (out
, ", D-Float");
4714 if ((e_flags
& EF_VAX_GFLOAT
))
4715 out
= stpcpy (out
, ", G-Float");
4719 if (e_flags
& EF_VISIUM_ARCH_MCM
)
4720 out
= stpcpy (out
, ", mcm");
4721 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
4722 out
= stpcpy (out
, ", mcm24");
4723 if (e_flags
& EF_VISIUM_ARCH_GR6
)
4724 out
= stpcpy (out
, ", gr6");
4728 out
= decode_RL78_machine_flags (out
, e_flags
);
4732 out
= decode_RX_machine_flags (out
, e_flags
);
4736 if (e_flags
& EF_S390_HIGH_GPRS
)
4737 out
= stpcpy (out
, ", highgprs");
4741 if ((e_flags
& EF_C6000_REL
))
4742 out
= stpcpy (out
, ", relocatable module");
4746 if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV3_1
)
4747 strcat (buf
, ", Kalray VLIW kv3-1");
4748 else if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV3_2
)
4749 strcat (buf
, ", Kalray VLIW kv3-2");
4750 else if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV4_1
)
4751 strcat (buf
, ", Kalray VLIW kv4-1");
4753 strcat (buf
, ", unknown KVX MPPA");
4757 out
= decode_MSP430_machine_flags (out
, e_flags
);
4761 out
= decode_Z80_machine_flags (out
, e_flags
);
4765 out
= decode_LOONGARCH_machine_flags (out
, e_flags
);
4774 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
4776 static char buff
[32];
4780 case ELFOSABI_NONE
: return "UNIX - System V";
4781 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
4782 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
4783 case ELFOSABI_GNU
: return "UNIX - GNU";
4784 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
4785 case ELFOSABI_AIX
: return "UNIX - AIX";
4786 case ELFOSABI_IRIX
: return "UNIX - IRIX";
4787 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
4788 case ELFOSABI_TRU64
: return "UNIX - TRU64";
4789 case ELFOSABI_MODESTO
: return "Novell - Modesto";
4790 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
4791 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
4792 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
4793 case ELFOSABI_AROS
: return "AROS";
4794 case ELFOSABI_FENIXOS
: return "FenixOS";
4795 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
4796 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
4799 switch (filedata
->file_header
.e_machine
)
4804 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA";
4805 case ELFOSABI_AMDGPU_PAL
: return "AMD PAL";
4806 case ELFOSABI_AMDGPU_MESA3D
: return "AMD Mesa3D";
4815 case ELFOSABI_ARM
: return "ARM";
4816 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
4827 case ELFOSABI_STANDALONE
: return _("Standalone App");
4836 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4837 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4846 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4852 get_aarch64_segment_type (unsigned long type
)
4856 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4857 case PT_AARCH64_MEMTAG_MTE
: return "AARCH64_MEMTAG_MTE";
4858 default: return NULL
;
4863 get_arm_segment_type (unsigned long type
)
4867 case PT_ARM_EXIDX
: return "EXIDX";
4868 default: return NULL
;
4873 get_s390_segment_type (unsigned long type
)
4877 case PT_S390_PGSTE
: return "S390_PGSTE";
4878 default: return NULL
;
4883 get_mips_segment_type (unsigned long type
)
4887 case PT_MIPS_REGINFO
: return "REGINFO";
4888 case PT_MIPS_RTPROC
: return "RTPROC";
4889 case PT_MIPS_OPTIONS
: return "OPTIONS";
4890 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4891 default: return NULL
;
4896 get_parisc_segment_type (unsigned long type
)
4900 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4901 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4902 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4903 default: return NULL
;
4908 get_ia64_segment_type (unsigned long type
)
4912 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
4913 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
4914 default: return NULL
;
4919 get_tic6x_segment_type (unsigned long type
)
4923 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4924 default: return NULL
;
4929 get_riscv_segment_type (unsigned long type
)
4933 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4934 default: return NULL
;
4939 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4941 if (e_machine
== EM_PARISC
)
4944 case PT_HP_TLS
: return "HP_TLS";
4945 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4946 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4947 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4948 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4949 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4950 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4951 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4952 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4953 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4954 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4955 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4956 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4957 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4958 case PT_HP_STACK
: return "HP_STACK";
4959 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4960 default: return NULL
;
4963 if (e_machine
== EM_IA_64
)
4966 case PT_HP_TLS
: return "HP_TLS";
4967 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4968 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4969 case PT_IA_64_HP_STACK
: return "HP_STACK";
4970 default: return NULL
;
4977 get_solaris_segment_type (unsigned long type
)
4981 case 0x6464e550: return "PT_SUNW_UNWIND";
4982 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4983 case 0x6ffffff7: return "PT_LOSUNW";
4984 case 0x6ffffffa: return "PT_SUNWBSS";
4985 case 0x6ffffffb: return "PT_SUNWSTACK";
4986 case 0x6ffffffc: return "PT_SUNWDTRACE";
4987 case 0x6ffffffd: return "PT_SUNWCAP";
4988 case 0x6fffffff: return "PT_HISUNW";
4989 default: return NULL
;
4994 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4996 static char buff
[32];
5000 case PT_NULL
: return "NULL";
5001 case PT_LOAD
: return "LOAD";
5002 case PT_DYNAMIC
: return "DYNAMIC";
5003 case PT_INTERP
: return "INTERP";
5004 case PT_NOTE
: return "NOTE";
5005 case PT_SHLIB
: return "SHLIB";
5006 case PT_PHDR
: return "PHDR";
5007 case PT_TLS
: return "TLS";
5008 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
5009 case PT_GNU_STACK
: return "GNU_STACK";
5010 case PT_GNU_RELRO
: return "GNU_RELRO";
5011 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
5012 case PT_GNU_SFRAME
: return "GNU_SFRAME";
5014 case PT_OPENBSD_MUTABLE
: return "OPENBSD_MUTABLE";
5015 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
5016 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
5017 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
5020 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
5022 const char * result
;
5024 switch (filedata
->file_header
.e_machine
)
5027 result
= get_aarch64_segment_type (p_type
);
5030 result
= get_arm_segment_type (p_type
);
5033 case EM_MIPS_RS3_LE
:
5034 result
= get_mips_segment_type (p_type
);
5037 result
= get_parisc_segment_type (p_type
);
5040 result
= get_ia64_segment_type (p_type
);
5043 result
= get_tic6x_segment_type (p_type
);
5047 result
= get_s390_segment_type (p_type
);
5050 result
= get_riscv_segment_type (p_type
);
5060 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
5062 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
5064 const char * result
= NULL
;
5066 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
5069 case ELFOSABI_FREEBSD
:
5070 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
5072 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
5077 result
= get_hpux_segment_type (p_type
,
5078 filedata
->file_header
.e_machine
);
5080 case ELFOSABI_SOLARIS
:
5081 result
= get_solaris_segment_type (p_type
);
5089 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
5092 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
5099 get_arc_section_type_name (unsigned int sh_type
)
5103 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
5111 get_mips_section_type_name (unsigned int sh_type
)
5115 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
5116 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
5117 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
5118 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
5119 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
5120 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
5121 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
5122 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
5123 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
5124 case SHT_MIPS_RELD
: return "MIPS_RELD";
5125 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
5126 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
5127 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
5128 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
5129 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
5130 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
5131 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
5132 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
5133 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
5134 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
5135 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
5136 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
5137 case SHT_MIPS_LINE
: return "MIPS_LINE";
5138 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
5139 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
5140 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
5141 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
5142 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
5143 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
5144 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
5145 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
5146 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
5147 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
5148 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
5149 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
5150 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
5151 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
5152 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
5153 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
5154 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
5155 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
5163 get_parisc_section_type_name (unsigned int sh_type
)
5167 case SHT_PARISC_EXT
: return "PARISC_EXT";
5168 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
5169 case SHT_PARISC_DOC
: return "PARISC_DOC";
5170 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
5171 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
5172 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
5173 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
5174 default: return NULL
;
5179 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
5181 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
5182 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
5183 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
5187 case SHT_IA_64_EXT
: return "IA_64_EXT";
5188 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
5189 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
5190 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
5191 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
5192 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
5193 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
5194 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
5195 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
5196 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
5204 get_x86_64_section_type_name (unsigned int sh_type
)
5208 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
5209 default: return NULL
;
5214 get_aarch64_section_type_name (unsigned int sh_type
)
5218 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
5219 default: return NULL
;
5224 get_arm_section_type_name (unsigned int sh_type
)
5228 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
5229 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
5230 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
5231 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
5232 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
5233 default: return NULL
;
5238 get_tic6x_section_type_name (unsigned int sh_type
)
5242 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
5243 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
5244 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
5245 case SHT_TI_ICODE
: return "TI_ICODE";
5246 case SHT_TI_XREF
: return "TI_XREF";
5247 case SHT_TI_HANDLER
: return "TI_HANDLER";
5248 case SHT_TI_INITINFO
: return "TI_INITINFO";
5249 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
5250 default: return NULL
;
5255 get_msp430_section_type_name (unsigned int sh_type
)
5259 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
5260 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
5261 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
5262 default: return NULL
;
5267 get_nfp_section_type_name (unsigned int sh_type
)
5271 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
5272 case SHT_NFP_INITREG
: return "NFP_INITREG";
5273 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
5274 default: return NULL
;
5279 get_v850_section_type_name (unsigned int sh_type
)
5283 case SHT_V850_SCOMMON
: return "V850 Small Common";
5284 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
5285 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
5286 case SHT_RENESAS_IOP
: return "RENESAS IOP";
5287 case SHT_RENESAS_INFO
: return "RENESAS INFO";
5288 default: return NULL
;
5293 get_riscv_section_type_name (unsigned int sh_type
)
5297 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
5298 default: return NULL
;
5303 get_csky_section_type_name (unsigned int sh_type
)
5307 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
5308 default: return NULL
;
5313 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
5315 static char buff
[32];
5316 const char * result
;
5320 case SHT_NULL
: return "NULL";
5321 case SHT_PROGBITS
: return "PROGBITS";
5322 case SHT_SYMTAB
: return "SYMTAB";
5323 case SHT_STRTAB
: return "STRTAB";
5324 case SHT_RELA
: return "RELA";
5325 case SHT_RELR
: return "RELR";
5326 case SHT_HASH
: return "HASH";
5327 case SHT_DYNAMIC
: return "DYNAMIC";
5328 case SHT_NOTE
: return "NOTE";
5329 case SHT_NOBITS
: return "NOBITS";
5330 case SHT_REL
: return "REL";
5331 case SHT_SHLIB
: return "SHLIB";
5332 case SHT_DYNSYM
: return "DYNSYM";
5333 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
5334 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
5335 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
5336 case SHT_GNU_HASH
: return "GNU_HASH";
5337 case SHT_GROUP
: return "GROUP";
5338 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
5339 case SHT_GNU_verdef
: return "VERDEF";
5340 case SHT_GNU_verneed
: return "VERNEED";
5341 case SHT_GNU_versym
: return "VERSYM";
5342 case 0x6ffffff0: return "VERSYM";
5343 case 0x6ffffffc: return "VERDEF";
5344 case 0x7ffffffd: return "AUXILIARY";
5345 case 0x7fffffff: return "FILTER";
5346 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
5349 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
5351 switch (filedata
->file_header
.e_machine
)
5354 case EM_ARC_COMPACT
:
5355 case EM_ARC_COMPACT2
:
5356 case EM_ARC_COMPACT3
:
5357 case EM_ARC_COMPACT3_64
:
5358 result
= get_arc_section_type_name (sh_type
);
5361 case EM_MIPS_RS3_LE
:
5362 result
= get_mips_section_type_name (sh_type
);
5365 result
= get_parisc_section_type_name (sh_type
);
5368 result
= get_ia64_section_type_name (filedata
, sh_type
);
5373 result
= get_x86_64_section_type_name (sh_type
);
5376 result
= get_aarch64_section_type_name (sh_type
);
5379 result
= get_arm_section_type_name (sh_type
);
5382 result
= get_tic6x_section_type_name (sh_type
);
5385 result
= get_msp430_section_type_name (sh_type
);
5388 result
= get_nfp_section_type_name (sh_type
);
5392 case EM_CYGNUS_V850
:
5393 result
= get_v850_section_type_name (sh_type
);
5396 result
= get_riscv_section_type_name (sh_type
);
5399 result
= get_csky_section_type_name (sh_type
);
5409 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
5411 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
5413 switch (filedata
->file_header
.e_machine
)
5416 result
= get_ia64_section_type_name (filedata
, sh_type
);
5419 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
5420 result
= get_solaris_section_type (sh_type
);
5425 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
5426 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
5427 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
5428 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
5440 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
5442 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
5444 switch (filedata
->file_header
.e_machine
)
5448 case EM_CYGNUS_V850
:
5449 result
= get_v850_section_type_name (sh_type
);
5459 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
5462 /* This message is probably going to be displayed in a 15
5463 character wide field, so put the hex value first. */
5464 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
5470 enum long_option_values
5472 OPTION_DEBUG_DUMP
= 512,
5483 OPTION_WITH_SYMBOL_VERSIONS
,
5484 OPTION_RECURSE_LIMIT
,
5485 OPTION_NO_RECURSE_LIMIT
,
5486 OPTION_NO_DEMANGLING
,
5490 static struct option options
[] =
5492 /* Note - This table is alpha-sorted on the 'val'
5493 field in order to make adding new options easier. */
5494 {"arch-specific", no_argument
, 0, 'A'},
5495 {"all", no_argument
, 0, 'a'},
5496 {"demangle", optional_argument
, 0, 'C'},
5497 {"archive-index", no_argument
, 0, 'c'},
5498 {"use-dynamic", no_argument
, 0, 'D'},
5499 {"dynamic", no_argument
, 0, 'd'},
5500 {"headers", no_argument
, 0, 'e'},
5501 {"section-groups", no_argument
, 0, 'g'},
5502 {"help", no_argument
, 0, 'H'},
5503 {"file-header", no_argument
, 0, 'h'},
5504 {"histogram", no_argument
, 0, 'I'},
5505 {"lint", no_argument
, 0, 'L'},
5506 {"enable-checks", no_argument
, 0, 'L'},
5507 {"program-headers", no_argument
, 0, 'l'},
5508 {"segments", no_argument
, 0, 'l'},
5509 {"full-section-name",no_argument
, 0, 'N'},
5510 {"notes", no_argument
, 0, 'n'},
5511 {"process-links", no_argument
, 0, 'P'},
5512 {"string-dump", required_argument
, 0, 'p'},
5513 {"relocated-dump", required_argument
, 0, 'R'},
5514 {"relocs", no_argument
, 0, 'r'},
5515 {"section-headers", no_argument
, 0, 'S'},
5516 {"sections", no_argument
, 0, 'S'},
5517 {"symbols", no_argument
, 0, 's'},
5518 {"syms", no_argument
, 0, 's'},
5519 {"silent-truncation",no_argument
, 0, 'T'},
5520 {"section-details", no_argument
, 0, 't'},
5521 {"unicode", required_argument
, NULL
, 'U'},
5522 {"unwind", no_argument
, 0, 'u'},
5523 {"version-info", no_argument
, 0, 'V'},
5524 {"version", no_argument
, 0, 'v'},
5525 {"wide", no_argument
, 0, 'W'},
5526 {"hex-dump", required_argument
, 0, 'x'},
5527 {"decompress", no_argument
, 0, 'z'},
5529 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
5530 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
5531 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5532 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5533 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
5534 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
5535 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
5536 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
5537 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
5538 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
5539 #ifdef ENABLE_LIBCTF
5540 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
5541 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
5542 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
5543 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
5545 {"sframe", optional_argument
, 0, OPTION_SFRAME_DUMP
},
5546 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
5548 {0, no_argument
, 0, 0}
5552 usage (FILE * stream
)
5554 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
5555 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
5556 fprintf (stream
, _(" Options are:\n"));
5557 fprintf (stream
, _("\
5558 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
5559 fprintf (stream
, _("\
5560 -h --file-header Display the ELF file header\n"));
5561 fprintf (stream
, _("\
5562 -l --program-headers Display the program headers\n"));
5563 fprintf (stream
, _("\
5564 --segments An alias for --program-headers\n"));
5565 fprintf (stream
, _("\
5566 -S --section-headers Display the sections' header\n"));
5567 fprintf (stream
, _("\
5568 --sections An alias for --section-headers\n"));
5569 fprintf (stream
, _("\
5570 -g --section-groups Display the section groups\n"));
5571 fprintf (stream
, _("\
5572 -t --section-details Display the section details\n"));
5573 fprintf (stream
, _("\
5574 -e --headers Equivalent to: -h -l -S\n"));
5575 fprintf (stream
, _("\
5576 -s --syms Display the symbol table\n"));
5577 fprintf (stream
, _("\
5578 --symbols An alias for --syms\n"));
5579 fprintf (stream
, _("\
5580 --dyn-syms Display the dynamic symbol table\n"));
5581 fprintf (stream
, _("\
5582 --lto-syms Display LTO symbol tables\n"));
5583 fprintf (stream
, _("\
5584 --sym-base=[0|8|10|16] \n\
5585 Force base for symbol sizes. The options are \n\
5586 mixed (the default), octal, decimal, hexadecimal.\n"));
5587 fprintf (stream
, _("\
5588 -C --demangle[=STYLE] Decode mangled/processed symbol names\n"));
5589 display_demangler_styles (stream
, _("\
5591 fprintf (stream
, _("\
5592 --no-demangle Do not demangle low-level symbol names. (default)\n"));
5593 fprintf (stream
, _("\
5594 --recurse-limit Enable a demangling recursion limit. (default)\n"));
5595 fprintf (stream
, _("\
5596 --no-recurse-limit Disable a demangling recursion limit\n"));
5597 fprintf (stream
, _("\
5598 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
5599 Display unicode characters as determined by the current locale\n\
5600 (default), escape sequences, \"<hex sequences>\", highlighted\n\
5601 escape sequences, or treat them as invalid and display as\n\
5602 \"{hex sequences}\"\n"));
5603 fprintf (stream
, _("\
5604 -n --notes Display the core notes (if present)\n"));
5605 fprintf (stream
, _("\
5606 -r --relocs Display the relocations (if present)\n"));
5607 fprintf (stream
, _("\
5608 -u --unwind Display the unwind info (if present)\n"));
5609 fprintf (stream
, _("\
5610 -d --dynamic Display the dynamic section (if present)\n"));
5611 fprintf (stream
, _("\
5612 -V --version-info Display the version sections (if present)\n"));
5613 fprintf (stream
, _("\
5614 -A --arch-specific Display architecture specific information (if any)\n"));
5615 fprintf (stream
, _("\
5616 -c --archive-index Display the symbol/file index in an archive\n"));
5617 fprintf (stream
, _("\
5618 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
5619 fprintf (stream
, _("\
5620 -L --lint|--enable-checks\n\
5621 Display warning messages for possible problems\n"));
5622 fprintf (stream
, _("\
5623 -x --hex-dump=<number|name>\n\
5624 Dump the contents of section <number|name> as bytes\n"));
5625 fprintf (stream
, _("\
5626 -p --string-dump=<number|name>\n\
5627 Dump the contents of section <number|name> as strings\n"));
5628 fprintf (stream
, _("\
5629 -R --relocated-dump=<number|name>\n\
5630 Dump the relocated contents of section <number|name>\n"));
5631 fprintf (stream
, _("\
5632 -z --decompress Decompress section before dumping it\n"));
5633 fprintf (stream
, _("\
5634 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
5635 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
5636 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
5637 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
5639 Display the contents of DWARF debug sections\n"));
5640 fprintf (stream
, _("\
5641 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5642 debuginfo files\n"));
5643 fprintf (stream
, _("\
5644 -P --process-links Display the contents of non-debug sections in separate\n\
5645 debuginfo files. (Implies -wK)\n"));
5646 #if DEFAULT_FOR_FOLLOW_LINKS
5647 fprintf (stream
, _("\
5648 -wK --debug-dump=follow-links\n\
5649 Follow links to separate debug info files (default)\n"));
5650 fprintf (stream
, _("\
5651 -wN --debug-dump=no-follow-links\n\
5652 Do not follow links to separate debug info files\n"));
5654 fprintf (stream
, _("\
5655 -wK --debug-dump=follow-links\n\
5656 Follow links to separate debug info files\n"));
5657 fprintf (stream
, _("\
5658 -wN --debug-dump=no-follow-links\n\
5659 Do not follow links to separate debug info files\n\
5662 #if HAVE_LIBDEBUGINFOD
5663 fprintf (stream
, _("\
5664 -wD --debug-dump=use-debuginfod\n\
5665 When following links, also query debuginfod servers (default)\n"));
5666 fprintf (stream
, _("\
5667 -wE --debug-dump=do-not-use-debuginfod\n\
5668 When following links, do not query debuginfod servers\n"));
5670 fprintf (stream
, _("\
5671 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
5672 fprintf (stream
, _("\
5673 --dwarf-start=N Display DIEs starting at offset N\n"));
5674 #ifdef ENABLE_LIBCTF
5675 fprintf (stream
, _("\
5676 --ctf=<number|name> Display CTF info from section <number|name>\n"));
5677 fprintf (stream
, _("\
5678 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
5679 fprintf (stream
, _("\
5680 --ctf-symbols=<number|name>\n\
5681 Use section <number|name> as the CTF external symtab\n"));
5682 fprintf (stream
, _("\
5683 --ctf-strings=<number|name>\n\
5684 Use section <number|name> as the CTF external strtab\n"));
5686 fprintf (stream
, _("\
5687 --sframe[=NAME] Display SFrame info from section NAME, (default '.sframe')\n"));
5689 #ifdef SUPPORT_DISASSEMBLY
5690 fprintf (stream
, _("\
5691 -i --instruction-dump=<number|name>\n\
5692 Disassemble the contents of section <number|name>\n"));
5694 fprintf (stream
, _("\
5695 -I --histogram Display histogram of bucket list lengths\n"));
5696 fprintf (stream
, _("\
5697 -W --wide Allow output width to exceed 80 characters\n"));
5698 fprintf (stream
, _("\
5699 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
5700 fprintf (stream
, _("\
5701 @<file> Read options from <file>\n"));
5702 fprintf (stream
, _("\
5703 -H --help Display this information\n"));
5704 fprintf (stream
, _("\
5705 -v --version Display the version number of readelf\n"));
5707 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
5708 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
5710 exit (stream
== stdout
? 0 : 1);
5713 /* Record the fact that the user wants the contents of section number
5714 SECTION to be displayed using the method(s) encoded as flags bits
5715 in TYPE. Note, TYPE can be zero if we are creating the array for
5719 request_dump_bynumber (struct dump_data
*dumpdata
,
5720 unsigned int section
, dump_type type
)
5722 if (section
>= dumpdata
->num_dump_sects
)
5724 dump_type
* new_dump_sects
;
5726 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
5727 sizeof (* new_dump_sects
));
5729 if (new_dump_sects
== NULL
)
5730 error (_("Out of memory allocating dump request table.\n"));
5733 if (dumpdata
->dump_sects
)
5735 /* Copy current flag settings. */
5736 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
5737 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
5739 free (dumpdata
->dump_sects
);
5742 dumpdata
->dump_sects
= new_dump_sects
;
5743 dumpdata
->num_dump_sects
= section
+ 1;
5747 if (dumpdata
->dump_sects
)
5748 dumpdata
->dump_sects
[section
] |= type
;
5751 /* Request a dump by section name. */
5754 request_dump_byname (const char * section
, dump_type type
)
5756 struct dump_list_entry
* new_request
;
5758 new_request
= (struct dump_list_entry
*)
5759 malloc (sizeof (struct dump_list_entry
));
5761 error (_("Out of memory allocating dump request table.\n"));
5763 new_request
->name
= strdup (section
);
5764 if (!new_request
->name
)
5765 error (_("Out of memory allocating dump request table.\n"));
5767 new_request
->type
= type
;
5769 new_request
->next
= dump_sects_byname
;
5770 dump_sects_byname
= new_request
;
5774 request_dump (struct dump_data
*dumpdata
, dump_type type
)
5780 section
= strtoul (optarg
, & cp
, 0);
5782 if (! *cp
&& section
>= 0)
5783 request_dump_bynumber (dumpdata
, section
, type
);
5785 request_dump_byname (optarg
, type
);
5789 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
5796 while ((c
= getopt_long
5797 (argc
, argv
, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
5815 do_section_groups
= true;
5818 do_histogram
= true;
5824 do_section_groups
= true;
5829 do_section_details
= true;
5840 do_using_dynamic
= true;
5864 do_histogram
= true;
5870 do_archive_index
= true;
5876 process_links
= true;
5877 do_follow_links
= true;
5878 dump_any_debugging
= true;
5881 request_dump (dumpdata
, HEX_DUMP
);
5884 request_dump (dumpdata
, STRING_DUMP
);
5887 request_dump (dumpdata
, RELOC_DUMP
);
5890 decompress_dumps
= true;
5895 do_debugging
= true;
5897 dump_any_debugging
= true;
5898 dwarf_select_sections_all ();
5902 do_debugging
= false;
5903 if (dwarf_select_sections_by_letters (optarg
))
5906 dump_any_debugging
= true;
5910 case OPTION_DEBUG_DUMP
:
5914 do_debugging
= true;
5915 dump_any_debugging
= true;
5916 dwarf_select_sections_all ();
5920 do_debugging
= false;
5921 if (dwarf_select_sections_by_names (optarg
))
5924 dump_any_debugging
= true;
5928 case OPTION_DWARF_DEPTH
:
5932 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5935 case OPTION_DWARF_START
:
5939 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5942 case OPTION_DWARF_CHECK
:
5945 case OPTION_CTF_DUMP
:
5947 request_dump (dumpdata
, CTF_DUMP
);
5949 case OPTION_CTF_SYMBOLS
:
5950 free (dump_ctf_symtab_name
);
5951 dump_ctf_symtab_name
= strdup (optarg
);
5953 case OPTION_CTF_STRINGS
:
5954 free (dump_ctf_strtab_name
);
5955 dump_ctf_strtab_name
= strdup (optarg
);
5957 case OPTION_CTF_PARENT
:
5958 free (dump_ctf_parent_name
);
5959 dump_ctf_parent_name
= strdup (optarg
);
5961 case OPTION_SFRAME_DUMP
:
5963 /* Providing section name is optional. request_dump (), however,
5964 thrives on non NULL optarg. Handle it explicitly here. */
5966 request_dump (dumpdata
, SFRAME_DUMP
);
5970 const char *sframe_sec_name
= strdup (".sframe");
5971 request_dump_byname (sframe_sec_name
, SFRAME_DUMP
);
5974 case OPTION_DYN_SYMS
:
5977 case OPTION_LTO_SYMS
:
5980 #ifdef SUPPORT_DISASSEMBLY
5982 request_dump (dumpdata
, DISASS_DUMP
);
5986 print_version (program_name
);
5995 do_not_show_symbol_truncation
= true;
6001 enum demangling_styles style
;
6003 style
= cplus_demangle_name_to_style (optarg
);
6004 if (style
== unknown_demangling
)
6005 error (_("unknown demangling style `%s'"), optarg
);
6007 cplus_demangle_set_style (style
);
6010 case OPTION_NO_DEMANGLING
:
6011 do_demangle
= false;
6013 case OPTION_RECURSE_LIMIT
:
6014 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
6016 case OPTION_NO_RECURSE_LIMIT
:
6017 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
6019 case OPTION_WITH_SYMBOL_VERSIONS
:
6020 /* Ignored for backward compatibility. */
6025 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
6026 else if (streq (optarg
, "default") || streq (optarg
, "d"))
6027 unicode_display
= unicode_default
;
6028 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
6029 unicode_display
= unicode_locale
;
6030 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
6031 unicode_display
= unicode_escape
;
6032 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
6033 unicode_display
= unicode_invalid
;
6034 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
6035 unicode_display
= unicode_hex
;
6036 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
6037 unicode_display
= unicode_highlight
;
6039 error (_("invalid argument to -U/--unicode: %s"), optarg
);
6042 case OPTION_SYM_BASE
:
6046 sym_base
= strtoul (optarg
, NULL
, 0);
6063 /* xgettext:c-format */
6064 error (_("Invalid option '-%c'\n"), c
);
6071 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
6072 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
6073 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
6074 && !do_section_groups
&& !do_archive_index
6075 && !do_dyn_syms
&& !do_lto_syms
)
6080 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
6081 do_segments
= do_header
= do_dump
= do_version
= true;
6082 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
6083 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
6092 get_elf_class (unsigned int elf_class
)
6094 static char buff
[32];
6098 case ELFCLASSNONE
: return _("none");
6099 case ELFCLASS32
: return "ELF32";
6100 case ELFCLASS64
: return "ELF64";
6102 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
6108 get_data_encoding (unsigned int encoding
)
6110 static char buff
[32];
6114 case ELFDATANONE
: return _("none");
6115 case ELFDATA2LSB
: return _("2's complement, little endian");
6116 case ELFDATA2MSB
: return _("2's complement, big endian");
6118 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
6124 check_magic_number (Filedata
* filedata
, Elf_Internal_Ehdr
* header
)
6126 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
6127 && header
->e_ident
[EI_MAG1
] == ELFMAG1
6128 && header
->e_ident
[EI_MAG2
] == ELFMAG2
6129 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
6132 /* Some compilers produce object files that are not in the ELF file format.
6133 As an aid to users of readelf, try to identify these cases and suggest
6136 FIXME: It is not clear if all four bytes are used as constant magic
6137 valus by all compilers. It may be necessary to recode this function if
6138 different tools use different length sequences. */
6142 unsigned char magic
[4];
6143 const char * obj_message
;
6144 const char * ar_message
;
6148 { { 'B', 'C', 0xc0, 0xde },
6149 N_("This is a LLVM bitcode file - try using llvm-bcanalyzer\n"),
6150 N_("This is a LLVM bitcode file - try extracing and then using llvm-bcanalyzer\n")
6152 { { 'g', 'o', ' ', 'o' },
6153 N_("This is a GO binary file - try using 'go tool objdump' or 'go tool nm'\n"),
6159 for (i
= ARRAY_SIZE (known_magic
); i
--;)
6161 if (header
->e_ident
[EI_MAG0
] == known_magic
[i
].magic
[0]
6162 && header
->e_ident
[EI_MAG1
] == known_magic
[i
].magic
[1]
6163 && header
->e_ident
[EI_MAG2
] == known_magic
[i
].magic
[2]
6164 && header
->e_ident
[EI_MAG3
] == known_magic
[i
].magic
[3])
6166 /* Some compiler's analyzer tools do not handle archives,
6167 so we provide two different kinds of error message. */
6168 if (filedata
->archive_file_size
> 0
6169 && known_magic
[i
].ar_message
!= NULL
)
6170 error ("%s", known_magic
[i
].ar_message
);
6172 error ("%s", known_magic
[i
].obj_message
);
6177 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
6181 /* Decode the data held in 'filedata->file_header'. */
6184 process_file_header (Filedata
* filedata
)
6186 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
6188 if (! check_magic_number (filedata
, header
))
6191 if (! filedata
->is_separate
)
6192 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
6198 if (filedata
->is_separate
)
6199 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
6201 printf (_("ELF Header:\n"));
6202 printf (_(" Magic: "));
6203 for (i
= 0; i
< EI_NIDENT
; i
++)
6204 printf ("%2.2x ", header
->e_ident
[i
]);
6206 printf (_(" Class: %s\n"),
6207 get_elf_class (header
->e_ident
[EI_CLASS
]));
6208 printf (_(" Data: %s\n"),
6209 get_data_encoding (header
->e_ident
[EI_DATA
]));
6210 printf (_(" Version: %d%s\n"),
6211 header
->e_ident
[EI_VERSION
],
6212 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
6214 : (header
->e_ident
[EI_VERSION
] != EV_NONE
6217 printf (_(" OS/ABI: %s\n"),
6218 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
6219 printf (_(" ABI Version: %d\n"),
6220 header
->e_ident
[EI_ABIVERSION
]);
6221 printf (_(" Type: %s\n"),
6222 get_file_type (filedata
));
6223 printf (_(" Machine: %s\n"),
6224 get_machine_name (header
->e_machine
));
6225 printf (_(" Version: 0x%lx\n"),
6228 printf (_(" Entry point address: "));
6229 print_vma (header
->e_entry
, PREFIX_HEX
);
6230 printf (_("\n Start of program headers: "));
6231 print_vma (header
->e_phoff
, DEC
);
6232 printf (_(" (bytes into file)\n Start of section headers: "));
6233 print_vma (header
->e_shoff
, DEC
);
6234 printf (_(" (bytes into file)\n"));
6236 printf (_(" Flags: 0x%lx%s\n"),
6238 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
6239 printf (_(" Size of this header: %u (bytes)\n"),
6241 printf (_(" Size of program headers: %u (bytes)\n"),
6242 header
->e_phentsize
);
6243 printf (_(" Number of program headers: %u"),
6245 if (filedata
->section_headers
!= NULL
6246 && header
->e_phnum
== PN_XNUM
6247 && filedata
->section_headers
[0].sh_info
!= 0)
6248 printf (" (%u)", filedata
->section_headers
[0].sh_info
);
6249 putc ('\n', stdout
);
6250 printf (_(" Size of section headers: %u (bytes)\n"),
6251 header
->e_shentsize
);
6252 printf (_(" Number of section headers: %u"),
6254 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
6256 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
6257 printf (" (%u)", header
->e_shnum
);
6259 putc ('\n', stdout
);
6260 printf (_(" Section header string table index: %u"),
6261 header
->e_shstrndx
);
6262 if (filedata
->section_headers
!= NULL
6263 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
6265 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
6266 printf (" (%u)", header
->e_shstrndx
);
6268 if (header
->e_shstrndx
!= SHN_UNDEF
6269 && header
->e_shstrndx
>= header
->e_shnum
)
6271 header
->e_shstrndx
= SHN_UNDEF
;
6272 printf (_(" <corrupt: out of range>"));
6274 putc ('\n', stdout
);
6277 if (filedata
->section_headers
!= NULL
)
6279 if (header
->e_phnum
== PN_XNUM
6280 && filedata
->section_headers
[0].sh_info
!= 0)
6282 /* Throw away any cached read of PN_XNUM headers. */
6283 free (filedata
->program_headers
);
6284 filedata
->program_headers
= NULL
;
6285 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
6287 if (header
->e_shnum
== SHN_UNDEF
)
6288 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
6289 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
6290 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
6291 if (header
->e_shstrndx
>= header
->e_shnum
)
6292 header
->e_shstrndx
= SHN_UNDEF
;
6298 /* Read in the program headers from FILEDATA and store them in PHEADERS.
6299 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
6302 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
6304 Elf32_External_Phdr
* phdrs
;
6305 Elf32_External_Phdr
* external
;
6306 Elf_Internal_Phdr
* internal
;
6308 unsigned int size
= filedata
->file_header
.e_phentsize
;
6309 unsigned int num
= filedata
->file_header
.e_phnum
;
6311 /* PR binutils/17531: Cope with unexpected section header sizes. */
6312 if (size
== 0 || num
== 0)
6314 if (size
< sizeof * phdrs
)
6316 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6319 if (size
> sizeof * phdrs
)
6320 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6322 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6323 size
, num
, _("program headers"));
6327 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6328 i
< filedata
->file_header
.e_phnum
;
6329 i
++, internal
++, external
++)
6331 internal
->p_type
= BYTE_GET (external
->p_type
);
6332 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6333 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6334 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6335 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6336 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6337 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6338 internal
->p_align
= BYTE_GET (external
->p_align
);
6345 /* Read in the program headers from FILEDATA and store them in PHEADERS.
6346 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
6349 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
6351 Elf64_External_Phdr
* phdrs
;
6352 Elf64_External_Phdr
* external
;
6353 Elf_Internal_Phdr
* internal
;
6355 unsigned int size
= filedata
->file_header
.e_phentsize
;
6356 unsigned int num
= filedata
->file_header
.e_phnum
;
6358 /* PR binutils/17531: Cope with unexpected section header sizes. */
6359 if (size
== 0 || num
== 0)
6361 if (size
< sizeof * phdrs
)
6363 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6366 if (size
> sizeof * phdrs
)
6367 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6369 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6370 size
, num
, _("program headers"));
6374 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6375 i
< filedata
->file_header
.e_phnum
;
6376 i
++, internal
++, external
++)
6378 internal
->p_type
= BYTE_GET (external
->p_type
);
6379 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6380 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6381 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6382 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6383 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6384 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6385 internal
->p_align
= BYTE_GET (external
->p_align
);
6392 /* Returns TRUE if the program headers were read into `program_headers'. */
6395 get_program_headers (Filedata
* filedata
)
6397 Elf_Internal_Phdr
* phdrs
;
6399 /* Check cache of prior read. */
6400 if (filedata
->program_headers
!= NULL
)
6403 /* Be kind to memory checkers by looking for
6404 e_phnum values which we know must be invalid. */
6405 if (filedata
->file_header
.e_phnum
6406 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
6407 >= filedata
->file_size
)
6409 error (_("Too many program headers - %#x - the file is not that big\n"),
6410 filedata
->file_header
.e_phnum
);
6414 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
6415 sizeof (Elf_Internal_Phdr
));
6418 error (_("Out of memory reading %u program headers\n"),
6419 filedata
->file_header
.e_phnum
);
6424 ? get_32bit_program_headers (filedata
, phdrs
)
6425 : get_64bit_program_headers (filedata
, phdrs
))
6427 filedata
->program_headers
= phdrs
;
6435 /* Print program header info and locate dynamic section. */
6438 process_program_headers (Filedata
* filedata
)
6440 Elf_Internal_Phdr
* segment
;
6442 Elf_Internal_Phdr
* previous_load
= NULL
;
6444 if (filedata
->file_header
.e_phnum
== 0)
6446 /* PR binutils/12467. */
6447 if (filedata
->file_header
.e_phoff
!= 0)
6448 warn (_("possibly corrupt ELF header - it has a non-zero program"
6449 " header offset, but no program headers\n"));
6450 else if (do_segments
)
6452 if (filedata
->is_separate
)
6453 printf (_("\nThere are no program headers in linked file '%s'.\n"),
6454 filedata
->file_name
);
6456 printf (_("\nThere are no program headers in this file.\n"));
6461 if (do_segments
&& !do_header
)
6463 if (filedata
->is_separate
)
6464 printf ("\nIn linked file '%s' the ELF file type is %s\n",
6465 filedata
->file_name
, get_file_type (filedata
));
6467 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
6468 printf (_("Entry point 0x%" PRIx64
"\n"),
6469 filedata
->file_header
.e_entry
);
6470 printf (ngettext ("There is %d program header,"
6471 " starting at offset %" PRIu64
"\n",
6472 "There are %d program headers,"
6473 " starting at offset %" PRIu64
"\n",
6474 filedata
->file_header
.e_phnum
),
6475 filedata
->file_header
.e_phnum
,
6476 filedata
->file_header
.e_phoff
);
6479 if (! get_program_headers (filedata
))
6484 if (filedata
->file_header
.e_phnum
> 1)
6485 printf (_("\nProgram Headers:\n"));
6487 printf (_("\nProgram Headers:\n"));
6491 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6494 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6498 (_(" Type Offset VirtAddr PhysAddr\n"));
6500 (_(" FileSiz MemSiz Flags Align\n"));
6504 uint64_t dynamic_addr
= 0;
6505 uint64_t dynamic_size
= 0;
6506 for (i
= 0, segment
= filedata
->program_headers
;
6507 i
< filedata
->file_header
.e_phnum
;
6512 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
6516 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6517 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
6518 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
6519 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
6520 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
6522 (segment
->p_flags
& PF_R
? 'R' : ' '),
6523 (segment
->p_flags
& PF_W
? 'W' : ' '),
6524 (segment
->p_flags
& PF_X
? 'E' : ' '));
6525 printf ("%#lx", (unsigned long) segment
->p_align
);
6529 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
6530 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6533 print_vma (segment
->p_offset
, FULL_HEX
);
6537 print_vma (segment
->p_vaddr
, FULL_HEX
);
6539 print_vma (segment
->p_paddr
, FULL_HEX
);
6542 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
6543 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
6546 print_vma (segment
->p_filesz
, FULL_HEX
);
6550 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
6551 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
6554 print_vma (segment
->p_memsz
, FULL_HEX
);
6558 (segment
->p_flags
& PF_R
? 'R' : ' '),
6559 (segment
->p_flags
& PF_W
? 'W' : ' '),
6560 (segment
->p_flags
& PF_X
? 'E' : ' '));
6562 if ((unsigned long) segment
->p_align
== segment
->p_align
)
6563 printf ("%#lx", (unsigned long) segment
->p_align
);
6566 print_vma (segment
->p_align
, PREFIX_HEX
);
6571 print_vma (segment
->p_offset
, FULL_HEX
);
6573 print_vma (segment
->p_vaddr
, FULL_HEX
);
6575 print_vma (segment
->p_paddr
, FULL_HEX
);
6577 print_vma (segment
->p_filesz
, FULL_HEX
);
6579 print_vma (segment
->p_memsz
, FULL_HEX
);
6581 (segment
->p_flags
& PF_R
? 'R' : ' '),
6582 (segment
->p_flags
& PF_W
? 'W' : ' '),
6583 (segment
->p_flags
& PF_X
? 'E' : ' '));
6584 print_vma (segment
->p_align
, PREFIX_HEX
);
6587 putc ('\n', stdout
);
6590 switch (segment
->p_type
)
6593 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
6594 required by the ELF standard, several programs, including the Linux
6595 kernel, make use of non-ordered segments. */
6597 && previous_load
->p_vaddr
> segment
->p_vaddr
)
6598 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
6600 if (segment
->p_memsz
< segment
->p_filesz
)
6601 error (_("the segment's file size is larger than its memory size\n"));
6602 previous_load
= segment
;
6606 /* PR 20815 - Verify that the program header is loaded into memory. */
6607 if (i
> 0 && previous_load
!= NULL
)
6608 error (_("the PHDR segment must occur before any LOAD segment\n"));
6609 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
6613 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
6615 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
6616 if (load
->p_type
== PT_LOAD
6617 && load
->p_offset
<= segment
->p_offset
6618 && (load
->p_offset
+ load
->p_filesz
6619 >= segment
->p_offset
+ segment
->p_filesz
)
6620 && load
->p_vaddr
<= segment
->p_vaddr
6621 && (load
->p_vaddr
+ load
->p_filesz
6622 >= segment
->p_vaddr
+ segment
->p_filesz
))
6625 if (j
== filedata
->file_header
.e_phnum
)
6626 error (_("the PHDR segment is not covered by a LOAD segment\n"));
6632 error (_("more than one dynamic segment\n"));
6634 /* By default, assume that the .dynamic section is the first
6635 section in the DYNAMIC segment. */
6636 dynamic_addr
= segment
->p_offset
;
6637 dynamic_size
= segment
->p_filesz
;
6639 /* Try to locate the .dynamic section. If there is
6640 a section header table, we can easily locate it. */
6641 if (filedata
->section_headers
!= NULL
)
6643 Elf_Internal_Shdr
* sec
;
6645 sec
= find_section (filedata
, ".dynamic");
6646 if (sec
== NULL
|| sec
->sh_size
== 0)
6648 /* A corresponding .dynamic section is expected, but on
6649 IA-64/OpenVMS it is OK for it to be missing. */
6650 if (!is_ia64_vms (filedata
))
6651 error (_("no .dynamic section in the dynamic segment\n"));
6655 if (sec
->sh_type
== SHT_NOBITS
)
6662 dynamic_addr
= sec
->sh_offset
;
6663 dynamic_size
= sec
->sh_size
;
6665 /* The PT_DYNAMIC segment, which is used by the run-time
6666 loader, should exactly match the .dynamic section. */
6668 && (dynamic_addr
!= segment
->p_offset
6669 || dynamic_size
!= segment
->p_filesz
))
6671 the .dynamic section is not the same as the dynamic segment\n"));
6674 /* PR binutils/17512: Avoid corrupt dynamic section info in the
6675 segment. Check this after matching against the section headers
6676 so we don't warn on debuginfo file (which have NOBITS .dynamic
6678 if (dynamic_addr
> filedata
->file_size
6679 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
6681 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
6688 if (segment
->p_offset
>= filedata
->file_size
6689 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
6690 || segment
->p_filesz
- 1 >= (size_t) -2
6691 || fseek64 (filedata
->handle
,
6692 filedata
->archive_file_offset
+ segment
->p_offset
,
6694 error (_("Unable to find program interpreter name\n"));
6697 size_t len
= segment
->p_filesz
;
6698 free (filedata
->program_interpreter
);
6699 filedata
->program_interpreter
= xmalloc (len
+ 1);
6700 len
= fread (filedata
->program_interpreter
, 1, len
,
6702 filedata
->program_interpreter
[len
] = 0;
6705 printf (_(" [Requesting program interpreter: %s]\n"),
6706 filedata
->program_interpreter
);
6713 && filedata
->section_headers
!= NULL
6714 && filedata
->string_table
!= NULL
)
6716 printf (_("\n Section to Segment mapping:\n"));
6717 printf (_(" Segment Sections...\n"));
6719 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
6722 Elf_Internal_Shdr
* section
;
6724 segment
= filedata
->program_headers
+ i
;
6725 section
= filedata
->section_headers
+ 1;
6727 printf (" %2.2d ", i
);
6729 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
6731 if (!ELF_TBSS_SPECIAL (section
, segment
)
6732 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
6733 printf ("%s ", printable_section_name (filedata
, section
));
6740 filedata
->dynamic_addr
= dynamic_addr
;
6741 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
6745 filedata
->dynamic_addr
= 0;
6746 filedata
->dynamic_size
= 1;
6750 /* Find the file offset corresponding to VMA by using the program headers. */
6753 offset_from_vma (Filedata
* filedata
, uint64_t vma
, uint64_t size
)
6755 Elf_Internal_Phdr
* seg
;
6757 if (! get_program_headers (filedata
))
6759 warn (_("Cannot interpret virtual addresses without program headers.\n"));
6763 for (seg
= filedata
->program_headers
;
6764 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
6767 if (seg
->p_type
!= PT_LOAD
)
6770 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
6771 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
6772 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
6775 warn (_("Virtual address %#" PRIx64
6776 " not located in any PT_LOAD segment.\n"), vma
);
6781 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
6782 If PROBE is true, this is just a probe and we do not generate any error
6783 messages if the load fails. */
6786 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
6788 Elf32_External_Shdr
* shdrs
;
6789 Elf_Internal_Shdr
* internal
;
6791 unsigned int size
= filedata
->file_header
.e_shentsize
;
6792 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6794 /* PR binutils/17531: Cope with unexpected section header sizes. */
6795 if (size
== 0 || num
== 0)
6798 /* The section header cannot be at the start of the file - that is
6799 where the ELF file header is located. A file with absolutely no
6800 sections in it will use a shoff of 0. */
6801 if (filedata
->file_header
.e_shoff
== 0)
6804 if (size
< sizeof * shdrs
)
6807 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6810 if (!probe
&& size
> sizeof * shdrs
)
6811 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6813 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
6815 probe
? NULL
: _("section headers"));
6819 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6820 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6821 if (filedata
->section_headers
== NULL
)
6824 error (_("Out of memory reading %u section headers\n"), num
);
6829 for (i
= 0, internal
= filedata
->section_headers
;
6833 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6834 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6835 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6836 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6837 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6838 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6839 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6840 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6841 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6842 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6843 if (!probe
&& internal
->sh_link
> num
)
6844 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6845 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6846 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6853 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
6856 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
6858 Elf64_External_Shdr
* shdrs
;
6859 Elf_Internal_Shdr
* internal
;
6861 unsigned int size
= filedata
->file_header
.e_shentsize
;
6862 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6864 /* PR binutils/17531: Cope with unexpected section header sizes. */
6865 if (size
== 0 || num
== 0)
6868 /* The section header cannot be at the start of the file - that is
6869 where the ELF file header is located. A file with absolutely no
6870 sections in it will use a shoff of 0. */
6871 if (filedata
->file_header
.e_shoff
== 0)
6874 if (size
< sizeof * shdrs
)
6877 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6881 if (! probe
&& size
> sizeof * shdrs
)
6882 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6884 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
6885 filedata
->file_header
.e_shoff
,
6887 probe
? NULL
: _("section headers"));
6891 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6892 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6893 if (filedata
->section_headers
== NULL
)
6896 error (_("Out of memory reading %u section headers\n"), num
);
6901 for (i
= 0, internal
= filedata
->section_headers
;
6905 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6906 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6907 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6908 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6909 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6910 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6911 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6912 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6913 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6914 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6915 if (!probe
&& internal
->sh_link
> num
)
6916 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6917 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6918 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6926 get_section_headers (Filedata
*filedata
, bool probe
)
6928 if (filedata
->section_headers
!= NULL
)
6932 return get_32bit_section_headers (filedata
, probe
);
6934 return get_64bit_section_headers (filedata
, probe
);
6937 static Elf_Internal_Sym
*
6938 get_32bit_elf_symbols (Filedata
*filedata
,
6939 Elf_Internal_Shdr
*section
,
6940 uint64_t *num_syms_return
)
6942 uint64_t number
= 0;
6943 Elf32_External_Sym
* esyms
= NULL
;
6944 Elf_External_Sym_Shndx
* shndx
= NULL
;
6945 Elf_Internal_Sym
* isyms
= NULL
;
6946 Elf_Internal_Sym
* psym
;
6948 elf_section_list
* entry
;
6950 if (section
->sh_size
== 0)
6952 if (num_syms_return
!= NULL
)
6953 * num_syms_return
= 0;
6957 /* Run some sanity checks first. */
6958 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6960 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
6961 printable_section_name (filedata
, section
),
6962 section
->sh_entsize
);
6966 if (section
->sh_size
> filedata
->file_size
)
6968 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
6969 printable_section_name (filedata
, section
),
6974 number
= section
->sh_size
/ section
->sh_entsize
;
6976 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
6978 error (_("Size (%#" PRIx64
") of section %s "
6979 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
6981 printable_section_name (filedata
, section
),
6982 section
->sh_entsize
);
6986 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6987 section
->sh_size
, _("symbols"));
6992 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6994 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
6999 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
7003 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
7004 entry
->hdr
->sh_offset
,
7005 1, entry
->hdr
->sh_size
,
7006 _("symbol table section indices"));
7010 /* PR17531: file: heap-buffer-overflow */
7011 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
7013 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
7014 printable_section_name (filedata
, entry
->hdr
),
7015 entry
->hdr
->sh_size
,
7021 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
7025 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
7029 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
7031 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
7032 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
7033 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
7034 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
7035 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
7037 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
7038 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
7039 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
7040 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
7041 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
7048 if (num_syms_return
!= NULL
)
7049 * num_syms_return
= isyms
== NULL
? 0 : number
;
7054 static Elf_Internal_Sym
*
7055 get_64bit_elf_symbols (Filedata
*filedata
,
7056 Elf_Internal_Shdr
*section
,
7057 uint64_t *num_syms_return
)
7059 uint64_t number
= 0;
7060 Elf64_External_Sym
* esyms
= NULL
;
7061 Elf_External_Sym_Shndx
* shndx
= NULL
;
7062 Elf_Internal_Sym
* isyms
= NULL
;
7063 Elf_Internal_Sym
* psym
;
7065 elf_section_list
* entry
;
7067 if (section
->sh_size
== 0)
7069 if (num_syms_return
!= NULL
)
7070 * num_syms_return
= 0;
7074 /* Run some sanity checks first. */
7075 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
7077 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
7078 printable_section_name (filedata
, section
),
7079 section
->sh_entsize
);
7083 if (section
->sh_size
> filedata
->file_size
)
7085 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
7086 printable_section_name (filedata
, section
),
7091 number
= section
->sh_size
/ section
->sh_entsize
;
7093 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
7095 error (_("Size (%#" PRIx64
") of section %s "
7096 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
7098 printable_section_name (filedata
, section
),
7099 section
->sh_entsize
);
7103 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
7104 section
->sh_size
, _("symbols"));
7109 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
7111 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
7116 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
7120 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
7121 entry
->hdr
->sh_offset
,
7122 1, entry
->hdr
->sh_size
,
7123 _("symbol table section indices"));
7127 /* PR17531: file: heap-buffer-overflow */
7128 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
7130 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
7131 printable_section_name (filedata
, entry
->hdr
),
7132 entry
->hdr
->sh_size
,
7138 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
7142 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
7146 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
7148 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
7149 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
7150 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
7151 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
7153 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
7155 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
7156 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
7157 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
7159 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
7160 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
7167 if (num_syms_return
!= NULL
)
7168 * num_syms_return
= isyms
== NULL
? 0 : number
;
7173 static Elf_Internal_Sym
*
7174 get_elf_symbols (Filedata
*filedata
,
7175 Elf_Internal_Shdr
*section
,
7176 uint64_t *num_syms_return
)
7179 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
7181 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
7185 get_elf_section_flags (Filedata
* filedata
, uint64_t sh_flags
)
7187 static char buff
[1024];
7189 unsigned int field_size
= is_32bit_elf
? 8 : 16;
7191 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
7192 uint64_t os_flags
= 0;
7193 uint64_t proc_flags
= 0;
7194 uint64_t unknown_flags
= 0;
7202 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
7203 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
7204 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
7205 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
7206 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
7207 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
7208 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
7209 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
7210 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
7211 /* 9 */ { STRING_COMMA_LEN ("TLS") },
7212 /* IA-64 specific. */
7213 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
7214 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
7215 /* IA-64 OpenVMS specific. */
7216 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
7217 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
7218 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
7219 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
7220 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
7221 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
7223 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
7224 /* SPARC specific. */
7225 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
7226 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
7228 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
7229 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
7230 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
7232 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
7234 /* 25 */ { STRING_COMMA_LEN ("VLE") },
7236 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
7239 if (do_section_details
)
7240 p
+= sprintf (p
, "[%*.*lx]: ",
7241 field_size
, field_size
, (unsigned long) sh_flags
);
7247 flag
= sh_flags
& - sh_flags
;
7250 if (do_section_details
)
7254 case SHF_WRITE
: sindex
= 0; break;
7255 case SHF_ALLOC
: sindex
= 1; break;
7256 case SHF_EXECINSTR
: sindex
= 2; break;
7257 case SHF_MERGE
: sindex
= 3; break;
7258 case SHF_STRINGS
: sindex
= 4; break;
7259 case SHF_INFO_LINK
: sindex
= 5; break;
7260 case SHF_LINK_ORDER
: sindex
= 6; break;
7261 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
7262 case SHF_GROUP
: sindex
= 8; break;
7263 case SHF_TLS
: sindex
= 9; break;
7264 case SHF_EXCLUDE
: sindex
= 18; break;
7265 case SHF_COMPRESSED
: sindex
= 20; break;
7269 switch (filedata
->file_header
.e_machine
)
7272 if (flag
== SHF_IA_64_SHORT
)
7274 else if (flag
== SHF_IA_64_NORECOV
)
7276 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
7279 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
7280 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
7281 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
7282 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
7283 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
7284 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
7294 case EM_OLD_SPARCV9
:
7295 case EM_SPARC32PLUS
:
7298 if (flag
== SHF_ORDERED
)
7305 case SHF_ENTRYSECT
: sindex
= 21; break;
7306 case SHF_ARM_PURECODE
: sindex
= 22; break;
7307 case SHF_COMDEF
: sindex
= 23; break;
7312 if (flag
== SHF_PPC_VLE
)
7319 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7322 case ELFOSABI_FREEBSD
:
7323 if (flag
== SHF_GNU_RETAIN
)
7327 if (flag
== SHF_GNU_MBIND
)
7328 /* We should not recognize SHF_GNU_MBIND for
7329 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7330 not set the EI_OSABI header byte. */
7341 if (p
!= buff
+ field_size
+ 4)
7343 if (size
< (10 + 2))
7345 warn (_("Internal error: not enough buffer room for section flag info"));
7346 return _("<unknown>");
7353 size
-= flags
[sindex
].len
;
7354 p
= stpcpy (p
, flags
[sindex
].str
);
7356 else if (flag
& SHF_MASKOS
)
7358 else if (flag
& SHF_MASKPROC
)
7361 unknown_flags
|= flag
;
7367 case SHF_WRITE
: *p
= 'W'; break;
7368 case SHF_ALLOC
: *p
= 'A'; break;
7369 case SHF_EXECINSTR
: *p
= 'X'; break;
7370 case SHF_MERGE
: *p
= 'M'; break;
7371 case SHF_STRINGS
: *p
= 'S'; break;
7372 case SHF_INFO_LINK
: *p
= 'I'; break;
7373 case SHF_LINK_ORDER
: *p
= 'L'; break;
7374 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
7375 case SHF_GROUP
: *p
= 'G'; break;
7376 case SHF_TLS
: *p
= 'T'; break;
7377 case SHF_EXCLUDE
: *p
= 'E'; break;
7378 case SHF_COMPRESSED
: *p
= 'C'; break;
7381 if ((filedata
->file_header
.e_machine
== EM_X86_64
7382 || filedata
->file_header
.e_machine
== EM_L1OM
7383 || filedata
->file_header
.e_machine
== EM_K1OM
)
7384 && flag
== SHF_X86_64_LARGE
)
7386 else if (filedata
->file_header
.e_machine
== EM_ARM
7387 && flag
== SHF_ARM_PURECODE
)
7389 else if (filedata
->file_header
.e_machine
== EM_PPC
7390 && flag
== SHF_PPC_VLE
)
7392 else if (flag
& SHF_MASKOS
)
7394 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7397 case ELFOSABI_FREEBSD
:
7398 if (flag
== SHF_GNU_RETAIN
)
7405 if (flag
== SHF_GNU_MBIND
)
7407 /* We should not recognize SHF_GNU_MBIND for
7408 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7409 not set the EI_OSABI header byte. */
7416 sh_flags
&= ~SHF_MASKOS
;
7420 else if (flag
& SHF_MASKPROC
)
7423 sh_flags
&= ~ SHF_MASKPROC
;
7433 if (do_section_details
)
7437 if (p
!= buff
+ field_size
+ 4)
7439 if (size
< 2 + 5 + field_size
+ 1)
7441 warn (_("Internal error: not enough buffer room for section flag info"));
7442 return _("<unknown>");
7448 size
-= 5 + field_size
;
7449 p
+= sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
7450 (unsigned long) os_flags
);
7454 if (p
!= buff
+ field_size
+ 4)
7456 if (size
< 2 + 7 + field_size
+ 1)
7458 warn (_("Internal error: not enough buffer room for section flag info"));
7459 return _("<unknown>");
7465 size
-= 7 + field_size
;
7466 p
+= sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
7467 (unsigned long) proc_flags
);
7471 if (p
!= buff
+ field_size
+ 4)
7473 if (size
< 2 + 10 + field_size
+ 1)
7475 warn (_("Internal error: not enough buffer room for section flag info"));
7476 return _("<unknown>");
7482 size
-= 10 + field_size
;
7483 p
+= sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
7484 (unsigned long) unknown_flags
);
7492 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
7493 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
,
7498 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
7500 if (size
< sizeof (* echdr
))
7502 error (_("Compressed section is too small even for a compression header\n"));
7506 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7507 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7508 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7509 return sizeof (*echdr
);
7513 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
7515 if (size
< sizeof (* echdr
))
7517 error (_("Compressed section is too small even for a compression header\n"));
7521 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7522 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7523 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7524 return sizeof (*echdr
);
7529 process_section_headers (Filedata
* filedata
)
7531 Elf_Internal_Shdr
* section
;
7534 if (filedata
->file_header
.e_shnum
== 0)
7536 /* PR binutils/12467. */
7537 if (filedata
->file_header
.e_shoff
!= 0)
7539 warn (_("possibly corrupt ELF file header - it has a non-zero"
7540 " section header offset, but no section headers\n"));
7543 else if (do_sections
)
7544 printf (_("\nThere are no sections in this file.\n"));
7549 if (do_sections
&& !do_header
)
7551 if (filedata
->is_separate
&& process_links
)
7552 printf (_("In linked file '%s': "), filedata
->file_name
);
7553 if (! filedata
->is_separate
|| process_links
)
7554 printf (ngettext ("There is %d section header, "
7555 "starting at offset %#" PRIx64
":\n",
7556 "There are %d section headers, "
7557 "starting at offset %#" PRIx64
":\n",
7558 filedata
->file_header
.e_shnum
),
7559 filedata
->file_header
.e_shnum
,
7560 filedata
->file_header
.e_shoff
);
7563 if (!get_section_headers (filedata
, false))
7566 /* Read in the string table, so that we have names to display. */
7567 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
7568 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
7570 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
7572 if (section
->sh_size
!= 0)
7574 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7575 1, section
->sh_size
,
7578 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
7582 /* Scan the sections for the dynamic symbol table
7583 and dynamic string table and debug sections. */
7584 eh_addr_size
= is_32bit_elf
? 4 : 8;
7585 switch (filedata
->file_header
.e_machine
)
7588 case EM_MIPS_RS3_LE
:
7589 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
7590 FDE addresses. However, the ABI also has a semi-official ILP32
7591 variant for which the normal FDE address size rules apply.
7593 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
7594 section, where XX is the size of longs in bits. Unfortunately,
7595 earlier compilers provided no way of distinguishing ILP32 objects
7596 from LP64 objects, so if there's any doubt, we should assume that
7597 the official LP64 form is being used. */
7598 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
7599 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
7605 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
7607 case E_H8_MACH_H8300
:
7608 case E_H8_MACH_H8300HN
:
7609 case E_H8_MACH_H8300SN
:
7610 case E_H8_MACH_H8300SXN
:
7613 case E_H8_MACH_H8300H
:
7614 case E_H8_MACH_H8300S
:
7615 case E_H8_MACH_H8300SX
:
7623 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
7625 case EF_M32C_CPU_M16C
:
7632 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
7635 uint64_t expected_entsize = is_32bit_elf ? size32 : size64; \
7636 if (section->sh_entsize != expected_entsize) \
7638 error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
7639 i, section->sh_entsize); \
7640 error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
7641 expected_entsize); \
7642 section->sh_entsize = expected_entsize; \
7647 #define CHECK_ENTSIZE(section, i, type) \
7648 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
7649 sizeof (Elf64_External_##type))
7651 for (i
= 0, section
= filedata
->section_headers
;
7652 i
< filedata
->file_header
.e_shnum
;
7655 const char *name
= section_name_print (filedata
, section
);
7657 /* Run some sanity checks on the headers and
7658 possibly fill in some file data as well. */
7659 switch (section
->sh_type
)
7662 if (filedata
->dynamic_symbols
!= NULL
)
7664 error (_("File contains multiple dynamic symbol tables\n"));
7668 CHECK_ENTSIZE (section
, i
, Sym
);
7669 filedata
->dynamic_symbols
7670 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
7671 filedata
->dynamic_symtab_section
= section
;
7675 if (streq (name
, ".dynstr"))
7677 if (filedata
->dynamic_strings
!= NULL
)
7679 error (_("File contains multiple dynamic string tables\n"));
7683 filedata
->dynamic_strings
7684 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7685 1, section
->sh_size
, _("dynamic strings"));
7686 filedata
->dynamic_strings_length
7687 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
7688 filedata
->dynamic_strtab_section
= section
;
7692 case SHT_SYMTAB_SHNDX
:
7694 elf_section_list
* entry
= xmalloc (sizeof * entry
);
7696 entry
->hdr
= section
;
7697 entry
->next
= filedata
->symtab_shndx_list
;
7698 filedata
->symtab_shndx_list
= entry
;
7703 CHECK_ENTSIZE (section
, i
, Sym
);
7707 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
7711 CHECK_ENTSIZE (section
, i
, Rel
);
7712 if (do_checks
&& section
->sh_size
== 0)
7713 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7717 CHECK_ENTSIZE (section
, i
, Rela
);
7718 if (do_checks
&& section
->sh_size
== 0)
7719 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7723 CHECK_ENTSIZE (section
, i
, Relr
);
7728 /* Having a zero sized section is not illegal according to the
7729 ELF standard, but it might be an indication that something
7730 is wrong. So issue a warning if we are running in lint mode. */
7731 if (do_checks
&& section
->sh_size
== 0)
7732 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
7739 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
7740 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
7741 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
7742 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
7744 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
7745 && (startswith (name
, ".debug_")
7746 || startswith (name
, ".zdebug_")))
7749 name
+= sizeof (".zdebug_") - 1;
7751 name
+= sizeof (".debug_") - 1;
7754 || (do_debug_info
&& startswith (name
, "info"))
7755 || (do_debug_info
&& startswith (name
, "types"))
7756 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
7757 || (do_debug_lines
&& strcmp (name
, "line") == 0)
7758 || (do_debug_lines
&& startswith (name
, "line."))
7759 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
7760 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
7761 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
7762 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
7763 || (do_debug_aranges
&& startswith (name
, "aranges"))
7764 || (do_debug_ranges
&& startswith (name
, "ranges"))
7765 || (do_debug_ranges
&& startswith (name
, "rnglists"))
7766 || (do_debug_frames
&& startswith (name
, "frame"))
7767 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
7768 || (do_debug_macinfo
&& startswith (name
, "macro"))
7769 || (do_debug_str
&& startswith (name
, "str"))
7770 || (do_debug_links
&& startswith (name
, "sup"))
7771 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
7772 || (do_debug_loc
&& startswith (name
, "loc"))
7773 || (do_debug_loc
&& startswith (name
, "loclists"))
7774 || (do_debug_addr
&& startswith (name
, "addr"))
7775 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
7776 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
7778 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7780 /* Linkonce section to be combined with .debug_info at link time. */
7781 else if ((do_debugging
|| do_debug_info
)
7782 && startswith (name
, ".gnu.linkonce.wi."))
7783 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7784 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
7785 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7786 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
7787 || streq (name
, ".debug_names")))
7788 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7789 /* Trace sections for Itanium VMS. */
7790 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
7791 || do_trace_aranges
)
7792 && startswith (name
, ".trace_"))
7794 name
+= sizeof (".trace_") - 1;
7797 || (do_trace_info
&& streq (name
, "info"))
7798 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
7799 || (do_trace_aranges
&& streq (name
, "aranges"))
7801 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7803 else if ((do_debugging
|| do_debug_links
)
7804 && (startswith (name
, ".gnu_debuglink")
7805 || startswith (name
, ".gnu_debugaltlink")))
7806 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7812 if (filedata
->is_separate
&& ! process_links
)
7815 if (filedata
->is_separate
)
7816 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
7817 else if (filedata
->file_header
.e_shnum
> 1)
7818 printf (_("\nSection Headers:\n"));
7820 printf (_("\nSection Header:\n"));
7824 if (do_section_details
)
7826 printf (_(" [Nr] Name\n"));
7827 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
7831 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
7835 if (do_section_details
)
7837 printf (_(" [Nr] Name\n"));
7838 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
7842 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
7846 if (do_section_details
)
7848 printf (_(" [Nr] Name\n"));
7849 printf (_(" Type Address Offset Link\n"));
7850 printf (_(" Size EntSize Info Align\n"));
7854 printf (_(" [Nr] Name Type Address Offset\n"));
7855 printf (_(" Size EntSize Flags Link Info Align\n"));
7859 if (do_section_details
)
7860 printf (_(" Flags\n"));
7862 for (i
= 0, section
= filedata
->section_headers
;
7863 i
< filedata
->file_header
.e_shnum
;
7866 /* Run some sanity checks on the section header. */
7868 /* Check the sh_link field. */
7869 switch (section
->sh_type
)
7873 if (section
->sh_link
== 0
7874 && (filedata
->file_header
.e_type
== ET_EXEC
7875 || filedata
->file_header
.e_type
== ET_DYN
))
7876 /* A dynamic relocation section where all entries use a
7877 zero symbol index need not specify a symtab section. */
7880 case SHT_SYMTAB_SHNDX
:
7884 case SHT_GNU_versym
:
7885 if (section
->sh_link
== 0
7886 || section
->sh_link
>= filedata
->file_header
.e_shnum
7887 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
7888 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
7889 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
7890 i
, section
->sh_link
);
7896 case SHT_GNU_verneed
:
7897 case SHT_GNU_verdef
:
7898 case SHT_GNU_LIBLIST
:
7899 if (section
->sh_link
== 0
7900 || section
->sh_link
>= filedata
->file_header
.e_shnum
7901 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
7902 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
7903 i
, section
->sh_link
);
7906 case SHT_INIT_ARRAY
:
7907 case SHT_FINI_ARRAY
:
7908 case SHT_PREINIT_ARRAY
:
7909 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7910 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7911 i
, section
->sh_link
);
7915 /* FIXME: Add support for target specific section types. */
7916 #if 0 /* Currently we do not check other section types as there are too
7917 many special cases. Stab sections for example have a type
7918 of SHT_PROGBITS but an sh_link field that links to the .stabstr
7920 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7921 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7922 i
, section
->sh_link
);
7927 /* Check the sh_info field. */
7928 switch (section
->sh_type
)
7932 if (section
->sh_info
== 0
7933 && (filedata
->file_header
.e_type
== ET_EXEC
7934 || filedata
->file_header
.e_type
== ET_DYN
))
7935 /* Dynamic relocations apply to segments, so they do not
7936 need to specify the section they relocate. */
7938 if (section
->sh_info
== 0
7939 || section
->sh_info
>= filedata
->file_header
.e_shnum
7940 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
7941 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
7942 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
7943 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
7944 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
7945 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
7946 /* FIXME: Are other section types valid ? */
7947 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
7948 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
7949 i
, section
->sh_info
);
7954 case SHT_SYMTAB_SHNDX
:
7955 case SHT_INIT_ARRAY
:
7956 case SHT_FINI_ARRAY
:
7957 case SHT_PREINIT_ARRAY
:
7958 if (section
->sh_info
!= 0)
7959 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7960 i
, section
->sh_info
);
7966 /* A symbol index - we assume that it is valid. */
7970 /* FIXME: Add support for target specific section types. */
7971 if (section
->sh_type
== SHT_NOBITS
)
7972 /* NOBITS section headers with non-zero sh_info fields can be
7973 created when a binary is stripped of everything but its debug
7974 information. The stripped sections have their headers
7975 preserved but their types set to SHT_NOBITS. So do not check
7976 this type of section. */
7978 else if (section
->sh_flags
& SHF_INFO_LINK
)
7980 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
7981 warn (_("[%2u]: Expected link to another section in info field"), i
);
7983 else if (section
->sh_type
< SHT_LOOS
7984 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
7985 && section
->sh_info
!= 0)
7986 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7987 i
, section
->sh_info
);
7991 /* Check the sh_size field. */
7992 if (section
->sh_size
> filedata
->file_size
7993 && section
->sh_type
!= SHT_NOBITS
7994 && section
->sh_type
!= SHT_NULL
7995 && section
->sh_type
< SHT_LOOS
)
7996 warn (_("Size of section %u is larger than the entire file!\n"), i
);
7998 printf (" [%2u] ", i
);
7999 if (do_section_details
)
8000 printf ("%s\n ", printable_section_name (filedata
, section
));
8002 print_symbol (-17, section_name_print (filedata
, section
));
8004 printf (do_wide
? " %-15s " : " %-15.15s ",
8005 get_section_type_name (filedata
, section
->sh_type
));
8009 const char * link_too_big
= NULL
;
8011 print_vma (section
->sh_addr
, LONG_HEX
);
8013 printf ( " %6.6lx %6.6lx %2.2lx",
8014 (unsigned long) section
->sh_offset
,
8015 (unsigned long) section
->sh_size
,
8016 (unsigned long) section
->sh_entsize
);
8018 if (do_section_details
)
8019 fputs (" ", stdout
);
8021 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8023 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
8026 /* The sh_link value is out of range. Normally this indicates
8027 an error but it can have special values in Solaris binaries. */
8028 switch (filedata
->file_header
.e_machine
)
8035 case EM_OLD_SPARCV9
:
8036 case EM_SPARC32PLUS
:
8039 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
8040 link_too_big
= "BEFORE";
8041 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
8042 link_too_big
= "AFTER";
8049 if (do_section_details
)
8051 if (link_too_big
!= NULL
&& * link_too_big
)
8052 printf ("<%s> ", link_too_big
);
8054 printf ("%2u ", section
->sh_link
);
8055 printf ("%3u %2lu\n", section
->sh_info
,
8056 (unsigned long) section
->sh_addralign
);
8059 printf ("%2u %3u %2lu\n",
8062 (unsigned long) section
->sh_addralign
);
8064 if (link_too_big
&& ! * link_too_big
)
8065 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
8066 i
, section
->sh_link
);
8070 print_vma (section
->sh_addr
, LONG_HEX
);
8072 if ((long) section
->sh_offset
== section
->sh_offset
)
8073 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
8077 print_vma (section
->sh_offset
, LONG_HEX
);
8080 if ((unsigned long) section
->sh_size
== section
->sh_size
)
8081 printf (" %6.6lx", (unsigned long) section
->sh_size
);
8085 print_vma (section
->sh_size
, LONG_HEX
);
8088 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
8089 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
8093 print_vma (section
->sh_entsize
, LONG_HEX
);
8096 if (do_section_details
)
8097 fputs (" ", stdout
);
8099 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8101 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
8103 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
8104 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
8107 print_vma (section
->sh_addralign
, DEC
);
8111 else if (do_section_details
)
8114 print_vma (section
->sh_addr
, LONG_HEX
);
8115 if ((long) section
->sh_offset
== section
->sh_offset
)
8116 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
8120 print_vma (section
->sh_offset
, LONG_HEX
);
8122 printf (" %u\n ", section
->sh_link
);
8123 print_vma (section
->sh_size
, LONG_HEX
);
8125 print_vma (section
->sh_entsize
, LONG_HEX
);
8127 printf (" %-16u %lu\n",
8129 (unsigned long) section
->sh_addralign
);
8134 print_vma (section
->sh_addr
, LONG_HEX
);
8135 if ((long) section
->sh_offset
== section
->sh_offset
)
8136 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
8140 print_vma (section
->sh_offset
, LONG_HEX
);
8143 print_vma (section
->sh_size
, LONG_HEX
);
8145 print_vma (section
->sh_entsize
, LONG_HEX
);
8147 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8149 printf (" %2u %3u %lu\n",
8152 (unsigned long) section
->sh_addralign
);
8155 if (do_section_details
)
8157 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
8158 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
8160 /* Minimum section size is 12 bytes for 32-bit compression
8161 header + 12 bytes for compressed data header. */
8162 unsigned char buf
[24];
8164 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
8165 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
8166 sizeof (buf
), _("compression header")))
8168 Elf_Internal_Chdr chdr
;
8170 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
8171 printf (_(" [<corrupt>]\n"));
8174 if (chdr
.ch_type
== ch_compress_zlib
)
8176 else if (chdr
.ch_type
== ch_compress_zstd
)
8179 printf (_(" [<unknown>: 0x%x], "),
8181 print_vma (chdr
.ch_size
, LONG_HEX
);
8182 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
8189 if (!do_section_details
)
8191 /* The ordering of the letters shown here matches the ordering of the
8192 corresponding SHF_xxx values, and hence the order in which these
8193 letters will be displayed to the user. */
8194 printf (_("Key to Flags:\n\
8195 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
8196 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
8197 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
8198 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
8201 case ELFOSABI_FREEBSD
:
8202 printf (_("R (retain), "));
8205 printf (_("D (mbind), "));
8210 if (filedata
->file_header
.e_machine
== EM_X86_64
8211 || filedata
->file_header
.e_machine
== EM_L1OM
8212 || filedata
->file_header
.e_machine
== EM_K1OM
)
8213 printf (_("l (large), "));
8214 else if (filedata
->file_header
.e_machine
== EM_ARM
)
8215 printf (_("y (purecode), "));
8216 else if (filedata
->file_header
.e_machine
== EM_PPC
)
8217 printf (_("v (VLE), "));
8218 printf ("p (processor specific)\n");
8225 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
8226 Elf_Internal_Sym
**symtab
, uint64_t *nsyms
,
8227 char **strtab
, uint64_t *strtablen
)
8231 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
8233 if (*symtab
== NULL
)
8236 if (symsec
->sh_link
!= 0)
8238 Elf_Internal_Shdr
*strsec
;
8240 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
8242 error (_("Bad sh_link in symbol table section\n"));
8249 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
8251 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8252 1, strsec
->sh_size
, _("string table"));
8253 if (*strtab
== NULL
)
8260 *strtablen
= strsec
->sh_size
;
8266 get_group_flags (unsigned int flags
)
8268 static char buff
[128];
8272 else if (flags
== GRP_COMDAT
)
8275 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
8277 flags
& GRP_MASKOS
? _("<OS specific>") : "",
8278 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
8279 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
8280 ? _("<unknown>") : ""));
8286 process_section_groups (Filedata
* filedata
)
8288 Elf_Internal_Shdr
* section
;
8290 struct group
* group
;
8291 Elf_Internal_Shdr
* symtab_sec
;
8292 Elf_Internal_Shdr
* strtab_sec
;
8293 Elf_Internal_Sym
* symtab
;
8298 /* Don't process section groups unless needed. */
8299 if (!do_unwind
&& !do_section_groups
)
8302 if (filedata
->file_header
.e_shnum
== 0)
8304 if (do_section_groups
)
8306 if (filedata
->is_separate
)
8307 printf (_("\nThere are no sections group in linked file '%s'.\n"),
8308 filedata
->file_name
);
8310 printf (_("\nThere are no section groups in this file.\n"));
8315 if (filedata
->section_headers
== NULL
)
8317 error (_("Section headers are not available!\n"));
8318 /* PR 13622: This can happen with a corrupt ELF header. */
8322 filedata
->section_headers_groups
8323 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
8324 sizeof (struct group
*));
8326 if (filedata
->section_headers_groups
== NULL
)
8328 error (_("Out of memory reading %u section group headers\n"),
8329 filedata
->file_header
.e_shnum
);
8333 /* Scan the sections for the group section. */
8334 filedata
->group_count
= 0;
8335 for (i
= 0, section
= filedata
->section_headers
;
8336 i
< filedata
->file_header
.e_shnum
;
8338 if (section
->sh_type
== SHT_GROUP
)
8339 filedata
->group_count
++;
8341 if (filedata
->group_count
== 0)
8343 if (do_section_groups
)
8345 if (filedata
->is_separate
)
8346 printf (_("\nThere are no section groups in linked file '%s'.\n"),
8347 filedata
->file_name
);
8349 printf (_("\nThere are no section groups in this file.\n"));
8355 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
8356 sizeof (struct group
));
8358 if (filedata
->section_groups
== NULL
)
8360 error (_("Out of memory reading %zu groups\n"), filedata
->group_count
);
8371 if (filedata
->is_separate
)
8372 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
8374 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
8375 i
< filedata
->file_header
.e_shnum
;
8378 if (section
->sh_type
== SHT_GROUP
)
8380 const char * name
= printable_section_name (filedata
, section
);
8381 const char * group_name
;
8382 unsigned char * start
;
8383 unsigned char * indices
;
8384 unsigned int entry
, j
, size
;
8385 Elf_Internal_Shdr
* sec
;
8386 Elf_Internal_Sym
* sym
;
8388 /* Get the symbol table. */
8389 if (section
->sh_link
>= filedata
->file_header
.e_shnum
8390 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
8393 error (_("Bad sh_link in group section `%s'\n"), name
);
8397 if (symtab_sec
!= sec
)
8401 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
8406 error (_("Corrupt header in group section `%s'\n"), name
);
8410 if (section
->sh_info
>= num_syms
)
8412 error (_("Bad sh_info in group section `%s'\n"), name
);
8416 sym
= symtab
+ section
->sh_info
;
8418 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8420 if (sym
->st_shndx
== 0
8421 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
8423 error (_("Bad sh_info in group section `%s'\n"), name
);
8427 group_name
= section_name_print (filedata
,
8428 filedata
->section_headers
8437 /* Get the string table. */
8438 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
8446 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
8451 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
8452 1, strtab_sec
->sh_size
,
8454 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
8456 group_name
= sym
->st_name
< strtab_size
8457 ? strtab
+ sym
->st_name
: _("<corrupt>");
8460 /* PR 17531: file: loop. */
8461 if (section
->sh_entsize
> section
->sh_size
)
8463 error (_("Section %s has sh_entsize (%#" PRIx64
")"
8464 " which is larger than its size (%#" PRIx64
")\n"),
8465 printable_section_name (filedata
, section
),
8466 section
->sh_entsize
,
8471 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
8472 1, section
->sh_size
,
8478 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
8479 entry
= byte_get (indices
, 4);
8482 if (do_section_groups
)
8484 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
8485 get_group_flags (entry
), i
, name
, group_name
, size
);
8487 printf (_(" [Index] Name\n"));
8490 group
->group_index
= i
;
8492 for (j
= 0; j
< size
; j
++)
8494 struct group_list
* g
;
8496 entry
= byte_get (indices
, 4);
8499 if (entry
>= filedata
->file_header
.e_shnum
)
8501 static unsigned num_group_errors
= 0;
8503 if (num_group_errors
++ < 10)
8505 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
8506 entry
, i
, filedata
->file_header
.e_shnum
- 1);
8507 if (num_group_errors
== 10)
8508 warn (_("Further error messages about overlarge group section indices suppressed\n"));
8513 if (filedata
->section_headers_groups
[entry
] != NULL
)
8517 static unsigned num_errs
= 0;
8519 if (num_errs
++ < 10)
8521 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
8523 filedata
->section_headers_groups
[entry
]->group_index
);
8525 warn (_("Further error messages about already contained group sections suppressed\n"));
8531 /* Intel C/C++ compiler may put section 0 in a
8532 section group. We just warn it the first time
8533 and ignore it afterwards. */
8534 static bool warned
= false;
8537 error (_("section 0 in group section [%5u]\n"),
8538 filedata
->section_headers_groups
[entry
]->group_index
);
8544 filedata
->section_headers_groups
[entry
] = group
;
8546 if (do_section_groups
)
8548 sec
= filedata
->section_headers
+ entry
;
8549 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
8552 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
8553 g
->section_index
= entry
;
8554 g
->next
= group
->root
;
8569 /* Data used to display dynamic fixups. */
8571 struct ia64_vms_dynfixup
8573 uint64_t needed_ident
; /* Library ident number. */
8574 uint64_t needed
; /* Index in the dstrtab of the library name. */
8575 uint64_t fixup_needed
; /* Index of the library. */
8576 uint64_t fixup_rela_cnt
; /* Number of fixups. */
8577 uint64_t fixup_rela_off
; /* Fixups offset in the dynamic segment. */
8580 /* Data used to display dynamic relocations. */
8582 struct ia64_vms_dynimgrela
8584 uint64_t img_rela_cnt
; /* Number of relocations. */
8585 uint64_t img_rela_off
; /* Reloc offset in the dynamic segment. */
8588 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
8592 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
8593 struct ia64_vms_dynfixup
* fixup
,
8594 const char * strtab
,
8595 unsigned int strtab_sz
)
8597 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
8599 const char * lib_name
;
8601 imfs
= get_data (NULL
, filedata
,
8602 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
8603 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
8604 _("dynamic section image fixups"));
8608 if (fixup
->needed
< strtab_sz
)
8609 lib_name
= strtab
+ fixup
->needed
;
8612 warn (_("corrupt library name index of %#" PRIx64
8613 " found in dynamic entry"), fixup
->needed
);
8617 printf (_("\nImage fixups for needed library #%" PRId64
8618 ": %s - ident: %" PRIx64
"\n"),
8619 fixup
->fixup_needed
, lib_name
, fixup
->needed_ident
);
8621 (_("Seg Offset Type SymVec DataType\n"));
8623 for (i
= 0; i
< (size_t) fixup
->fixup_rela_cnt
; i
++)
8628 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
8629 printf ("%016" PRIx64
" ", BYTE_GET (imfs
[i
].fixup_offset
));
8630 type
= BYTE_GET (imfs
[i
].type
);
8631 rtype
= elf_ia64_reloc_type (type
);
8633 printf ("0x%08x ", type
);
8635 printf ("%-32s ", rtype
);
8636 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
8637 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
8644 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
8647 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
8649 Elf64_External_VMS_IMAGE_RELA
*imrs
;
8652 imrs
= get_data (NULL
, filedata
,
8653 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
8654 sizeof (*imrs
), imgrela
->img_rela_cnt
,
8655 _("dynamic section image relocations"));
8659 printf (_("\nImage relocs\n"));
8661 (_("Seg Offset Type Addend Seg Sym Off\n"));
8663 for (i
= 0; i
< (size_t) imgrela
->img_rela_cnt
; i
++)
8668 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
8669 printf ("%08" PRIx64
" ", BYTE_GET (imrs
[i
].rela_offset
));
8670 type
= BYTE_GET (imrs
[i
].type
);
8671 rtype
= elf_ia64_reloc_type (type
);
8673 printf ("0x%08x ", type
);
8675 printf ("%-31s ", rtype
);
8676 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
8677 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
8678 printf ("%08" PRIx64
"\n", BYTE_GET (imrs
[i
].sym_offset
));
8685 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
8688 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
8690 struct ia64_vms_dynfixup fixup
;
8691 struct ia64_vms_dynimgrela imgrela
;
8692 Elf_Internal_Dyn
*entry
;
8693 uint64_t strtab_off
= 0;
8694 uint64_t strtab_sz
= 0;
8695 char *strtab
= NULL
;
8698 memset (&fixup
, 0, sizeof (fixup
));
8699 memset (&imgrela
, 0, sizeof (imgrela
));
8701 /* Note: the order of the entries is specified by the OpenVMS specs. */
8702 for (entry
= filedata
->dynamic_section
;
8703 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
8706 switch (entry
->d_tag
)
8708 case DT_IA_64_VMS_STRTAB_OFFSET
:
8709 strtab_off
= entry
->d_un
.d_val
;
8712 strtab_sz
= entry
->d_un
.d_val
;
8714 strtab
= get_data (NULL
, filedata
,
8715 filedata
->dynamic_addr
+ strtab_off
,
8716 1, strtab_sz
, _("dynamic string section"));
8721 case DT_IA_64_VMS_NEEDED_IDENT
:
8722 fixup
.needed_ident
= entry
->d_un
.d_val
;
8725 fixup
.needed
= entry
->d_un
.d_val
;
8727 case DT_IA_64_VMS_FIXUP_NEEDED
:
8728 fixup
.fixup_needed
= entry
->d_un
.d_val
;
8730 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
8731 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
8733 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
8734 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
8735 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
8738 case DT_IA_64_VMS_IMG_RELA_CNT
:
8739 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
8741 case DT_IA_64_VMS_IMG_RELA_OFF
:
8742 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
8743 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
8762 relocation_type rel_type
;
8764 dynamic_relocations
[] =
8766 { "REL", DT_REL
, DT_RELSZ
, reltype_rel
},
8767 { "RELA", DT_RELA
, DT_RELASZ
, reltype_rela
},
8768 { "RELR", DT_RELR
, DT_RELRSZ
, reltype_relr
},
8769 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, reltype_unknown
}
8772 /* Process the reloc section. */
8775 process_relocs (Filedata
* filedata
)
8778 uint64_t rel_offset
;
8783 if (do_using_dynamic
)
8785 relocation_type rel_type
;
8787 bool has_dynamic_reloc
;
8790 has_dynamic_reloc
= false;
8792 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8794 rel_type
= dynamic_relocations
[i
].rel_type
;
8795 name
= dynamic_relocations
[i
].name
;
8796 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
8797 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
8800 has_dynamic_reloc
= true;
8802 if (rel_type
== reltype_unknown
)
8804 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
8805 switch (filedata
->dynamic_info
[DT_PLTREL
])
8808 rel_type
= reltype_rel
;
8811 rel_type
= reltype_rela
;
8818 if (filedata
->is_separate
)
8820 (_("\nIn linked file '%s' section '%s' at offset %#" PRIx64
8821 " contains %" PRId64
" bytes:\n"),
8822 filedata
->file_name
, name
, rel_offset
, rel_size
);
8825 (_("\n'%s' relocation section at offset %#" PRIx64
8826 " contains %" PRId64
" bytes:\n"),
8827 name
, rel_offset
, rel_size
);
8829 dump_relocations (filedata
,
8830 offset_from_vma (filedata
, rel_offset
, rel_size
),
8832 filedata
->dynamic_symbols
,
8833 filedata
->num_dynamic_syms
,
8834 filedata
->dynamic_strings
,
8835 filedata
->dynamic_strings_length
,
8836 rel_type
, true /* is_dynamic */);
8840 if (is_ia64_vms (filedata
))
8841 if (process_ia64_vms_dynamic_relocs (filedata
))
8842 has_dynamic_reloc
= true;
8844 if (! has_dynamic_reloc
)
8846 if (filedata
->is_separate
)
8847 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
8848 filedata
->file_name
);
8850 printf (_("\nThere are no dynamic relocations in this file.\n"));
8855 Elf_Internal_Shdr
* section
;
8859 for (i
= 0, section
= filedata
->section_headers
;
8860 i
< filedata
->file_header
.e_shnum
;
8863 if ( section
->sh_type
!= SHT_RELA
8864 && section
->sh_type
!= SHT_REL
8865 && section
->sh_type
!= SHT_RELR
)
8868 rel_offset
= section
->sh_offset
;
8869 rel_size
= section
->sh_size
;
8873 relocation_type rel_type
;
8876 if (filedata
->is_separate
)
8877 printf (_("\nIn linked file '%s' relocation section "),
8878 filedata
->file_name
);
8880 printf (_("\nRelocation section "));
8882 if (filedata
->string_table
== NULL
)
8883 printf ("%d", section
->sh_name
);
8885 printf ("'%s'", printable_section_name (filedata
, section
));
8887 num_rela
= rel_size
/ section
->sh_entsize
;
8888 printf (ngettext (" at offset %#" PRIx64
8889 " contains %" PRIu64
" entry:\n",
8890 " at offset %#" PRIx64
8891 " contains %" PRId64
" entries:\n",
8893 rel_offset
, num_rela
);
8895 rel_type
= section
->sh_type
== SHT_RELA
? reltype_rela
:
8896 section
->sh_type
== SHT_REL
? reltype_rel
: reltype_relr
;
8898 if (section
->sh_link
!= 0
8899 && section
->sh_link
< filedata
->file_header
.e_shnum
)
8901 Elf_Internal_Shdr
*symsec
;
8902 Elf_Internal_Sym
*symtab
;
8904 uint64_t strtablen
= 0;
8905 char *strtab
= NULL
;
8907 symsec
= filedata
->section_headers
+ section
->sh_link
;
8908 if (symsec
->sh_type
!= SHT_SYMTAB
8909 && symsec
->sh_type
!= SHT_DYNSYM
)
8912 if (!get_symtab (filedata
, symsec
,
8913 &symtab
, &nsyms
, &strtab
, &strtablen
))
8916 dump_relocations (filedata
, rel_offset
, rel_size
,
8917 symtab
, nsyms
, strtab
, strtablen
,
8919 symsec
->sh_type
== SHT_DYNSYM
);
8924 dump_relocations (filedata
, rel_offset
, rel_size
,
8925 NULL
, 0, NULL
, 0, rel_type
, false /* is_dynamic */);
8933 /* Users sometimes forget the -D option, so try to be helpful. */
8934 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8936 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
8938 if (filedata
->is_separate
)
8939 printf (_("\nThere are no static relocations in linked file '%s'."),
8940 filedata
->file_name
);
8942 printf (_("\nThere are no static relocations in this file."));
8943 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
8948 if (i
== ARRAY_SIZE (dynamic_relocations
))
8950 if (filedata
->is_separate
)
8951 printf (_("\nThere are no relocations in linked file '%s'.\n"),
8952 filedata
->file_name
);
8954 printf (_("\nThere are no relocations in this file.\n"));
8962 /* An absolute address consists of a section and an offset. If the
8963 section is NULL, the offset itself is the address, otherwise, the
8964 address equals to LOAD_ADDRESS(section) + offset. */
8968 unsigned short section
;
8972 /* Find the nearest symbol at or below ADDR. Returns the symbol
8973 name, if found, and the offset from the symbol to ADDR. */
8976 find_symbol_for_address (Filedata
*filedata
,
8977 Elf_Internal_Sym
*symtab
,
8980 uint64_t strtab_size
,
8981 struct absaddr addr
,
8982 const char **symname
,
8985 uint64_t dist
= 0x100000;
8986 Elf_Internal_Sym
* sym
;
8987 Elf_Internal_Sym
* beg
;
8988 Elf_Internal_Sym
* end
;
8989 Elf_Internal_Sym
* best
= NULL
;
8991 REMOVE_ARCH_BITS (addr
.offset
);
8993 end
= symtab
+ nsyms
;
8999 sym
= beg
+ (end
- beg
) / 2;
9001 value
= sym
->st_value
;
9002 REMOVE_ARCH_BITS (value
);
9004 if (sym
->st_name
!= 0
9005 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
9006 && addr
.offset
>= value
9007 && addr
.offset
- value
< dist
)
9010 dist
= addr
.offset
- value
;
9015 if (addr
.offset
< value
)
9023 *symname
= (best
->st_name
>= strtab_size
9024 ? _("<corrupt>") : strtab
+ best
->st_name
);
9030 *offset
= addr
.offset
;
9033 static /* signed */ int
9034 symcmp (const void *p
, const void *q
)
9036 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
9037 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
9039 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
9042 /* Process the unwind section. */
9044 #include "unwind-ia64.h"
9046 struct ia64_unw_table_entry
9048 struct absaddr start
;
9050 struct absaddr info
;
9053 struct ia64_unw_aux_info
9055 struct ia64_unw_table_entry
* table
; /* Unwind table. */
9056 uint64_t table_len
; /* Length of unwind table. */
9057 unsigned char * info
; /* Unwind info. */
9058 uint64_t info_size
; /* Size of unwind info. */
9059 uint64_t info_addr
; /* Starting address of unwind info. */
9060 uint64_t seg_base
; /* Starting address of segment. */
9061 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9062 uint64_t nsyms
; /* Number of symbols. */
9063 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9064 uint64_t nfuns
; /* Number of entries in funtab. */
9065 char * strtab
; /* The string table. */
9066 uint64_t strtab_size
; /* Size of string table. */
9070 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
9072 struct ia64_unw_table_entry
* tp
;
9077 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9078 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9079 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9080 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9082 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9084 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9088 const unsigned char * dp
;
9089 const unsigned char * head
;
9090 const unsigned char * end
;
9091 const char * procname
;
9093 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9094 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
9096 fputs ("\n<", stdout
);
9100 fputs (procname
, stdout
);
9103 printf ("+%" PRIx64
, offset
);
9106 fputs (">: [", stdout
);
9107 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9108 fputc ('-', stdout
);
9109 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9110 printf ("], info at +0x%" PRIx64
"\n",
9111 tp
->info
.offset
- aux
->seg_base
);
9113 /* PR 17531: file: 86232b32. */
9114 if (aux
->info
== NULL
)
9117 offset
= tp
->info
.offset
;
9118 if (tp
->info
.section
)
9120 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
9122 warn (_("Invalid section %u in table entry %td\n"),
9123 tp
->info
.section
, tp
- aux
->table
);
9127 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
9129 offset
-= aux
->info_addr
;
9130 /* PR 17531: file: 0997b4d1. */
9131 if (offset
>= aux
->info_size
9132 || aux
->info_size
- offset
< 8)
9134 warn (_("Invalid offset %" PRIx64
" in table entry %td\n"),
9135 tp
->info
.offset
, tp
- aux
->table
);
9140 head
= aux
->info
+ offset
;
9141 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
9143 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
9144 (unsigned) UNW_VER (stamp
),
9145 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
9146 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
9147 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
9148 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
9150 if (UNW_VER (stamp
) != 1)
9152 printf (_("\tUnknown version.\n"));
9157 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
9158 /* PR 17531: file: 16ceda89. */
9159 if (end
> aux
->info
+ aux
->info_size
)
9160 end
= aux
->info
+ aux
->info_size
;
9161 for (dp
= head
+ 8; dp
< end
;)
9162 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
9171 slurp_ia64_unwind_table (Filedata
* filedata
,
9172 struct ia64_unw_aux_info
* aux
,
9173 Elf_Internal_Shdr
* sec
)
9175 uint64_t size
, nrelas
, i
;
9176 Elf_Internal_Phdr
* seg
;
9177 struct ia64_unw_table_entry
* tep
;
9178 Elf_Internal_Shdr
* relsec
;
9179 Elf_Internal_Rela
* rela
;
9180 Elf_Internal_Rela
* rp
;
9181 unsigned char * table
;
9183 Elf_Internal_Sym
* sym
;
9184 const char * relname
;
9188 /* First, find the starting address of the segment that includes
9191 if (filedata
->file_header
.e_phnum
)
9193 if (! get_program_headers (filedata
))
9196 for (seg
= filedata
->program_headers
;
9197 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9200 if (seg
->p_type
!= PT_LOAD
)
9203 if (sec
->sh_addr
>= seg
->p_vaddr
9204 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9206 aux
->seg_base
= seg
->p_vaddr
;
9212 /* Second, build the unwind table from the contents of the unwind section: */
9213 size
= sec
->sh_size
;
9214 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9219 aux
->table_len
= size
/ (3 * eh_addr_size
);
9220 aux
->table
= (struct ia64_unw_table_entry
*)
9221 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
9224 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
9226 tep
->start
.section
= SHN_UNDEF
;
9227 tep
->end
.section
= SHN_UNDEF
;
9228 tep
->info
.section
= SHN_UNDEF
;
9229 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9230 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9231 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9232 tep
->start
.offset
+= aux
->seg_base
;
9233 tep
->end
.offset
+= aux
->seg_base
;
9234 tep
->info
.offset
+= aux
->seg_base
;
9238 /* Third, apply any relocations to the unwind table: */
9239 for (relsec
= filedata
->section_headers
;
9240 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9243 if (relsec
->sh_type
!= SHT_RELA
9244 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9245 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9248 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9257 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9259 unsigned int sym_ndx
;
9260 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9261 relname
= elf_ia64_reloc_type (r_type
);
9263 /* PR 17531: file: 9fa67536. */
9264 if (relname
== NULL
)
9266 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9270 if (! startswith (relname
, "R_IA64_SEGREL"))
9272 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9276 i
= rp
->r_offset
/ (3 * eh_addr_size
);
9278 /* PR 17531: file: 5bc8d9bf. */
9279 if (i
>= aux
->table_len
)
9281 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9286 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9287 if (sym_ndx
>= aux
->nsyms
)
9289 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9293 sym
= aux
->symtab
+ sym_ndx
;
9295 switch (rp
->r_offset
/ eh_addr_size
% 3)
9298 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9299 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
9302 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9303 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
9306 aux
->table
[i
].info
.section
= sym
->st_shndx
;
9307 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
9321 ia64_process_unwind (Filedata
* filedata
)
9323 Elf_Internal_Shdr
* sec
;
9324 Elf_Internal_Shdr
* unwsec
= NULL
;
9325 uint64_t i
, unwcount
= 0, unwstart
= 0;
9326 struct ia64_unw_aux_info aux
;
9329 memset (& aux
, 0, sizeof (aux
));
9331 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9333 if (sec
->sh_type
== SHT_SYMTAB
)
9337 error (_("Multiple symbol tables encountered\n"));
9343 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9344 &aux
.strtab
, &aux
.strtab_size
))
9347 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9352 printf (_("\nThere are no unwind sections in this file.\n"));
9354 while (unwcount
-- > 0)
9359 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
9360 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9361 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9366 /* We have already counted the number of SHT_IA64_UNWIND
9367 sections so the loop above should never fail. */
9368 assert (unwsec
!= NULL
);
9371 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
9373 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
9375 /* We need to find which section group it is in. */
9376 struct group_list
* g
;
9378 if (filedata
->section_headers_groups
== NULL
9379 || filedata
->section_headers_groups
[i
] == NULL
)
9380 i
= filedata
->file_header
.e_shnum
;
9383 g
= filedata
->section_headers_groups
[i
]->root
;
9385 for (; g
!= NULL
; g
= g
->next
)
9387 sec
= filedata
->section_headers
+ g
->section_index
;
9389 if (section_name_valid (filedata
, sec
)
9390 && streq (section_name (filedata
, sec
),
9391 ELF_STRING_ia64_unwind_info
))
9396 i
= filedata
->file_header
.e_shnum
;
9399 else if (section_name_valid (filedata
, unwsec
)
9400 && startswith (section_name (filedata
, unwsec
),
9401 ELF_STRING_ia64_unwind_once
))
9403 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
9404 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
9405 suffix
= section_name (filedata
, unwsec
) + len
;
9406 for (i
= 0, sec
= filedata
->section_headers
;
9407 i
< filedata
->file_header
.e_shnum
;
9409 if (section_name_valid (filedata
, sec
)
9410 && startswith (section_name (filedata
, sec
),
9411 ELF_STRING_ia64_unwind_info_once
)
9412 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9417 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
9418 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
9419 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
9420 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
9422 if (section_name_valid (filedata
, unwsec
)
9423 && startswith (section_name (filedata
, unwsec
),
9424 ELF_STRING_ia64_unwind
))
9425 suffix
= section_name (filedata
, unwsec
) + len
;
9426 for (i
= 0, sec
= filedata
->section_headers
;
9427 i
< filedata
->file_header
.e_shnum
;
9429 if (section_name_valid (filedata
, sec
)
9430 && startswith (section_name (filedata
, sec
),
9431 ELF_STRING_ia64_unwind_info
)
9432 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9436 if (i
== filedata
->file_header
.e_shnum
)
9438 printf (_("\nCould not find unwind info section for "));
9440 if (filedata
->string_table
== NULL
)
9441 printf ("%d", unwsec
->sh_name
);
9443 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9447 aux
.info_addr
= sec
->sh_addr
;
9448 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
9451 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
9453 printf (_("\nUnwind section "));
9455 if (filedata
->string_table
== NULL
)
9456 printf ("%d", unwsec
->sh_name
);
9458 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9460 printf (_(" at offset %#" PRIx64
" contains %" PRIu64
" entries:\n"),
9462 unwsec
->sh_size
/ (3 * eh_addr_size
));
9464 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
9465 && aux
.table_len
> 0)
9466 dump_ia64_unwind (filedata
, & aux
);
9468 free ((char *) aux
.table
);
9469 free ((char *) aux
.info
);
9476 free ((char *) aux
.strtab
);
9481 struct hppa_unw_table_entry
9483 struct absaddr start
;
9485 unsigned int Cannot_unwind
:1; /* 0 */
9486 unsigned int Millicode
:1; /* 1 */
9487 unsigned int Millicode_save_sr0
:1; /* 2 */
9488 unsigned int Region_description
:2; /* 3..4 */
9489 unsigned int reserved1
:1; /* 5 */
9490 unsigned int Entry_SR
:1; /* 6 */
9491 unsigned int Entry_FR
:4; /* Number saved 7..10 */
9492 unsigned int Entry_GR
:5; /* Number saved 11..15 */
9493 unsigned int Args_stored
:1; /* 16 */
9494 unsigned int Variable_Frame
:1; /* 17 */
9495 unsigned int Separate_Package_Body
:1; /* 18 */
9496 unsigned int Frame_Extension_Millicode
:1; /* 19 */
9497 unsigned int Stack_Overflow_Check
:1; /* 20 */
9498 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
9499 unsigned int Ada_Region
:1; /* 22 */
9500 unsigned int cxx_info
:1; /* 23 */
9501 unsigned int cxx_try_catch
:1; /* 24 */
9502 unsigned int sched_entry_seq
:1; /* 25 */
9503 unsigned int reserved2
:1; /* 26 */
9504 unsigned int Save_SP
:1; /* 27 */
9505 unsigned int Save_RP
:1; /* 28 */
9506 unsigned int Save_MRP_in_frame
:1; /* 29 */
9507 unsigned int extn_ptr_defined
:1; /* 30 */
9508 unsigned int Cleanup_defined
:1; /* 31 */
9510 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
9511 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
9512 unsigned int Large_frame
:1; /* 2 */
9513 unsigned int Pseudo_SP_Set
:1; /* 3 */
9514 unsigned int reserved4
:1; /* 4 */
9515 unsigned int Total_frame_size
:27; /* 5..31 */
9518 struct hppa_unw_aux_info
9520 struct hppa_unw_table_entry
* table
; /* Unwind table. */
9521 uint64_t table_len
; /* Length of unwind table. */
9522 uint64_t seg_base
; /* Starting address of segment. */
9523 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9524 uint64_t nsyms
; /* Number of symbols. */
9525 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9526 uint64_t nfuns
; /* Number of entries in funtab. */
9527 char * strtab
; /* The string table. */
9528 uint64_t strtab_size
; /* Size of string table. */
9532 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
9534 struct hppa_unw_table_entry
* tp
;
9538 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9539 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9540 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9541 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9543 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9545 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9548 const char * procname
;
9550 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9551 aux
->strtab_size
, tp
->start
, &procname
,
9554 fputs ("\n<", stdout
);
9558 fputs (procname
, stdout
);
9561 printf ("+%" PRIx64
, offset
);
9564 fputs (">: [", stdout
);
9565 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9566 fputc ('-', stdout
);
9567 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9570 #define PF(_m) if (tp->_m) printf (#_m " ");
9571 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
9574 PF(Millicode_save_sr0
);
9575 /* PV(Region_description); */
9581 PF(Separate_Package_Body
);
9582 PF(Frame_Extension_Millicode
);
9583 PF(Stack_Overflow_Check
);
9584 PF(Two_Instruction_SP_Increment
);
9588 PF(sched_entry_seq
);
9591 PF(Save_MRP_in_frame
);
9592 PF(extn_ptr_defined
);
9593 PF(Cleanup_defined
);
9594 PF(MPE_XL_interrupt_marker
);
9595 PF(HP_UX_interrupt_marker
);
9598 PV(Total_frame_size
);
9611 slurp_hppa_unwind_table (Filedata
* filedata
,
9612 struct hppa_unw_aux_info
* aux
,
9613 Elf_Internal_Shdr
* sec
)
9615 uint64_t size
, unw_ent_size
, nentries
, nrelas
, i
;
9616 Elf_Internal_Phdr
* seg
;
9617 struct hppa_unw_table_entry
* tep
;
9618 Elf_Internal_Shdr
* relsec
;
9619 Elf_Internal_Rela
* rela
;
9620 Elf_Internal_Rela
* rp
;
9621 unsigned char * table
;
9623 Elf_Internal_Sym
* sym
;
9624 const char * relname
;
9626 /* First, find the starting address of the segment that includes
9628 if (filedata
->file_header
.e_phnum
)
9630 if (! get_program_headers (filedata
))
9633 for (seg
= filedata
->program_headers
;
9634 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9637 if (seg
->p_type
!= PT_LOAD
)
9640 if (sec
->sh_addr
>= seg
->p_vaddr
9641 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9643 aux
->seg_base
= seg
->p_vaddr
;
9649 /* Second, build the unwind table from the contents of the unwind
9651 size
= sec
->sh_size
;
9652 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9658 nentries
= size
/ unw_ent_size
;
9659 size
= unw_ent_size
* nentries
;
9661 aux
->table_len
= nentries
;
9662 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
9663 xcmalloc (nentries
, sizeof (aux
->table
[0]));
9665 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
9667 unsigned int tmp1
, tmp2
;
9669 tep
->start
.section
= SHN_UNDEF
;
9670 tep
->end
.section
= SHN_UNDEF
;
9672 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
9673 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
9674 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
9675 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
9677 tep
->start
.offset
+= aux
->seg_base
;
9678 tep
->end
.offset
+= aux
->seg_base
;
9680 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
9681 tep
->Millicode
= (tmp1
>> 30) & 0x1;
9682 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
9683 tep
->Region_description
= (tmp1
>> 27) & 0x3;
9684 tep
->reserved1
= (tmp1
>> 26) & 0x1;
9685 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
9686 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
9687 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
9688 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
9689 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
9690 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
9691 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
9692 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
9693 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
9694 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
9695 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
9696 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
9697 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
9698 tep
->reserved2
= (tmp1
>> 5) & 0x1;
9699 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
9700 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
9701 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
9702 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
9703 tep
->Cleanup_defined
= tmp1
& 0x1;
9705 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
9706 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
9707 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
9708 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
9709 tep
->reserved4
= (tmp2
>> 27) & 0x1;
9710 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
9714 /* Third, apply any relocations to the unwind table. */
9715 for (relsec
= filedata
->section_headers
;
9716 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9719 if (relsec
->sh_type
!= SHT_RELA
9720 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9721 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9724 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9728 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9730 unsigned int sym_ndx
;
9731 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9732 relname
= elf_hppa_reloc_type (r_type
);
9734 if (relname
== NULL
)
9736 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9740 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
9741 if (! startswith (relname
, "R_PARISC_SEGREL"))
9743 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9747 i
= rp
->r_offset
/ unw_ent_size
;
9748 if (i
>= aux
->table_len
)
9750 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9755 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9756 if (sym_ndx
>= aux
->nsyms
)
9758 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9762 sym
= aux
->symtab
+ sym_ndx
;
9764 switch ((rp
->r_offset
% unw_ent_size
) / 4)
9767 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9768 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
9771 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9772 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
9786 hppa_process_unwind (Filedata
* filedata
)
9788 struct hppa_unw_aux_info aux
;
9789 Elf_Internal_Shdr
* unwsec
= NULL
;
9790 Elf_Internal_Shdr
* sec
;
9794 if (filedata
->string_table
== NULL
)
9797 memset (& aux
, 0, sizeof (aux
));
9799 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9801 if (sec
->sh_type
== SHT_SYMTAB
)
9805 error (_("Multiple symbol tables encountered\n"));
9811 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9812 &aux
.strtab
, &aux
.strtab_size
))
9815 else if (section_name_valid (filedata
, sec
)
9816 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9821 printf (_("\nThere are no unwind sections in this file.\n"));
9823 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9825 if (section_name_valid (filedata
, sec
)
9826 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9828 uint64_t num_unwind
= sec
->sh_size
/ 16;
9830 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
9831 "contains %" PRIu64
" entry:\n",
9832 "\nUnwind section '%s' at offset %#" PRIx64
" "
9833 "contains %" PRIu64
" entries:\n",
9835 printable_section_name (filedata
, sec
),
9839 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
9842 if (res
&& aux
.table_len
> 0)
9844 if (! dump_hppa_unwind (filedata
, &aux
))
9848 free ((char *) aux
.table
);
9854 free ((char *) aux
.strtab
);
9861 unsigned char * data
; /* The unwind data. */
9862 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
9863 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
9864 uint64_t nrelas
; /* The number of relocations. */
9865 unsigned int rel_type
; /* REL or RELA ? */
9866 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
9869 struct arm_unw_aux_info
9871 Filedata
* filedata
; /* The file containing the unwind sections. */
9872 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
9873 uint64_t nsyms
; /* Number of symbols. */
9874 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9875 uint64_t nfuns
; /* Number of these symbols. */
9876 char * strtab
; /* The file's string table. */
9877 uint64_t strtab_size
; /* Size of string table. */
9881 arm_print_vma_and_name (Filedata
* filedata
,
9882 struct arm_unw_aux_info
* aux
,
9884 struct absaddr addr
)
9886 const char *procname
;
9887 uint64_t sym_offset
;
9889 if (addr
.section
== SHN_UNDEF
)
9892 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9893 aux
->strtab_size
, addr
, &procname
,
9896 print_vma (fn
, PREFIX_HEX
);
9900 fputs (" <", stdout
);
9901 fputs (procname
, stdout
);
9904 printf ("+0x%" PRIx64
, sym_offset
);
9905 fputc ('>', stdout
);
9912 arm_free_section (struct arm_section
*arm_sec
)
9914 free (arm_sec
->data
);
9915 free (arm_sec
->rela
);
9918 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
9919 cached section and install SEC instead.
9920 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
9921 and return its valued in * WORDP, relocating if necessary.
9922 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
9923 relocation's offset in ADDR.
9924 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
9925 into the string table of the symbol associated with the reloc. If no
9926 reloc was applied store -1 there.
9927 5) Return TRUE upon success, FALSE otherwise. */
9930 get_unwind_section_word (Filedata
* filedata
,
9931 struct arm_unw_aux_info
* aux
,
9932 struct arm_section
* arm_sec
,
9933 Elf_Internal_Shdr
* sec
,
9934 uint64_t word_offset
,
9935 unsigned int * wordp
,
9936 struct absaddr
* addr
,
9937 uint64_t * sym_name
)
9939 Elf_Internal_Rela
*rp
;
9940 Elf_Internal_Sym
*sym
;
9941 const char * relname
;
9945 if (sec
== NULL
|| arm_sec
== NULL
)
9948 addr
->section
= SHN_UNDEF
;
9951 if (sym_name
!= NULL
)
9952 *sym_name
= (uint64_t) -1;
9954 /* If necessary, update the section cache. */
9955 if (sec
!= arm_sec
->sec
)
9957 Elf_Internal_Shdr
*relsec
;
9959 arm_free_section (arm_sec
);
9962 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
9963 sec
->sh_size
, _("unwind data"));
9964 arm_sec
->rela
= NULL
;
9965 arm_sec
->nrelas
= 0;
9967 for (relsec
= filedata
->section_headers
;
9968 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9971 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
9972 || filedata
->section_headers
+ relsec
->sh_info
!= sec
9973 /* PR 15745: Check the section type as well. */
9974 || (relsec
->sh_type
!= SHT_REL
9975 && relsec
->sh_type
!= SHT_RELA
))
9978 arm_sec
->rel_type
= relsec
->sh_type
;
9979 if (relsec
->sh_type
== SHT_REL
)
9981 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
9983 & arm_sec
->rela
, & arm_sec
->nrelas
))
9986 else /* relsec->sh_type == SHT_RELA */
9988 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
9990 & arm_sec
->rela
, & arm_sec
->nrelas
))
9996 arm_sec
->next_rela
= arm_sec
->rela
;
9999 /* If there is no unwind data we can do nothing. */
10000 if (arm_sec
->data
== NULL
)
10003 /* If the offset is invalid then fail. */
10004 if (/* PR 21343 *//* PR 18879 */
10006 || word_offset
> sec
->sh_size
- 4)
10009 /* Get the word at the required offset. */
10010 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
10012 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
10013 if (arm_sec
->rela
== NULL
)
10019 /* Look through the relocs to find the one that applies to the provided offset. */
10021 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
10023 uint64_t prelval
, offset
;
10025 if (rp
->r_offset
> word_offset
&& !wrapped
)
10027 rp
= arm_sec
->rela
;
10030 if (rp
->r_offset
> word_offset
)
10033 if (rp
->r_offset
& 3)
10035 warn (_("Skipping unexpected relocation at offset %#" PRIx64
"\n"),
10040 if (rp
->r_offset
< word_offset
)
10043 /* PR 17531: file: 027-161405-0.004 */
10044 if (aux
->symtab
== NULL
)
10047 if (arm_sec
->rel_type
== SHT_REL
)
10049 offset
= word
& 0x7fffffff;
10050 if (offset
& 0x40000000)
10051 offset
|= ~ (uint64_t) 0x7fffffff;
10053 else if (arm_sec
->rel_type
== SHT_RELA
)
10054 offset
= rp
->r_addend
;
10057 error (_("Unknown section relocation type %d encountered\n"),
10058 arm_sec
->rel_type
);
10062 /* PR 17531 file: 027-1241568-0.004. */
10063 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
10065 error (_("Bad symbol index in unwind relocation "
10066 "(%" PRIu64
" > %" PRIu64
")\n"),
10067 ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
10071 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
10072 offset
+= sym
->st_value
;
10073 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
10075 /* Check that we are processing the expected reloc type. */
10076 if (filedata
->file_header
.e_machine
== EM_ARM
)
10078 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
10079 if (relname
== NULL
)
10081 warn (_("Skipping unknown ARM relocation type: %d\n"),
10082 (int) ELF32_R_TYPE (rp
->r_info
));
10086 if (streq (relname
, "R_ARM_NONE"))
10089 if (! streq (relname
, "R_ARM_PREL31"))
10091 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
10095 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10097 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
10098 if (relname
== NULL
)
10100 warn (_("Skipping unknown C6000 relocation type: %d\n"),
10101 (int) ELF32_R_TYPE (rp
->r_info
));
10105 if (streq (relname
, "R_C6000_NONE"))
10108 if (! streq (relname
, "R_C6000_PREL31"))
10110 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
10118 /* This function currently only supports ARM and TI unwinders. */
10119 warn (_("Only TI and ARM unwinders are currently supported\n"));
10123 word
= (word
& ~ (uint64_t) 0x7fffffff) | (prelval
& 0x7fffffff);
10124 addr
->section
= sym
->st_shndx
;
10125 addr
->offset
= offset
;
10128 * sym_name
= sym
->st_name
;
10133 arm_sec
->next_rela
= rp
;
10138 static const char *tic6x_unwind_regnames
[16] =
10140 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
10141 "A14", "A13", "A12", "A11", "A10",
10142 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
10146 decode_tic6x_unwind_regmask (unsigned int mask
)
10150 for (i
= 12; mask
; mask
>>= 1, i
--)
10154 fputs (tic6x_unwind_regnames
[i
], stdout
);
10156 fputs (", ", stdout
);
10162 if (remaining == 0 && more_words) \
10164 data_offset += 4; \
10165 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
10166 data_offset, & word, & addr, NULL)) \
10172 #define GET_OP(OP) \
10177 (OP) = word >> 24; \
10182 printf (_("[Truncated opcode]\n")); \
10185 printf ("0x%02x ", OP)
10188 decode_arm_unwind_bytecode (Filedata
* filedata
,
10189 struct arm_unw_aux_info
* aux
,
10191 unsigned int remaining
,
10192 unsigned int more_words
,
10193 uint64_t data_offset
,
10194 Elf_Internal_Shdr
* data_sec
,
10195 struct arm_section
* data_arm_sec
)
10197 struct absaddr addr
;
10200 /* Decode the unwinding instructions. */
10203 unsigned int op
, op2
;
10206 if (remaining
== 0)
10212 printf (" 0x%02x ", op
);
10214 if ((op
& 0xc0) == 0x00)
10216 int offset
= ((op
& 0x3f) << 2) + 4;
10218 printf (" vsp = vsp + %d", offset
);
10220 else if ((op
& 0xc0) == 0x40)
10222 int offset
= ((op
& 0x3f) << 2) + 4;
10224 printf (" vsp = vsp - %d", offset
);
10226 else if ((op
& 0xf0) == 0x80)
10229 if (op
== 0x80 && op2
== 0)
10230 printf (_("Refuse to unwind"));
10233 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
10238 for (i
= 0; i
< 12; i
++)
10239 if (mask
& (1 << i
))
10245 printf ("r%d", 4 + i
);
10250 else if ((op
& 0xf0) == 0x90)
10252 if (op
== 0x9d || op
== 0x9f)
10253 printf (_(" [Reserved]"));
10255 printf (" vsp = r%d", op
& 0x0f);
10257 else if ((op
& 0xf0) == 0xa0)
10259 int end
= 4 + (op
& 0x07);
10264 for (i
= 4; i
<= end
; i
++)
10280 else if (op
== 0xb0)
10281 printf (_(" finish"));
10282 else if (op
== 0xb1)
10285 if (op2
== 0 || (op2
& 0xf0) != 0)
10286 printf (_("[Spare]"));
10289 unsigned int mask
= op2
& 0x0f;
10294 for (i
= 0; i
< 12; i
++)
10295 if (mask
& (1 << i
))
10306 else if (op
== 0xb2)
10308 unsigned char buf
[9];
10309 unsigned int i
, len
;
10312 for (i
= 0; i
< sizeof (buf
); i
++)
10315 if ((buf
[i
] & 0x80) == 0)
10318 if (i
== sizeof (buf
))
10320 error (_("corrupt change to vsp\n"));
10325 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10326 assert (len
== i
+ 1);
10327 offset
= offset
* 4 + 0x204;
10328 printf ("vsp = vsp + %" PRId64
, offset
);
10331 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
10333 unsigned int first
, last
;
10339 first
= first
+ 16;
10340 printf ("pop {D%d", first
);
10342 printf ("-D%d", first
+ last
);
10345 else if (op
== 0xb4)
10346 printf (_(" pop {ra_auth_code}"));
10347 else if (op
== 0xb5)
10348 printf (_(" vsp as modifier for PAC validation"));
10349 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
10351 unsigned int count
= op
& 0x07;
10353 printf ("pop {D8");
10355 printf ("-D%d", 8 + count
);
10358 else if (op
>= 0xc0 && op
<= 0xc5)
10360 unsigned int count
= op
& 0x07;
10362 printf (" pop {wR10");
10364 printf ("-wR%d", 10 + count
);
10367 else if (op
== 0xc6)
10369 unsigned int first
, last
;
10374 printf ("pop {wR%d", first
);
10376 printf ("-wR%d", first
+ last
);
10379 else if (op
== 0xc7)
10382 if (op2
== 0 || (op2
& 0xf0) != 0)
10383 printf (_("[Spare]"));
10386 unsigned int mask
= op2
& 0x0f;
10391 for (i
= 0; i
< 4; i
++)
10392 if (mask
& (1 << i
))
10398 printf ("wCGR%d", i
);
10405 printf (_(" [unsupported opcode]"));
10416 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
10417 struct arm_unw_aux_info
* aux
,
10419 unsigned int remaining
,
10420 unsigned int more_words
,
10421 uint64_t data_offset
,
10422 Elf_Internal_Shdr
* data_sec
,
10423 struct arm_section
* data_arm_sec
)
10425 struct absaddr addr
;
10427 /* Decode the unwinding instructions. */
10430 unsigned int op
, op2
;
10433 if (remaining
== 0)
10439 printf (" 0x%02x ", op
);
10441 if ((op
& 0xc0) == 0x00)
10443 int offset
= ((op
& 0x3f) << 3) + 8;
10444 printf (" sp = sp + %d", offset
);
10446 else if ((op
& 0xc0) == 0x80)
10449 if (op
== 0x80 && op2
== 0)
10450 printf (_("Refuse to unwind"));
10453 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10455 printf ("pop compact {");
10459 decode_tic6x_unwind_regmask (mask
);
10463 else if ((op
& 0xf0) == 0xc0)
10466 unsigned int nregs
;
10471 unsigned int offset
;
10475 /* Scan entire instruction first so that GET_OP output is not
10476 interleaved with disassembly. */
10478 for (i
= 0; nregs
< (op
& 0xf); i
++)
10484 regpos
[nregs
].offset
= i
* 2;
10485 regpos
[nregs
].reg
= reg
;
10492 regpos
[nregs
].offset
= i
* 2 + 1;
10493 regpos
[nregs
].reg
= reg
;
10498 printf (_("pop frame {"));
10501 printf (_("*corrupt* - no registers specified"));
10506 for (i
= i
* 2; i
> 0; i
--)
10508 if (regpos
[reg
].offset
== i
- 1)
10510 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10517 fputs (name
, stdout
);
10525 else if (op
== 0xd0)
10526 printf (" MOV FP, SP");
10527 else if (op
== 0xd1)
10528 printf (" __c6xabi_pop_rts");
10529 else if (op
== 0xd2)
10531 unsigned char buf
[9];
10532 unsigned int i
, len
;
10535 for (i
= 0; i
< sizeof (buf
); i
++)
10538 if ((buf
[i
] & 0x80) == 0)
10541 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10542 if (i
== sizeof (buf
))
10544 warn (_("Corrupt stack pointer adjustment detected\n"));
10548 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10549 assert (len
== i
+ 1);
10550 offset
= offset
* 8 + 0x408;
10551 printf (_("sp = sp + %" PRId64
), offset
);
10553 else if ((op
& 0xf0) == 0xe0)
10555 if ((op
& 0x0f) == 7)
10556 printf (" RETURN");
10558 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10562 printf (_(" [unsupported opcode]"));
10571 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10575 offset
= word
& 0x7fffffff;
10576 if (offset
& 0x40000000)
10577 offset
|= ~ (uint64_t) 0x7fffffff;
10579 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10582 return offset
+ where
;
10586 decode_arm_unwind (Filedata
* filedata
,
10587 struct arm_unw_aux_info
* aux
,
10589 unsigned int remaining
,
10590 uint64_t data_offset
,
10591 Elf_Internal_Shdr
* data_sec
,
10592 struct arm_section
* data_arm_sec
)
10595 unsigned int more_words
= 0;
10596 struct absaddr addr
;
10597 uint64_t sym_name
= (uint64_t) -1;
10600 if (remaining
== 0)
10602 /* Fetch the first word.
10603 Note - when decoding an object file the address extracted
10604 here will always be 0. So we also pass in the sym_name
10605 parameter so that we can find the symbol associated with
10606 the personality routine. */
10607 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10608 & word
, & addr
, & sym_name
))
10615 addr
.section
= SHN_UNDEF
;
10619 if ((word
& 0x80000000) == 0)
10621 /* Expand prel31 for personality routine. */
10623 const char *procname
;
10625 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
10626 printf (_(" Personality routine: "));
10628 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
10629 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
10631 procname
= aux
->strtab
+ sym_name
;
10632 print_vma (fn
, PREFIX_HEX
);
10635 fputs (" <", stdout
);
10636 fputs (procname
, stdout
);
10637 fputc ('>', stdout
);
10641 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
10642 fputc ('\n', stdout
);
10644 /* The GCC personality routines use the standard compact
10645 encoding, starting with one byte giving the number of
10647 if (procname
!= NULL
10648 && (startswith (procname
, "__gcc_personality_v0")
10649 || startswith (procname
, "__gxx_personality_v0")
10650 || startswith (procname
, "__gcj_personality_v0")
10651 || startswith (procname
, "__gnu_objc_personality_v0")))
10658 printf (_(" [Truncated data]\n"));
10661 more_words
= word
>> 24;
10671 /* ARM EHABI Section 6.3:
10673 An exception-handling table entry for the compact model looks like:
10675 31 30-28 27-24 23-0
10676 -- ----- ----- ----
10677 1 0 index Data for personalityRoutine[index] */
10679 if (filedata
->file_header
.e_machine
== EM_ARM
10680 && (word
& 0x70000000))
10682 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
10686 per_index
= (word
>> 24) & 0x7f;
10687 printf (_(" Compact model index: %d\n"), per_index
);
10688 if (per_index
== 0)
10694 else if (per_index
< 3)
10696 more_words
= (word
>> 16) & 0xff;
10702 switch (filedata
->file_header
.e_machine
)
10707 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10708 data_offset
, data_sec
, data_arm_sec
))
10713 warn (_("Unknown ARM compact model index encountered\n"));
10714 printf (_(" [reserved]\n"));
10722 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10723 data_offset
, data_sec
, data_arm_sec
))
10726 else if (per_index
< 5)
10728 if (((word
>> 17) & 0x7f) == 0x7f)
10729 printf (_(" Restore stack from frame pointer\n"));
10731 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
10732 printf (_(" Registers restored: "));
10733 if (per_index
== 4)
10734 printf (" (compact) ");
10735 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
10737 printf (_(" Return register: %s\n"),
10738 tic6x_unwind_regnames
[word
& 0xf]);
10741 printf (_(" [reserved (%d)]\n"), per_index
);
10745 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
10746 filedata
->file_header
.e_machine
);
10750 /* Decode the descriptors. Not implemented. */
10756 dump_arm_unwind (Filedata
* filedata
,
10757 struct arm_unw_aux_info
* aux
,
10758 Elf_Internal_Shdr
* exidx_sec
)
10760 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10761 unsigned int i
, exidx_len
;
10765 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10766 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10767 exidx_len
= exidx_sec
->sh_size
/ 8;
10769 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10770 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10771 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10772 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10773 aux
->nfuns
= nfuns
;
10774 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10776 for (i
= 0; i
< exidx_len
; i
++)
10778 unsigned int exidx_fn
, exidx_entry
;
10779 struct absaddr fn_addr
, entry_addr
;
10782 fputc ('\n', stdout
);
10784 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10785 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10786 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10787 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10789 free (aux
->funtab
);
10790 arm_free_section (& exidx_arm_sec
);
10791 arm_free_section (& extab_arm_sec
);
10795 /* ARM EHABI, Section 5:
10796 An index table entry consists of 2 words.
10797 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10798 if (exidx_fn
& 0x80000000)
10800 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10804 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10806 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10807 fputs (": ", stdout
);
10809 if (exidx_entry
== 1)
10811 print_vma (exidx_entry
, PREFIX_HEX
);
10812 fputs (" [cantunwind]\n", stdout
);
10814 else if (exidx_entry
& 0x80000000)
10816 print_vma (exidx_entry
, PREFIX_HEX
);
10817 fputc ('\n', stdout
);
10818 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10822 uint64_t table
, table_offset
= 0;
10823 Elf_Internal_Shdr
*table_sec
;
10825 fputs ("@", stdout
);
10826 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10827 print_vma (table
, PREFIX_HEX
);
10830 /* Locate the matching .ARM.extab. */
10831 if (entry_addr
.section
!= SHN_UNDEF
10832 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10834 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10835 table_offset
= entry_addr
.offset
;
10837 if (table_offset
> table_sec
->sh_size
)
10839 warn (_("Unwind entry contains corrupt offset (%#" PRIx64
") into section %s\n"),
10841 printable_section_name (filedata
, table_sec
));
10848 table_sec
= find_section_by_address (filedata
, table
);
10849 if (table_sec
!= NULL
)
10850 table_offset
= table
- table_sec
->sh_addr
;
10853 if (table_sec
== NULL
)
10855 warn (_("Could not locate .ARM.extab section containing %#" PRIx64
".\n"),
10861 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10869 free (aux
->funtab
);
10870 arm_free_section (&exidx_arm_sec
);
10871 arm_free_section (&extab_arm_sec
);
10876 /* Used for both ARM and C6X unwinding tables. */
10879 arm_process_unwind (Filedata
* filedata
)
10881 struct arm_unw_aux_info aux
;
10882 Elf_Internal_Shdr
*unwsec
= NULL
;
10883 Elf_Internal_Shdr
*sec
;
10885 unsigned int sec_type
;
10888 switch (filedata
->file_header
.e_machine
)
10891 sec_type
= SHT_ARM_EXIDX
;
10895 sec_type
= SHT_C6000_UNWIND
;
10899 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
10900 filedata
->file_header
.e_machine
);
10904 if (filedata
->string_table
== NULL
)
10907 memset (& aux
, 0, sizeof (aux
));
10908 aux
.filedata
= filedata
;
10910 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10912 if (sec
->sh_type
== SHT_SYMTAB
)
10916 error (_("Multiple symbol tables encountered\n"));
10922 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10923 &aux
.strtab
, &aux
.strtab_size
))
10926 else if (sec
->sh_type
== sec_type
)
10930 if (unwsec
== NULL
)
10931 printf (_("\nThere are no unwind sections in this file.\n"));
10933 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10935 if (sec
->sh_type
== sec_type
)
10937 uint64_t num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
10938 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
10939 "contains %" PRIu64
" entry:\n",
10940 "\nUnwind section '%s' at offset %#" PRIx64
" "
10941 "contains %" PRIu64
" entries:\n",
10943 printable_section_name (filedata
, sec
),
10947 if (! dump_arm_unwind (filedata
, &aux
, sec
))
10953 free ((char *) aux
.strtab
);
10959 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
10961 printf (_("No processor specific unwind information to decode\n"));
10966 process_unwind (Filedata
* filedata
)
10968 struct unwind_handler
10970 unsigned int machtype
;
10971 bool (* handler
)(Filedata
*);
10974 { EM_ARM
, arm_process_unwind
},
10975 { EM_IA_64
, ia64_process_unwind
},
10976 { EM_PARISC
, hppa_process_unwind
},
10977 { EM_TI_C6000
, arm_process_unwind
},
10978 { EM_386
, no_processor_specific_unwind
},
10979 { EM_X86_64
, no_processor_specific_unwind
},
10987 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10988 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10989 return handlers
[i
].handler (filedata
);
10991 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10992 get_machine_name (filedata
->file_header
.e_machine
));
10997 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10999 switch (entry
->d_tag
)
11001 case DT_AARCH64_BTI_PLT
:
11002 case DT_AARCH64_PAC_PLT
:
11005 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11012 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
11014 switch (entry
->d_tag
)
11016 case DT_MIPS_FLAGS
:
11017 if (entry
->d_un
.d_val
== 0)
11018 printf (_("NONE"));
11021 static const char * opts
[] =
11023 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
11024 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
11025 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
11026 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
11032 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
11033 if (entry
->d_un
.d_val
& (1 << cnt
))
11035 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
11041 case DT_MIPS_IVERSION
:
11042 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11043 printf (_("Interface Version: %s"),
11044 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11046 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
11047 entry
->d_un
.d_ptr
);
11050 case DT_MIPS_TIME_STAMP
:
11054 time_t atime
= entry
->d_un
.d_val
;
11056 tmp
= gmtime (&atime
);
11057 /* PR 17531: file: 6accc532. */
11059 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
11061 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
11062 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11063 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11064 printf (_("Time Stamp: %s"), timebuf
);
11068 case DT_MIPS_RLD_VERSION
:
11069 case DT_MIPS_LOCAL_GOTNO
:
11070 case DT_MIPS_CONFLICTNO
:
11071 case DT_MIPS_LIBLISTNO
:
11072 case DT_MIPS_SYMTABNO
:
11073 case DT_MIPS_UNREFEXTNO
:
11074 case DT_MIPS_HIPAGENO
:
11075 case DT_MIPS_DELTA_CLASS_NO
:
11076 case DT_MIPS_DELTA_INSTANCE_NO
:
11077 case DT_MIPS_DELTA_RELOC_NO
:
11078 case DT_MIPS_DELTA_SYM_NO
:
11079 case DT_MIPS_DELTA_CLASSSYM_NO
:
11080 case DT_MIPS_COMPACT_SIZE
:
11081 print_vma (entry
->d_un
.d_val
, DEC
);
11084 case DT_MIPS_XHASH
:
11085 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11086 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11087 /* Falls through. */
11090 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11096 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
11098 switch (entry
->d_tag
)
11100 case DT_HP_DLD_FLAGS
:
11109 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
11110 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
11111 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
11112 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
11113 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
11114 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
11115 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
11116 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
11117 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
11118 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
11119 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
11120 { DT_HP_GST
, "HP_GST" },
11121 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
11122 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
11123 { DT_HP_NODELETE
, "HP_NODELETE" },
11124 { DT_HP_GROUP
, "HP_GROUP" },
11125 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
11129 uint64_t val
= entry
->d_un
.d_val
;
11131 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
11132 if (val
& flags
[cnt
].bit
)
11136 fputs (flags
[cnt
].str
, stdout
);
11138 val
^= flags
[cnt
].bit
;
11141 if (val
!= 0 || first
)
11145 print_vma (val
, HEX
);
11151 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11157 /* VMS vs Unix time offset and factor. */
11159 #define VMS_EPOCH_OFFSET 35067168000000000LL
11160 #define VMS_GRANULARITY_FACTOR 10000000
11162 #define INT64_MIN (-9223372036854775807LL - 1)
11165 /* Display a VMS time in a human readable format. */
11168 print_vms_time (int64_t vmstime
)
11170 struct tm
*tm
= NULL
;
11173 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
11175 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
11177 if (unxtime
== vmstime
)
11178 tm
= gmtime (&unxtime
);
11181 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
11182 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
11183 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
11187 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
11189 switch (entry
->d_tag
)
11191 case DT_IA_64_PLT_RESERVE
:
11192 /* First 3 slots reserved. */
11193 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11195 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
11198 case DT_IA_64_VMS_LINKTIME
:
11199 print_vms_time (entry
->d_un
.d_val
);
11202 case DT_IA_64_VMS_LNKFLAGS
:
11203 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11204 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
11205 printf (" CALL_DEBUG");
11206 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
11207 printf (" NOP0BUFS");
11208 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
11209 printf (" P0IMAGE");
11210 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
11211 printf (" MKTHREADS");
11212 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
11213 printf (" UPCALLS");
11214 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
11215 printf (" IMGSTA");
11216 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
11217 printf (" INITIALIZE");
11218 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
11220 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
11221 printf (" EXE_INIT");
11222 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
11223 printf (" TBK_IN_IMG");
11224 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
11225 printf (" DBG_IN_IMG");
11226 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
11227 printf (" TBK_IN_DSF");
11228 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
11229 printf (" DBG_IN_DSF");
11230 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
11231 printf (" SIGNATURES");
11232 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
11233 printf (" REL_SEG_OFF");
11237 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11244 get_32bit_dynamic_section (Filedata
* filedata
)
11246 Elf32_External_Dyn
* edyn
;
11247 Elf32_External_Dyn
* ext
;
11248 Elf_Internal_Dyn
* entry
;
11250 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
11251 filedata
->dynamic_addr
, 1,
11252 filedata
->dynamic_size
,
11253 _("dynamic section"));
11257 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
11258 might not have the luxury of section headers. Look for the DT_NULL
11259 terminator to determine the number of entries. */
11260 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
11261 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
11264 filedata
->dynamic_nent
++;
11265 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
11269 filedata
->dynamic_section
11270 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
11271 if (filedata
->dynamic_section
== NULL
)
11273 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11274 filedata
->dynamic_nent
);
11279 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
11280 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11283 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
11284 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
11293 get_64bit_dynamic_section (Filedata
* filedata
)
11295 Elf64_External_Dyn
* edyn
;
11296 Elf64_External_Dyn
* ext
;
11297 Elf_Internal_Dyn
* entry
;
11299 /* Read in the data. */
11300 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
11301 filedata
->dynamic_addr
, 1,
11302 filedata
->dynamic_size
,
11303 _("dynamic section"));
11307 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
11308 might not have the luxury of section headers. Look for the DT_NULL
11309 terminator to determine the number of entries. */
11310 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
11311 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
11312 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
11315 filedata
->dynamic_nent
++;
11316 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
11320 filedata
->dynamic_section
11321 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
11322 if (filedata
->dynamic_section
== NULL
)
11324 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11325 filedata
->dynamic_nent
);
11330 /* Convert from external to internal formats. */
11331 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
11332 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11335 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
11336 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
11345 get_dynamic_section (Filedata
*filedata
)
11347 if (filedata
->dynamic_section
)
11351 return get_32bit_dynamic_section (filedata
);
11353 return get_64bit_dynamic_section (filedata
);
11357 print_dynamic_flags (uint64_t flags
)
11365 flag
= flags
& - flags
;
11371 putc (' ', stdout
);
11375 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
11376 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
11377 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
11378 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
11379 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
11380 default: fputs (_("unknown"), stdout
); break;
11387 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
11389 unsigned char * e_data
;
11392 /* If size_t is smaller than uint64_t, eg because you are building
11393 on a 32-bit host, then make sure that when number is cast to
11394 size_t no information is lost. */
11395 if ((size_t) number
!= number
11396 || ent_size
* number
/ ent_size
!= number
)
11398 error (_("Size overflow prevents reading %" PRIu64
11399 " elements of size %u\n"),
11404 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11405 attempting to allocate memory when the read is bound to fail. */
11406 if (ent_size
* number
> filedata
->file_size
)
11408 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
11413 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11414 if (e_data
== NULL
)
11416 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
11421 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11423 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
11424 number
* ent_size
);
11429 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11430 if (i_data
== NULL
)
11432 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11439 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11447 get_num_dynamic_syms (Filedata
* filedata
)
11449 uint64_t num_of_syms
= 0;
11451 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11452 return num_of_syms
;
11454 if (filedata
->dynamic_info
[DT_HASH
])
11456 unsigned char nb
[8];
11457 unsigned char nc
[8];
11458 unsigned int hash_ent_size
= 4;
11460 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11461 || filedata
->file_header
.e_machine
== EM_S390
11462 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11463 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11466 if (fseek64 (filedata
->handle
,
11467 (filedata
->archive_file_offset
11468 + offset_from_vma (filedata
,
11469 filedata
->dynamic_info
[DT_HASH
],
11470 sizeof nb
+ sizeof nc
)),
11473 error (_("Unable to seek to start of dynamic information\n"));
11477 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11479 error (_("Failed to read in number of buckets\n"));
11483 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11485 error (_("Failed to read in number of chains\n"));
11489 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11490 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11492 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11494 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11496 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11499 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11500 num_of_syms
= filedata
->nchains
;
11503 if (num_of_syms
== 0)
11505 free (filedata
->buckets
);
11506 filedata
->buckets
= NULL
;
11507 free (filedata
->chains
);
11508 filedata
->chains
= NULL
;
11509 filedata
->nbuckets
= 0;
11513 if (filedata
->dynamic_info_DT_GNU_HASH
)
11515 unsigned char nb
[16];
11516 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11517 uint64_t buckets_vma
;
11520 if (fseek64 (filedata
->handle
,
11521 (filedata
->archive_file_offset
11522 + offset_from_vma (filedata
,
11523 filedata
->dynamic_info_DT_GNU_HASH
,
11527 error (_("Unable to seek to start of dynamic information\n"));
11531 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11533 error (_("Failed to read in number of buckets\n"));
11537 filedata
->ngnubuckets
= byte_get (nb
, 4);
11538 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11539 bitmaskwords
= byte_get (nb
+ 8, 4);
11540 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11542 buckets_vma
+= bitmaskwords
* 4;
11544 buckets_vma
+= bitmaskwords
* 8;
11546 if (fseek64 (filedata
->handle
,
11547 (filedata
->archive_file_offset
11548 + offset_from_vma (filedata
, buckets_vma
, 4)),
11551 error (_("Unable to seek to start of dynamic information\n"));
11555 filedata
->gnubuckets
11556 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11558 if (filedata
->gnubuckets
== NULL
)
11561 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11562 if (filedata
->gnubuckets
[i
] != 0)
11564 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11567 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11568 maxchain
= filedata
->gnubuckets
[i
];
11571 if (maxchain
== 0xffffffff)
11574 maxchain
-= filedata
->gnusymidx
;
11576 if (fseek64 (filedata
->handle
,
11577 (filedata
->archive_file_offset
11578 + offset_from_vma (filedata
,
11579 buckets_vma
+ 4 * (filedata
->ngnubuckets
11584 error (_("Unable to seek to start of dynamic information\n"));
11590 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11592 error (_("Failed to determine last chain length\n"));
11596 if (maxchain
+ 1 == 0)
11601 while ((byte_get (nb
, 4) & 1) == 0);
11603 if (fseek64 (filedata
->handle
,
11604 (filedata
->archive_file_offset
11605 + offset_from_vma (filedata
, (buckets_vma
11606 + 4 * filedata
->ngnubuckets
),
11610 error (_("Unable to seek to start of dynamic information\n"));
11614 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11615 filedata
->ngnuchains
= maxchain
;
11617 if (filedata
->gnuchains
== NULL
)
11620 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11622 if (fseek64 (filedata
->handle
,
11623 (filedata
->archive_file_offset
11624 + offset_from_vma (filedata
, (buckets_vma
11625 + 4 * (filedata
->ngnubuckets
11629 error (_("Unable to seek to start of dynamic information\n"));
11633 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11634 if (filedata
->mipsxlat
== NULL
)
11638 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
11639 if (filedata
->gnubuckets
[hn
] != 0)
11641 uint64_t si
= filedata
->gnubuckets
[hn
];
11642 uint64_t off
= si
- filedata
->gnusymidx
;
11646 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11648 if (off
< filedata
->ngnuchains
11649 && filedata
->mipsxlat
[off
] >= num_of_syms
)
11650 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
11654 if (si
>= num_of_syms
)
11655 num_of_syms
= si
+ 1;
11659 while (off
< filedata
->ngnuchains
11660 && (filedata
->gnuchains
[off
++] & 1) == 0);
11663 if (num_of_syms
== 0)
11666 free (filedata
->mipsxlat
);
11667 filedata
->mipsxlat
= NULL
;
11668 free (filedata
->gnuchains
);
11669 filedata
->gnuchains
= NULL
;
11670 free (filedata
->gnubuckets
);
11671 filedata
->gnubuckets
= NULL
;
11672 filedata
->ngnubuckets
= 0;
11673 filedata
->ngnuchains
= 0;
11677 return num_of_syms
;
11680 /* Parse and display the contents of the dynamic section. */
11683 process_dynamic_section (Filedata
* filedata
)
11685 Elf_Internal_Dyn
* entry
;
11687 if (filedata
->dynamic_size
<= 1)
11691 if (filedata
->is_separate
)
11692 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
11693 filedata
->file_name
);
11695 printf (_("\nThere is no dynamic section in this file.\n"));
11701 if (!get_dynamic_section (filedata
))
11704 /* Find the appropriate symbol table. */
11705 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
11707 uint64_t num_of_syms
;
11709 for (entry
= filedata
->dynamic_section
;
11710 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11712 if (entry
->d_tag
== DT_SYMTAB
)
11713 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
11714 else if (entry
->d_tag
== DT_SYMENT
)
11715 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
11716 else if (entry
->d_tag
== DT_HASH
)
11717 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
11718 else if (entry
->d_tag
== DT_GNU_HASH
)
11719 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11720 else if ((filedata
->file_header
.e_machine
== EM_MIPS
11721 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
11722 && entry
->d_tag
== DT_MIPS_XHASH
)
11724 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11725 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11728 num_of_syms
= get_num_dynamic_syms (filedata
);
11730 if (num_of_syms
!= 0
11731 && filedata
->dynamic_symbols
== NULL
11732 && filedata
->dynamic_info
[DT_SYMTAB
]
11733 && filedata
->dynamic_info
[DT_SYMENT
])
11735 Elf_Internal_Phdr
*seg
;
11736 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
11738 if (! get_program_headers (filedata
))
11740 error (_("Cannot interpret virtual addresses "
11741 "without program headers.\n"));
11745 for (seg
= filedata
->program_headers
;
11746 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11749 if (seg
->p_type
!= PT_LOAD
)
11752 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11754 /* See PR 21379 for a reproducer. */
11755 error (_("Invalid PT_LOAD entry\n"));
11759 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11760 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11762 /* Since we do not know how big the symbol table is,
11763 we default to reading in up to the end of PT_LOAD
11764 segment and processing that. This is overkill, I
11765 know, but it should work. */
11766 Elf_Internal_Shdr section
;
11767 section
.sh_offset
= (vma
- seg
->p_vaddr
11769 section
.sh_size
= (num_of_syms
11770 * filedata
->dynamic_info
[DT_SYMENT
]);
11771 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11774 && filedata
->dynamic_symtab_section
!= NULL
11775 && ((filedata
->dynamic_symtab_section
->sh_offset
11776 != section
.sh_offset
)
11777 || (filedata
->dynamic_symtab_section
->sh_size
11778 != section
.sh_size
)
11779 || (filedata
->dynamic_symtab_section
->sh_entsize
11780 != section
.sh_entsize
)))
11782 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11784 section
.sh_name
= filedata
->string_table_length
;
11785 filedata
->dynamic_symbols
11786 = get_elf_symbols (filedata
, §ion
,
11787 &filedata
->num_dynamic_syms
);
11788 if (filedata
->dynamic_symbols
== NULL
11789 || filedata
->num_dynamic_syms
!= num_of_syms
)
11791 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11800 /* Similarly find a string table. */
11801 if (filedata
->dynamic_strings
== NULL
)
11802 for (entry
= filedata
->dynamic_section
;
11803 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11806 if (entry
->d_tag
== DT_STRTAB
)
11807 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11809 if (entry
->d_tag
== DT_STRSZ
)
11810 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11812 if (filedata
->dynamic_info
[DT_STRTAB
]
11813 && filedata
->dynamic_info
[DT_STRSZ
])
11816 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11818 offset
= offset_from_vma (filedata
,
11819 filedata
->dynamic_info
[DT_STRTAB
],
11822 && filedata
->dynamic_strtab_section
11823 && ((filedata
->dynamic_strtab_section
->sh_offset
11824 != (file_ptr
) offset
)
11825 || (filedata
->dynamic_strtab_section
->sh_size
11828 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11830 filedata
->dynamic_strings
11831 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11832 _("dynamic string table"));
11833 if (filedata
->dynamic_strings
== NULL
)
11835 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11839 filedata
->dynamic_strings_length
= str_tab_len
;
11844 /* And find the syminfo section if available. */
11845 if (filedata
->dynamic_syminfo
== NULL
)
11847 uint64_t syminsz
= 0;
11849 for (entry
= filedata
->dynamic_section
;
11850 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11853 if (entry
->d_tag
== DT_SYMINENT
)
11855 /* Note: these braces are necessary to avoid a syntax
11856 error from the SunOS4 C compiler. */
11857 /* PR binutils/17531: A corrupt file can trigger this test.
11858 So do not use an assert, instead generate an error message. */
11859 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11860 error (_("Bad value (%d) for SYMINENT entry\n"),
11861 (int) entry
->d_un
.d_val
);
11863 else if (entry
->d_tag
== DT_SYMINSZ
)
11864 syminsz
= entry
->d_un
.d_val
;
11865 else if (entry
->d_tag
== DT_SYMINFO
)
11866 filedata
->dynamic_syminfo_offset
11867 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11870 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11872 Elf_External_Syminfo
* extsyminfo
;
11873 Elf_External_Syminfo
* extsym
;
11874 Elf_Internal_Syminfo
* syminfo
;
11876 /* There is a syminfo section. Read the data. */
11877 extsyminfo
= (Elf_External_Syminfo
*)
11878 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11879 1, syminsz
, _("symbol information"));
11883 if (filedata
->dynamic_syminfo
!= NULL
)
11885 error (_("Multiple dynamic symbol information sections found\n"));
11886 free (filedata
->dynamic_syminfo
);
11888 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11889 if (filedata
->dynamic_syminfo
== NULL
)
11891 error (_("Out of memory allocating %" PRIu64
11892 " bytes for dynamic symbol info\n"),
11897 filedata
->dynamic_syminfo_nent
11898 = syminsz
/ sizeof (Elf_External_Syminfo
);
11899 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
11900 syminfo
< (filedata
->dynamic_syminfo
11901 + filedata
->dynamic_syminfo_nent
);
11902 ++syminfo
, ++extsym
)
11904 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
11905 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
11912 if (do_dynamic
&& filedata
->dynamic_addr
)
11914 if (filedata
->is_separate
)
11915 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11916 "\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11917 filedata
->dynamic_nent
),
11918 filedata
->file_name
,
11919 filedata
->dynamic_addr
,
11920 filedata
->dynamic_nent
);
11922 printf (ngettext ("\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11923 "\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11924 filedata
->dynamic_nent
),
11925 filedata
->dynamic_addr
,
11926 filedata
->dynamic_nent
);
11929 printf (_(" Tag Type Name/Value\n"));
11931 for (entry
= filedata
->dynamic_section
;
11932 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11937 const char * dtype
;
11940 print_vma (entry
->d_tag
, FULL_HEX
);
11941 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
11942 printf (" (%s)%*s", dtype
,
11943 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
11946 switch (entry
->d_tag
)
11950 print_dynamic_flags (entry
->d_un
.d_val
);
11960 switch (entry
->d_tag
)
11963 printf (_("Auxiliary library"));
11967 printf (_("Filter library"));
11971 printf (_("Configuration file"));
11975 printf (_("Dependency audit library"));
11979 printf (_("Audit library"));
11983 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11984 printf (": [%s]\n",
11985 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11989 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11998 printf (_("Flags:"));
12000 if (entry
->d_un
.d_val
== 0)
12001 printf (_(" None\n"));
12004 uint64_t val
= entry
->d_un
.d_val
;
12006 if (val
& DTF_1_PARINIT
)
12008 printf (" PARINIT");
12009 val
^= DTF_1_PARINIT
;
12011 if (val
& DTF_1_CONFEXP
)
12013 printf (" CONFEXP");
12014 val
^= DTF_1_CONFEXP
;
12017 printf (" %" PRIx64
, val
);
12026 printf (_("Flags:"));
12028 if (entry
->d_un
.d_val
== 0)
12029 printf (_(" None\n"));
12032 uint64_t val
= entry
->d_un
.d_val
;
12034 if (val
& DF_P1_LAZYLOAD
)
12036 printf (" LAZYLOAD");
12037 val
^= DF_P1_LAZYLOAD
;
12039 if (val
& DF_P1_GROUPPERM
)
12041 printf (" GROUPPERM");
12042 val
^= DF_P1_GROUPPERM
;
12045 printf (" %" PRIx64
, val
);
12054 printf (_("Flags:"));
12055 if (entry
->d_un
.d_val
== 0)
12056 printf (_(" None\n"));
12059 uint64_t val
= entry
->d_un
.d_val
;
12061 if (val
& DF_1_NOW
)
12066 if (val
& DF_1_GLOBAL
)
12068 printf (" GLOBAL");
12069 val
^= DF_1_GLOBAL
;
12071 if (val
& DF_1_GROUP
)
12076 if (val
& DF_1_NODELETE
)
12078 printf (" NODELETE");
12079 val
^= DF_1_NODELETE
;
12081 if (val
& DF_1_LOADFLTR
)
12083 printf (" LOADFLTR");
12084 val
^= DF_1_LOADFLTR
;
12086 if (val
& DF_1_INITFIRST
)
12088 printf (" INITFIRST");
12089 val
^= DF_1_INITFIRST
;
12091 if (val
& DF_1_NOOPEN
)
12093 printf (" NOOPEN");
12094 val
^= DF_1_NOOPEN
;
12096 if (val
& DF_1_ORIGIN
)
12098 printf (" ORIGIN");
12099 val
^= DF_1_ORIGIN
;
12101 if (val
& DF_1_DIRECT
)
12103 printf (" DIRECT");
12104 val
^= DF_1_DIRECT
;
12106 if (val
& DF_1_TRANS
)
12111 if (val
& DF_1_INTERPOSE
)
12113 printf (" INTERPOSE");
12114 val
^= DF_1_INTERPOSE
;
12116 if (val
& DF_1_NODEFLIB
)
12118 printf (" NODEFLIB");
12119 val
^= DF_1_NODEFLIB
;
12121 if (val
& DF_1_NODUMP
)
12123 printf (" NODUMP");
12124 val
^= DF_1_NODUMP
;
12126 if (val
& DF_1_CONFALT
)
12128 printf (" CONFALT");
12129 val
^= DF_1_CONFALT
;
12131 if (val
& DF_1_ENDFILTEE
)
12133 printf (" ENDFILTEE");
12134 val
^= DF_1_ENDFILTEE
;
12136 if (val
& DF_1_DISPRELDNE
)
12138 printf (" DISPRELDNE");
12139 val
^= DF_1_DISPRELDNE
;
12141 if (val
& DF_1_DISPRELPND
)
12143 printf (" DISPRELPND");
12144 val
^= DF_1_DISPRELPND
;
12146 if (val
& DF_1_NODIRECT
)
12148 printf (" NODIRECT");
12149 val
^= DF_1_NODIRECT
;
12151 if (val
& DF_1_IGNMULDEF
)
12153 printf (" IGNMULDEF");
12154 val
^= DF_1_IGNMULDEF
;
12156 if (val
& DF_1_NOKSYMS
)
12158 printf (" NOKSYMS");
12159 val
^= DF_1_NOKSYMS
;
12161 if (val
& DF_1_NOHDR
)
12166 if (val
& DF_1_EDITED
)
12168 printf (" EDITED");
12169 val
^= DF_1_EDITED
;
12171 if (val
& DF_1_NORELOC
)
12173 printf (" NORELOC");
12174 val
^= DF_1_NORELOC
;
12176 if (val
& DF_1_SYMINTPOSE
)
12178 printf (" SYMINTPOSE");
12179 val
^= DF_1_SYMINTPOSE
;
12181 if (val
& DF_1_GLOBAUDIT
)
12183 printf (" GLOBAUDIT");
12184 val
^= DF_1_GLOBAUDIT
;
12186 if (val
& DF_1_SINGLETON
)
12188 printf (" SINGLETON");
12189 val
^= DF_1_SINGLETON
;
12191 if (val
& DF_1_STUB
)
12196 if (val
& DF_1_PIE
)
12201 if (val
& DF_1_KMOD
)
12206 if (val
& DF_1_WEAKFILTER
)
12208 printf (" WEAKFILTER");
12209 val
^= DF_1_WEAKFILTER
;
12211 if (val
& DF_1_NOCOMMON
)
12213 printf (" NOCOMMON");
12214 val
^= DF_1_NOCOMMON
;
12217 printf (" %" PRIx64
, val
);
12224 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12226 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
12247 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12253 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12254 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12260 switch (entry
->d_tag
)
12263 printf (_("Shared library: [%s]"), name
);
12265 if (filedata
->program_interpreter
12266 && streq (name
, filedata
->program_interpreter
))
12267 printf (_(" program interpreter"));
12271 printf (_("Library soname: [%s]"), name
);
12275 printf (_("Library rpath: [%s]"), name
);
12279 printf (_("Library runpath: [%s]"), name
);
12283 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12288 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12303 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12304 /* Fall through. */
12308 case DT_PREINIT_ARRAYSZ
:
12309 case DT_INIT_ARRAYSZ
:
12310 case DT_FINI_ARRAYSZ
:
12311 case DT_GNU_CONFLICTSZ
:
12312 case DT_GNU_LIBLISTSZ
:
12315 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
12316 printf (_(" (bytes)\n"));
12321 case DT_VERNEEDNUM
:
12326 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
12335 case DT_INIT_ARRAY
:
12336 case DT_FINI_ARRAY
:
12339 if (entry
->d_tag
== DT_USED
12340 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12343 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12347 printf (_("Not needed object: [%s]\n"), name
);
12352 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12358 /* The value of this entry is ignored. */
12363 case DT_GNU_PRELINKED
:
12367 time_t atime
= entry
->d_un
.d_val
;
12369 tmp
= gmtime (&atime
);
12370 /* PR 17533 file: 041-1244816-0.004. */
12372 printf (_("<corrupt time val: %" PRIx64
),
12375 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
12376 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12377 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12383 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12386 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12391 case DT_GNU_FLAGS_1
:
12394 printf (_("Flags:"));
12395 if (entry
->d_un
.d_val
== 0)
12396 printf (_(" None\n"));
12399 uint64_t val
= entry
->d_un
.d_val
;
12401 if (val
& DF_GNU_1_UNIQUE
)
12403 printf (" UNIQUE");
12404 val
^= DF_GNU_1_UNIQUE
;
12407 printf (" %" PRIx64
, val
);
12414 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
12415 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
12416 = entry
->d_un
.d_val
;
12420 switch (filedata
->file_header
.e_machine
)
12423 dynamic_section_aarch64_val (entry
);
12426 case EM_MIPS_RS3_LE
:
12427 dynamic_section_mips_val (filedata
, entry
);
12430 dynamic_section_parisc_val (entry
);
12433 dynamic_section_ia64_val (entry
);
12436 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12448 get_ver_flags (unsigned int flags
)
12450 static char buff
[128];
12457 if (flags
& VER_FLG_BASE
)
12458 strcat (buff
, "BASE");
12460 if (flags
& VER_FLG_WEAK
)
12462 if (flags
& VER_FLG_BASE
)
12463 strcat (buff
, " | ");
12465 strcat (buff
, "WEAK");
12468 if (flags
& VER_FLG_INFO
)
12470 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12471 strcat (buff
, " | ");
12473 strcat (buff
, "INFO");
12476 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12478 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12479 strcat (buff
, " | ");
12481 strcat (buff
, _("<unknown>"));
12487 /* Display the contents of the version sections. */
12490 process_version_sections (Filedata
* filedata
)
12492 Elf_Internal_Shdr
* section
;
12494 bool found
= false;
12499 for (i
= 0, section
= filedata
->section_headers
;
12500 i
< filedata
->file_header
.e_shnum
;
12503 switch (section
->sh_type
)
12505 case SHT_GNU_verdef
:
12507 Elf_External_Verdef
* edefs
;
12514 if (filedata
->is_separate
)
12515 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12516 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12518 filedata
->file_name
,
12519 printable_section_name (filedata
, section
),
12522 printf (ngettext ("\nVersion definition section '%s' "
12523 "contains %u entry:\n",
12524 "\nVersion definition section '%s' "
12525 "contains %u entries:\n",
12527 printable_section_name (filedata
, section
),
12530 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12531 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12532 section
->sh_offset
, section
->sh_link
,
12533 printable_section_name_from_index (filedata
, section
->sh_link
));
12535 edefs
= (Elf_External_Verdef
*)
12536 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12537 _("version definition section"));
12540 endbuf
= (char *) edefs
+ section
->sh_size
;
12542 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12545 Elf_External_Verdef
* edef
;
12546 Elf_Internal_Verdef ent
;
12547 Elf_External_Verdaux
* eaux
;
12548 Elf_Internal_Verdaux aux
;
12552 vstart
= ((char *) edefs
) + idx
;
12553 if (vstart
+ sizeof (*edef
) > endbuf
)
12556 edef
= (Elf_External_Verdef
*) vstart
;
12558 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12559 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12560 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12561 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12562 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12563 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12564 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12566 printf (_(" %#06zx: Rev: %d Flags: %s"),
12567 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12569 printf (_(" Index: %d Cnt: %d "),
12570 ent
.vd_ndx
, ent
.vd_cnt
);
12572 /* Check for overflow. */
12573 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12576 vstart
+= ent
.vd_aux
;
12578 if (vstart
+ sizeof (*eaux
) > endbuf
)
12580 eaux
= (Elf_External_Verdaux
*) vstart
;
12582 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12583 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12585 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12586 printf (_("Name: %s\n"),
12587 get_dynamic_name (filedata
, aux
.vda_name
));
12589 printf (_("Name index: %ld\n"), aux
.vda_name
);
12591 isum
= idx
+ ent
.vd_aux
;
12593 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12595 if (aux
.vda_next
< sizeof (*eaux
)
12596 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12598 warn (_("Invalid vda_next field of %lx\n"),
12603 /* Check for overflow. */
12604 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12607 isum
+= aux
.vda_next
;
12608 vstart
+= aux
.vda_next
;
12610 if (vstart
+ sizeof (*eaux
) > endbuf
)
12612 eaux
= (Elf_External_Verdaux
*) vstart
;
12614 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12615 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12617 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12618 printf (_(" %#06zx: Parent %d: %s\n"),
12620 get_dynamic_name (filedata
, aux
.vda_name
));
12622 printf (_(" %#06zx: Parent %d, name index: %ld\n"),
12623 isum
, j
, aux
.vda_name
);
12626 if (j
< ent
.vd_cnt
)
12627 printf (_(" Version def aux past end of section\n"));
12630 file: id:000001,src:000172+005151,op:splice,rep:2. */
12631 if (ent
.vd_next
< sizeof (*edef
)
12632 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
12634 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
12635 cnt
= section
->sh_info
;
12638 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
12641 idx
+= ent
.vd_next
;
12644 if (cnt
< section
->sh_info
)
12645 printf (_(" Version definition past end of section\n"));
12651 case SHT_GNU_verneed
:
12653 Elf_External_Verneed
* eneed
;
12660 if (filedata
->is_separate
)
12661 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
12662 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
12664 filedata
->file_name
,
12665 printable_section_name (filedata
, section
),
12668 printf (ngettext ("\nVersion needs section '%s' "
12669 "contains %u entry:\n",
12670 "\nVersion needs section '%s' "
12671 "contains %u entries:\n",
12673 printable_section_name (filedata
, section
),
12676 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12677 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12678 section
->sh_offset
, section
->sh_link
,
12679 printable_section_name_from_index (filedata
, section
->sh_link
));
12681 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
12682 section
->sh_offset
, 1,
12684 _("Version Needs section"));
12687 endbuf
= (char *) eneed
+ section
->sh_size
;
12689 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12691 Elf_External_Verneed
* entry
;
12692 Elf_Internal_Verneed ent
;
12697 vstart
= ((char *) eneed
) + idx
;
12698 if (vstart
+ sizeof (*entry
) > endbuf
)
12701 entry
= (Elf_External_Verneed
*) vstart
;
12703 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
12704 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
12705 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
12706 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
12707 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
12709 printf (_(" %#06zx: Version: %d"), idx
, ent
.vn_version
);
12711 if (valid_dynamic_name (filedata
, ent
.vn_file
))
12712 printf (_(" File: %s"),
12713 get_dynamic_name (filedata
, ent
.vn_file
));
12715 printf (_(" File: %lx"), ent
.vn_file
);
12717 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
12719 /* Check for overflow. */
12720 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
12722 vstart
+= ent
.vn_aux
;
12724 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
12726 Elf_External_Vernaux
* eaux
;
12727 Elf_Internal_Vernaux aux
;
12729 if (vstart
+ sizeof (*eaux
) > endbuf
)
12731 eaux
= (Elf_External_Vernaux
*) vstart
;
12733 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
12734 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
12735 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
12736 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
12737 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12739 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12740 printf (_(" %#06zx: Name: %s"),
12741 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12743 printf (_(" %#06zx: Name index: %lx"),
12744 isum
, aux
.vna_name
);
12746 printf (_(" Flags: %s Version: %d\n"),
12747 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12749 if (aux
.vna_next
< sizeof (*eaux
)
12750 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12752 warn (_("Invalid vna_next field of %lx\n"),
12757 /* Check for overflow. */
12758 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12760 isum
+= aux
.vna_next
;
12761 vstart
+= aux
.vna_next
;
12764 if (j
< ent
.vn_cnt
)
12765 warn (_("Missing Version Needs auxiliary information\n"));
12767 if (ent
.vn_next
< sizeof (*entry
)
12768 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12770 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12771 cnt
= section
->sh_info
;
12774 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12776 idx
+= ent
.vn_next
;
12779 if (cnt
< section
->sh_info
)
12780 warn (_("Missing Version Needs information\n"));
12786 case SHT_GNU_versym
:
12788 Elf_Internal_Shdr
* link_section
;
12791 unsigned char * edata
;
12792 unsigned short * data
;
12794 Elf_Internal_Sym
* symbols
;
12795 Elf_Internal_Shdr
* string_sec
;
12799 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12802 link_section
= filedata
->section_headers
+ section
->sh_link
;
12803 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12805 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12810 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12811 if (symbols
== NULL
)
12814 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12816 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12817 string_sec
->sh_size
,
12818 _("version string table"));
12825 if (filedata
->is_separate
)
12826 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entry:\n",
12827 "\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entries:\n",
12829 filedata
->file_name
,
12830 printable_section_name (filedata
, section
),
12833 printf (ngettext ("\nVersion symbols section '%s' "
12834 "contains %" PRIu64
" entry:\n",
12835 "\nVersion symbols section '%s' "
12836 "contains %" PRIu64
" entries:\n",
12838 printable_section_name (filedata
, section
),
12841 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12842 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12843 section
->sh_offset
, section
->sh_link
,
12844 printable_section_name (filedata
, link_section
));
12846 off
= offset_from_vma (filedata
,
12847 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12848 total
* sizeof (short));
12849 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12850 sizeof (short), total
,
12851 _("version symbol data"));
12859 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12861 for (cnt
= total
; cnt
--;)
12862 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12867 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12871 char *invalid
= _("*invalid*");
12873 printf (" %03x:", cnt
);
12875 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12876 switch (data
[cnt
+ j
])
12879 fputs (_(" 0 (*local*) "), stdout
);
12883 fputs (_(" 1 (*global*) "), stdout
);
12887 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12888 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12890 /* If this index value is greater than the size of the symbols
12891 array, break to avoid an out-of-bounds read. */
12892 if (cnt
+ j
>= num_syms
)
12894 warn (_("invalid index into symbol array\n"));
12899 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12901 Elf_Internal_Verneed ivn
;
12904 offset
= offset_from_vma
12906 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12907 sizeof (Elf_External_Verneed
));
12911 Elf_Internal_Vernaux ivna
;
12912 Elf_External_Verneed evn
;
12913 Elf_External_Vernaux evna
;
12916 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12917 _("version need")) == NULL
)
12920 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12921 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12923 a_off
= offset
+ ivn
.vn_aux
;
12927 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
12928 1, _("version need aux (2)")) == NULL
)
12931 ivna
.vna_other
= 0;
12935 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12936 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12939 a_off
+= ivna
.vna_next
;
12941 while (ivna
.vna_other
!= data
[cnt
+ j
]
12942 && ivna
.vna_next
!= 0);
12944 if (ivna
.vna_other
== data
[cnt
+ j
])
12946 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12948 if (ivna
.vna_name
>= string_sec
->sh_size
)
12951 name
= strtab
+ ivna
.vna_name
;
12955 offset
+= ivn
.vn_next
;
12957 while (ivn
.vn_next
);
12960 if (data
[cnt
+ j
] != 0x8001
12961 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12963 Elf_Internal_Verdef ivd
;
12964 Elf_External_Verdef evd
;
12967 offset
= offset_from_vma
12969 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12974 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12975 _("version def")) == NULL
)
12978 /* PR 17531: file: 046-1082287-0.004. */
12979 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12984 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12985 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12988 offset
+= ivd
.vd_next
;
12990 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12991 && ivd
.vd_next
!= 0);
12993 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12995 Elf_External_Verdaux evda
;
12996 Elf_Internal_Verdaux ivda
;
12998 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13000 if (get_data (&evda
, filedata
,
13001 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
13003 _("version def aux")) == NULL
)
13006 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13008 if (ivda
.vda_name
>= string_sec
->sh_size
)
13010 else if (name
!= NULL
&& name
!= invalid
)
13011 name
= _("*both*");
13013 name
= strtab
+ ivda
.vda_name
;
13017 nn
+= printf ("(%s%-*s",
13019 12 - (int) strlen (name
),
13023 printf ("%*c", 18 - nn
, ' ');
13042 if (filedata
->is_separate
)
13043 printf (_("\nNo version information found in linked file '%s'.\n"),
13044 filedata
->file_name
);
13046 printf (_("\nNo version information found in this file.\n"));
13052 static const char *
13053 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
13055 static char buff
[64];
13059 case STB_LOCAL
: return "LOCAL";
13060 case STB_GLOBAL
: return "GLOBAL";
13061 case STB_WEAK
: return "WEAK";
13063 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
13064 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
13066 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
13068 if (binding
== STB_GNU_UNIQUE
13069 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
13071 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
13074 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
13079 static const char *
13080 get_symbol_type (Filedata
* filedata
, unsigned int type
)
13082 static char buff
[64];
13086 case STT_NOTYPE
: return "NOTYPE";
13087 case STT_OBJECT
: return "OBJECT";
13088 case STT_FUNC
: return "FUNC";
13089 case STT_SECTION
: return "SECTION";
13090 case STT_FILE
: return "FILE";
13091 case STT_COMMON
: return "COMMON";
13092 case STT_TLS
: return "TLS";
13093 case STT_RELC
: return "RELC";
13094 case STT_SRELC
: return "SRELC";
13096 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
13098 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
13099 return "THUMB_FUNC";
13101 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
13104 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
13105 return "PARISC_MILLI";
13107 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
13109 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
13111 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13113 if (type
== STT_HP_OPAQUE
)
13114 return "HP_OPAQUE";
13115 if (type
== STT_HP_STUB
)
13119 if (type
== STT_GNU_IFUNC
13120 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
13121 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
13124 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
13127 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
13132 static const char *
13133 get_symbol_visibility (unsigned int visibility
)
13135 switch (visibility
)
13137 case STV_DEFAULT
: return "DEFAULT";
13138 case STV_INTERNAL
: return "INTERNAL";
13139 case STV_HIDDEN
: return "HIDDEN";
13140 case STV_PROTECTED
: return "PROTECTED";
13142 error (_("Unrecognized visibility value: %u\n"), visibility
);
13143 return _("<unknown>");
13147 static const char *
13148 get_alpha_symbol_other (unsigned int other
)
13152 case STO_ALPHA_NOPV
: return "NOPV";
13153 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
13155 error (_("Unrecognized alpha specific other value: %u\n"), other
);
13156 return _("<unknown>");
13160 static const char *
13161 get_solaris_symbol_visibility (unsigned int visibility
)
13163 switch (visibility
)
13165 case 4: return "EXPORTED";
13166 case 5: return "SINGLETON";
13167 case 6: return "ELIMINATE";
13168 default: return get_symbol_visibility (visibility
);
13172 static const char *
13173 get_aarch64_symbol_other (unsigned int other
)
13175 static char buf
[32];
13177 if (other
& STO_AARCH64_VARIANT_PCS
)
13179 other
&= ~STO_AARCH64_VARIANT_PCS
;
13181 return "VARIANT_PCS";
13182 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
13188 static const char *
13189 get_mips_symbol_other (unsigned int other
)
13193 case STO_OPTIONAL
: return "OPTIONAL";
13194 case STO_MIPS_PLT
: return "MIPS PLT";
13195 case STO_MIPS_PIC
: return "MIPS PIC";
13196 case STO_MICROMIPS
: return "MICROMIPS";
13197 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
13198 case STO_MIPS16
: return "MIPS16";
13199 default: return NULL
;
13203 static const char *
13204 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
13206 if (is_ia64_vms (filedata
))
13208 static char res
[32];
13212 /* Function types is for images and .STB files only. */
13213 switch (filedata
->file_header
.e_type
)
13217 switch (VMS_ST_FUNC_TYPE (other
))
13219 case VMS_SFT_CODE_ADDR
:
13220 strcat (res
, " CA");
13222 case VMS_SFT_SYMV_IDX
:
13223 strcat (res
, " VEC");
13226 strcat (res
, " FD");
13228 case VMS_SFT_RESERVE
:
13229 strcat (res
, " RSV");
13232 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
13233 VMS_ST_FUNC_TYPE (other
));
13234 strcat (res
, " <unknown>");
13241 switch (VMS_ST_LINKAGE (other
))
13243 case VMS_STL_IGNORE
:
13244 strcat (res
, " IGN");
13246 case VMS_STL_RESERVE
:
13247 strcat (res
, " RSV");
13250 strcat (res
, " STD");
13253 strcat (res
, " LNK");
13256 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
13257 VMS_ST_LINKAGE (other
));
13258 strcat (res
, " <unknown>");
13270 static const char *
13271 get_ppc64_symbol_other (unsigned int other
)
13273 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
13276 other
>>= STO_PPC64_LOCAL_BIT
;
13279 static char buf
[64];
13281 other
= ppc64_decode_local_entry (other
);
13282 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
13288 static const char *
13289 get_riscv_symbol_other (unsigned int other
)
13291 static char buf
[32];
13294 if (other
& STO_RISCV_VARIANT_CC
)
13296 strcat (buf
, _(" VARIANT_CC"));
13297 other
&= ~STO_RISCV_VARIANT_CC
;
13301 snprintf (buf
, sizeof buf
, " %x", other
);
13310 static const char *
13311 get_symbol_other (Filedata
* filedata
, unsigned int other
)
13313 const char * result
= NULL
;
13314 static char buff
[64];
13319 switch (filedata
->file_header
.e_machine
)
13322 result
= get_alpha_symbol_other (other
);
13325 result
= get_aarch64_symbol_other (other
);
13328 result
= get_mips_symbol_other (other
);
13331 result
= get_ia64_symbol_other (filedata
, other
);
13334 result
= get_ppc64_symbol_other (other
);
13337 result
= get_riscv_symbol_other (other
);
13347 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
13351 static const char *
13352 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
13354 static char buff
[32];
13358 case SHN_UNDEF
: return "UND";
13359 case SHN_ABS
: return "ABS";
13360 case SHN_COMMON
: return "COM";
13362 if (type
== SHN_IA_64_ANSI_COMMON
13363 && filedata
->file_header
.e_machine
== EM_IA_64
13364 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
13366 else if ((filedata
->file_header
.e_machine
== EM_X86_64
13367 || filedata
->file_header
.e_machine
== EM_L1OM
13368 || filedata
->file_header
.e_machine
== EM_K1OM
)
13369 && type
== SHN_X86_64_LCOMMON
)
13370 return "LARGE_COM";
13371 else if ((type
== SHN_MIPS_SCOMMON
13372 && filedata
->file_header
.e_machine
== EM_MIPS
)
13373 || (type
== SHN_TIC6X_SCOMMON
13374 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
13376 else if (type
== SHN_MIPS_SUNDEFINED
13377 && filedata
->file_header
.e_machine
== EM_MIPS
)
13379 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
13380 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
13381 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
13382 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
13383 else if (type
>= SHN_LORESERVE
)
13384 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
13385 else if (filedata
->file_header
.e_shnum
!= 0
13386 && type
>= filedata
->file_header
.e_shnum
)
13387 sprintf (buff
, _("bad section index[%3d]"), type
);
13389 sprintf (buff
, "%3d", type
);
13396 static const char *
13397 get_symbol_version_string (Filedata
*filedata
,
13399 const char *strtab
,
13400 size_t strtab_size
,
13402 Elf_Internal_Sym
*psym
,
13403 enum versioned_symbol_info
*sym_info
,
13404 unsigned short *vna_other
)
13406 unsigned char data
[2];
13407 unsigned short vers_data
;
13409 unsigned short max_vd_ndx
;
13412 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
13415 offset
= offset_from_vma (filedata
,
13416 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
13417 sizeof data
+ si
* sizeof (vers_data
));
13419 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
13420 sizeof (data
), 1, _("version data")) == NULL
)
13423 vers_data
= byte_get (data
, 2);
13425 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
13428 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13431 /* Usually we'd only see verdef for defined symbols, and verneed for
13432 undefined symbols. However, symbols defined by the linker in
13433 .dynbss for variables copied from a shared library in order to
13434 avoid text relocations are defined yet have verneed. We could
13435 use a heuristic to detect the special case, for example, check
13436 for verneed first on symbols defined in SHT_NOBITS sections, but
13437 it is simpler and more reliable to just look for both verdef and
13438 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13440 if (psym
->st_shndx
!= SHN_UNDEF
13441 && vers_data
!= 0x8001
13442 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13444 Elf_Internal_Verdef ivd
;
13445 Elf_Internal_Verdaux ivda
;
13446 Elf_External_Verdaux evda
;
13449 off
= offset_from_vma (filedata
,
13450 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13451 sizeof (Elf_External_Verdef
));
13455 Elf_External_Verdef evd
;
13457 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13458 _("version def")) == NULL
)
13467 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13468 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13469 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13470 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13473 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13474 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13476 off
+= ivd
.vd_next
;
13478 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13480 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13482 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13485 off
-= ivd
.vd_next
;
13488 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13489 _("version def aux")) != NULL
)
13491 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13493 if (psym
->st_name
!= ivda
.vda_name
)
13494 return (ivda
.vda_name
< strtab_size
13495 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13500 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13502 Elf_External_Verneed evn
;
13503 Elf_Internal_Verneed ivn
;
13504 Elf_Internal_Vernaux ivna
;
13506 offset
= offset_from_vma (filedata
,
13507 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13513 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13514 _("version need")) == NULL
)
13517 ivna
.vna_other
= 0;
13522 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13523 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13525 vna_off
= offset
+ ivn
.vn_aux
;
13529 Elf_External_Vernaux evna
;
13531 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13532 _("version need aux (3)")) == NULL
)
13535 ivna
.vna_other
= 0;
13540 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13541 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13542 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13545 vna_off
+= ivna
.vna_next
;
13547 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13549 if (ivna
.vna_other
== vers_data
)
13552 offset
+= ivn
.vn_next
;
13554 while (ivn
.vn_next
!= 0);
13556 if (ivna
.vna_other
== vers_data
)
13558 *sym_info
= symbol_undefined
;
13559 *vna_other
= ivna
.vna_other
;
13560 return (ivna
.vna_name
< strtab_size
13561 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13563 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13564 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13565 return _("<corrupt>");
13570 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13572 static unsigned int
13573 print_dynamic_symbol_size (uint64_t vma
, int base
)
13578 return print_vma (vma
, OCTAL_5
);
13581 return print_vma (vma
, UNSIGNED_5
);
13584 return print_vma (vma
, PREFIX_HEX_5
);
13588 return print_vma (vma
, DEC_5
);
13593 print_dynamic_symbol (Filedata
*filedata
, uint64_t si
,
13594 Elf_Internal_Sym
*symtab
,
13595 Elf_Internal_Shdr
*section
,
13596 char *strtab
, size_t strtab_size
)
13598 const char *version_string
;
13599 enum versioned_symbol_info sym_info
;
13600 unsigned short vna_other
;
13603 Elf_Internal_Sym
*psym
= symtab
+ si
;
13605 printf ("%6" PRId64
": ", si
);
13606 print_vma (psym
->st_value
, LONG_HEX
);
13608 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
13609 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13610 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13611 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13612 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13615 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13617 printf (" %-7s", get_symbol_visibility (vis
));
13618 /* Check to see if any other bits in the st_other field are set.
13619 Note - displaying this information disrupts the layout of the
13620 table being generated, but for the moment this case is very rare. */
13621 if (psym
->st_other
^ vis
)
13622 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13624 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
13626 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
13627 && psym
->st_shndx
< filedata
->file_header
.e_shnum
13628 && filedata
->section_headers
!= NULL
13629 && psym
->st_name
== 0)
13632 = section_name_valid (filedata
,
13633 filedata
->section_headers
+ psym
->st_shndx
);
13635 section_name_print (filedata
,
13636 filedata
->section_headers
+ psym
->st_shndx
)
13641 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
13642 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
13646 = get_symbol_version_string (filedata
,
13648 || section
->sh_type
== SHT_DYNSYM
),
13649 strtab
, strtab_size
, si
,
13650 psym
, &sym_info
, &vna_other
);
13652 int len_avail
= 21;
13653 if (! do_wide
&& version_string
!= NULL
)
13657 len_avail
-= 1 + strlen (version_string
);
13659 if (sym_info
== symbol_undefined
)
13660 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
13661 else if (sym_info
!= symbol_hidden
)
13665 print_symbol (len_avail
, sstr
);
13667 if (version_string
)
13669 if (sym_info
== symbol_undefined
)
13670 printf ("@%s (%d)", version_string
, vna_other
);
13672 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
13678 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
13680 && si
>= section
->sh_info
13681 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
13682 && filedata
->file_header
.e_machine
!= EM_MIPS
13683 /* Solaris binaries have been found to violate this requirement as
13684 well. Not sure if this is a bug or an ABI requirement. */
13685 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
13686 warn (_("local symbol %" PRIu64
" found at index >= %s's sh_info value of %u\n"),
13687 si
, printable_section_name (filedata
, section
), section
->sh_info
);
13690 static const char *
13691 get_lto_kind (unsigned int kind
)
13695 case 0: return "DEF";
13696 case 1: return "WEAKDEF";
13697 case 2: return "UNDEF";
13698 case 3: return "WEAKUNDEF";
13699 case 4: return "COMMON";
13704 static char buffer
[30];
13705 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
13706 sprintf (buffer
, "<unknown: %u>", kind
);
13710 static const char *
13711 get_lto_visibility (unsigned int visibility
)
13713 switch (visibility
)
13715 case 0: return "DEFAULT";
13716 case 1: return "PROTECTED";
13717 case 2: return "INTERNAL";
13718 case 3: return "HIDDEN";
13723 static char buffer
[30];
13724 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
13725 sprintf (buffer
, "<unknown: %u>", visibility
);
13729 static const char *
13730 get_lto_sym_type (unsigned int sym_type
)
13734 case 0: return "UNKNOWN";
13735 case 1: return "FUNCTION";
13736 case 2: return "VARIABLE";
13741 static char buffer
[30];
13742 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
13743 sprintf (buffer
, "<unknown: %u>", sym_type
);
13747 /* Display an LTO format symbol table.
13748 FIXME: The format of LTO symbol tables is not formalized.
13749 So this code could need changing in the future. */
13752 display_lto_symtab (Filedata
* filedata
,
13753 Elf_Internal_Shdr
* section
)
13755 if (section
->sh_size
== 0)
13757 if (filedata
->is_separate
)
13758 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
13759 printable_section_name (filedata
, section
),
13760 filedata
->file_name
);
13762 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13763 printable_section_name (filedata
, section
));
13768 if (section
->sh_size
> filedata
->file_size
)
13770 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
13771 printable_section_name (filedata
, section
),
13776 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13777 section
->sh_size
, 1, _("LTO symbols"));
13778 if (alloced_data
== NULL
)
13781 /* Look for extended data for the symbol table. */
13782 Elf_Internal_Shdr
* ext
;
13783 void * ext_data_orig
= NULL
;
13784 char * ext_data
= NULL
;
13785 char * ext_data_end
= NULL
;
13786 char * ext_name
= NULL
;
13788 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13789 (section_name (filedata
, section
)
13790 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13791 && ext_name
!= NULL
/* Paranoia. */
13792 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13794 if (ext
->sh_size
< 3)
13795 error (_("LTO Symbol extension table '%s' is empty!\n"),
13796 printable_section_name (filedata
, ext
));
13799 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13801 _("LTO ext symbol data"));
13802 if (ext_data
!= NULL
)
13804 ext_data_end
= ext_data
+ ext
->sh_size
;
13805 if (* ext_data
++ != 1)
13806 error (_("Unexpected version number in symbol extension table\n"));
13811 const unsigned char * data
= (const unsigned char *) alloced_data
;
13812 const unsigned char * end
= data
+ section
->sh_size
;
13814 if (filedata
->is_separate
)
13815 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13819 if (ext_data_orig
!= NULL
)
13822 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13823 printable_section_name (filedata
, section
),
13824 printable_section_name (filedata
, ext
));
13827 printf (_("LTO Symbol table '%s'\n"),
13828 printable_section_name (filedata
, section
));
13829 printf (_(" and extension table '%s' contain:\n"),
13830 printable_section_name (filedata
, ext
));
13834 printf (_("LTO Symbol table '%s' contains:\n"),
13835 printable_section_name (filedata
, section
));
13837 /* FIXME: Add a wide version. */
13838 if (ext_data_orig
!= NULL
)
13839 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13841 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13843 /* FIXME: We do not handle style prefixes. */
13847 const unsigned char * sym_name
= data
;
13848 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13852 const unsigned char * comdat_key
= data
;
13853 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13857 if (data
+ 2 + 8 + 4 > end
)
13860 unsigned int kind
= *data
++;
13861 unsigned int visibility
= *data
++;
13863 uint64_t size
= byte_get (data
, 8);
13866 uint64_t slot
= byte_get (data
, 4);
13869 if (ext_data
!= NULL
)
13871 if (ext_data
< (ext_data_end
- 1))
13873 unsigned int sym_type
= * ext_data
++;
13874 unsigned int sec_kind
= * ext_data
++;
13876 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
13877 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13878 get_lto_kind (kind
),
13879 get_lto_visibility (visibility
),
13882 get_lto_sym_type (sym_type
),
13884 print_symbol (6, (const char *) sym_name
);
13888 error (_("Ran out of LTO symbol extension data\n"));
13890 /* FIXME: return FAIL result ? */
13895 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
13896 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13897 get_lto_kind (kind
),
13898 get_lto_visibility (visibility
),
13901 print_symbol (21, (const char *) sym_name
);
13906 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
13908 error (_("Data remains in the LTO symbol extension table\n"));
13912 free (alloced_data
);
13913 free (ext_data_orig
);
13918 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
13919 free (alloced_data
);
13920 free (ext_data_orig
);
13925 /* Display LTO symbol tables. */
13928 process_lto_symbol_tables (Filedata
* filedata
)
13930 Elf_Internal_Shdr
* section
;
13937 if (filedata
->section_headers
== NULL
)
13940 for (i
= 0, section
= filedata
->section_headers
;
13941 i
< filedata
->file_header
.e_shnum
;
13943 if (section_name_valid (filedata
, section
)
13944 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
13945 res
&= display_lto_symtab (filedata
, section
);
13950 /* Dump the symbol table. */
13953 process_symbol_table (Filedata
* filedata
)
13955 Elf_Internal_Shdr
* section
;
13957 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
13960 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
13962 && do_using_dynamic
13963 && filedata
->dynamic_strings
!= NULL
13964 && filedata
->dynamic_symbols
!= NULL
)
13968 if (filedata
->is_separate
)
13970 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table"
13971 " contains %" PRIu64
" entry:\n",
13972 "\nIn linked file '%s' the dynamic symbol table"
13973 " contains %" PRIu64
" entries:\n",
13974 filedata
->num_dynamic_syms
),
13975 filedata
->file_name
,
13976 filedata
->num_dynamic_syms
);
13980 printf (ngettext ("\nSymbol table for image contains %" PRIu64
13982 "\nSymbol table for image contains %" PRIu64
13984 filedata
->num_dynamic_syms
),
13985 filedata
->num_dynamic_syms
);
13988 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13990 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13992 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
13993 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
13994 filedata
->dynamic_strings
,
13995 filedata
->dynamic_strings_length
);
13997 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
13998 && filedata
->section_headers
!= NULL
)
14002 for (i
= 0, section
= filedata
->section_headers
;
14003 i
< filedata
->file_header
.e_shnum
;
14006 char * strtab
= NULL
;
14007 uint64_t strtab_size
= 0;
14008 Elf_Internal_Sym
* symtab
;
14009 uint64_t si
, num_syms
;
14011 if ((section
->sh_type
!= SHT_SYMTAB
14012 && section
->sh_type
!= SHT_DYNSYM
)
14014 && section
->sh_type
== SHT_SYMTAB
))
14017 if (section
->sh_entsize
== 0)
14019 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
14020 printable_section_name (filedata
, section
));
14024 num_syms
= section
->sh_size
/ section
->sh_entsize
;
14026 if (filedata
->is_separate
)
14027 printf (ngettext ("\nIn linked file '%s' symbol section '%s'"
14028 " contains %" PRIu64
" entry:\n",
14029 "\nIn linked file '%s' symbol section '%s'"
14030 " contains %" PRIu64
" entries:\n",
14032 filedata
->file_name
,
14033 printable_section_name (filedata
, section
),
14036 printf (ngettext ("\nSymbol table '%s' contains %" PRIu64
14038 "\nSymbol table '%s' contains %" PRIu64
14041 printable_section_name (filedata
, section
),
14045 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14047 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14049 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
14050 if (symtab
== NULL
)
14053 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
14055 strtab
= filedata
->string_table
;
14056 strtab_size
= filedata
->string_table_length
;
14058 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
14060 Elf_Internal_Shdr
* string_sec
;
14062 string_sec
= filedata
->section_headers
+ section
->sh_link
;
14064 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
14065 1, string_sec
->sh_size
,
14066 _("string table"));
14067 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
14070 for (si
= 0; si
< num_syms
; si
++)
14071 print_dynamic_symbol (filedata
, si
, symtab
, section
,
14072 strtab
, strtab_size
);
14075 if (strtab
!= filedata
->string_table
)
14081 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
14083 if (do_histogram
&& filedata
->buckets
!= NULL
)
14089 uint64_t maxlength
= 0;
14090 uint64_t nzero_counts
= 0;
14091 uint64_t nsyms
= 0;
14094 printf (ngettext ("\nHistogram for bucket list length "
14095 "(total of %" PRIu64
" bucket):\n",
14096 "\nHistogram for bucket list length "
14097 "(total of %" PRIu64
" buckets):\n",
14098 filedata
->nbuckets
),
14099 filedata
->nbuckets
);
14101 lengths
= calloc (filedata
->nbuckets
, sizeof (*lengths
));
14102 if (lengths
== NULL
)
14104 error (_("Out of memory allocating space for histogram buckets\n"));
14107 visited
= xcmalloc (filedata
->nchains
, 1);
14108 memset (visited
, 0, filedata
->nchains
);
14110 printf (_(" Length Number %% of total Coverage\n"));
14111 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
14113 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
14116 if (maxlength
< ++lengths
[hn
])
14118 if (si
>= filedata
->nchains
|| visited
[si
])
14120 error (_("histogram chain is corrupt\n"));
14128 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
14129 if (counts
== NULL
)
14132 error (_("Out of memory allocating space for histogram counts\n"));
14136 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
14137 ++counts
[lengths
[hn
]];
14139 if (filedata
->nbuckets
> 0)
14142 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
14143 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
14144 for (i
= 1; i
<= maxlength
; ++i
)
14146 nzero_counts
+= counts
[i
] * i
;
14147 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
14148 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
14149 (nzero_counts
* 100.0) / nsyms
);
14157 free (filedata
->buckets
);
14158 filedata
->buckets
= NULL
;
14159 filedata
->nbuckets
= 0;
14160 free (filedata
->chains
);
14161 filedata
->chains
= NULL
;
14163 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
14168 uint64_t maxlength
= 0;
14169 uint64_t nzero_counts
= 0;
14170 uint64_t nsyms
= 0;
14172 printf (ngettext ("\nHistogram for `%s' bucket list length "
14173 "(total of %" PRIu64
" bucket):\n",
14174 "\nHistogram for `%s' bucket list length "
14175 "(total of %" PRIu64
" buckets):\n",
14176 filedata
->ngnubuckets
),
14177 GNU_HASH_SECTION_NAME (filedata
),
14178 filedata
->ngnubuckets
);
14180 lengths
= calloc (filedata
->ngnubuckets
, sizeof (*lengths
));
14181 if (lengths
== NULL
)
14183 error (_("Out of memory allocating space for gnu histogram buckets\n"));
14187 printf (_(" Length Number %% of total Coverage\n"));
14189 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
14190 if (filedata
->gnubuckets
[hn
] != 0)
14192 uint64_t off
, length
= 1;
14194 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
14195 /* PR 17531 file: 010-77222-0.004. */
14196 off
< filedata
->ngnuchains
14197 && (filedata
->gnuchains
[off
] & 1) == 0;
14200 lengths
[hn
] = length
;
14201 if (length
> maxlength
)
14202 maxlength
= length
;
14206 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
14207 if (counts
== NULL
)
14210 error (_("Out of memory allocating space for gnu histogram counts\n"));
14214 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
14215 ++counts
[lengths
[hn
]];
14217 if (filedata
->ngnubuckets
> 0)
14220 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
14221 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
14222 for (j
= 1; j
<= maxlength
; ++j
)
14224 nzero_counts
+= counts
[j
] * j
;
14225 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
14226 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
14227 (nzero_counts
* 100.0) / nsyms
);
14234 free (filedata
->gnubuckets
);
14235 filedata
->gnubuckets
= NULL
;
14236 filedata
->ngnubuckets
= 0;
14237 free (filedata
->gnuchains
);
14238 filedata
->gnuchains
= NULL
;
14239 filedata
->ngnuchains
= 0;
14240 free (filedata
->mipsxlat
);
14241 filedata
->mipsxlat
= NULL
;
14245 free (filedata
->gnubuckets
);
14246 filedata
->gnubuckets
= NULL
;
14247 filedata
->ngnubuckets
= 0;
14248 free (filedata
->gnuchains
);
14249 filedata
->gnuchains
= NULL
;
14250 filedata
->ngnuchains
= 0;
14251 free (filedata
->mipsxlat
);
14252 filedata
->mipsxlat
= NULL
;
14253 free (filedata
->buckets
);
14254 filedata
->buckets
= NULL
;
14255 filedata
->nbuckets
= 0;
14256 free (filedata
->chains
);
14257 filedata
->chains
= NULL
;
14262 process_syminfo (Filedata
* filedata
)
14266 if (filedata
->dynamic_syminfo
== NULL
14268 /* No syminfo, this is ok. */
14271 /* There better should be a dynamic symbol section. */
14272 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
14275 if (filedata
->is_separate
)
14276 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entry:\n",
14277 "\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entries:\n",
14278 filedata
->dynamic_syminfo_nent
),
14279 filedata
->file_name
,
14280 filedata
->dynamic_syminfo_offset
,
14281 filedata
->dynamic_syminfo_nent
);
14283 printf (ngettext ("\nDynamic info segment at offset %#" PRIx64
14284 " contains %d entry:\n",
14285 "\nDynamic info segment at offset %#" PRIx64
14286 " contains %d entries:\n",
14287 filedata
->dynamic_syminfo_nent
),
14288 filedata
->dynamic_syminfo_offset
,
14289 filedata
->dynamic_syminfo_nent
);
14291 printf (_(" Num: Name BoundTo Flags\n"));
14292 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
14294 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
14296 printf ("%4d: ", i
);
14297 if (i
>= filedata
->num_dynamic_syms
)
14298 printf (_("<corrupt index>"));
14299 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
14300 print_symbol (30, get_dynamic_name (filedata
,
14301 filedata
->dynamic_symbols
[i
].st_name
));
14303 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
14306 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
14308 case SYMINFO_BT_SELF
:
14309 fputs ("SELF ", stdout
);
14311 case SYMINFO_BT_PARENT
:
14312 fputs ("PARENT ", stdout
);
14315 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
14316 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
14317 && valid_dynamic_name (filedata
,
14318 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
14320 print_symbol (10, get_dynamic_name (filedata
,
14321 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
14325 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
14329 if (flags
& SYMINFO_FLG_DIRECT
)
14330 printf (" DIRECT");
14331 if (flags
& SYMINFO_FLG_PASSTHRU
)
14332 printf (" PASSTHRU");
14333 if (flags
& SYMINFO_FLG_COPY
)
14335 if (flags
& SYMINFO_FLG_LAZYLOAD
)
14336 printf (" LAZYLOAD");
14344 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
14345 is contained by the region START .. END. The types of ADDR, START
14346 and END should all be the same. Note both ADDR + NELEM and END
14347 point to just beyond the end of the regions that are being tested. */
14348 #define IN_RANGE(START,END,ADDR,NELEM) \
14349 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
14351 /* Check to see if the given reloc needs to be handled in a target specific
14352 manner. If so then process the reloc and return TRUE otherwise return
14355 If called with reloc == NULL, then this is a signal that reloc processing
14356 for the current section has finished, and any saved state should be
14360 target_specific_reloc_handling (Filedata
*filedata
,
14361 Elf_Internal_Rela
*reloc
,
14362 unsigned char *start
,
14363 unsigned char *end
,
14364 Elf_Internal_Sym
*symtab
,
14367 unsigned int reloc_type
= 0;
14368 uint64_t sym_index
= 0;
14372 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
14373 sym_index
= get_reloc_symindex (reloc
->r_info
);
14376 switch (filedata
->file_header
.e_machine
)
14380 switch (reloc_type
)
14382 /* For .uleb128 .LFE1-.LFB1, loongarch write 0 to object file
14383 at assembly time. */
14384 case 107: /* R_LARCH_ADD_ULEB128. */
14385 case 108: /* R_LARCH_SUB_ULEB128. */
14387 uint64_t value
= 0;
14388 unsigned int reloc_size
= 0;
14391 if (reloc
->r_offset
< (size_t) (end
- start
))
14392 value
= read_leb128 (start
+ reloc
->r_offset
, end
, false,
14393 &reloc_size
, &leb_ret
);
14394 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14395 error (_("LoongArch ULEB128 field at 0x%lx contains invalid "
14396 "ULEB128 value\n"),
14397 (long) reloc
->r_offset
);
14399 else if (sym_index
>= num_syms
)
14400 error (_("%s reloc contains invalid symbol index "
14403 ? "R_LARCH_ADD_ULEB128"
14404 : "R_LARCH_SUB_ULEB128"),
14408 if (reloc_type
== 107)
14409 value
+= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14411 value
-= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14413 /* Write uleb128 value to p. */
14414 bfd_byte
*p
= start
+ reloc
->r_offset
;
14417 bfd_byte c
= value
& 0x7f;
14419 if (--reloc_size
!= 0)
14423 while (reloc_size
);
14433 case EM_MSP430_OLD
:
14435 static Elf_Internal_Sym
* saved_sym
= NULL
;
14443 switch (reloc_type
)
14445 case 10: /* R_MSP430_SYM_DIFF */
14446 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
14447 if (uses_msp430x_relocs (filedata
))
14449 /* Fall through. */
14450 case 21: /* R_MSP430X_SYM_DIFF */
14451 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
14453 if (sym_index
>= num_syms
)
14454 error (_("%s reloc contains invalid symbol index "
14455 "%" PRIu64
"\n"), "MSP430 SYM_DIFF", sym_index
);
14457 saved_sym
= symtab
+ sym_index
;
14460 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14461 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
14462 goto handle_sym_diff
;
14464 case 5: /* R_MSP430_16_BYTE */
14465 case 9: /* R_MSP430_8 */
14466 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14467 if (uses_msp430x_relocs (filedata
))
14469 goto handle_sym_diff
;
14471 case 2: /* R_MSP430_ABS16 */
14472 case 15: /* R_MSP430X_ABS16 */
14473 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14474 if (! uses_msp430x_relocs (filedata
))
14476 goto handle_sym_diff
;
14479 if (saved_sym
!= NULL
)
14482 unsigned int reloc_size
= 0;
14484 switch (reloc_type
)
14486 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14489 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14490 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14491 if (reloc
->r_offset
< (size_t) (end
- start
))
14492 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14493 &reloc_size
, &leb_ret
);
14500 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14501 error (_("MSP430 ULEB128 field at %#" PRIx64
14502 " contains invalid ULEB128 value\n"),
14504 else if (sym_index
>= num_syms
)
14505 error (_("%s reloc contains invalid symbol index "
14506 "%" PRIu64
"\n"), "MSP430", sym_index
);
14509 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14510 - saved_sym
->st_value
);
14512 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14513 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14516 error (_("MSP430 sym diff reloc contains invalid offset: "
14527 if (saved_sym
!= NULL
)
14528 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14535 case EM_CYGNUS_MN10300
:
14537 static Elf_Internal_Sym
* saved_sym
= NULL
;
14545 switch (reloc_type
)
14547 case 34: /* R_MN10300_ALIGN */
14549 case 33: /* R_MN10300_SYM_DIFF */
14550 if (sym_index
>= num_syms
)
14551 error (_("%s reloc contains invalid symbol index "
14552 "%" PRIu64
"\n"), "MN10300_SYM_DIFF", sym_index
);
14554 saved_sym
= symtab
+ sym_index
;
14557 case 1: /* R_MN10300_32 */
14558 case 2: /* R_MN10300_16 */
14559 if (saved_sym
!= NULL
)
14561 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14564 if (sym_index
>= num_syms
)
14565 error (_("%s reloc contains invalid symbol index "
14566 "%" PRIu64
"\n"), "MN10300", sym_index
);
14569 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14570 - saved_sym
->st_value
);
14572 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14573 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14575 error (_("MN10300 sym diff reloc contains invalid offset:"
14576 " %#" PRIx64
"\n"),
14585 if (saved_sym
!= NULL
)
14586 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
14594 static uint64_t saved_sym1
= 0;
14595 static uint64_t saved_sym2
= 0;
14596 static uint64_t value
;
14600 saved_sym1
= saved_sym2
= 0;
14604 switch (reloc_type
)
14606 case 0x80: /* R_RL78_SYM. */
14607 saved_sym1
= saved_sym2
;
14608 if (sym_index
>= num_syms
)
14609 error (_("%s reloc contains invalid symbol index "
14610 "%" PRIu64
"\n"), "RL78_SYM", sym_index
);
14613 saved_sym2
= symtab
[sym_index
].st_value
;
14614 saved_sym2
+= reloc
->r_addend
;
14618 case 0x83: /* R_RL78_OPsub. */
14619 value
= saved_sym1
- saved_sym2
;
14620 saved_sym2
= saved_sym1
= 0;
14624 case 0x41: /* R_RL78_ABS32. */
14625 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
14626 byte_put (start
+ reloc
->r_offset
, value
, 4);
14628 error (_("RL78 sym diff reloc contains invalid offset: "
14634 case 0x43: /* R_RL78_ABS16. */
14635 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
14636 byte_put (start
+ reloc
->r_offset
, value
, 2);
14638 error (_("RL78 sym diff reloc contains invalid offset: "
14654 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
14655 DWARF debug sections. This is a target specific test. Note - we do not
14656 go through the whole including-target-headers-multiple-times route, (as
14657 we have already done with <elf/h8.h>) because this would become very
14658 messy and even then this function would have to contain target specific
14659 information (the names of the relocs instead of their numeric values).
14660 FIXME: This is not the correct way to solve this problem. The proper way
14661 is to have target specific reloc sizing and typing functions created by
14662 the reloc-macros.h header, in the same way that it already creates the
14663 reloc naming functions. */
14666 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14668 /* Please keep this table alpha-sorted for ease of visual lookup. */
14669 switch (filedata
->file_header
.e_machine
)
14673 return reloc_type
== 1; /* R_386_32. */
14675 return reloc_type
== 1; /* R_68K_32. */
14677 return reloc_type
== 1; /* R_860_32. */
14679 return reloc_type
== 2; /* R_960_32. */
14681 return (reloc_type
== 258
14682 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
14684 return reloc_type
== 11; /* R_BPF_DATA_32 */
14685 case EM_ADAPTEVA_EPIPHANY
:
14686 return reloc_type
== 3;
14688 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
14690 return reloc_type
== 1; /* R_ARC_32. */
14691 case EM_ARC_COMPACT
:
14692 case EM_ARC_COMPACT2
:
14693 case EM_ARC_COMPACT3
:
14694 case EM_ARC_COMPACT3_64
:
14695 return reloc_type
== 4; /* R_ARC_32. */
14697 return reloc_type
== 2; /* R_ARM_ABS32 */
14700 return reloc_type
== 1;
14702 return reloc_type
== 0x12; /* R_byte4_data. */
14704 return reloc_type
== 3; /* R_CRIS_32. */
14706 return reloc_type
== 3; /* R_CR16_NUM32. */
14708 return reloc_type
== 15; /* R_CRX_NUM32. */
14710 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
14711 case EM_CYGNUS_FRV
:
14712 return reloc_type
== 1;
14713 case EM_CYGNUS_D10V
:
14715 return reloc_type
== 6; /* R_D10V_32. */
14716 case EM_CYGNUS_D30V
:
14718 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
14720 return reloc_type
== 3; /* R_DLX_RELOC_32. */
14721 case EM_CYGNUS_FR30
:
14723 return reloc_type
== 3; /* R_FR30_32. */
14725 return reloc_type
== 1; /* R_FT32_32. */
14729 return reloc_type
== 1; /* R_H8_DIR32. */
14731 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
14732 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
14733 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
14734 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
14737 return reloc_type
== 2; /* R_IP2K_32. */
14739 return reloc_type
== 2; /* R_IQ2000_32. */
14741 return reloc_type
== 2; /* R_KVX_32. */
14742 case EM_LATTICEMICO32
:
14743 return reloc_type
== 3; /* R_LM32_32. */
14745 return reloc_type
== 1; /* R_LARCH_32. */
14748 return reloc_type
== 3; /* R_M32C_32. */
14750 return reloc_type
== 34; /* R_M32R_32_RELA. */
14753 return reloc_type
== 6; /* R_M68HC11_32. */
14755 return reloc_type
== 7 || /* R_S12Z_EXT32 */
14756 reloc_type
== 6; /* R_S12Z_CW32. */
14758 return reloc_type
== 1; /* R_MCORE_ADDR32. */
14759 case EM_CYGNUS_MEP
:
14760 return reloc_type
== 4; /* R_MEP_32. */
14762 return reloc_type
== 2; /* R_METAG_ADDR32. */
14763 case EM_MICROBLAZE
:
14764 return reloc_type
== 1; /* R_MICROBLAZE_32. */
14766 return reloc_type
== 2; /* R_MIPS_32. */
14768 return reloc_type
== 4; /* R_MMIX_32. */
14769 case EM_CYGNUS_MN10200
:
14771 return reloc_type
== 1; /* R_MN10200_32. */
14772 case EM_CYGNUS_MN10300
:
14774 return reloc_type
== 1; /* R_MN10300_32. */
14776 return reloc_type
== 1; /* R_MOXIE_32. */
14777 case EM_MSP430_OLD
:
14779 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
14781 return reloc_type
== 2; /* R_MT_32. */
14783 return reloc_type
== 20; /* R_NDS32_32_RELA. */
14784 case EM_ALTERA_NIOS2
:
14785 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
14787 return reloc_type
== 1; /* R_NIOS_32. */
14789 return reloc_type
== 1; /* R_OR1K_32. */
14791 return (reloc_type
== 1 /* R_PARISC_DIR32. */
14792 || reloc_type
== 2 /* R_PARISC_DIR21L. */
14793 || reloc_type
== 41); /* R_PARISC_SECREL32. */
14796 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
14798 return reloc_type
== 1; /* R_PPC64_ADDR32. */
14800 return reloc_type
== 1; /* R_PPC_ADDR32. */
14802 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
14804 return reloc_type
== 1; /* R_RISCV_32. */
14806 return reloc_type
== 1; /* R_RL78_DIR32. */
14808 return reloc_type
== 1; /* R_RX_DIR32. */
14810 return reloc_type
== 1; /* R_I370_ADDR31. */
14813 return reloc_type
== 4; /* R_S390_32. */
14815 return reloc_type
== 8; /* R_SCORE_ABS32. */
14817 return reloc_type
== 1; /* R_SH_DIR32. */
14818 case EM_SPARC32PLUS
:
14821 return reloc_type
== 3 /* R_SPARC_32. */
14822 || reloc_type
== 23; /* R_SPARC_UA32. */
14824 return reloc_type
== 6; /* R_SPU_ADDR32 */
14826 return reloc_type
== 1; /* R_C6000_ABS32. */
14828 return reloc_type
== 2; /* R_TILEGX_32. */
14830 return reloc_type
== 1; /* R_TILEPRO_32. */
14831 case EM_CYGNUS_V850
:
14833 return reloc_type
== 6; /* R_V850_ABS32. */
14835 return reloc_type
== 0x33; /* R_V810_WORD. */
14837 return reloc_type
== 1; /* R_VAX_32. */
14839 return reloc_type
== 3; /* R_VISIUM_32. */
14840 case EM_WEBASSEMBLY
:
14841 return reloc_type
== 1; /* R_WASM32_32. */
14845 return reloc_type
== 10; /* R_X86_64_32. */
14847 return reloc_type
== 4; /* R_XGATE_32. */
14849 return reloc_type
== 1; /* R_XSTROMY16_32. */
14850 case EM_XTENSA_OLD
:
14852 return reloc_type
== 1; /* R_XTENSA_32. */
14854 return reloc_type
== 6; /* R_Z80_32. */
14857 static unsigned int prev_warn
= 0;
14859 /* Avoid repeating the same warning multiple times. */
14860 if (prev_warn
!= filedata
->file_header
.e_machine
)
14861 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
14862 filedata
->file_header
.e_machine
);
14863 prev_warn
= filedata
->file_header
.e_machine
;
14869 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14870 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
14873 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14875 switch (filedata
->file_header
.e_machine
)
14876 /* Please keep this table alpha-sorted for ease of visual lookup. */
14880 return reloc_type
== 2; /* R_386_PC32. */
14882 return reloc_type
== 4; /* R_68K_PC32. */
14884 return reloc_type
== 261; /* R_AARCH64_PREL32 */
14885 case EM_ADAPTEVA_EPIPHANY
:
14886 return reloc_type
== 6;
14888 return reloc_type
== 10; /* R_ALPHA_SREL32. */
14889 case EM_ARC_COMPACT
:
14890 case EM_ARC_COMPACT2
:
14891 case EM_ARC_COMPACT3
:
14892 case EM_ARC_COMPACT3_64
:
14893 return reloc_type
== 49; /* R_ARC_32_PCREL. */
14895 return reloc_type
== 3; /* R_ARM_REL32 */
14898 return reloc_type
== 36; /* R_AVR_32_PCREL. */
14900 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
14901 case EM_MICROBLAZE
:
14902 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
14904 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
14906 return reloc_type
== 9; /* R_PARISC_PCREL32. */
14908 return reloc_type
== 26; /* R_PPC_REL32. */
14910 return reloc_type
== 26; /* R_PPC64_REL32. */
14912 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
14915 return reloc_type
== 5; /* R_390_PC32. */
14917 return reloc_type
== 2; /* R_SH_REL32. */
14918 case EM_SPARC32PLUS
:
14921 return reloc_type
== 6; /* R_SPARC_DISP32. */
14923 return reloc_type
== 13; /* R_SPU_REL32. */
14925 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
14927 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
14929 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
14933 return reloc_type
== 2; /* R_X86_64_PC32. */
14935 return reloc_type
== 4; /* R_VAX_PCREL32. */
14936 case EM_XTENSA_OLD
:
14938 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
14940 return reloc_type
== 7; /* R_KVX_32_PCREL */
14942 /* Do not abort or issue an error message here. Not all targets use
14943 pc-relative 32-bit relocs in their DWARF debug information and we
14944 have already tested for target coverage in is_32bit_abs_reloc. A
14945 more helpful warning message will be generated by apply_relocations
14946 anyway, so just return. */
14951 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14952 a 64-bit absolute RELA relocation used in DWARF debug sections. */
14955 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14957 switch (filedata
->file_header
.e_machine
)
14960 return reloc_type
== 257; /* R_AARCH64_ABS64. */
14961 case EM_ARC_COMPACT3_64
:
14962 return reloc_type
== 5; /* R_ARC_64. */
14964 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
14966 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
14967 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
14969 return reloc_type
== 2; /* R_LARCH_64 */
14971 return reloc_type
== 80; /* R_PARISC_DIR64. */
14973 return reloc_type
== 38; /* R_PPC64_ADDR64. */
14975 return reloc_type
== 2; /* R_RISCV_64. */
14976 case EM_SPARC32PLUS
:
14979 return reloc_type
== 32 /* R_SPARC_64. */
14980 || reloc_type
== 54; /* R_SPARC_UA64. */
14984 return reloc_type
== 1; /* R_X86_64_64. */
14987 return reloc_type
== 22; /* R_S390_64. */
14989 return reloc_type
== 1; /* R_TILEGX_64. */
14991 return reloc_type
== 18; /* R_MIPS_64. */
14993 return reloc_type
== 3; /* R_KVX_64 */
14999 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
15000 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
15003 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15005 switch (filedata
->file_header
.e_machine
)
15008 return reloc_type
== 260; /* R_AARCH64_PREL64. */
15010 return reloc_type
== 11; /* R_ALPHA_SREL64. */
15012 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
15013 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
15015 return reloc_type
== 72; /* R_PARISC_PCREL64. */
15017 return reloc_type
== 44; /* R_PPC64_REL64. */
15018 case EM_SPARC32PLUS
:
15021 return reloc_type
== 46; /* R_SPARC_DISP64. */
15025 return reloc_type
== 24; /* R_X86_64_PC64. */
15028 return reloc_type
== 23; /* R_S390_PC64. */
15030 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
15036 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15037 a 24-bit absolute RELA relocation used in DWARF debug sections. */
15040 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15042 switch (filedata
->file_header
.e_machine
)
15044 case EM_CYGNUS_MN10200
:
15046 return reloc_type
== 4; /* R_MN10200_24. */
15048 return reloc_type
== 5; /* R_FT32_20. */
15050 return reloc_type
== 5; /* R_Z80_24. */
15056 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15057 a 16-bit absolute RELA relocation used in DWARF debug sections. */
15060 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15062 /* Please keep this table alpha-sorted for ease of visual lookup. */
15063 switch (filedata
->file_header
.e_machine
)
15066 case EM_ARC_COMPACT
:
15067 case EM_ARC_COMPACT2
:
15068 case EM_ARC_COMPACT3
:
15069 case EM_ARC_COMPACT3_64
:
15070 return reloc_type
== 2; /* R_ARC_16. */
15071 case EM_ADAPTEVA_EPIPHANY
:
15072 return reloc_type
== 5;
15075 return reloc_type
== 4; /* R_AVR_16. */
15076 case EM_CYGNUS_D10V
:
15078 return reloc_type
== 3; /* R_D10V_16. */
15080 return reloc_type
== 2; /* R_FT32_16. */
15084 return reloc_type
== R_H8_DIR16
;
15087 return reloc_type
== 1; /* R_IP2K_16. */
15090 return reloc_type
== 1; /* R_M32C_16 */
15091 case EM_CYGNUS_MN10200
:
15093 return reloc_type
== 2; /* R_MN10200_16. */
15094 case EM_CYGNUS_MN10300
:
15096 return reloc_type
== 2; /* R_MN10300_16. */
15098 return reloc_type
== 1; /* R_KVX_16 */
15100 if (uses_msp430x_relocs (filedata
))
15101 return reloc_type
== 2; /* R_MSP430_ABS16. */
15102 /* Fall through. */
15103 case EM_MSP430_OLD
:
15104 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
15106 return reloc_type
== 19; /* R_NDS32_16_RELA. */
15107 case EM_ALTERA_NIOS2
:
15108 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
15110 return reloc_type
== 9; /* R_NIOS_16. */
15112 return reloc_type
== 2; /* R_OR1K_16. */
15114 return reloc_type
== 55; /* R_RISCV_SET16. */
15116 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
15118 return reloc_type
== 2; /* R_C6000_ABS16. */
15120 return reloc_type
== 2; /* R_VISIUM_16. */
15122 return reloc_type
== 3; /* R_XGATE_16. */
15124 return reloc_type
== 4; /* R_Z80_16. */
15130 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15131 a 8-bit absolute RELA relocation used in DWARF debug sections. */
15134 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15136 switch (filedata
->file_header
.e_machine
)
15139 return reloc_type
== 54; /* R_RISCV_SET8. */
15141 return reloc_type
== 1; /* R_Z80_8. */
15147 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15148 a 6-bit absolute RELA relocation used in DWARF debug sections. */
15151 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15153 switch (filedata
->file_header
.e_machine
)
15156 return reloc_type
== 53; /* R_RISCV_SET6. */
15162 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15163 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
15166 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15168 /* Please keep this table alpha-sorted for ease of visual lookup. */
15169 switch (filedata
->file_header
.e_machine
)
15172 return reloc_type
== 50; /* R_LARCH_ADD32. */
15174 return reloc_type
== 35; /* R_RISCV_ADD32. */
15180 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15181 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
15184 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15186 /* Please keep this table alpha-sorted for ease of visual lookup. */
15187 switch (filedata
->file_header
.e_machine
)
15190 return reloc_type
== 55; /* R_LARCH_SUB32. */
15192 return reloc_type
== 39; /* R_RISCV_SUB32. */
15198 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15199 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
15202 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15204 /* Please keep this table alpha-sorted for ease of visual lookup. */
15205 switch (filedata
->file_header
.e_machine
)
15208 return reloc_type
== 51; /* R_LARCH_ADD64. */
15210 return reloc_type
== 36; /* R_RISCV_ADD64. */
15216 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15217 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
15220 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15222 /* Please keep this table alpha-sorted for ease of visual lookup. */
15223 switch (filedata
->file_header
.e_machine
)
15226 return reloc_type
== 56; /* R_LARCH_SUB64. */
15228 return reloc_type
== 40; /* R_RISCV_SUB64. */
15234 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15235 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
15238 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15240 /* Please keep this table alpha-sorted for ease of visual lookup. */
15241 switch (filedata
->file_header
.e_machine
)
15244 return reloc_type
== 48; /* R_LARCH_ADD16. */
15246 return reloc_type
== 34; /* R_RISCV_ADD16. */
15252 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15253 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
15256 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15258 /* Please keep this table alpha-sorted for ease of visual lookup. */
15259 switch (filedata
->file_header
.e_machine
)
15262 return reloc_type
== 53; /* R_LARCH_SUB16. */
15264 return reloc_type
== 38; /* R_RISCV_SUB16. */
15270 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15271 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
15274 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15276 /* Please keep this table alpha-sorted for ease of visual lookup. */
15277 switch (filedata
->file_header
.e_machine
)
15280 return reloc_type
== 47; /* R_LARCH_ADD8. */
15282 return reloc_type
== 33; /* R_RISCV_ADD8. */
15288 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15289 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
15292 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15294 /* Please keep this table alpha-sorted for ease of visual lookup. */
15295 switch (filedata
->file_header
.e_machine
)
15298 return reloc_type
== 52; /* R_LARCH_SUB8. */
15300 return reloc_type
== 37; /* R_RISCV_SUB8. */
15306 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15307 a 6-bit inplace add RELA relocation used in DWARF debug sections. */
15310 is_6bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15312 switch (filedata
->file_header
.e_machine
)
15315 return reloc_type
== 105; /* R_LARCH_ADD6. */
15321 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15322 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
15325 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15327 switch (filedata
->file_header
.e_machine
)
15330 return reloc_type
== 106; /* R_LARCH_SUB6. */
15332 return reloc_type
== 52; /* R_RISCV_SUB6. */
15338 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
15339 relocation entries (possibly formerly used for SHT_GROUP sections). */
15342 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15344 switch (filedata
->file_header
.e_machine
)
15346 case EM_386
: /* R_386_NONE. */
15347 case EM_68K
: /* R_68K_NONE. */
15348 case EM_ADAPTEVA_EPIPHANY
:
15349 case EM_ALPHA
: /* R_ALPHA_NONE. */
15350 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
15351 case EM_ARC
: /* R_ARC_NONE. */
15352 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
15353 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
15354 case EM_ARC_COMPACT3
: /* R_ARC_NONE. */
15355 case EM_ARC_COMPACT3_64
: /* R_ARC_NONE. */
15356 case EM_ARM
: /* R_ARM_NONE. */
15357 case EM_CRIS
: /* R_CRIS_NONE. */
15358 case EM_FT32
: /* R_FT32_NONE. */
15359 case EM_IA_64
: /* R_IA64_NONE. */
15360 case EM_K1OM
: /* R_X86_64_NONE. */
15361 case EM_KVX
: /* R_KVX_NONE. */
15362 case EM_L1OM
: /* R_X86_64_NONE. */
15363 case EM_M32R
: /* R_M32R_NONE. */
15364 case EM_MIPS
: /* R_MIPS_NONE. */
15365 case EM_MN10300
: /* R_MN10300_NONE. */
15366 case EM_MOXIE
: /* R_MOXIE_NONE. */
15367 case EM_NIOS32
: /* R_NIOS_NONE. */
15368 case EM_OR1K
: /* R_OR1K_NONE. */
15369 case EM_PARISC
: /* R_PARISC_NONE. */
15370 case EM_PPC64
: /* R_PPC64_NONE. */
15371 case EM_PPC
: /* R_PPC_NONE. */
15372 case EM_RISCV
: /* R_RISCV_NONE. */
15373 case EM_S390
: /* R_390_NONE. */
15375 case EM_SH
: /* R_SH_NONE. */
15376 case EM_SPARC32PLUS
:
15377 case EM_SPARC
: /* R_SPARC_NONE. */
15379 case EM_TILEGX
: /* R_TILEGX_NONE. */
15380 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
15381 case EM_TI_C6000
:/* R_C6000_NONE. */
15382 case EM_X86_64
: /* R_X86_64_NONE. */
15383 case EM_Z80
: /* R_Z80_NONE. */
15384 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
15385 return reloc_type
== 0;
15388 return reloc_type
== 0 || reloc_type
== 256;
15391 return (reloc_type
== 0 /* R_AVR_NONE. */
15392 || reloc_type
== 30 /* R_AVR_DIFF8. */
15393 || reloc_type
== 31 /* R_AVR_DIFF16. */
15394 || reloc_type
== 32 /* R_AVR_DIFF32. */);
15396 return reloc_type
== 3; /* R_METAG_NONE. */
15398 return (reloc_type
== 0 /* R_NDS32_NONE. */
15399 || reloc_type
== 205 /* R_NDS32_DIFF8. */
15400 || reloc_type
== 206 /* R_NDS32_DIFF16. */
15401 || reloc_type
== 207 /* R_NDS32_DIFF32. */
15402 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
15404 return (reloc_type
== 0 /* R_PRU_NONE. */
15405 || reloc_type
== 65 /* R_PRU_DIFF8. */
15406 || reloc_type
== 66 /* R_PRU_DIFF16. */
15407 || reloc_type
== 67 /* R_PRU_DIFF32. */);
15408 case EM_XTENSA_OLD
:
15410 return (reloc_type
== 0 /* R_XTENSA_NONE. */
15411 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
15412 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
15413 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
15414 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
15415 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
15416 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
15417 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
15418 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
15419 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
15424 /* Returns TRUE if there is a relocation against
15425 section NAME at OFFSET bytes. */
15428 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
15430 Elf_Internal_Rela
* relocs
;
15431 Elf_Internal_Rela
* rp
;
15433 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
15436 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
15438 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
15439 if (rp
->r_offset
== offset
)
15445 /* Apply relocations to a section.
15446 Returns TRUE upon success, FALSE otherwise.
15447 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
15448 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
15449 will be set to the number of relocs loaded.
15451 Note: So far support has been added only for those relocations
15452 which can be found in debug sections. FIXME: Add support for
15453 more relocations ? */
15456 apply_relocations (Filedata
*filedata
,
15457 const Elf_Internal_Shdr
*section
,
15458 unsigned char *start
,
15460 void **relocs_return
,
15461 uint64_t *num_relocs_return
)
15463 Elf_Internal_Shdr
* relsec
;
15464 unsigned char * end
= start
+ size
;
15466 if (relocs_return
!= NULL
)
15468 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
15469 * num_relocs_return
= 0;
15472 if (filedata
->file_header
.e_type
!= ET_REL
)
15473 /* No relocs to apply. */
15476 /* Find the reloc section associated with the section. */
15477 for (relsec
= filedata
->section_headers
;
15478 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15482 uint64_t num_relocs
;
15483 Elf_Internal_Rela
* relocs
;
15484 Elf_Internal_Rela
* rp
;
15485 Elf_Internal_Shdr
* symsec
;
15486 Elf_Internal_Sym
* symtab
;
15488 Elf_Internal_Sym
* sym
;
15490 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15491 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15492 || filedata
->section_headers
+ relsec
->sh_info
!= section
15493 || relsec
->sh_size
== 0
15494 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15497 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
15498 if (symsec
->sh_type
!= SHT_SYMTAB
15499 && symsec
->sh_type
!= SHT_DYNSYM
)
15502 is_rela
= relsec
->sh_type
== SHT_RELA
;
15506 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
15507 relsec
->sh_size
, & relocs
, & num_relocs
))
15512 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
15513 relsec
->sh_size
, & relocs
, & num_relocs
))
15517 /* SH uses RELA but uses in place value instead of the addend field. */
15518 if (filedata
->file_header
.e_machine
== EM_SH
)
15521 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
15523 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
15526 unsigned int reloc_type
;
15527 unsigned int reloc_size
;
15528 bool reloc_inplace
= false;
15529 bool reloc_subtract
= false;
15530 unsigned char *rloc
;
15531 uint64_t sym_index
;
15533 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
15535 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
15537 else if (is_none_reloc (filedata
, reloc_type
))
15539 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
15540 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
15542 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
15543 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15545 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15547 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15549 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15550 || is_6bit_abs_reloc (filedata
, reloc_type
))
15552 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15554 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15557 reloc_inplace
= true;
15559 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15561 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15564 reloc_inplace
= true;
15566 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
15568 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
15571 reloc_inplace
= true;
15573 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
15575 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
15578 reloc_inplace
= true;
15580 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
15582 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15585 reloc_inplace
= true;
15589 static unsigned int prev_reloc
= 0;
15591 if (reloc_type
!= prev_reloc
)
15592 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
15593 reloc_type
, printable_section_name (filedata
, section
));
15594 prev_reloc
= reloc_type
;
15598 rloc
= start
+ rp
->r_offset
;
15599 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
15601 warn (_("skipping invalid relocation offset %#" PRIx64
15602 " in section %s\n"),
15604 printable_section_name (filedata
, section
));
15608 sym_index
= get_reloc_symindex (rp
->r_info
);
15609 if (sym_index
>= num_syms
)
15611 warn (_("skipping invalid relocation symbol index %#" PRIx64
15612 " in section %s\n"),
15613 sym_index
, printable_section_name (filedata
, section
));
15616 sym
= symtab
+ sym_index
;
15618 /* If the reloc has a symbol associated with it,
15619 make sure that it is of an appropriate type.
15621 Relocations against symbols without type can happen.
15622 Gcc -feliminate-dwarf2-dups may generate symbols
15623 without type for debug info.
15625 Icc generates relocations against function symbols
15626 instead of local labels.
15628 Relocations against object symbols can happen, eg when
15629 referencing a global array. For an example of this see
15630 the _clz.o binary in libgcc.a. */
15632 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
15633 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
15635 warn (_("skipping unexpected symbol type %s in section %s relocation %tu\n"),
15636 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
15637 printable_section_name (filedata
, relsec
),
15644 addend
+= rp
->r_addend
;
15645 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
15646 partial_inplace. */
15648 || (filedata
->file_header
.e_machine
== EM_XTENSA
15649 && reloc_type
== 1)
15650 || ((filedata
->file_header
.e_machine
== EM_PJ
15651 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
15652 && reloc_type
== 1)
15653 || ((filedata
->file_header
.e_machine
== EM_D30V
15654 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
15655 && reloc_type
== 12)
15658 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15659 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
15661 addend
+= byte_get (rloc
, reloc_size
);
15664 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
15665 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15667 /* On HPPA, all pc-relative relocations are biased by 8. */
15668 if (filedata
->file_header
.e_machine
== EM_PARISC
)
15670 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
15673 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
15674 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
)
15675 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15677 if (reloc_subtract
)
15678 addend
-= sym
->st_value
;
15680 addend
+= sym
->st_value
;
15681 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
15682 byte_put (rloc
, addend
, reloc_size
);
15684 else if (reloc_subtract
)
15685 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
15687 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
15691 /* Let the target specific reloc processing code know that
15692 we have finished with these relocs. */
15693 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
15697 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
15698 * num_relocs_return
= num_relocs
;
15709 #ifdef SUPPORT_DISASSEMBLY
15711 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15713 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
15715 /* FIXME: XXX -- to be done --- XXX */
15721 /* Reads in the contents of SECTION from FILE, returning a pointer
15722 to a malloc'ed buffer or NULL if something went wrong. */
15725 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15727 uint64_t num_bytes
= section
->sh_size
;
15729 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
15731 printf (_("Section '%s' has no data to dump.\n"),
15732 printable_section_name (filedata
, section
));
15736 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
15737 _("section contents"));
15740 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
15743 uncompress_section_contents (bool is_zstd
,
15744 unsigned char ** buffer
,
15745 uint64_t uncompressed_size
,
15747 uint64_t file_size
)
15749 uint64_t compressed_size
= *size
;
15750 unsigned char *compressed_buffer
= *buffer
;
15751 unsigned char *uncompressed_buffer
= NULL
;
15755 /* Similar to _bfd_section_size_insane() in the BFD library we expect an
15756 upper limit of ~10x compression. Any compression larger than that is
15757 thought to be due to fuzzing of the compression header. */
15758 if (uncompressed_size
> file_size
* 10)
15760 error (_("Uncompressed section size is suspiciously large: 0x%" PRIu64
"\n"),
15761 uncompressed_size
);
15765 uncompressed_buffer
= xmalloc (uncompressed_size
);
15770 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
15771 compressed_buffer
, compressed_size
);
15772 if (ZSTD_isError (ret
))
15778 /* It is possible the section consists of several compressed
15779 buffers concatenated together, so we uncompress in a loop. */
15780 /* PR 18313: The state field in the z_stream structure is supposed
15781 to be invisible to the user (ie us), but some compilers will
15782 still complain about it being used without initialisation. So
15783 we first zero the entire z_stream structure and then set the fields
15785 memset (&strm
, 0, sizeof strm
);
15786 strm
.avail_in
= compressed_size
;
15787 strm
.next_in
= (Bytef
*)compressed_buffer
;
15788 strm
.avail_out
= uncompressed_size
;
15790 rc
= inflateInit (&strm
);
15791 while (strm
.avail_in
> 0)
15795 strm
.next_out
= ((Bytef
*)uncompressed_buffer
15796 + (uncompressed_size
- strm
.avail_out
));
15797 rc
= inflate (&strm
, Z_FINISH
);
15798 if (rc
!= Z_STREAM_END
)
15800 rc
= inflateReset (&strm
);
15802 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
15806 *buffer
= uncompressed_buffer
;
15807 *size
= uncompressed_size
;
15811 free (uncompressed_buffer
);
15812 /* Indicate decompression failure. */
15818 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15820 Elf_Internal_Shdr
*relsec
;
15821 uint64_t num_bytes
;
15822 unsigned char *data
;
15823 unsigned char *end
;
15824 unsigned char *real_start
;
15825 unsigned char *start
;
15826 bool some_strings_shown
;
15828 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15830 /* PR 21820: Do not fail if the section was empty. */
15831 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15833 num_bytes
= section
->sh_size
;
15835 if (filedata
->is_separate
)
15836 printf (_("\nString dump of section '%s' in linked file %s:\n"),
15837 printable_section_name (filedata
, section
),
15838 filedata
->file_name
);
15840 printf (_("\nString dump of section '%s':\n"),
15841 printable_section_name (filedata
, section
));
15843 if (decompress_dumps
)
15845 uint64_t new_size
= num_bytes
;
15846 uint64_t uncompressed_size
= 0;
15847 bool is_zstd
= false;
15849 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15851 Elf_Internal_Chdr chdr
;
15852 unsigned int compression_header_size
15853 = get_compression_header (& chdr
, (unsigned char *) start
,
15855 if (compression_header_size
== 0)
15856 /* An error message will have already been generated
15857 by get_compression_header. */
15860 if (chdr
.ch_type
== ch_compress_zlib
)
15863 else if (chdr
.ch_type
== ch_compress_zstd
)
15868 warn (_("section '%s' has unsupported compress type: %d\n"),
15869 printable_section_name (filedata
, section
), chdr
.ch_type
);
15872 uncompressed_size
= chdr
.ch_size
;
15873 start
+= compression_header_size
;
15874 new_size
-= compression_header_size
;
15876 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15878 /* Read the zlib header. In this case, it should be "ZLIB"
15879 followed by the uncompressed section size, 8 bytes in
15880 big-endian order. */
15881 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15882 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15883 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15884 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15885 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15886 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15887 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15888 uncompressed_size
+= start
[11];
15893 if (uncompressed_size
)
15895 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15896 &new_size
, filedata
->file_size
))
15897 num_bytes
= new_size
;
15900 error (_("Unable to decompress section %s\n"),
15901 printable_section_name (filedata
, section
));
15906 start
= real_start
;
15909 /* If the section being dumped has relocations against it the user might
15910 be expecting these relocations to have been applied. Check for this
15911 case and issue a warning message in order to avoid confusion.
15912 FIXME: Maybe we ought to have an option that dumps a section with
15913 relocs applied ? */
15914 for (relsec
= filedata
->section_headers
;
15915 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15918 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15919 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15920 || filedata
->section_headers
+ relsec
->sh_info
!= section
15921 || relsec
->sh_size
== 0
15922 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15925 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15930 end
= start
+ num_bytes
;
15931 some_strings_shown
= false;
15933 #ifdef HAVE_MBSTATE_T
15935 /* Initialise the multibyte conversion state. */
15936 memset (& state
, 0, sizeof (state
));
15939 bool continuing
= false;
15943 while (!ISPRINT (* data
))
15944 if (++ data
>= end
)
15949 size_t maxlen
= end
- data
;
15954 continuing
= false;
15958 printf (" [%6tx] ", data
- start
);
15972 /* PR 25543: Treat new-lines as string-ending characters. */
15981 /* Do not print control characters directly as they can affect terminal
15982 settings. Such characters usually appear in the names generated
15983 by the assembler for local labels. */
15986 printf ("^%c", c
+ 0x40);
15988 else if (ISPRINT (c
))
15995 #ifdef HAVE_MBSTATE_T
15998 /* Let printf do the hard work of displaying multibyte characters. */
15999 printf ("%.1s", data
- 1);
16000 #ifdef HAVE_MBSTATE_T
16001 /* Try to find out how many bytes made up the character that was
16002 just printed. Advance the symbol pointer past the bytes that
16004 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
16008 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
16018 printf (_("<corrupt>\n"));
16021 some_strings_shown
= true;
16025 if (! some_strings_shown
)
16026 printf (_(" No strings found in this section."));
16039 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
16040 Filedata
*filedata
,
16043 Elf_Internal_Shdr
*relsec
;
16045 uint64_t section_size
;
16047 unsigned char *data
;
16048 unsigned char *real_start
;
16049 unsigned char *start
;
16051 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
16053 /* PR 21820: Do not fail if the section was empty. */
16054 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
16056 section_size
= section
->sh_size
;
16058 if (filedata
->is_separate
)
16059 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
16060 printable_section_name (filedata
, section
),
16061 filedata
->file_name
);
16063 printf (_("\nHex dump of section '%s':\n"),
16064 printable_section_name (filedata
, section
));
16066 if (decompress_dumps
)
16068 uint64_t new_size
= section_size
;
16069 uint64_t uncompressed_size
= 0;
16070 bool is_zstd
= false;
16072 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
16074 Elf_Internal_Chdr chdr
;
16075 unsigned int compression_header_size
16076 = get_compression_header (& chdr
, start
, section_size
);
16078 if (compression_header_size
== 0)
16079 /* An error message will have already been generated
16080 by get_compression_header. */
16083 if (chdr
.ch_type
== ch_compress_zlib
)
16086 else if (chdr
.ch_type
== ch_compress_zstd
)
16091 warn (_("section '%s' has unsupported compress type: %d\n"),
16092 printable_section_name (filedata
, section
), chdr
.ch_type
);
16095 uncompressed_size
= chdr
.ch_size
;
16096 start
+= compression_header_size
;
16097 new_size
-= compression_header_size
;
16099 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
16101 /* Read the zlib header. In this case, it should be "ZLIB"
16102 followed by the uncompressed section size, 8 bytes in
16103 big-endian order. */
16104 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16105 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16106 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16107 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16108 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16109 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16110 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16111 uncompressed_size
+= start
[11];
16116 if (uncompressed_size
)
16118 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16119 &new_size
, filedata
->file_size
))
16121 section_size
= new_size
;
16125 error (_("Unable to decompress section %s\n"),
16126 printable_section_name (filedata
, section
));
16127 /* FIXME: Print the section anyway ? */
16132 start
= real_start
;
16137 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
16142 /* If the section being dumped has relocations against it the user might
16143 be expecting these relocations to have been applied. Check for this
16144 case and issue a warning message in order to avoid confusion.
16145 FIXME: Maybe we ought to have an option that dumps a section with
16146 relocs applied ? */
16147 for (relsec
= filedata
->section_headers
;
16148 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
16151 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
16152 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
16153 || filedata
->section_headers
+ relsec
->sh_info
!= section
16154 || relsec
->sh_size
== 0
16155 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
16158 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
16163 addr
= section
->sh_addr
;
16164 bytes
= section_size
;
16173 lbytes
= (bytes
> 16 ? 16 : bytes
);
16175 printf (" 0x%8.8" PRIx64
" ", addr
);
16177 for (j
= 0; j
< 16; j
++)
16180 printf ("%2.2x", data
[j
]);
16188 for (j
= 0; j
< lbytes
; j
++)
16191 if (k
>= ' ' && k
< 0x7f)
16214 #ifdef ENABLE_LIBCTF
16215 static ctf_sect_t
*
16216 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
16218 buf
->cts_name
= section_name_print (filedata
, shdr
);
16219 buf
->cts_size
= shdr
->sh_size
;
16220 buf
->cts_entsize
= shdr
->sh_entsize
;
16225 /* Formatting callback function passed to ctf_dump. Returns either the pointer
16226 it is passed, or a pointer to newly-allocated storage, in which case
16227 dump_ctf() will free it when it no longer needs it. */
16230 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
16231 char *s
, void *arg
)
16233 const char *blanks
= arg
;
16236 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
16241 /* Dump CTF errors/warnings. */
16243 dump_ctf_errs (ctf_dict_t
*fp
)
16245 ctf_next_t
*it
= NULL
;
16250 /* Dump accumulated errors and warnings. */
16251 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
16253 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
16257 if (err
!= ECTF_NEXT_END
)
16258 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
16261 /* Dump one CTF archive member. */
16264 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
16267 const char *things
[] = {"Header", "Labels", "Data objects",
16268 "Function objects", "Variables", "Types", "Strings",
16270 const char **thing
;
16273 /* Don't print out the name of the default-named archive member if it appears
16274 first in the list. The name .ctf appears everywhere, even for things that
16275 aren't really archives, so printing it out is liable to be confusing; also,
16276 the common case by far is for only one archive member to exist, and hiding
16277 it in that case seems worthwhile. */
16279 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
16280 printf (_("\nCTF archive member: %s:\n"), name
);
16282 if (ctf_parent_name (ctf
) != NULL
)
16283 ctf_import (ctf
, parent
);
16285 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
16287 ctf_dump_state_t
*s
= NULL
;
16290 printf ("\n %s:\n", *thing
);
16291 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
16292 (void *) " ")) != NULL
)
16294 printf ("%s\n", item
);
16298 if (ctf_errno (ctf
))
16300 error (_("Iteration failed: %s, %s\n"), *thing
,
16301 ctf_errmsg (ctf_errno (ctf
)));
16306 dump_ctf_errs (ctf
);
16310 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16312 Elf_Internal_Shdr
* symtab_sec
= NULL
;
16313 Elf_Internal_Shdr
* strtab_sec
= NULL
;
16314 void * data
= NULL
;
16315 void * symdata
= NULL
;
16316 void * strdata
= NULL
;
16317 ctf_sect_t ctfsect
, symsect
, strsect
;
16318 ctf_sect_t
* symsectp
= NULL
;
16319 ctf_sect_t
* strsectp
= NULL
;
16320 ctf_archive_t
* ctfa
= NULL
;
16321 ctf_dict_t
* parent
= NULL
;
16324 ctf_next_t
*i
= NULL
;
16330 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
16331 data
= get_section_contents (section
, filedata
);
16332 ctfsect
.cts_data
= data
;
16334 if (!dump_ctf_symtab_name
)
16335 dump_ctf_symtab_name
= strdup (".dynsym");
16337 if (!dump_ctf_strtab_name
)
16338 dump_ctf_strtab_name
= strdup (".dynstr");
16340 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
16342 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
16344 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
16347 if ((symdata
= (void *) get_data (NULL
, filedata
,
16348 symtab_sec
->sh_offset
, 1,
16349 symtab_sec
->sh_size
,
16350 _("symbols"))) == NULL
)
16352 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
16353 symsect
.cts_data
= symdata
;
16356 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
16358 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
16360 error (_("No string table section named %s\n"),
16361 dump_ctf_strtab_name
);
16364 if ((strdata
= (void *) get_data (NULL
, filedata
,
16365 strtab_sec
->sh_offset
, 1,
16366 strtab_sec
->sh_size
,
16367 _("strings"))) == NULL
)
16369 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
16370 strsect
.cts_data
= strdata
;
16373 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
16374 libctf papers over the difference, so we can pretend it is always an
16377 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
16379 dump_ctf_errs (NULL
);
16380 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16384 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
16387 /* Preload the parent dict, since it will need to be imported into every
16389 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
16391 dump_ctf_errs (NULL
);
16392 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16398 if (filedata
->is_separate
)
16399 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
16400 printable_section_name (filedata
, section
),
16401 filedata
->file_name
);
16403 printf (_("\nDump of CTF section '%s':\n"),
16404 printable_section_name (filedata
, section
));
16406 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
16407 dump_ctf_archive_member (fp
, name
, parent
, member
++);
16408 if (err
!= ECTF_NEXT_END
)
16410 dump_ctf_errs (NULL
);
16411 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
16416 ctf_dict_close (parent
);
16426 dump_section_as_sframe (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16428 void * data
= NULL
;
16429 sframe_decoder_ctx
*sfd_ctx
= NULL
;
16430 const char *print_name
= printable_section_name (filedata
, section
);
16436 if (strcmp (print_name
, "") == 0)
16438 error (_("Section name must be provided \n"));
16443 data
= get_section_contents (section
, filedata
);
16444 sf_size
= section
->sh_size
;
16445 /* Decode the contents of the section. */
16446 sfd_ctx
= sframe_decode ((const char*)data
, sf_size
, &err
);
16450 error (_("SFrame decode failure: %s\n"), sframe_errmsg (err
));
16454 printf (_("Contents of the SFrame section %s:"), print_name
);
16455 /* Dump the contents as text. */
16456 dump_sframe (sfd_ctx
, section
->sh_addr
);
16464 load_specific_debug_section (enum dwarf_section_display_enum debug
,
16465 const Elf_Internal_Shdr
* sec
,
16468 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16470 Filedata
* filedata
= (Filedata
*) data
;
16472 if (section
->start
!= NULL
)
16474 /* If it is already loaded, do nothing. */
16475 if (streq (section
->filename
, filedata
->file_name
))
16477 free (section
->start
);
16480 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
16481 section
->address
= sec
->sh_addr
;
16482 section
->filename
= filedata
->file_name
;
16483 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
16485 sec
->sh_size
, buf
);
16486 if (section
->start
== NULL
)
16490 unsigned char *start
= section
->start
;
16491 uint64_t size
= sec
->sh_size
;
16492 uint64_t uncompressed_size
= 0;
16493 bool is_zstd
= false;
16495 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
16497 Elf_Internal_Chdr chdr
;
16498 unsigned int compression_header_size
;
16500 if (size
< (is_32bit_elf
16501 ? sizeof (Elf32_External_Chdr
)
16502 : sizeof (Elf64_External_Chdr
)))
16504 warn (_("compressed section %s is too small to contain a compression header\n"),
16509 compression_header_size
= get_compression_header (&chdr
, start
, size
);
16510 if (compression_header_size
== 0)
16511 /* An error message will have already been generated
16512 by get_compression_header. */
16515 if (chdr
.ch_type
== ch_compress_zlib
)
16518 else if (chdr
.ch_type
== ch_compress_zstd
)
16523 warn (_("section '%s' has unsupported compress type: %d\n"),
16524 section
->name
, chdr
.ch_type
);
16527 uncompressed_size
= chdr
.ch_size
;
16528 start
+= compression_header_size
;
16529 size
-= compression_header_size
;
16531 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
16533 /* Read the zlib header. In this case, it should be "ZLIB"
16534 followed by the uncompressed section size, 8 bytes in
16535 big-endian order. */
16536 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16537 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16538 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16539 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16540 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16541 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16542 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16543 uncompressed_size
+= start
[11];
16548 if (uncompressed_size
)
16550 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16551 &size
, filedata
->file_size
))
16553 /* Free the compressed buffer, update the section buffer
16554 and the section size if uncompress is successful. */
16555 free (section
->start
);
16556 section
->start
= start
;
16560 error (_("Unable to decompress section %s\n"),
16561 printable_section_name (filedata
, sec
));
16566 section
->size
= size
;
16569 if (section
->start
== NULL
)
16572 if (debug_displays
[debug
].relocate
)
16574 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
16575 & section
->reloc_info
, & section
->num_relocs
))
16580 section
->reloc_info
= NULL
;
16581 section
->num_relocs
= 0;
16587 #if HAVE_LIBDEBUGINFOD
16588 /* Return a hex string representation of the build-id. */
16590 get_build_id (void * data
)
16592 Filedata
* filedata
= (Filedata
*) data
;
16593 Elf_Internal_Shdr
* shdr
;
16596 /* Iterate through notes to find note.gnu.build-id.
16597 FIXME: Only the first note in any note section is examined. */
16598 for (i
= 0, shdr
= filedata
->section_headers
;
16599 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
16602 if (shdr
->sh_type
!= SHT_NOTE
)
16607 size_t data_remaining
;
16609 Elf_External_Note
* enote
;
16610 Elf_Internal_Note inote
;
16612 uint64_t offset
= shdr
->sh_offset
;
16613 uint64_t align
= shdr
->sh_addralign
;
16614 uint64_t length
= shdr
->sh_size
;
16616 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16622 else if (align
!= 4 && align
!= 8)
16628 end
= (char *) enote
+ length
;
16629 data_remaining
= end
- (char *) enote
;
16631 if (!is_ia64_vms (filedata
))
16633 min_notesz
= offsetof (Elf_External_Note
, name
);
16634 if (data_remaining
< min_notesz
)
16637 malformed note encountered in section %s whilst scanning for build-id note\n"),
16638 printable_section_name (filedata
, shdr
));
16642 data_remaining
-= min_notesz
;
16644 inote
.type
= BYTE_GET (enote
->type
);
16645 inote
.namesz
= BYTE_GET (enote
->namesz
);
16646 inote
.namedata
= enote
->name
;
16647 inote
.descsz
= BYTE_GET (enote
->descsz
);
16648 inote
.descdata
= ((char *) enote
16649 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
16650 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16651 next
= ((char *) enote
16652 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
16656 Elf64_External_VMS_Note
*vms_enote
;
16658 /* PR binutils/15191
16659 Make sure that there is enough data to read. */
16660 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16661 if (data_remaining
< min_notesz
)
16664 malformed note encountered in section %s whilst scanning for build-id note\n"),
16665 printable_section_name (filedata
, shdr
));
16669 data_remaining
-= min_notesz
;
16671 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
16672 inote
.type
= BYTE_GET (vms_enote
->type
);
16673 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
16674 inote
.namedata
= vms_enote
->name
;
16675 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
16676 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16677 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16678 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16681 /* Skip malformed notes. */
16682 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
16683 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
16684 || (size_t) (next
- inote
.descdata
) < inote
.descsz
16685 || ((size_t) (next
- inote
.descdata
)
16686 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
16689 malformed note encountered in section %s whilst scanning for build-id note\n"),
16690 printable_section_name (filedata
, shdr
));
16695 /* Check if this is the build-id note. If so then convert the build-id
16696 bytes to a hex string. */
16697 if (inote
.namesz
> 0
16698 && startswith (inote
.namedata
, "GNU")
16699 && inote
.type
== NT_GNU_BUILD_ID
)
16704 build_id
= malloc (inote
.descsz
* 2 + 1);
16705 if (build_id
== NULL
)
16711 for (j
= 0; j
< inote
.descsz
; ++j
)
16712 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
16713 build_id
[inote
.descsz
* 2] = '\0';
16716 return (unsigned char *) build_id
;
16723 #endif /* HAVE_LIBDEBUGINFOD */
16725 /* If this is not NULL, load_debug_section will only look for sections
16726 within the list of sections given here. */
16727 static unsigned int * section_subset
= NULL
;
16730 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
16732 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16733 Elf_Internal_Shdr
* sec
;
16734 Filedata
* filedata
= (Filedata
*) data
;
16736 if (!dump_any_debugging
)
16739 /* Without section headers we cannot find any sections. */
16740 if (filedata
->section_headers
== NULL
)
16743 if (filedata
->string_table
== NULL
16744 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
16745 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
16747 Elf_Internal_Shdr
* strs
;
16749 /* Read in the string table, so that we have section names to scan. */
16750 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
16752 if (strs
!= NULL
&& strs
->sh_size
!= 0)
16754 filedata
->string_table
16755 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
16756 1, strs
->sh_size
, _("string table"));
16758 filedata
->string_table_length
16759 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
16763 /* Locate the debug section. */
16764 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
16766 section
->name
= section
->uncompressed_name
;
16769 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
16771 section
->name
= section
->compressed_name
;
16776 /* If we're loading from a subset of sections, and we've loaded
16777 a section matching this name before, it's likely that it's a
16779 if (section_subset
!= NULL
)
16780 free_debug_section (debug
);
16782 return load_specific_debug_section (debug
, sec
, data
);
16786 free_debug_section (enum dwarf_section_display_enum debug
)
16788 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16790 if (section
->start
== NULL
)
16793 free ((char *) section
->start
);
16794 section
->start
= NULL
;
16795 section
->address
= 0;
16798 free (section
->reloc_info
);
16799 section
->reloc_info
= NULL
;
16800 section
->num_relocs
= 0;
16804 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16806 const char *name
= (section_name_valid (filedata
, section
)
16807 ? section_name (filedata
, section
) : "");
16808 const char *print_name
= printable_section_name (filedata
, section
);
16810 bool result
= true;
16813 length
= section
->sh_size
;
16816 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
16819 if (section
->sh_type
== SHT_NOBITS
)
16821 /* There is no point in dumping the contents of a debugging section
16822 which has the NOBITS type - the bits in the file will be random.
16823 This can happen when a file containing a .eh_frame section is
16824 stripped with the --only-keep-debug command line option. */
16825 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
16830 if (startswith (name
, ".gnu.linkonce.wi."))
16831 name
= ".debug_info";
16833 /* See if we know how to display the contents of this section. */
16834 for (i
= 0; i
< max
; i
++)
16836 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
16837 struct dwarf_section_display
* display
= debug_displays
+ i
;
16838 struct dwarf_section
* sec
= & display
->section
;
16840 if (streq (sec
->uncompressed_name
, name
)
16841 || (id
== line
&& startswith (name
, ".debug_line."))
16842 || streq (sec
->compressed_name
, name
))
16844 bool secondary
= (section
!= find_section (filedata
, name
));
16847 free_debug_section (id
);
16849 if (i
== line
&& startswith (name
, ".debug_line."))
16851 else if (streq (sec
->uncompressed_name
, name
))
16852 sec
->name
= sec
->uncompressed_name
;
16854 sec
->name
= sec
->compressed_name
;
16856 if (load_specific_debug_section (id
, section
, filedata
))
16858 /* If this debug section is part of a CU/TU set in a .dwp file,
16859 restrict load_debug_section to the sections in that set. */
16860 section_subset
= find_cu_tu_set (filedata
, shndx
);
16862 result
&= display
->display (sec
, filedata
);
16864 section_subset
= NULL
;
16866 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
16867 free_debug_section (id
);
16875 printf (_("Unrecognized debug section: %s\n"), print_name
);
16882 /* Set DUMP_SECTS for all sections where dumps were requested
16883 based on section name. */
16886 initialise_dumps_byname (Filedata
* filedata
)
16888 struct dump_list_entry
* cur
;
16890 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
16895 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
16896 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
16897 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
16900 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
16904 if (!any
&& !filedata
->is_separate
)
16905 warn (_("Section '%s' was not dumped because it does not exist\n"),
16911 process_section_contents (Filedata
* filedata
)
16913 Elf_Internal_Shdr
* section
;
16920 initialise_dumps_byname (filedata
);
16922 for (i
= 0, section
= filedata
->section_headers
;
16923 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
16926 dump_type dump
= filedata
->dump
.dump_sects
[i
];
16928 if (filedata
->is_separate
&& ! process_links
)
16929 dump
&= DEBUG_DUMP
;
16931 #ifdef SUPPORT_DISASSEMBLY
16932 if (dump
& DISASS_DUMP
)
16934 if (! disassemble_section (section
, filedata
))
16938 if (dump
& HEX_DUMP
)
16940 if (! dump_section_as_bytes (section
, filedata
, false))
16944 if (dump
& RELOC_DUMP
)
16946 if (! dump_section_as_bytes (section
, filedata
, true))
16950 if (dump
& STRING_DUMP
)
16952 if (! dump_section_as_strings (section
, filedata
))
16956 if (dump
& DEBUG_DUMP
)
16958 if (! display_debug_section (i
, section
, filedata
))
16962 #ifdef ENABLE_LIBCTF
16963 if (dump
& CTF_DUMP
)
16965 if (! dump_section_as_ctf (section
, filedata
))
16969 if (dump
& SFRAME_DUMP
)
16971 if (! dump_section_as_sframe (section
, filedata
))
16976 if (! filedata
->is_separate
)
16978 /* Check to see if the user requested a
16979 dump of a section that does not exist. */
16980 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
16981 if (filedata
->dump
.dump_sects
[i
])
16983 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
16992 process_mips_fpe_exception (int mask
)
16998 if (mask
& OEX_FPU_INEX
)
16999 fputs ("INEX", stdout
), first
= false;
17000 if (mask
& OEX_FPU_UFLO
)
17001 printf ("%sUFLO", first
? "" : "|"), first
= false;
17002 if (mask
& OEX_FPU_OFLO
)
17003 printf ("%sOFLO", first
? "" : "|"), first
= false;
17004 if (mask
& OEX_FPU_DIV0
)
17005 printf ("%sDIV0", first
? "" : "|"), first
= false;
17006 if (mask
& OEX_FPU_INVAL
)
17007 printf ("%sINVAL", first
? "" : "|");
17010 fputs ("0", stdout
);
17013 /* Display's the value of TAG at location P. If TAG is
17014 greater than 0 it is assumed to be an unknown tag, and
17015 a message is printed to this effect. Otherwise it is
17016 assumed that a message has already been printed.
17018 If the bottom bit of TAG is set it assumed to have a
17019 string value, otherwise it is assumed to have an integer
17022 Returns an updated P pointing to the first unread byte
17023 beyond the end of TAG's value.
17025 Reads at or beyond END will not be made. */
17027 static unsigned char *
17028 display_tag_value (signed int tag
,
17030 const unsigned char * const end
)
17035 printf (" Tag_unknown_%d: ", tag
);
17039 warn (_("<corrupt tag>\n"));
17043 /* PR 17531 file: 027-19978-0.004. */
17044 size_t maxlen
= (end
- p
) - 1;
17049 print_symbol ((int) maxlen
, (const char *) p
);
17050 p
+= strnlen ((char *) p
, maxlen
) + 1;
17054 printf (_("<corrupt string tag>"));
17055 p
= (unsigned char *) end
;
17061 READ_ULEB (val
, p
, end
);
17062 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
17069 /* ARC ABI attributes section. */
17071 static unsigned char *
17072 display_arc_attribute (unsigned char * p
,
17073 const unsigned char * const end
)
17078 READ_ULEB (tag
, p
, end
);
17082 case Tag_ARC_PCS_config
:
17083 READ_ULEB (val
, p
, end
);
17084 printf (" Tag_ARC_PCS_config: ");
17088 printf (_("Absent/Non standard\n"));
17091 printf (_("Bare metal/mwdt\n"));
17094 printf (_("Bare metal/newlib\n"));
17097 printf (_("Linux/uclibc\n"));
17100 printf (_("Linux/glibc\n"));
17103 printf (_("Unknown\n"));
17108 case Tag_ARC_CPU_base
:
17109 READ_ULEB (val
, p
, end
);
17110 printf (" Tag_ARC_CPU_base: ");
17115 printf (_("Absent\n"));
17117 case TAG_CPU_ARC6xx
:
17118 printf ("ARC6xx\n");
17120 case TAG_CPU_ARC7xx
:
17121 printf ("ARC7xx\n");
17123 case TAG_CPU_ARCEM
:
17124 printf ("ARCEM\n");
17126 case TAG_CPU_ARCHS
:
17127 printf ("ARCHS\n");
17132 case Tag_ARC_CPU_variation
:
17133 READ_ULEB (val
, p
, end
);
17134 printf (" Tag_ARC_CPU_variation: ");
17138 if (val
> 0 && val
< 16)
17139 printf ("Core%d\n", val
);
17141 printf ("Unknown\n");
17145 printf (_("Absent\n"));
17150 case Tag_ARC_CPU_name
:
17151 printf (" Tag_ARC_CPU_name: ");
17152 p
= display_tag_value (-1, p
, end
);
17155 case Tag_ARC_ABI_rf16
:
17156 READ_ULEB (val
, p
, end
);
17157 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
17160 case Tag_ARC_ABI_osver
:
17161 READ_ULEB (val
, p
, end
);
17162 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
17165 case Tag_ARC_ABI_pic
:
17166 case Tag_ARC_ABI_sda
:
17167 READ_ULEB (val
, p
, end
);
17168 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
17169 : " Tag_ARC_ABI_pic: ");
17173 printf (_("Absent\n"));
17182 printf (_("Unknown\n"));
17187 case Tag_ARC_ABI_tls
:
17188 READ_ULEB (val
, p
, end
);
17189 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
17192 case Tag_ARC_ABI_enumsize
:
17193 READ_ULEB (val
, p
, end
);
17194 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
17198 case Tag_ARC_ABI_exceptions
:
17199 READ_ULEB (val
, p
, end
);
17200 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
17204 case Tag_ARC_ABI_double_size
:
17205 READ_ULEB (val
, p
, end
);
17206 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
17209 case Tag_ARC_ISA_config
:
17210 printf (" Tag_ARC_ISA_config: ");
17211 p
= display_tag_value (-1, p
, end
);
17214 case Tag_ARC_ISA_apex
:
17215 printf (" Tag_ARC_ISA_apex: ");
17216 p
= display_tag_value (-1, p
, end
);
17219 case Tag_ARC_ISA_mpy_option
:
17220 READ_ULEB (val
, p
, end
);
17221 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
17224 case Tag_ARC_ATR_version
:
17225 READ_ULEB (val
, p
, end
);
17226 printf (" Tag_ARC_ATR_version: %d\n", val
);
17230 return display_tag_value (tag
& 1, p
, end
);
17236 /* ARM EABI attributes section. */
17241 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
17243 const char *const *table
;
17244 } arm_attr_public_tag
;
17246 static const char *const arm_attr_tag_CPU_arch
[] =
17247 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
17248 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
17249 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
17250 "v8.1-M.mainline", "v9"};
17251 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
17252 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
17253 {"No", "Thumb-1", "Thumb-2", "Yes"};
17254 static const char *const arm_attr_tag_FP_arch
[] =
17255 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
17256 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
17257 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
17258 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
17259 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
17260 "NEON for ARMv8.1"};
17261 static const char *const arm_attr_tag_PCS_config
[] =
17262 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
17263 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
17264 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
17265 {"V6", "SB", "TLS", "Unused"};
17266 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
17267 {"Absolute", "PC-relative", "SB-relative", "None"};
17268 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
17269 {"Absolute", "PC-relative", "None"};
17270 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
17271 {"None", "direct", "GOT-indirect"};
17272 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
17273 {"None", "??? 1", "2", "??? 3", "4"};
17274 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
17275 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
17276 {"Unused", "Needed", "Sign only"};
17277 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
17278 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
17279 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
17280 {"Unused", "Finite", "RTABI", "IEEE 754"};
17281 static const char *const arm_attr_tag_ABI_enum_size
[] =
17282 {"Unused", "small", "int", "forced to int"};
17283 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
17284 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
17285 static const char *const arm_attr_tag_ABI_VFP_args
[] =
17286 {"AAPCS", "VFP registers", "custom", "compatible"};
17287 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
17288 {"AAPCS", "WMMX registers", "custom"};
17289 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
17290 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
17291 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
17292 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
17293 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
17294 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
17295 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
17296 static const char *const arm_attr_tag_FP_HP_extension
[] =
17297 {"Not Allowed", "Allowed"};
17298 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
17299 {"None", "IEEE 754", "Alternative Format"};
17300 static const char *const arm_attr_tag_DSP_extension
[] =
17301 {"Follow architecture", "Allowed"};
17302 static const char *const arm_attr_tag_MPextension_use
[] =
17303 {"Not Allowed", "Allowed"};
17304 static const char *const arm_attr_tag_DIV_use
[] =
17305 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
17306 "Allowed in v7-A with integer division extension"};
17307 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
17308 static const char *const arm_attr_tag_Virtualization_use
[] =
17309 {"Not Allowed", "TrustZone", "Virtualization Extensions",
17310 "TrustZone and Virtualization Extensions"};
17311 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
17312 {"Not Allowed", "Allowed"};
17314 static const char *const arm_attr_tag_MVE_arch
[] =
17315 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
17317 static const char * arm_attr_tag_PAC_extension
[] =
17318 {"No PAC/AUT instructions",
17319 "PAC/AUT instructions permitted in the NOP space",
17320 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
17322 static const char * arm_attr_tag_BTI_extension
[] =
17323 {"BTI instructions not permitted",
17324 "BTI instructions permitted in the NOP space",
17325 "BTI instructions permitted in the NOP and in the non-NOP space"};
17327 static const char * arm_attr_tag_BTI_use
[] =
17328 {"Compiled without branch target enforcement",
17329 "Compiled with branch target enforcement"};
17331 static const char * arm_attr_tag_PACRET_use
[] =
17332 {"Compiled without return address signing and authentication",
17333 "Compiled with return address signing and authentication"};
17335 #define LOOKUP(id, name) \
17336 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
17337 static arm_attr_public_tag arm_attr_public_tags
[] =
17339 {4, "CPU_raw_name", 1, NULL
},
17340 {5, "CPU_name", 1, NULL
},
17341 LOOKUP(6, CPU_arch
),
17342 {7, "CPU_arch_profile", 0, NULL
},
17343 LOOKUP(8, ARM_ISA_use
),
17344 LOOKUP(9, THUMB_ISA_use
),
17345 LOOKUP(10, FP_arch
),
17346 LOOKUP(11, WMMX_arch
),
17347 LOOKUP(12, Advanced_SIMD_arch
),
17348 LOOKUP(13, PCS_config
),
17349 LOOKUP(14, ABI_PCS_R9_use
),
17350 LOOKUP(15, ABI_PCS_RW_data
),
17351 LOOKUP(16, ABI_PCS_RO_data
),
17352 LOOKUP(17, ABI_PCS_GOT_use
),
17353 LOOKUP(18, ABI_PCS_wchar_t
),
17354 LOOKUP(19, ABI_FP_rounding
),
17355 LOOKUP(20, ABI_FP_denormal
),
17356 LOOKUP(21, ABI_FP_exceptions
),
17357 LOOKUP(22, ABI_FP_user_exceptions
),
17358 LOOKUP(23, ABI_FP_number_model
),
17359 {24, "ABI_align_needed", 0, NULL
},
17360 {25, "ABI_align_preserved", 0, NULL
},
17361 LOOKUP(26, ABI_enum_size
),
17362 LOOKUP(27, ABI_HardFP_use
),
17363 LOOKUP(28, ABI_VFP_args
),
17364 LOOKUP(29, ABI_WMMX_args
),
17365 LOOKUP(30, ABI_optimization_goals
),
17366 LOOKUP(31, ABI_FP_optimization_goals
),
17367 {32, "compatibility", 0, NULL
},
17368 LOOKUP(34, CPU_unaligned_access
),
17369 LOOKUP(36, FP_HP_extension
),
17370 LOOKUP(38, ABI_FP_16bit_format
),
17371 LOOKUP(42, MPextension_use
),
17372 LOOKUP(44, DIV_use
),
17373 LOOKUP(46, DSP_extension
),
17374 LOOKUP(48, MVE_arch
),
17375 LOOKUP(50, PAC_extension
),
17376 LOOKUP(52, BTI_extension
),
17377 LOOKUP(74, BTI_use
),
17378 LOOKUP(76, PACRET_use
),
17379 {64, "nodefaults", 0, NULL
},
17380 {65, "also_compatible_with", 0, NULL
},
17381 LOOKUP(66, T2EE_use
),
17382 {67, "conformance", 1, NULL
},
17383 LOOKUP(68, Virtualization_use
),
17384 LOOKUP(70, MPextension_use_legacy
)
17388 static unsigned char *
17389 display_arm_attribute (unsigned char * p
,
17390 const unsigned char * const end
)
17394 arm_attr_public_tag
* attr
;
17398 READ_ULEB (tag
, p
, end
);
17400 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
17402 if (arm_attr_public_tags
[i
].tag
== tag
)
17404 attr
= &arm_attr_public_tags
[i
];
17411 printf (" Tag_%s: ", attr
->name
);
17412 switch (attr
->type
)
17417 case 7: /* Tag_CPU_arch_profile. */
17418 READ_ULEB (val
, p
, end
);
17421 case 0: printf (_("None\n")); break;
17422 case 'A': printf (_("Application\n")); break;
17423 case 'R': printf (_("Realtime\n")); break;
17424 case 'M': printf (_("Microcontroller\n")); break;
17425 case 'S': printf (_("Application or Realtime\n")); break;
17426 default: printf ("??? (%d)\n", val
); break;
17430 case 24: /* Tag_align_needed. */
17431 READ_ULEB (val
, p
, end
);
17434 case 0: printf (_("None\n")); break;
17435 case 1: printf (_("8-byte\n")); break;
17436 case 2: printf (_("4-byte\n")); break;
17437 case 3: printf ("??? 3\n"); break;
17440 printf (_("8-byte and up to %d-byte extended\n"),
17443 printf ("??? (%d)\n", val
);
17448 case 25: /* Tag_align_preserved. */
17449 READ_ULEB (val
, p
, end
);
17452 case 0: printf (_("None\n")); break;
17453 case 1: printf (_("8-byte, except leaf SP\n")); break;
17454 case 2: printf (_("8-byte\n")); break;
17455 case 3: printf ("??? 3\n"); break;
17458 printf (_("8-byte and up to %d-byte extended\n"),
17461 printf ("??? (%d)\n", val
);
17466 case 32: /* Tag_compatibility. */
17468 READ_ULEB (val
, p
, end
);
17469 printf (_("flag = %d, vendor = "), val
);
17472 size_t maxlen
= (end
- p
) - 1;
17474 print_symbol ((int) maxlen
, (const char *) p
);
17475 p
+= strnlen ((char *) p
, maxlen
) + 1;
17479 printf (_("<corrupt>"));
17480 p
= (unsigned char *) end
;
17486 case 64: /* Tag_nodefaults. */
17487 /* PR 17531: file: 001-505008-0.01. */
17490 printf (_("True\n"));
17493 case 65: /* Tag_also_compatible_with. */
17494 READ_ULEB (val
, p
, end
);
17495 if (val
== 6 /* Tag_CPU_arch. */)
17497 READ_ULEB (val
, p
, end
);
17498 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
17499 printf ("??? (%d)\n", val
);
17501 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
17505 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
17510 printf (_("<unknown: %d>\n"), tag
);
17516 return display_tag_value (-1, p
, end
);
17518 return display_tag_value (0, p
, end
);
17521 assert (attr
->type
& 0x80);
17522 READ_ULEB (val
, p
, end
);
17523 type
= attr
->type
& 0x7f;
17525 printf ("??? (%d)\n", val
);
17527 printf ("%s\n", attr
->table
[val
]);
17532 return display_tag_value (tag
, p
, end
);
17535 static unsigned char *
17536 display_gnu_attribute (unsigned char * p
,
17537 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
17538 const unsigned char * const end
)
17543 READ_ULEB (tag
, p
, end
);
17545 /* Tag_compatibility is the only generic GNU attribute defined at
17549 READ_ULEB (val
, p
, end
);
17551 printf (_("flag = %d, vendor = "), val
);
17554 printf (_("<corrupt>\n"));
17555 warn (_("corrupt vendor attribute\n"));
17561 size_t maxlen
= (end
- p
) - 1;
17563 print_symbol ((int) maxlen
, (const char *) p
);
17564 p
+= strnlen ((char *) p
, maxlen
) + 1;
17568 printf (_("<corrupt>"));
17569 p
= (unsigned char *) end
;
17576 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
17577 return display_proc_gnu_attribute (p
, tag
, end
);
17579 return display_tag_value (tag
, p
, end
);
17582 static unsigned char *
17583 display_m68k_gnu_attribute (unsigned char * p
,
17585 const unsigned char * const end
)
17589 if (tag
== Tag_GNU_M68K_ABI_FP
)
17591 printf (" Tag_GNU_M68K_ABI_FP: ");
17594 printf (_("<corrupt>\n"));
17597 READ_ULEB (val
, p
, end
);
17600 printf ("(%#x), ", val
);
17605 printf (_("unspecified hard/soft float\n"));
17608 printf (_("hard float\n"));
17611 printf (_("soft float\n"));
17617 return display_tag_value (tag
& 1, p
, end
);
17620 static unsigned char *
17621 display_power_gnu_attribute (unsigned char * p
,
17623 const unsigned char * const end
)
17627 if (tag
== Tag_GNU_Power_ABI_FP
)
17629 printf (" Tag_GNU_Power_ABI_FP: ");
17632 printf (_("<corrupt>\n"));
17635 READ_ULEB (val
, p
, end
);
17638 printf ("(%#x), ", val
);
17643 printf (_("unspecified hard/soft float, "));
17646 printf (_("hard float, "));
17649 printf (_("soft float, "));
17652 printf (_("single-precision hard float, "));
17659 printf (_("unspecified long double\n"));
17662 printf (_("128-bit IBM long double\n"));
17665 printf (_("64-bit long double\n"));
17668 printf (_("128-bit IEEE long double\n"));
17674 if (tag
== Tag_GNU_Power_ABI_Vector
)
17676 printf (" Tag_GNU_Power_ABI_Vector: ");
17679 printf (_("<corrupt>\n"));
17682 READ_ULEB (val
, p
, end
);
17685 printf ("(%#x), ", val
);
17690 printf (_("unspecified\n"));
17693 printf (_("generic\n"));
17696 printf ("AltiVec\n");
17705 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
17707 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
17710 printf (_("<corrupt>\n"));
17713 READ_ULEB (val
, p
, end
);
17716 printf ("(%#x), ", val
);
17721 printf (_("unspecified\n"));
17724 printf ("r3/r4\n");
17727 printf (_("memory\n"));
17736 return display_tag_value (tag
& 1, p
, end
);
17739 static unsigned char *
17740 display_s390_gnu_attribute (unsigned char * p
,
17742 const unsigned char * const end
)
17746 if (tag
== Tag_GNU_S390_ABI_Vector
)
17748 printf (" Tag_GNU_S390_ABI_Vector: ");
17749 READ_ULEB (val
, p
, end
);
17754 printf (_("any\n"));
17757 printf (_("software\n"));
17760 printf (_("hardware\n"));
17763 printf ("??? (%d)\n", val
);
17769 return display_tag_value (tag
& 1, p
, end
);
17773 display_sparc_hwcaps (unsigned int mask
)
17779 if (mask
& ELF_SPARC_HWCAP_MUL32
)
17780 fputs ("mul32", stdout
), first
= false;
17781 if (mask
& ELF_SPARC_HWCAP_DIV32
)
17782 printf ("%sdiv32", first
? "" : "|"), first
= false;
17783 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
17784 printf ("%sfsmuld", first
? "" : "|"), first
= false;
17785 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
17786 printf ("%sv8plus", first
? "" : "|"), first
= false;
17787 if (mask
& ELF_SPARC_HWCAP_POPC
)
17788 printf ("%spopc", first
? "" : "|"), first
= false;
17789 if (mask
& ELF_SPARC_HWCAP_VIS
)
17790 printf ("%svis", first
? "" : "|"), first
= false;
17791 if (mask
& ELF_SPARC_HWCAP_VIS2
)
17792 printf ("%svis2", first
? "" : "|"), first
= false;
17793 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
17794 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
17795 if (mask
& ELF_SPARC_HWCAP_FMAF
)
17796 printf ("%sfmaf", first
? "" : "|"), first
= false;
17797 if (mask
& ELF_SPARC_HWCAP_VIS3
)
17798 printf ("%svis3", first
? "" : "|"), first
= false;
17799 if (mask
& ELF_SPARC_HWCAP_HPC
)
17800 printf ("%shpc", first
? "" : "|"), first
= false;
17801 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
17802 printf ("%srandom", first
? "" : "|"), first
= false;
17803 if (mask
& ELF_SPARC_HWCAP_TRANS
)
17804 printf ("%strans", first
? "" : "|"), first
= false;
17805 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
17806 printf ("%sfjfmau", first
? "" : "|"), first
= false;
17807 if (mask
& ELF_SPARC_HWCAP_IMA
)
17808 printf ("%sima", first
? "" : "|"), first
= false;
17809 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
17810 printf ("%scspare", first
? "" : "|"), first
= false;
17813 fputc ('0', stdout
);
17814 fputc ('\n', stdout
);
17818 display_sparc_hwcaps2 (unsigned int mask
)
17824 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
17825 fputs ("fjathplus", stdout
), first
= false;
17826 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
17827 printf ("%svis3b", first
? "" : "|"), first
= false;
17828 if (mask
& ELF_SPARC_HWCAP2_ADP
)
17829 printf ("%sadp", first
? "" : "|"), first
= false;
17830 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
17831 printf ("%ssparc5", first
? "" : "|"), first
= false;
17832 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
17833 printf ("%smwait", first
? "" : "|"), first
= false;
17834 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
17835 printf ("%sxmpmul", first
? "" : "|"), first
= false;
17836 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
17837 printf ("%sxmont2", first
? "" : "|"), first
= false;
17838 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
17839 printf ("%snsec", first
? "" : "|"), first
= false;
17840 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
17841 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
17842 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
17843 printf ("%sfjdes", first
? "" : "|"), first
= false;
17844 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
17845 printf ("%sfjaes", first
? "" : "|"), first
= false;
17848 fputc ('0', stdout
);
17849 fputc ('\n', stdout
);
17852 static unsigned char *
17853 display_sparc_gnu_attribute (unsigned char * p
,
17855 const unsigned char * const end
)
17859 if (tag
== Tag_GNU_Sparc_HWCAPS
)
17861 READ_ULEB (val
, p
, end
);
17862 printf (" Tag_GNU_Sparc_HWCAPS: ");
17863 display_sparc_hwcaps (val
);
17866 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
17868 READ_ULEB (val
, p
, end
);
17869 printf (" Tag_GNU_Sparc_HWCAPS2: ");
17870 display_sparc_hwcaps2 (val
);
17874 return display_tag_value (tag
, p
, end
);
17878 print_mips_fp_abi_value (unsigned int val
)
17882 case Val_GNU_MIPS_ABI_FP_ANY
:
17883 printf (_("Hard or soft float\n"));
17885 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
17886 printf (_("Hard float (double precision)\n"));
17888 case Val_GNU_MIPS_ABI_FP_SINGLE
:
17889 printf (_("Hard float (single precision)\n"));
17891 case Val_GNU_MIPS_ABI_FP_SOFT
:
17892 printf (_("Soft float\n"));
17894 case Val_GNU_MIPS_ABI_FP_OLD_64
:
17895 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
17897 case Val_GNU_MIPS_ABI_FP_XX
:
17898 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
17900 case Val_GNU_MIPS_ABI_FP_64
:
17901 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
17903 case Val_GNU_MIPS_ABI_FP_64A
:
17904 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
17906 case Val_GNU_MIPS_ABI_FP_NAN2008
:
17907 printf (_("NaN 2008 compatibility\n"));
17910 printf ("??? (%d)\n", val
);
17915 static unsigned char *
17916 display_mips_gnu_attribute (unsigned char * p
,
17918 const unsigned char * const end
)
17920 if (tag
== Tag_GNU_MIPS_ABI_FP
)
17924 printf (" Tag_GNU_MIPS_ABI_FP: ");
17925 READ_ULEB (val
, p
, end
);
17926 print_mips_fp_abi_value (val
);
17930 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
17934 printf (" Tag_GNU_MIPS_ABI_MSA: ");
17935 READ_ULEB (val
, p
, end
);
17939 case Val_GNU_MIPS_ABI_MSA_ANY
:
17940 printf (_("Any MSA or not\n"));
17942 case Val_GNU_MIPS_ABI_MSA_128
:
17943 printf (_("128-bit MSA\n"));
17946 printf ("??? (%d)\n", val
);
17952 return display_tag_value (tag
& 1, p
, end
);
17955 static unsigned char *
17956 display_tic6x_attribute (unsigned char * p
,
17957 const unsigned char * const end
)
17962 READ_ULEB (tag
, p
, end
);
17967 printf (" Tag_ISA: ");
17968 READ_ULEB (val
, p
, end
);
17972 case C6XABI_Tag_ISA_none
:
17973 printf (_("None\n"));
17975 case C6XABI_Tag_ISA_C62X
:
17978 case C6XABI_Tag_ISA_C67X
:
17981 case C6XABI_Tag_ISA_C67XP
:
17982 printf ("C67x+\n");
17984 case C6XABI_Tag_ISA_C64X
:
17987 case C6XABI_Tag_ISA_C64XP
:
17988 printf ("C64x+\n");
17990 case C6XABI_Tag_ISA_C674X
:
17991 printf ("C674x\n");
17994 printf ("??? (%d)\n", val
);
17999 case Tag_ABI_wchar_t
:
18000 printf (" Tag_ABI_wchar_t: ");
18001 READ_ULEB (val
, p
, end
);
18005 printf (_("Not used\n"));
18008 printf (_("2 bytes\n"));
18011 printf (_("4 bytes\n"));
18014 printf ("??? (%d)\n", val
);
18019 case Tag_ABI_stack_align_needed
:
18020 printf (" Tag_ABI_stack_align_needed: ");
18021 READ_ULEB (val
, p
, end
);
18025 printf (_("8-byte\n"));
18028 printf (_("16-byte\n"));
18031 printf ("??? (%d)\n", val
);
18036 case Tag_ABI_stack_align_preserved
:
18037 READ_ULEB (val
, p
, end
);
18038 printf (" Tag_ABI_stack_align_preserved: ");
18042 printf (_("8-byte\n"));
18045 printf (_("16-byte\n"));
18048 printf ("??? (%d)\n", val
);
18054 READ_ULEB (val
, p
, end
);
18055 printf (" Tag_ABI_DSBT: ");
18059 printf (_("DSBT addressing not used\n"));
18062 printf (_("DSBT addressing used\n"));
18065 printf ("??? (%d)\n", val
);
18071 READ_ULEB (val
, p
, end
);
18072 printf (" Tag_ABI_PID: ");
18076 printf (_("Data addressing position-dependent\n"));
18079 printf (_("Data addressing position-independent, GOT near DP\n"));
18082 printf (_("Data addressing position-independent, GOT far from DP\n"));
18085 printf ("??? (%d)\n", val
);
18091 READ_ULEB (val
, p
, end
);
18092 printf (" Tag_ABI_PIC: ");
18096 printf (_("Code addressing position-dependent\n"));
18099 printf (_("Code addressing position-independent\n"));
18102 printf ("??? (%d)\n", val
);
18107 case Tag_ABI_array_object_alignment
:
18108 READ_ULEB (val
, p
, end
);
18109 printf (" Tag_ABI_array_object_alignment: ");
18113 printf (_("8-byte\n"));
18116 printf (_("4-byte\n"));
18119 printf (_("16-byte\n"));
18122 printf ("??? (%d)\n", val
);
18127 case Tag_ABI_array_object_align_expected
:
18128 READ_ULEB (val
, p
, end
);
18129 printf (" Tag_ABI_array_object_align_expected: ");
18133 printf (_("8-byte\n"));
18136 printf (_("4-byte\n"));
18139 printf (_("16-byte\n"));
18142 printf ("??? (%d)\n", val
);
18147 case Tag_ABI_compatibility
:
18149 READ_ULEB (val
, p
, end
);
18150 printf (" Tag_ABI_compatibility: ");
18151 printf (_("flag = %d, vendor = "), val
);
18154 size_t maxlen
= (end
- p
) - 1;
18156 print_symbol ((int) maxlen
, (const char *) p
);
18157 p
+= strnlen ((char *) p
, maxlen
) + 1;
18161 printf (_("<corrupt>"));
18162 p
= (unsigned char *) end
;
18168 case Tag_ABI_conformance
:
18170 printf (" Tag_ABI_conformance: \"");
18173 size_t maxlen
= (end
- p
) - 1;
18175 print_symbol ((int) maxlen
, (const char *) p
);
18176 p
+= strnlen ((char *) p
, maxlen
) + 1;
18180 printf (_("<corrupt>"));
18181 p
= (unsigned char *) end
;
18188 return display_tag_value (tag
, p
, end
);
18192 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
18195 size_t bytes
= end
- p
;
18202 int lbytes
= (bytes
> 16 ? 16 : bytes
);
18204 printf (" 0x%8.8" PRIx64
" ", addr
);
18206 for (j
= 0; j
< 16; j
++)
18209 printf ("%2.2x", p
[j
]);
18217 for (j
= 0; j
< lbytes
; j
++)
18220 if (k
>= ' ' && k
< 0x7f)
18236 static unsigned char *
18237 display_msp430_attribute (unsigned char * p
,
18238 const unsigned char * const end
)
18243 READ_ULEB (tag
, p
, end
);
18247 case OFBA_MSPABI_Tag_ISA
:
18248 printf (" Tag_ISA: ");
18249 READ_ULEB (val
, p
, end
);
18252 case 0: printf (_("None\n")); break;
18253 case 1: printf (_("MSP430\n")); break;
18254 case 2: printf (_("MSP430X\n")); break;
18255 default: printf ("??? (%" PRId64
")\n", val
); break;
18259 case OFBA_MSPABI_Tag_Code_Model
:
18260 printf (" Tag_Code_Model: ");
18261 READ_ULEB (val
, p
, end
);
18264 case 0: printf (_("None\n")); break;
18265 case 1: printf (_("Small\n")); break;
18266 case 2: printf (_("Large\n")); break;
18267 default: printf ("??? (%" PRId64
")\n", val
); break;
18271 case OFBA_MSPABI_Tag_Data_Model
:
18272 printf (" Tag_Data_Model: ");
18273 READ_ULEB (val
, p
, end
);
18276 case 0: printf (_("None\n")); break;
18277 case 1: printf (_("Small\n")); break;
18278 case 2: printf (_("Large\n")); break;
18279 case 3: printf (_("Restricted Large\n")); break;
18280 default: printf ("??? (%" PRId64
")\n", val
); break;
18285 printf (_(" <unknown tag %" PRId64
">: "), tag
);
18292 size_t maxlen
= (end
- p
) - 1;
18294 print_symbol ((int) maxlen
, (const char *) p
);
18295 p
+= strnlen ((char *) p
, maxlen
) + 1;
18299 printf (_("<corrupt>"));
18300 p
= (unsigned char *) end
;
18306 READ_ULEB (val
, p
, end
);
18307 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
18316 static unsigned char *
18317 display_msp430_gnu_attribute (unsigned char * p
,
18319 const unsigned char * const end
)
18321 if (tag
== Tag_GNU_MSP430_Data_Region
)
18325 printf (" Tag_GNU_MSP430_Data_Region: ");
18326 READ_ULEB (val
, p
, end
);
18330 case Val_GNU_MSP430_Data_Region_Any
:
18331 printf (_("Any Region\n"));
18333 case Val_GNU_MSP430_Data_Region_Lower
:
18334 printf (_("Lower Region Only\n"));
18337 printf ("??? (%" PRIu64
")\n", val
);
18341 return display_tag_value (tag
& 1, p
, end
);
18344 struct riscv_attr_tag_t
{
18349 static struct riscv_attr_tag_t riscv_attr_tag
[] =
18351 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
18354 T(priv_spec_minor
),
18355 T(priv_spec_revision
),
18356 T(unaligned_access
),
18361 static unsigned char *
18362 display_riscv_attribute (unsigned char *p
,
18363 const unsigned char * const end
)
18367 struct riscv_attr_tag_t
*attr
= NULL
;
18370 READ_ULEB (tag
, p
, end
);
18372 /* Find the name of attribute. */
18373 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
18375 if (riscv_attr_tag
[i
].tag
== tag
)
18377 attr
= &riscv_attr_tag
[i
];
18383 printf (" %s: ", attr
->name
);
18385 return display_tag_value (tag
, p
, end
);
18389 case Tag_RISCV_priv_spec
:
18390 case Tag_RISCV_priv_spec_minor
:
18391 case Tag_RISCV_priv_spec_revision
:
18392 READ_ULEB (val
, p
, end
);
18393 printf ("%" PRIu64
"\n", val
);
18395 case Tag_RISCV_unaligned_access
:
18396 READ_ULEB (val
, p
, end
);
18400 printf (_("No unaligned access\n"));
18403 printf (_("Unaligned access\n"));
18407 case Tag_RISCV_stack_align
:
18408 READ_ULEB (val
, p
, end
);
18409 printf (_("%" PRIu64
"-bytes\n"), val
);
18411 case Tag_RISCV_arch
:
18412 p
= display_tag_value (-1, p
, end
);
18415 return display_tag_value (tag
, p
, end
);
18421 static unsigned char *
18422 display_csky_attribute (unsigned char * p
,
18423 const unsigned char * const end
)
18427 READ_ULEB (tag
, p
, end
);
18429 if (tag
>= Tag_CSKY_MAX
)
18431 return display_tag_value (-1, p
, end
);
18436 case Tag_CSKY_ARCH_NAME
:
18437 printf (" Tag_CSKY_ARCH_NAME:\t\t");
18438 return display_tag_value (-1, p
, end
);
18439 case Tag_CSKY_CPU_NAME
:
18440 printf (" Tag_CSKY_CPU_NAME:\t\t");
18441 return display_tag_value (-1, p
, end
);
18443 case Tag_CSKY_ISA_FLAGS
:
18444 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
18445 return display_tag_value (0, p
, end
);
18446 case Tag_CSKY_ISA_EXT_FLAGS
:
18447 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
18448 return display_tag_value (0, p
, end
);
18450 case Tag_CSKY_DSP_VERSION
:
18451 printf (" Tag_CSKY_DSP_VERSION:\t\t");
18452 READ_ULEB (val
, p
, end
);
18453 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
18454 printf ("DSP Extension\n");
18455 else if (val
== VAL_CSKY_DSP_VERSION_2
)
18456 printf ("DSP 2.0\n");
18459 case Tag_CSKY_VDSP_VERSION
:
18460 printf (" Tag_CSKY_VDSP_VERSION:\t");
18461 READ_ULEB (val
, p
, end
);
18462 printf ("VDSP Version %" PRId64
"\n", val
);
18465 case Tag_CSKY_FPU_VERSION
:
18466 printf (" Tag_CSKY_FPU_VERSION:\t\t");
18467 READ_ULEB (val
, p
, end
);
18468 if (val
== VAL_CSKY_FPU_VERSION_1
)
18469 printf ("ABIV1 FPU Version 1\n");
18470 else if (val
== VAL_CSKY_FPU_VERSION_2
)
18471 printf ("FPU Version 2\n");
18474 case Tag_CSKY_FPU_ABI
:
18475 printf (" Tag_CSKY_FPU_ABI:\t\t");
18476 READ_ULEB (val
, p
, end
);
18477 if (val
== VAL_CSKY_FPU_ABI_HARD
)
18479 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
18480 printf ("SoftFP\n");
18481 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
18484 case Tag_CSKY_FPU_ROUNDING
:
18485 READ_ULEB (val
, p
, end
);
18488 printf (" Tag_CSKY_FPU_ROUNDING:\t");
18489 printf ("Needed\n");
18492 case Tag_CSKY_FPU_DENORMAL
:
18493 READ_ULEB (val
, p
, end
);
18496 printf (" Tag_CSKY_FPU_DENORMAL:\t");
18497 printf ("Needed\n");
18500 case Tag_CSKY_FPU_Exception
:
18501 READ_ULEB (val
, p
, end
);
18504 printf (" Tag_CSKY_FPU_Exception:\t");
18505 printf ("Needed\n");
18508 case Tag_CSKY_FPU_NUMBER_MODULE
:
18509 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
18510 return display_tag_value (-1, p
, end
);
18511 case Tag_CSKY_FPU_HARDFP
:
18512 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
18513 READ_ULEB (val
, p
, end
);
18514 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
18516 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
18517 printf (" Single");
18518 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
18519 printf (" Double");
18523 return display_tag_value (tag
, p
, end
);
18529 process_attributes (Filedata
* filedata
,
18530 const char * public_name
,
18531 unsigned int proc_type
,
18532 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
18533 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
18535 Elf_Internal_Shdr
* sect
;
18539 /* Find the section header so that we get the size. */
18540 for (i
= 0, sect
= filedata
->section_headers
;
18541 i
< filedata
->file_header
.e_shnum
;
18544 unsigned char * contents
;
18547 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
18550 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18551 sect
->sh_size
, _("attributes"));
18552 if (contents
== NULL
)
18559 /* The first character is the version of the attributes.
18560 Currently only version 1, (aka 'A') is recognised here. */
18563 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
18568 uint64_t section_len
;
18570 section_len
= sect
->sh_size
- 1;
18573 while (section_len
> 0)
18576 unsigned int namelen
;
18577 bool public_section
;
18580 if (section_len
<= 4)
18582 error (_("Tag section ends prematurely\n"));
18586 attr_len
= byte_get (p
, 4);
18589 if (attr_len
> section_len
)
18591 error (_("Bad attribute length (%u > %u)\n"),
18592 (unsigned) attr_len
, (unsigned) section_len
);
18593 attr_len
= section_len
;
18596 /* PR 17531: file: 001-101425-0.004 */
18597 else if (attr_len
< 5)
18599 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
18604 section_len
-= attr_len
;
18607 namelen
= strnlen ((char *) p
, attr_len
) + 1;
18608 if (namelen
== 0 || namelen
>= attr_len
)
18610 error (_("Corrupt attribute section name\n"));
18615 printf (_("Attribute Section: "));
18616 print_symbol (INT_MAX
, (const char *) p
);
18619 if (public_name
&& streq ((char *) p
, public_name
))
18620 public_section
= true;
18622 public_section
= false;
18624 if (streq ((char *) p
, "gnu"))
18625 gnu_section
= true;
18627 gnu_section
= false;
18630 attr_len
-= namelen
;
18632 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
18637 unsigned char * end
;
18639 /* PR binutils/17531: Safe handling of corrupt files. */
18642 error (_("Unused bytes at end of section\n"));
18649 size
= byte_get (p
, 4);
18650 if (size
> attr_len
)
18652 error (_("Bad subsection length (%u > %u)\n"),
18653 (unsigned) size
, (unsigned) attr_len
);
18657 /* PR binutils/17531: Safe handling of corrupt files. */
18660 error (_("Bad subsection length (%u < 6)\n"),
18668 end
= p
+ size
- 1;
18669 assert (end
<= contents
+ sect
->sh_size
);
18675 printf (_("File Attributes\n"));
18678 printf (_("Section Attributes:"));
18681 printf (_("Symbol Attributes:"));
18682 /* Fall through. */
18686 READ_ULEB (val
, p
, end
);
18689 printf (" %d", val
);
18694 printf (_("Unknown tag: %d\n"), tag
);
18695 public_section
= false;
18699 if (public_section
&& display_pub_attribute
!= NULL
)
18702 p
= display_pub_attribute (p
, end
);
18705 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
18708 p
= display_gnu_attribute (p
,
18709 display_proc_gnu_attribute
,
18715 printf (_(" Unknown attribute:\n"));
18716 display_raw_attribute (p
, end
);
18731 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
18732 Print the Address, Access and Initial fields of an entry at VMA ADDR
18733 and return the VMA of the next entry, or -1 if there was a problem.
18734 Does not read from DATA_END or beyond. */
18737 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
18738 unsigned char * data_end
)
18741 print_vma (addr
, LONG_HEX
);
18743 if (addr
< pltgot
+ 0xfff0)
18744 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
18746 printf ("%10s", "");
18749 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18753 unsigned char * from
= data
+ addr
- pltgot
;
18755 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
18757 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
18758 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
18759 return (uint64_t) -1;
18763 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18764 print_vma (entry
, LONG_HEX
);
18767 return addr
+ (is_32bit_elf
? 4 : 8);
18770 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
18771 PLTGOT. Print the Address and Initial fields of an entry at VMA
18772 ADDR and return the VMA of the next entry. */
18775 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
18778 print_vma (addr
, LONG_HEX
);
18781 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18786 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18787 print_vma (entry
, LONG_HEX
);
18789 return addr
+ (is_32bit_elf
? 4 : 8);
18793 print_mips_ases (unsigned int mask
)
18795 if (mask
& AFL_ASE_DSP
)
18796 fputs ("\n\tDSP ASE", stdout
);
18797 if (mask
& AFL_ASE_DSPR2
)
18798 fputs ("\n\tDSP R2 ASE", stdout
);
18799 if (mask
& AFL_ASE_DSPR3
)
18800 fputs ("\n\tDSP R3 ASE", stdout
);
18801 if (mask
& AFL_ASE_EVA
)
18802 fputs ("\n\tEnhanced VA Scheme", stdout
);
18803 if (mask
& AFL_ASE_MCU
)
18804 fputs ("\n\tMCU (MicroController) ASE", stdout
);
18805 if (mask
& AFL_ASE_MDMX
)
18806 fputs ("\n\tMDMX ASE", stdout
);
18807 if (mask
& AFL_ASE_MIPS3D
)
18808 fputs ("\n\tMIPS-3D ASE", stdout
);
18809 if (mask
& AFL_ASE_MT
)
18810 fputs ("\n\tMT ASE", stdout
);
18811 if (mask
& AFL_ASE_SMARTMIPS
)
18812 fputs ("\n\tSmartMIPS ASE", stdout
);
18813 if (mask
& AFL_ASE_VIRT
)
18814 fputs ("\n\tVZ ASE", stdout
);
18815 if (mask
& AFL_ASE_MSA
)
18816 fputs ("\n\tMSA ASE", stdout
);
18817 if (mask
& AFL_ASE_MIPS16
)
18818 fputs ("\n\tMIPS16 ASE", stdout
);
18819 if (mask
& AFL_ASE_MICROMIPS
)
18820 fputs ("\n\tMICROMIPS ASE", stdout
);
18821 if (mask
& AFL_ASE_XPA
)
18822 fputs ("\n\tXPA ASE", stdout
);
18823 if (mask
& AFL_ASE_MIPS16E2
)
18824 fputs ("\n\tMIPS16e2 ASE", stdout
);
18825 if (mask
& AFL_ASE_CRC
)
18826 fputs ("\n\tCRC ASE", stdout
);
18827 if (mask
& AFL_ASE_GINV
)
18828 fputs ("\n\tGINV ASE", stdout
);
18829 if (mask
& AFL_ASE_LOONGSON_MMI
)
18830 fputs ("\n\tLoongson MMI ASE", stdout
);
18831 if (mask
& AFL_ASE_LOONGSON_CAM
)
18832 fputs ("\n\tLoongson CAM ASE", stdout
);
18833 if (mask
& AFL_ASE_LOONGSON_EXT
)
18834 fputs ("\n\tLoongson EXT ASE", stdout
);
18835 if (mask
& AFL_ASE_LOONGSON_EXT2
)
18836 fputs ("\n\tLoongson EXT2 ASE", stdout
);
18838 fprintf (stdout
, "\n\t%s", _("None"));
18839 else if ((mask
& ~AFL_ASE_MASK
) != 0)
18840 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
18844 print_mips_isa_ext (unsigned int isa_ext
)
18849 fputs (_("None"), stdout
);
18852 fputs ("RMI XLR", stdout
);
18854 case AFL_EXT_OCTEON3
:
18855 fputs ("Cavium Networks Octeon3", stdout
);
18857 case AFL_EXT_OCTEON2
:
18858 fputs ("Cavium Networks Octeon2", stdout
);
18860 case AFL_EXT_OCTEONP
:
18861 fputs ("Cavium Networks OcteonP", stdout
);
18863 case AFL_EXT_OCTEON
:
18864 fputs ("Cavium Networks Octeon", stdout
);
18867 fputs ("Toshiba R5900", stdout
);
18870 fputs ("MIPS R4650", stdout
);
18873 fputs ("LSI R4010", stdout
);
18876 fputs ("NEC VR4100", stdout
);
18879 fputs ("Toshiba R3900", stdout
);
18881 case AFL_EXT_10000
:
18882 fputs ("MIPS R10000", stdout
);
18885 fputs ("Broadcom SB-1", stdout
);
18888 fputs ("NEC VR4111/VR4181", stdout
);
18891 fputs ("NEC VR4120", stdout
);
18894 fputs ("NEC VR5400", stdout
);
18897 fputs ("NEC VR5500", stdout
);
18899 case AFL_EXT_LOONGSON_2E
:
18900 fputs ("ST Microelectronics Loongson 2E", stdout
);
18902 case AFL_EXT_LOONGSON_2F
:
18903 fputs ("ST Microelectronics Loongson 2F", stdout
);
18905 case AFL_EXT_INTERAPTIV_MR2
:
18906 fputs ("Imagination interAptiv MR2", stdout
);
18909 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
18914 get_mips_reg_size (int reg_size
)
18916 return (reg_size
== AFL_REG_NONE
) ? 0
18917 : (reg_size
== AFL_REG_32
) ? 32
18918 : (reg_size
== AFL_REG_64
) ? 64
18919 : (reg_size
== AFL_REG_128
) ? 128
18924 process_mips_specific (Filedata
* filedata
)
18926 Elf_Internal_Dyn
* entry
;
18927 Elf_Internal_Shdr
*sect
= NULL
;
18928 size_t liblist_offset
= 0;
18929 size_t liblistno
= 0;
18930 size_t conflictsno
= 0;
18931 size_t options_offset
= 0;
18932 size_t conflicts_offset
= 0;
18933 size_t pltrelsz
= 0;
18935 uint64_t pltgot
= 0;
18936 uint64_t mips_pltgot
= 0;
18937 uint64_t jmprel
= 0;
18938 uint64_t local_gotno
= 0;
18939 uint64_t gotsym
= 0;
18940 uint64_t symtabno
= 0;
18943 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18944 display_mips_gnu_attribute
))
18947 sect
= find_section (filedata
, ".MIPS.abiflags");
18951 Elf_External_ABIFlags_v0
*abiflags_ext
;
18952 Elf_Internal_ABIFlags_v0 abiflags_in
;
18954 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
18956 error (_("Corrupt MIPS ABI Flags section.\n"));
18961 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18962 sect
->sh_size
, _("MIPS ABI Flags section"));
18965 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
18966 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
18967 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
18968 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
18969 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
18970 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
18971 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
18972 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
18973 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
18974 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
18975 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
18977 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
18978 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
18979 if (abiflags_in
.isa_rev
> 1)
18980 printf ("r%d", abiflags_in
.isa_rev
);
18981 printf ("\nGPR size: %d",
18982 get_mips_reg_size (abiflags_in
.gpr_size
));
18983 printf ("\nCPR1 size: %d",
18984 get_mips_reg_size (abiflags_in
.cpr1_size
));
18985 printf ("\nCPR2 size: %d",
18986 get_mips_reg_size (abiflags_in
.cpr2_size
));
18987 fputs ("\nFP ABI: ", stdout
);
18988 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
18989 fputs ("ISA Extension: ", stdout
);
18990 print_mips_isa_ext (abiflags_in
.isa_ext
);
18991 fputs ("\nASEs:", stdout
);
18992 print_mips_ases (abiflags_in
.ases
);
18993 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
18994 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
18995 fputc ('\n', stdout
);
18996 free (abiflags_ext
);
19001 /* We have a lot of special sections. Thanks SGI! */
19002 if (filedata
->dynamic_section
== NULL
)
19004 /* No dynamic information available. See if there is static GOT. */
19005 sect
= find_section (filedata
, ".got");
19008 unsigned char *data_end
;
19009 unsigned char *data
;
19013 pltgot
= sect
->sh_addr
;
19016 addr_size
= (is_32bit_elf
? 4 : 8);
19017 end
= pltgot
+ sect
->sh_size
;
19019 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
19021 _("Global Offset Table data"));
19022 /* PR 12855: Null data is handled gracefully throughout. */
19023 data_end
= data
+ (end
- pltgot
);
19025 printf (_("\nStatic GOT:\n"));
19026 printf (_(" Canonical gp value: "));
19027 print_vma (ent
+ 0x7ff0, LONG_HEX
);
19030 /* In a dynamic binary GOT[0] is reserved for the dynamic
19031 loader to store the lazy resolver pointer, however in
19032 a static binary it may well have been omitted and GOT
19033 reduced to a table of addresses.
19034 PR 21344: Check for the entry being fully available
19035 before fetching it. */
19037 && data
+ ent
- pltgot
+ addr_size
<= data_end
19038 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
19040 printf (_(" Reserved entries:\n"));
19041 printf (_(" %*s %10s %*s\n"),
19042 addr_size
* 2, _("Address"), _("Access"),
19043 addr_size
* 2, _("Value"));
19044 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19046 if (ent
== (uint64_t) -1)
19047 goto sgot_print_fail
;
19049 /* Check for the MSB of GOT[1] being set, identifying a
19050 GNU object. This entry will be used by some runtime
19051 loaders, to store the module pointer. Otherwise this
19052 is an ordinary local entry.
19053 PR 21344: Check for the entry being fully available
19054 before fetching it. */
19056 && data
+ ent
- pltgot
+ addr_size
<= data_end
19057 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19058 >> (addr_size
* 8 - 1)) != 0)
19060 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19062 if (ent
== (uint64_t) -1)
19063 goto sgot_print_fail
;
19068 if (data
!= NULL
&& ent
< end
)
19070 printf (_(" Local entries:\n"));
19071 printf (" %*s %10s %*s\n",
19072 addr_size
* 2, _("Address"), _("Access"),
19073 addr_size
* 2, _("Value"));
19076 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19078 if (ent
== (uint64_t) -1)
19079 goto sgot_print_fail
;
19090 for (entry
= filedata
->dynamic_section
;
19091 /* PR 17531 file: 012-50589-0.004. */
19092 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
19093 && entry
->d_tag
!= DT_NULL
);
19095 switch (entry
->d_tag
)
19097 case DT_MIPS_LIBLIST
:
19099 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
19100 liblistno
* sizeof (Elf32_External_Lib
));
19102 case DT_MIPS_LIBLISTNO
:
19103 liblistno
= entry
->d_un
.d_val
;
19105 case DT_MIPS_OPTIONS
:
19106 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
19108 case DT_MIPS_CONFLICT
:
19110 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
19111 conflictsno
* sizeof (Elf32_External_Conflict
));
19113 case DT_MIPS_CONFLICTNO
:
19114 conflictsno
= entry
->d_un
.d_val
;
19117 pltgot
= entry
->d_un
.d_ptr
;
19119 case DT_MIPS_LOCAL_GOTNO
:
19120 local_gotno
= entry
->d_un
.d_val
;
19122 case DT_MIPS_GOTSYM
:
19123 gotsym
= entry
->d_un
.d_val
;
19125 case DT_MIPS_SYMTABNO
:
19126 symtabno
= entry
->d_un
.d_val
;
19128 case DT_MIPS_PLTGOT
:
19129 mips_pltgot
= entry
->d_un
.d_ptr
;
19132 pltrel
= entry
->d_un
.d_val
;
19135 pltrelsz
= entry
->d_un
.d_val
;
19138 jmprel
= entry
->d_un
.d_ptr
;
19144 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
19146 Elf32_External_Lib
* elib
;
19149 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
19150 sizeof (Elf32_External_Lib
),
19152 _("liblist section data"));
19155 printf (ngettext ("\nSection '.liblist' contains %zu entry:\n",
19156 "\nSection '.liblist' contains %zu entries:\n",
19159 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
19162 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
19169 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19170 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19171 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19172 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19173 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19175 tmp
= gmtime (&atime
);
19176 snprintf (timebuf
, sizeof (timebuf
),
19177 "%04u-%02u-%02uT%02u:%02u:%02u",
19178 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19179 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19181 printf ("%3zu: ", cnt
);
19182 if (valid_dynamic_name (filedata
, liblist
.l_name
))
19183 print_symbol (20, get_dynamic_name (filedata
, liblist
.l_name
));
19185 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
19186 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
19187 liblist
.l_version
);
19189 if (liblist
.l_flags
== 0)
19193 static const struct
19200 { " EXACT_MATCH", LL_EXACT_MATCH
},
19201 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
19202 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
19203 { " EXPORTS", LL_EXPORTS
},
19204 { " DELAY_LOAD", LL_DELAY_LOAD
},
19205 { " DELTA", LL_DELTA
}
19207 int flags
= liblist
.l_flags
;
19210 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
19211 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
19213 fputs (l_flags_vals
[fcnt
].name
, stdout
);
19214 flags
^= l_flags_vals
[fcnt
].bit
;
19217 printf (" %#x", (unsigned int) flags
);
19229 if (options_offset
!= 0)
19231 Elf_External_Options
* eopt
;
19235 /* Find the section header so that we get the size. */
19236 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
19237 /* PR 17533 file: 012-277276-0.004. */
19240 error (_("No MIPS_OPTIONS header found\n"));
19244 if (sect
->sh_size
< sizeof (* eopt
))
19246 error (_("The MIPS options section is too small.\n"));
19250 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
19251 sect
->sh_size
, _("options"));
19254 Elf_Internal_Options option
;
19257 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
19259 Elf_External_Options
* eoption
;
19260 unsigned int optsize
;
19262 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
19264 optsize
= BYTE_GET (eoption
->size
);
19266 /* PR 17531: file: ffa0fa3b. */
19267 if (optsize
< sizeof (* eopt
)
19268 || optsize
> sect
->sh_size
- offset
)
19270 error (_("Invalid size (%u) for MIPS option\n"),
19279 printf (ngettext ("\nSection '%s' contains %d entry:\n",
19280 "\nSection '%s' contains %d entries:\n",
19282 printable_section_name (filedata
, sect
), cnt
);
19288 Elf_External_Options
* eoption
;
19290 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
19292 option
.kind
= BYTE_GET (eoption
->kind
);
19293 option
.size
= BYTE_GET (eoption
->size
);
19294 option
.section
= BYTE_GET (eoption
->section
);
19295 option
.info
= BYTE_GET (eoption
->info
);
19297 switch (option
.kind
)
19300 /* This shouldn't happen. */
19301 printf (" NULL %" PRId16
" %" PRIx32
,
19302 option
.section
, option
.info
);
19306 printf (" REGINFO ");
19307 if (filedata
->file_header
.e_machine
== EM_MIPS
)
19309 Elf32_External_RegInfo
* ereg
;
19310 Elf32_RegInfo reginfo
;
19313 if (option
.size
< (sizeof (Elf_External_Options
)
19314 + sizeof (Elf32_External_RegInfo
)))
19316 printf (_("<corrupt>\n"));
19317 error (_("Truncated MIPS REGINFO option\n"));
19322 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
19324 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19325 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19326 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19327 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19328 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19329 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19331 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
19332 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19334 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19335 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19336 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19337 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19342 Elf64_External_RegInfo
* ereg
;
19343 Elf64_Internal_RegInfo reginfo
;
19345 if (option
.size
< (sizeof (Elf_External_Options
)
19346 + sizeof (Elf64_External_RegInfo
)))
19348 printf (_("<corrupt>\n"));
19349 error (_("Truncated MIPS REGINFO option\n"));
19354 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
19355 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19356 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19357 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19358 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19359 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19360 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19362 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
19363 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19365 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19366 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19367 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19368 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19370 offset
+= option
.size
;
19373 case ODK_EXCEPTIONS
:
19374 fputs (" EXCEPTIONS fpe_min(", stdout
);
19375 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
19376 fputs (") fpe_max(", stdout
);
19377 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
19378 fputs (")", stdout
);
19380 if (option
.info
& OEX_PAGE0
)
19381 fputs (" PAGE0", stdout
);
19382 if (option
.info
& OEX_SMM
)
19383 fputs (" SMM", stdout
);
19384 if (option
.info
& OEX_FPDBUG
)
19385 fputs (" FPDBUG", stdout
);
19386 if (option
.info
& OEX_DISMISS
)
19387 fputs (" DISMISS", stdout
);
19391 fputs (" PAD ", stdout
);
19392 if (option
.info
& OPAD_PREFIX
)
19393 fputs (" PREFIX", stdout
);
19394 if (option
.info
& OPAD_POSTFIX
)
19395 fputs (" POSTFIX", stdout
);
19396 if (option
.info
& OPAD_SYMBOL
)
19397 fputs (" SYMBOL", stdout
);
19401 fputs (" HWPATCH ", stdout
);
19402 if (option
.info
& OHW_R4KEOP
)
19403 fputs (" R4KEOP", stdout
);
19404 if (option
.info
& OHW_R8KPFETCH
)
19405 fputs (" R8KPFETCH", stdout
);
19406 if (option
.info
& OHW_R5KEOP
)
19407 fputs (" R5KEOP", stdout
);
19408 if (option
.info
& OHW_R5KCVTL
)
19409 fputs (" R5KCVTL", stdout
);
19413 fputs (" FILL ", stdout
);
19414 /* XXX Print content of info word? */
19418 fputs (" TAGS ", stdout
);
19419 /* XXX Print content of info word? */
19423 fputs (" HWAND ", stdout
);
19424 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19425 fputs (" R4KEOP_CHECKED", stdout
);
19426 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19427 fputs (" R4KEOP_CLEAN", stdout
);
19431 fputs (" HWOR ", stdout
);
19432 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19433 fputs (" R4KEOP_CHECKED", stdout
);
19434 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19435 fputs (" R4KEOP_CLEAN", stdout
);
19439 printf (" GP_GROUP %#06x self-contained %#06x",
19440 option
.info
& OGP_GROUP
,
19441 (option
.info
& OGP_SELF
) >> 16);
19445 printf (" IDENT %#06x self-contained %#06x",
19446 option
.info
& OGP_GROUP
,
19447 (option
.info
& OGP_SELF
) >> 16);
19451 /* This shouldn't happen. */
19452 printf (" %3d ??? %" PRId16
" %" PRIx32
,
19453 option
.kind
, option
.section
, option
.info
);
19457 len
= sizeof (* eopt
);
19458 while (len
< option
.size
)
19460 unsigned char datum
= *((unsigned char *) eoption
+ len
);
19462 if (ISPRINT (datum
))
19463 printf ("%c", datum
);
19465 printf ("\\%03o", datum
);
19468 fputs ("\n", stdout
);
19470 offset
+= option
.size
;
19478 if (conflicts_offset
!= 0 && conflictsno
!= 0)
19480 Elf32_Conflict
* iconf
;
19483 if (filedata
->dynamic_symbols
== NULL
)
19485 error (_("conflict list found without a dynamic symbol table\n"));
19489 /* PR 21345 - print a slightly more helpful error message
19490 if we are sure that the cmalloc will fail. */
19491 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
19493 error (_("Overlarge number of conflicts detected: %zx\n"),
19498 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
19501 error (_("Out of memory allocating space for dynamic conflicts\n"));
19507 Elf32_External_Conflict
* econf32
;
19509 econf32
= (Elf32_External_Conflict
*)
19510 get_data (NULL
, filedata
, conflicts_offset
,
19511 sizeof (*econf32
), conflictsno
, _("conflict"));
19518 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19519 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
19525 Elf64_External_Conflict
* econf64
;
19527 econf64
= (Elf64_External_Conflict
*)
19528 get_data (NULL
, filedata
, conflicts_offset
,
19529 sizeof (*econf64
), conflictsno
, _("conflict"));
19536 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19537 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
19542 printf (ngettext ("\nSection '.conflict' contains %zu entry:\n",
19543 "\nSection '.conflict' contains %zu entries:\n",
19546 puts (_(" Num: Index Value Name"));
19548 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19550 printf ("%5zu: %8lu ", cnt
, iconf
[cnt
]);
19552 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
19553 printf (_("<corrupt symbol index>"));
19556 Elf_Internal_Sym
* psym
;
19558 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
19559 print_vma (psym
->st_value
, FULL_HEX
);
19561 if (valid_dynamic_name (filedata
, psym
->st_name
))
19562 print_symbol (25, get_dynamic_name (filedata
, psym
->st_name
));
19564 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19572 if (pltgot
!= 0 && local_gotno
!= 0)
19574 uint64_t ent
, local_end
, global_end
;
19576 unsigned char * data
;
19577 unsigned char * data_end
;
19581 addr_size
= (is_32bit_elf
? 4 : 8);
19582 local_end
= pltgot
+ local_gotno
* addr_size
;
19584 /* PR binutils/17533 file: 012-111227-0.004 */
19585 if (symtabno
< gotsym
)
19587 error (_("The GOT symbol offset (%" PRIu64
19588 ") is greater than the symbol table size (%" PRIu64
")\n"),
19593 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
19594 /* PR 17531: file: 54c91a34. */
19595 if (global_end
< local_end
)
19597 error (_("Too many GOT symbols: %" PRIu64
"\n"), symtabno
);
19601 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
19602 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
19603 global_end
- pltgot
, 1,
19604 _("Global Offset Table data"));
19605 /* PR 12855: Null data is handled gracefully throughout. */
19606 data_end
= data
+ (global_end
- pltgot
);
19608 printf (_("\nPrimary GOT:\n"));
19609 printf (_(" Canonical gp value: "));
19610 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
19613 printf (_(" Reserved entries:\n"));
19614 printf (_(" %*s %10s %*s Purpose\n"),
19615 addr_size
* 2, _("Address"), _("Access"),
19616 addr_size
* 2, _("Initial"));
19617 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19618 printf (_(" Lazy resolver\n"));
19619 if (ent
== (uint64_t) -1)
19620 goto got_print_fail
;
19622 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
19623 This entry will be used by some runtime loaders, to store the
19624 module pointer. Otherwise this is an ordinary local entry.
19625 PR 21344: Check for the entry being fully available before
19628 && data
+ ent
- pltgot
+ addr_size
<= data_end
19629 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19630 >> (addr_size
* 8 - 1)) != 0)
19632 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19633 printf (_(" Module pointer (GNU extension)\n"));
19634 if (ent
== (uint64_t) -1)
19635 goto got_print_fail
;
19639 if (data
!= NULL
&& ent
< local_end
)
19641 printf (_(" Local entries:\n"));
19642 printf (" %*s %10s %*s\n",
19643 addr_size
* 2, _("Address"), _("Access"),
19644 addr_size
* 2, _("Initial"));
19645 while (ent
< local_end
)
19647 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19649 if (ent
== (uint64_t) -1)
19650 goto got_print_fail
;
19655 if (data
!= NULL
&& gotsym
< symtabno
)
19659 printf (_(" Global entries:\n"));
19660 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
19661 addr_size
* 2, _("Address"),
19663 addr_size
* 2, _("Initial"),
19664 addr_size
* 2, _("Sym.Val."),
19666 /* Note for translators: "Ndx" = abbreviated form of "Index". */
19667 _("Ndx"), _("Name"));
19669 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
19671 for (i
= gotsym
; i
< symtabno
; i
++)
19673 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19676 if (filedata
->dynamic_symbols
== NULL
)
19677 printf (_("<no dynamic symbols>"));
19678 else if (i
< filedata
->num_dynamic_syms
)
19680 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
19682 print_vma (psym
->st_value
, LONG_HEX
);
19683 printf (" %-7s %3s ",
19684 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19685 get_symbol_index_type (filedata
, psym
->st_shndx
));
19687 if (valid_dynamic_name (filedata
, psym
->st_name
))
19688 print_symbol (sym_width
,
19689 get_dynamic_name (filedata
, psym
->st_name
));
19691 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19694 printf (_("<symbol index %zu exceeds number of dynamic symbols>"),
19698 if (ent
== (uint64_t) -1)
19708 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
19711 uint64_t offset
, rel_offset
;
19713 unsigned char * data
;
19714 int addr_size
, sym_width
;
19715 Elf_Internal_Rela
* rels
;
19717 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
19718 if (pltrel
== DT_RELA
)
19720 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19725 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19730 addr_size
= (is_32bit_elf
? 4 : 8);
19731 end
= mips_pltgot
+ (2 + count
) * addr_size
;
19733 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
19734 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
19735 1, _("Procedure Linkage Table data"));
19742 printf ("\nPLT GOT:\n\n");
19743 printf (_(" Reserved entries:\n"));
19744 printf (_(" %*s %*s Purpose\n"),
19745 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
19746 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19747 printf (_(" PLT lazy resolver\n"));
19748 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19749 printf (_(" Module pointer\n"));
19752 printf (_(" Entries:\n"));
19753 printf (" %*s %*s %*s %-7s %3s %s\n",
19754 addr_size
* 2, _("Address"),
19755 addr_size
* 2, _("Initial"),
19756 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
19757 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
19758 for (i
= 0; i
< count
; i
++)
19760 uint64_t idx
= get_reloc_symindex (rels
[i
].r_info
);
19762 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19765 if (idx
>= filedata
->num_dynamic_syms
)
19766 printf (_("<corrupt symbol index: %" PRIu64
">"), idx
);
19769 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
19771 print_vma (psym
->st_value
, LONG_HEX
);
19772 printf (" %-7s %3s ",
19773 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19774 get_symbol_index_type (filedata
, psym
->st_shndx
));
19775 if (valid_dynamic_name (filedata
, psym
->st_name
))
19776 print_symbol (sym_width
,
19777 get_dynamic_name (filedata
, psym
->st_name
));
19779 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19793 process_nds32_specific (Filedata
* filedata
)
19795 Elf_Internal_Shdr
*sect
= NULL
;
19797 sect
= find_section (filedata
, ".nds32_e_flags");
19798 if (sect
!= NULL
&& sect
->sh_size
>= 4)
19800 unsigned char *buf
;
19803 printf ("\nNDS32 elf flags section:\n");
19804 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
19805 _("NDS32 elf flags section"));
19810 flag
= byte_get (buf
, 4);
19812 switch (flag
& 0x3)
19815 printf ("(VEC_SIZE):\tNo entry.\n");
19818 printf ("(VEC_SIZE):\t4 bytes\n");
19821 printf ("(VEC_SIZE):\t16 bytes\n");
19824 printf ("(VEC_SIZE):\treserved\n");
19833 process_gnu_liblist (Filedata
* filedata
)
19835 Elf_Internal_Shdr
* section
;
19836 Elf_Internal_Shdr
* string_sec
;
19837 Elf32_External_Lib
* elib
;
19839 size_t strtab_size
;
19841 uint64_t num_liblist
;
19848 for (i
= 0, section
= filedata
->section_headers
;
19849 i
< filedata
->file_header
.e_shnum
;
19852 switch (section
->sh_type
)
19854 case SHT_GNU_LIBLIST
:
19855 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
19858 elib
= (Elf32_External_Lib
*)
19859 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
19860 _("liblist section data"));
19868 string_sec
= filedata
->section_headers
+ section
->sh_link
;
19869 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
19870 string_sec
->sh_size
,
19871 _("liblist string table"));
19873 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
19880 strtab_size
= string_sec
->sh_size
;
19882 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
19883 printf (ngettext ("\nLibrary list section '%s' contains %" PRIu64
19885 "\nLibrary list section '%s' contains %" PRIu64
19888 printable_section_name (filedata
, section
),
19891 puts (_(" Library Time Stamp Checksum Version Flags"));
19893 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
19901 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19902 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19903 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19904 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19905 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19907 tmp
= gmtime (&atime
);
19908 snprintf (timebuf
, sizeof (timebuf
),
19909 "%04u-%02u-%02uT%02u:%02u:%02u",
19910 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19911 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19913 printf ("%3zu: ", cnt
);
19915 printf ("%-20s", liblist
.l_name
< strtab_size
19916 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19918 printf ("%-20.20s", liblist
.l_name
< strtab_size
19919 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19920 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
19921 liblist
.l_version
, liblist
.l_flags
);
19932 static const char *
19933 get_note_type (Filedata
* filedata
, unsigned e_type
)
19935 static char buff
[64];
19937 if (filedata
->file_header
.e_type
== ET_CORE
)
19941 return _("NT_AUXV (auxiliary vector)");
19943 return _("NT_PRSTATUS (prstatus structure)");
19945 return _("NT_FPREGSET (floating point registers)");
19947 return _("NT_PRPSINFO (prpsinfo structure)");
19948 case NT_TASKSTRUCT
:
19949 return _("NT_TASKSTRUCT (task structure)");
19951 return _("NT_GDB_TDESC (GDB XML target description)");
19953 return _("NT_PRXFPREG (user_xfpregs structure)");
19955 return _("NT_PPC_VMX (ppc Altivec registers)");
19957 return _("NT_PPC_VSX (ppc VSX registers)");
19959 return _("NT_PPC_TAR (ppc TAR register)");
19961 return _("NT_PPC_PPR (ppc PPR register)");
19963 return _("NT_PPC_DSCR (ppc DSCR register)");
19965 return _("NT_PPC_EBB (ppc EBB registers)");
19967 return _("NT_PPC_PMU (ppc PMU registers)");
19968 case NT_PPC_TM_CGPR
:
19969 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
19970 case NT_PPC_TM_CFPR
:
19971 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
19972 case NT_PPC_TM_CVMX
:
19973 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
19974 case NT_PPC_TM_CVSX
:
19975 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
19976 case NT_PPC_TM_SPR
:
19977 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
19978 case NT_PPC_TM_CTAR
:
19979 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
19980 case NT_PPC_TM_CPPR
:
19981 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
19982 case NT_PPC_TM_CDSCR
:
19983 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
19985 return _("NT_386_TLS (x86 TLS information)");
19986 case NT_386_IOPERM
:
19987 return _("NT_386_IOPERM (x86 I/O permissions)");
19988 case NT_X86_XSTATE
:
19989 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
19991 return _("NT_X86_CET (x86 CET state)");
19992 case NT_S390_HIGH_GPRS
:
19993 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
19994 case NT_S390_TIMER
:
19995 return _("NT_S390_TIMER (s390 timer register)");
19996 case NT_S390_TODCMP
:
19997 return _("NT_S390_TODCMP (s390 TOD comparator register)");
19998 case NT_S390_TODPREG
:
19999 return _("NT_S390_TODPREG (s390 TOD programmable register)");
20001 return _("NT_S390_CTRS (s390 control registers)");
20002 case NT_S390_PREFIX
:
20003 return _("NT_S390_PREFIX (s390 prefix register)");
20004 case NT_S390_LAST_BREAK
:
20005 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
20006 case NT_S390_SYSTEM_CALL
:
20007 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
20009 return _("NT_S390_TDB (s390 transaction diagnostic block)");
20010 case NT_S390_VXRS_LOW
:
20011 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
20012 case NT_S390_VXRS_HIGH
:
20013 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
20014 case NT_S390_GS_CB
:
20015 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
20016 case NT_S390_GS_BC
:
20017 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
20019 return _("NT_ARM_VFP (arm VFP registers)");
20021 return _("NT_ARM_TLS (AArch TLS registers)");
20022 case NT_ARM_HW_BREAK
:
20023 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
20024 case NT_ARM_HW_WATCH
:
20025 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
20026 case NT_ARM_SYSTEM_CALL
:
20027 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
20029 return _("NT_ARM_SVE (AArch SVE registers)");
20030 case NT_ARM_PAC_MASK
:
20031 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
20032 case NT_ARM_PACA_KEYS
:
20033 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
20034 case NT_ARM_PACG_KEYS
:
20035 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
20036 case NT_ARM_TAGGED_ADDR_CTRL
:
20037 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
20039 return _("NT_ARM_SSVE (AArch64 streaming SVE registers)");
20041 return _("NT_ARM_ZA (AArch64 SME ZA register)");
20043 return _("NT_ARM_ZT (AArch64 SME2 ZT registers)");
20044 case NT_ARM_PAC_ENABLED_KEYS
:
20045 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
20047 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
20049 return _("NT_RISCV_CSR (RISC-V control and status registers)");
20051 return _("NT_PSTATUS (pstatus structure)");
20053 return _("NT_FPREGS (floating point registers)");
20055 return _("NT_PSINFO (psinfo structure)");
20057 return _("NT_LWPSTATUS (lwpstatus_t structure)");
20059 return _("NT_LWPSINFO (lwpsinfo_t structure)");
20060 case NT_WIN32PSTATUS
:
20061 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
20063 return _("NT_SIGINFO (siginfo_t data)");
20065 return _("NT_FILE (mapped files)");
20073 return _("NT_VERSION (version)");
20075 return _("NT_ARCH (architecture)");
20076 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
20078 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
20080 case NT_GO_BUILDID
:
20081 return _("GO BUILDID");
20082 case FDO_PACKAGING_METADATA
:
20083 return _("FDO_PACKAGING_METADATA");
20088 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20093 print_core_note (Elf_Internal_Note
*pnote
)
20095 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
20096 uint64_t count
, page_size
;
20097 unsigned char *descdata
, *filenames
, *descend
;
20099 if (pnote
->type
!= NT_FILE
)
20108 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
20109 /* Still "successful". */
20113 if (pnote
->descsz
< 2 * addr_size
)
20115 error (_(" Malformed note - too short for header\n"));
20119 descdata
= (unsigned char *) pnote
->descdata
;
20120 descend
= descdata
+ pnote
->descsz
;
20122 if (descdata
[pnote
->descsz
- 1] != '\0')
20124 error (_(" Malformed note - does not end with \\0\n"));
20128 count
= byte_get (descdata
, addr_size
);
20129 descdata
+= addr_size
;
20131 page_size
= byte_get (descdata
, addr_size
);
20132 descdata
+= addr_size
;
20134 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
20135 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
20137 error (_(" Malformed note - too short for supplied file count\n"));
20141 printf (_(" Page size: "));
20142 print_vma (page_size
, DEC
);
20145 printf (_(" %*s%*s%*s\n"),
20146 (int) (2 + 2 * addr_size
), _("Start"),
20147 (int) (4 + 2 * addr_size
), _("End"),
20148 (int) (4 + 2 * addr_size
), _("Page Offset"));
20149 filenames
= descdata
+ count
* 3 * addr_size
;
20150 while (count
-- > 0)
20152 uint64_t start
, end
, file_ofs
;
20154 if (filenames
== descend
)
20156 error (_(" Malformed note - filenames end too early\n"));
20160 start
= byte_get (descdata
, addr_size
);
20161 descdata
+= addr_size
;
20162 end
= byte_get (descdata
, addr_size
);
20163 descdata
+= addr_size
;
20164 file_ofs
= byte_get (descdata
, addr_size
);
20165 descdata
+= addr_size
;
20168 print_vma (start
, FULL_HEX
);
20170 print_vma (end
, FULL_HEX
);
20172 print_vma (file_ofs
, FULL_HEX
);
20173 printf ("\n %s\n", filenames
);
20175 filenames
+= 1 + strlen ((char *) filenames
);
20181 static const char *
20182 get_gnu_elf_note_type (unsigned e_type
)
20184 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
20187 case NT_GNU_ABI_TAG
:
20188 return _("NT_GNU_ABI_TAG (ABI version tag)");
20190 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
20191 case NT_GNU_BUILD_ID
:
20192 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
20193 case NT_GNU_GOLD_VERSION
:
20194 return _("NT_GNU_GOLD_VERSION (gold version)");
20195 case NT_GNU_PROPERTY_TYPE_0
:
20196 return _("NT_GNU_PROPERTY_TYPE_0");
20197 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
20198 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
20199 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
20200 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
20203 static char buff
[64];
20205 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20212 decode_x86_compat_isa (unsigned int bitmask
)
20216 unsigned int bit
= bitmask
& (- bitmask
);
20221 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
20224 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
20227 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
20230 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
20233 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
20236 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
20239 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
20242 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
20245 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
20248 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
20251 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
20254 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
20255 printf ("AVX512F");
20257 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
20258 printf ("AVX512CD");
20260 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
20261 printf ("AVX512ER");
20263 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
20264 printf ("AVX512PF");
20266 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
20267 printf ("AVX512VL");
20269 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
20270 printf ("AVX512DQ");
20272 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
20273 printf ("AVX512BW");
20276 printf (_("<unknown: %x>"), bit
);
20285 decode_x86_compat_2_isa (unsigned int bitmask
)
20289 printf (_("<None>"));
20295 unsigned int bit
= bitmask
& (- bitmask
);
20300 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
20303 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
20306 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
20309 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
20312 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
20315 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
20318 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
20321 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
20324 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
20327 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
20330 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
20331 printf ("AVX512F");
20333 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
20334 printf ("AVX512CD");
20336 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
20337 printf ("AVX512ER");
20339 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
20340 printf ("AVX512PF");
20342 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
20343 printf ("AVX512VL");
20345 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
20346 printf ("AVX512DQ");
20348 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
20349 printf ("AVX512BW");
20351 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
20352 printf ("AVX512_4FMAPS");
20354 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
20355 printf ("AVX512_4VNNIW");
20357 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
20358 printf ("AVX512_BITALG");
20360 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
20361 printf ("AVX512_IFMA");
20363 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
20364 printf ("AVX512_VBMI");
20366 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
20367 printf ("AVX512_VBMI2");
20369 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
20370 printf ("AVX512_VNNI");
20372 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
20373 printf ("AVX512_BF16");
20376 printf (_("<unknown: %x>"), bit
);
20384 static const char *
20385 get_amdgpu_elf_note_type (unsigned int e_type
)
20389 case NT_AMDGPU_METADATA
:
20390 return _("NT_AMDGPU_METADATA (code object metadata)");
20393 static char buf
[64];
20394 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
20401 decode_x86_isa (unsigned int bitmask
)
20405 unsigned int bit
= bitmask
& (- bitmask
);
20410 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
20411 printf ("x86-64-baseline");
20413 case GNU_PROPERTY_X86_ISA_1_V2
:
20414 printf ("x86-64-v2");
20416 case GNU_PROPERTY_X86_ISA_1_V3
:
20417 printf ("x86-64-v3");
20419 case GNU_PROPERTY_X86_ISA_1_V4
:
20420 printf ("x86-64-v4");
20423 printf (_("<unknown: %x>"), bit
);
20432 decode_x86_feature_1 (unsigned int bitmask
)
20436 printf (_("<None>"));
20442 unsigned int bit
= bitmask
& (- bitmask
);
20447 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
20450 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
20453 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
20454 printf ("LAM_U48");
20456 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
20457 printf ("LAM_U57");
20460 printf (_("<unknown: %x>"), bit
);
20469 decode_x86_feature_2 (unsigned int bitmask
)
20473 printf (_("<None>"));
20479 unsigned int bit
= bitmask
& (- bitmask
);
20484 case GNU_PROPERTY_X86_FEATURE_2_X86
:
20487 case GNU_PROPERTY_X86_FEATURE_2_X87
:
20490 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
20493 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
20496 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
20499 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
20502 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
20505 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
20508 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
20511 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
20514 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
20515 printf ("XSAVEOPT");
20517 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
20521 printf (_("<unknown: %x>"), bit
);
20530 decode_aarch64_feature_1_and (unsigned int bitmask
)
20534 unsigned int bit
= bitmask
& (- bitmask
);
20539 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
20543 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
20548 printf (_("<unknown: %x>"), bit
);
20557 decode_1_needed (unsigned int bitmask
)
20561 unsigned int bit
= bitmask
& (- bitmask
);
20566 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
20567 printf ("indirect external access");
20570 printf (_("<unknown: %x>"), bit
);
20579 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
20581 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
20582 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
20583 unsigned int size
= is_32bit_elf
? 4 : 8;
20585 printf (_(" Properties: "));
20587 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
20589 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
20593 while (ptr
< ptr_end
)
20597 unsigned int datasz
;
20599 if ((size_t) (ptr_end
- ptr
) < 8)
20601 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
20605 type
= byte_get (ptr
, 4);
20606 datasz
= byte_get (ptr
+ 4, 4);
20610 if (datasz
> (size_t) (ptr_end
- ptr
))
20612 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
20617 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
20619 if (filedata
->file_header
.e_machine
== EM_X86_64
20620 || filedata
->file_header
.e_machine
== EM_IAMCU
20621 || filedata
->file_header
.e_machine
== EM_386
)
20623 unsigned int bitmask
;
20626 bitmask
= byte_get (ptr
, 4);
20632 case GNU_PROPERTY_X86_ISA_1_USED
:
20634 printf (_("x86 ISA used: <corrupt length: %#x> "),
20638 printf ("x86 ISA used: ");
20639 decode_x86_isa (bitmask
);
20643 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
20645 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20649 printf ("x86 ISA needed: ");
20650 decode_x86_isa (bitmask
);
20654 case GNU_PROPERTY_X86_FEATURE_1_AND
:
20656 printf (_("x86 feature: <corrupt length: %#x> "),
20660 printf ("x86 feature: ");
20661 decode_x86_feature_1 (bitmask
);
20665 case GNU_PROPERTY_X86_FEATURE_2_USED
:
20667 printf (_("x86 feature used: <corrupt length: %#x> "),
20671 printf ("x86 feature used: ");
20672 decode_x86_feature_2 (bitmask
);
20676 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
20678 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
20681 printf ("x86 feature needed: ");
20682 decode_x86_feature_2 (bitmask
);
20686 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
20688 printf (_("x86 ISA used: <corrupt length: %#x> "),
20692 printf ("x86 ISA used: ");
20693 decode_x86_compat_isa (bitmask
);
20697 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
20699 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20703 printf ("x86 ISA needed: ");
20704 decode_x86_compat_isa (bitmask
);
20708 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
20710 printf (_("x86 ISA used: <corrupt length: %#x> "),
20714 printf ("x86 ISA used: ");
20715 decode_x86_compat_2_isa (bitmask
);
20719 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
20721 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20725 printf ("x86 ISA needed: ");
20726 decode_x86_compat_2_isa (bitmask
);
20734 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
20736 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
20738 printf ("AArch64 feature: ");
20740 printf (_("<corrupt length: %#x> "), datasz
);
20742 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
20751 case GNU_PROPERTY_STACK_SIZE
:
20752 printf (_("stack size: "));
20753 if (datasz
!= size
)
20754 printf (_("<corrupt length: %#x> "), datasz
);
20756 printf ("%#" PRIx64
, byte_get (ptr
, size
));
20759 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
20760 printf ("no copy on protected ");
20762 printf (_("<corrupt length: %#x> "), datasz
);
20766 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
20767 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
20768 || (type
>= GNU_PROPERTY_UINT32_OR_LO
20769 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
20773 case GNU_PROPERTY_1_NEEDED
:
20775 printf (_("1_needed: <corrupt length: %#x> "),
20779 unsigned int bitmask
= byte_get (ptr
, 4);
20780 printf ("1_needed: ");
20781 decode_1_needed (bitmask
);
20788 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
20789 printf (_("UINT32_AND (%#x): "), type
);
20791 printf (_("UINT32_OR (%#x): "), type
);
20793 printf (_("<corrupt length: %#x> "), datasz
);
20795 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
20802 if (type
< GNU_PROPERTY_LOPROC
)
20803 printf (_("<unknown type %#x data: "), type
);
20804 else if (type
< GNU_PROPERTY_LOUSER
)
20805 printf (_("<processor-specific type %#x data: "), type
);
20807 printf (_("<application-specific type %#x data: "), type
);
20808 for (j
= 0; j
< datasz
; ++j
)
20809 printf ("%02x ", ptr
[j
] & 0xff);
20813 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
20814 if (ptr
== ptr_end
)
20827 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
20829 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
20830 switch (pnote
->type
)
20832 case NT_GNU_BUILD_ID
:
20836 printf (_(" Build ID: "));
20837 for (i
= 0; i
< pnote
->descsz
; ++i
)
20838 printf ("%02x", pnote
->descdata
[i
] & 0xff);
20843 case NT_GNU_ABI_TAG
:
20845 unsigned int os
, major
, minor
, subminor
;
20846 const char *osname
;
20848 /* PR 17531: file: 030-599401-0.004. */
20849 if (pnote
->descsz
< 16)
20851 printf (_(" <corrupt GNU_ABI_TAG>\n"));
20855 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20856 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20857 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
20858 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
20862 case GNU_ABI_TAG_LINUX
:
20865 case GNU_ABI_TAG_HURD
:
20868 case GNU_ABI_TAG_SOLARIS
:
20869 osname
= "Solaris";
20871 case GNU_ABI_TAG_FREEBSD
:
20872 osname
= "FreeBSD";
20874 case GNU_ABI_TAG_NETBSD
:
20877 case GNU_ABI_TAG_SYLLABLE
:
20878 osname
= "Syllable";
20880 case GNU_ABI_TAG_NACL
:
20884 osname
= "Unknown";
20888 printf (_(" OS: %s, ABI: %d.%d.%d\n"), osname
,
20889 major
, minor
, subminor
);
20893 case NT_GNU_GOLD_VERSION
:
20897 printf (_(" Version: "));
20898 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
20899 printf ("%c", pnote
->descdata
[i
]);
20906 unsigned int num_entries
, mask
;
20908 /* Hardware capabilities information. Word 0 is the number of entries.
20909 Word 1 is a bitmask of enabled entries. The rest of the descriptor
20910 is a series of entries, where each entry is a single byte followed
20911 by a nul terminated string. The byte gives the bit number to test
20912 if enabled in the bitmask. */
20913 printf (_(" Hardware Capabilities: "));
20914 if (pnote
->descsz
< 8)
20916 error (_("<corrupt GNU_HWCAP>\n"));
20919 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20920 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20921 printf (_("num entries: %d, enabled mask: %x\n"), num_entries
, mask
);
20922 /* FIXME: Add code to display the entries... */
20926 case NT_GNU_PROPERTY_TYPE_0
:
20927 print_gnu_property_note (filedata
, pnote
);
20931 /* Handle unrecognised types. An error message should have already been
20932 created by get_gnu_elf_note_type(), so all that we need to do is to
20933 display the data. */
20937 printf (_(" Description data: "));
20938 for (i
= 0; i
< pnote
->descsz
; ++i
)
20939 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20948 static const char *
20949 get_v850_elf_note_type (enum v850_notes n_type
)
20951 static char buff
[64];
20955 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
20956 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
20957 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
20958 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
20959 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
20960 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
20962 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
20968 print_v850_note (Elf_Internal_Note
* pnote
)
20972 if (pnote
->descsz
!= 4)
20975 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
20979 printf (_("not set\n"));
20983 switch (pnote
->type
)
20985 case V850_NOTE_ALIGNMENT
:
20988 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
20989 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
20993 case V850_NOTE_DATA_SIZE
:
20996 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
20997 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
21001 case V850_NOTE_FPU_INFO
:
21004 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
21005 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
21009 case V850_NOTE_MMU_INFO
:
21010 case V850_NOTE_CACHE_INFO
:
21011 case V850_NOTE_SIMD_INFO
:
21012 if (val
== EF_RH850_SIMD
)
21014 printf (_("yes\n"));
21020 /* An 'unknown note type' message will already have been displayed. */
21024 printf (_("unknown value: %x\n"), val
);
21029 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
21031 unsigned int version
;
21033 switch (pnote
->type
)
21035 case NT_NETBSD_IDENT
:
21036 if (pnote
->descsz
< 1)
21038 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
21039 if ((version
/ 10000) % 100)
21040 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
21041 version
, version
/ 100000000, (version
/ 1000000) % 100,
21042 (version
/ 10000) % 100 > 26 ? "Z" : "",
21043 'A' + (version
/ 10000) % 26);
21045 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
21046 version
, version
/ 100000000, (version
/ 1000000) % 100,
21047 (version
/ 100) % 100);
21050 case NT_NETBSD_MARCH
:
21051 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
21055 case NT_NETBSD_PAX
:
21056 if (pnote
->descsz
< 1)
21058 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
21059 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
21060 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
21061 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
21062 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
21063 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
21064 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
21065 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
21069 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
21070 pnote
->descsz
, pnote
->type
);
21074 static const char *
21075 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21079 case NT_FREEBSD_THRMISC
:
21080 return _("NT_THRMISC (thrmisc structure)");
21081 case NT_FREEBSD_PROCSTAT_PROC
:
21082 return _("NT_PROCSTAT_PROC (proc data)");
21083 case NT_FREEBSD_PROCSTAT_FILES
:
21084 return _("NT_PROCSTAT_FILES (files data)");
21085 case NT_FREEBSD_PROCSTAT_VMMAP
:
21086 return _("NT_PROCSTAT_VMMAP (vmmap data)");
21087 case NT_FREEBSD_PROCSTAT_GROUPS
:
21088 return _("NT_PROCSTAT_GROUPS (groups data)");
21089 case NT_FREEBSD_PROCSTAT_UMASK
:
21090 return _("NT_PROCSTAT_UMASK (umask data)");
21091 case NT_FREEBSD_PROCSTAT_RLIMIT
:
21092 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
21093 case NT_FREEBSD_PROCSTAT_OSREL
:
21094 return _("NT_PROCSTAT_OSREL (osreldate data)");
21095 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
21096 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
21097 case NT_FREEBSD_PROCSTAT_AUXV
:
21098 return _("NT_PROCSTAT_AUXV (auxv data)");
21099 case NT_FREEBSD_PTLWPINFO
:
21100 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
21101 case NT_FREEBSD_X86_SEGBASES
:
21102 return _("NT_X86_SEGBASES (x86 segment base registers)");
21104 return get_note_type (filedata
, e_type
);
21107 static const char *
21108 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21110 static char buff
[64];
21114 case NT_NETBSDCORE_PROCINFO
:
21115 /* NetBSD core "procinfo" structure. */
21116 return _("NetBSD procinfo structure");
21118 case NT_NETBSDCORE_AUXV
:
21119 return _("NetBSD ELF auxiliary vector data");
21121 case NT_NETBSDCORE_LWPSTATUS
:
21122 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
21125 /* As of Jan 2020 there are no other machine-independent notes
21126 defined for NetBSD core files. If the note type is less
21127 than the start of the machine-dependent note types, we don't
21130 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
21132 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21138 switch (filedata
->file_header
.e_machine
)
21140 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
21141 and PT_GETFPREGS == mach+2. */
21146 case EM_SPARC32PLUS
:
21150 case NT_NETBSDCORE_FIRSTMACH
+ 0:
21151 return _("PT_GETREGS (reg structure)");
21152 case NT_NETBSDCORE_FIRSTMACH
+ 2:
21153 return _("PT_GETFPREGS (fpreg structure)");
21159 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
21160 There's also old PT___GETREGS40 == mach + 1 for old reg
21161 structure which lacks GBR. */
21165 case NT_NETBSDCORE_FIRSTMACH
+ 1:
21166 return _("PT___GETREGS40 (old reg structure)");
21167 case NT_NETBSDCORE_FIRSTMACH
+ 3:
21168 return _("PT_GETREGS (reg structure)");
21169 case NT_NETBSDCORE_FIRSTMACH
+ 5:
21170 return _("PT_GETFPREGS (fpreg structure)");
21176 /* On all other arch's, PT_GETREGS == mach+1 and
21177 PT_GETFPREGS == mach+3. */
21181 case NT_NETBSDCORE_FIRSTMACH
+ 1:
21182 return _("PT_GETREGS (reg structure)");
21183 case NT_NETBSDCORE_FIRSTMACH
+ 3:
21184 return _("PT_GETFPREGS (fpreg structure)");
21190 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
21191 e_type
- NT_NETBSDCORE_FIRSTMACH
);
21195 static const char *
21196 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21200 case NT_OPENBSD_PROCINFO
:
21201 return _("OpenBSD procinfo structure");
21202 case NT_OPENBSD_AUXV
:
21203 return _("OpenBSD ELF auxiliary vector data");
21204 case NT_OPENBSD_REGS
:
21205 return _("OpenBSD regular registers");
21206 case NT_OPENBSD_FPREGS
:
21207 return _("OpenBSD floating point registers");
21208 case NT_OPENBSD_WCOOKIE
:
21209 return _("OpenBSD window cookie");
21212 return get_note_type (filedata
, e_type
);
21215 static const char *
21216 get_qnx_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21220 case QNT_DEBUG_FULLPATH
:
21221 return _("QNX debug fullpath");
21222 case QNT_DEBUG_RELOC
:
21223 return _("QNX debug relocation");
21225 return _("QNX stack");
21226 case QNT_GENERATOR
:
21227 return _("QNX generator");
21228 case QNT_DEFAULT_LIB
:
21229 return _("QNX default library");
21230 case QNT_CORE_SYSINFO
:
21231 return _("QNX core sysinfo");
21232 case QNT_CORE_INFO
:
21233 return _("QNX core info");
21234 case QNT_CORE_STATUS
:
21235 return _("QNX core status");
21236 case QNT_CORE_GREG
:
21237 return _("QNX general registers");
21238 case QNT_CORE_FPREG
:
21239 return _("QNX floating point registers");
21241 return _("QNX link map");
21244 return get_note_type (filedata
, e_type
);
21247 static const char *
21248 get_stapsdt_note_type (unsigned e_type
)
21250 static char buff
[64];
21255 return _("NT_STAPSDT (SystemTap probe descriptors)");
21261 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21266 print_stapsdt_note (Elf_Internal_Note
*pnote
)
21268 size_t len
, maxlen
;
21269 size_t addr_size
= is_32bit_elf
? 4 : 8;
21270 char *data
= pnote
->descdata
;
21271 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
21272 uint64_t pc
, base_addr
, semaphore
;
21273 char *provider
, *probe
, *arg_fmt
;
21275 if (pnote
->descsz
< (addr_size
* 3))
21276 goto stapdt_note_too_small
;
21278 pc
= byte_get ((unsigned char *) data
, addr_size
);
21281 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
21284 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
21287 if (data
>= data_end
)
21288 goto stapdt_note_too_small
;
21289 maxlen
= data_end
- data
;
21290 len
= strnlen (data
, maxlen
);
21297 goto stapdt_note_too_small
;
21299 if (data
>= data_end
)
21300 goto stapdt_note_too_small
;
21301 maxlen
= data_end
- data
;
21302 len
= strnlen (data
, maxlen
);
21309 goto stapdt_note_too_small
;
21311 if (data
>= data_end
)
21312 goto stapdt_note_too_small
;
21313 maxlen
= data_end
- data
;
21314 len
= strnlen (data
, maxlen
);
21321 goto stapdt_note_too_small
;
21323 printf (_(" Provider: %s\n"), provider
);
21324 printf (_(" Name: %s\n"), probe
);
21325 printf (_(" Location: "));
21326 print_vma (pc
, FULL_HEX
);
21327 printf (_(", Base: "));
21328 print_vma (base_addr
, FULL_HEX
);
21329 printf (_(", Semaphore: "));
21330 print_vma (semaphore
, FULL_HEX
);
21332 printf (_(" Arguments: %s\n"), arg_fmt
);
21334 return data
== data_end
;
21336 stapdt_note_too_small
:
21337 printf (_(" <corrupt - note is too small>\n"));
21338 error (_("corrupt stapdt note - the data size is too small\n"));
21343 print_fdo_note (Elf_Internal_Note
* pnote
)
21345 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
21347 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
21353 static const char *
21354 get_ia64_vms_note_type (unsigned e_type
)
21356 static char buff
[64];
21361 return _("NT_VMS_MHD (module header)");
21363 return _("NT_VMS_LNM (language name)");
21365 return _("NT_VMS_SRC (source files)");
21367 return "NT_VMS_TITLE";
21369 return _("NT_VMS_EIDC (consistency check)");
21370 case NT_VMS_FPMODE
:
21371 return _("NT_VMS_FPMODE (FP mode)");
21372 case NT_VMS_LINKTIME
:
21373 return "NT_VMS_LINKTIME";
21374 case NT_VMS_IMGNAM
:
21375 return _("NT_VMS_IMGNAM (image name)");
21377 return _("NT_VMS_IMGID (image id)");
21378 case NT_VMS_LINKID
:
21379 return _("NT_VMS_LINKID (link id)");
21380 case NT_VMS_IMGBID
:
21381 return _("NT_VMS_IMGBID (build id)");
21382 case NT_VMS_GSTNAM
:
21383 return _("NT_VMS_GSTNAM (sym table name)");
21384 case NT_VMS_ORIG_DYN
:
21385 return "NT_VMS_ORIG_DYN";
21386 case NT_VMS_PATCHTIME
:
21387 return "NT_VMS_PATCHTIME";
21389 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21395 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
21397 unsigned int maxlen
= pnote
->descsz
;
21399 if (maxlen
< 2 || maxlen
!= pnote
->descsz
)
21400 goto desc_size_fail
;
21402 switch (pnote
->type
)
21406 goto desc_size_fail
;
21408 size_t l
= strnlen (pnote
->descdata
+ 34, maxlen
- 34);
21410 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
21411 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
21412 if (l
+ 34 < maxlen
)
21414 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
21415 if (l
+ 35 < maxlen
)
21416 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
21418 printf (_(" Module version : <missing>\n"));
21422 printf (_(" Module name : <missing>\n"));
21423 printf (_(" Module version : <missing>\n"));
21428 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
21431 case NT_VMS_FPMODE
:
21432 printf (_(" Floating Point mode: "));
21434 goto desc_size_fail
;
21435 /* FIXME: Generate an error if descsz > 8 ? */
21437 printf ("0x%016" PRIx64
"\n",
21438 byte_get ((unsigned char *) pnote
->descdata
, 8));
21441 case NT_VMS_LINKTIME
:
21442 printf (_(" Link time: "));
21444 goto desc_size_fail
;
21445 /* FIXME: Generate an error if descsz > 8 ? */
21447 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21451 case NT_VMS_PATCHTIME
:
21452 printf (_(" Patch time: "));
21454 goto desc_size_fail
;
21455 /* FIXME: Generate an error if descsz > 8 ? */
21457 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21461 case NT_VMS_ORIG_DYN
:
21463 goto desc_size_fail
;
21465 printf (_(" Major id: %u, minor id: %u\n"),
21466 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
21467 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
21468 printf (_(" Last modified : "));
21469 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
21470 printf (_("\n Link flags : "));
21471 printf ("0x%016" PRIx64
"\n",
21472 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
21473 printf (_(" Header flags: 0x%08x\n"),
21474 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
21475 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
21478 case NT_VMS_IMGNAM
:
21479 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
21482 case NT_VMS_GSTNAM
:
21483 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
21487 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
21490 case NT_VMS_LINKID
:
21491 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
21501 printf (_(" <corrupt - data size is too small>\n"));
21502 error (_("corrupt IA64 note: data size is too small\n"));
21506 struct build_attr_cache
{
21507 Filedata
*filedata
;
21509 uint64_t strtablen
;
21510 Elf_Internal_Sym
*symtab
;
21514 /* Find the symbol associated with a build attribute that is attached
21515 to address OFFSET. If PNAME is non-NULL then store the name of
21516 the symbol (if found) in the provided pointer, Returns NULL if a
21517 symbol could not be found. */
21519 static Elf_Internal_Sym
*
21520 get_symbol_for_build_attribute (Filedata
*filedata
,
21523 const char **pname
)
21525 Elf_Internal_Sym
*saved_sym
= NULL
;
21526 Elf_Internal_Sym
*sym
;
21528 if (filedata
->section_headers
!= NULL
21529 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
21531 Elf_Internal_Shdr
* symsec
;
21533 free (ba_cache
.strtab
);
21534 ba_cache
.strtab
= NULL
;
21535 free (ba_cache
.symtab
);
21536 ba_cache
.symtab
= NULL
;
21538 /* Load the symbol and string sections. */
21539 for (symsec
= filedata
->section_headers
;
21540 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
21543 if (symsec
->sh_type
== SHT_SYMTAB
21544 && get_symtab (filedata
, symsec
,
21545 &ba_cache
.symtab
, &ba_cache
.nsyms
,
21546 &ba_cache
.strtab
, &ba_cache
.strtablen
))
21549 ba_cache
.filedata
= filedata
;
21552 if (ba_cache
.symtab
== NULL
)
21555 /* Find a symbol whose value matches offset. */
21556 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
21557 if (sym
->st_value
== offset
)
21559 if (sym
->st_name
>= ba_cache
.strtablen
)
21560 /* Huh ? This should not happen. */
21563 if (ba_cache
.strtab
[sym
->st_name
] == 0)
21566 /* The AArch64, ARM and RISC-V architectures define mapping symbols
21567 (eg $d, $x, $t) which we want to ignore. */
21568 if (ba_cache
.strtab
[sym
->st_name
] == '$'
21569 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
21570 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
21575 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
21576 and FILE or OBJECT symbols over NOTYPE symbols. We skip
21577 FUNC symbols entirely. */
21578 switch (ELF_ST_TYPE (sym
->st_info
))
21585 /* If the symbol has a size associated
21586 with it then we can stop searching. */
21587 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
21592 /* Ignore function symbols. */
21599 switch (ELF_ST_BIND (sym
->st_info
))
21602 if (saved_sym
== NULL
21603 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
21608 if (saved_sym
== NULL
)
21618 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
21626 if (saved_sym
&& pname
)
21627 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
21632 /* Returns true iff addr1 and addr2 are in the same section. */
21635 same_section (Filedata
* filedata
, uint64_t addr1
, uint64_t addr2
)
21637 Elf_Internal_Shdr
* a1
;
21638 Elf_Internal_Shdr
* a2
;
21640 a1
= find_section_by_address (filedata
, addr1
);
21641 a2
= find_section_by_address (filedata
, addr2
);
21643 return a1
== a2
&& a1
!= NULL
;
21647 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
21648 Filedata
* filedata
)
21650 static uint64_t global_offset
= 0;
21651 static uint64_t global_end
= 0;
21652 static uint64_t func_offset
= 0;
21653 static uint64_t func_end
= 0;
21655 Elf_Internal_Sym
*sym
;
21659 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
21661 switch (pnote
->descsz
)
21664 /* A zero-length description means that the range of
21665 the previous note of the same type should be used. */
21668 if (global_end
> global_offset
)
21669 printf (_(" Applies to region from %#" PRIx64
21670 " to %#" PRIx64
"\n"), global_offset
, global_end
);
21672 printf (_(" Applies to region from %#" PRIx64
21673 "\n"), global_offset
);
21677 if (func_end
> func_offset
)
21678 printf (_(" Applies to region from %#" PRIx64
21679 " to %#" PRIx64
"\n"), func_offset
, func_end
);
21681 printf (_(" Applies to region from %#" PRIx64
21682 "\n"), func_offset
);
21687 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21692 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21693 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21697 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
21698 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
21702 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
21703 printf (_(" <invalid descsz>"));
21708 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
21709 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
21710 in order to avoid them being confused with the start address of the
21711 first function in the file... */
21712 if (sym
== NULL
&& is_open_attr
)
21713 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
21716 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
21717 end
= start
+ sym
->st_size
;
21721 /* FIXME: Need to properly allow for section alignment.
21722 16 is just the alignment used on x86_64. */
21724 && start
> BFD_ALIGN (global_end
, 16)
21725 /* Build notes are not guaranteed to be organised in order of
21726 increasing address, but we should find the all of the notes
21727 for one section in the same place. */
21728 && same_section (filedata
, start
, global_end
))
21729 warn (_("Gap in build notes detected from %#" PRIx64
21730 " to %#" PRIx64
"\n"),
21731 global_end
+ 1, start
- 1);
21733 printf (_(" Applies to region from %#" PRIx64
), start
);
21734 global_offset
= start
;
21738 printf (_(" to %#" PRIx64
), end
);
21744 printf (_(" Applies to region from %#" PRIx64
), start
);
21745 func_offset
= start
;
21749 printf (_(" to %#" PRIx64
), end
);
21755 printf (_(" (%s)"), name
);
21762 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
21764 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
21765 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
21766 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
21768 char name_attribute
;
21769 const char * expected_types
;
21770 const char * name
= pnote
->namedata
;
21774 if (name
== NULL
|| pnote
->namesz
< 2)
21776 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21777 print_symbol (-20, _(" <corrupt name>"));
21786 /* Version 2 of the spec adds a "GA" prefix to the name field. */
21787 if (name
[0] == 'G' && name
[1] == 'A')
21789 if (pnote
->namesz
< 4)
21791 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21792 print_symbol (-20, _(" <corrupt name>"));
21801 switch ((name_type
= * name
))
21803 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21804 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21805 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21806 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21807 printf ("%c", * name
);
21811 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
21812 print_symbol (-20, _("<unknown name type>"));
21819 switch ((name_attribute
= * name
))
21821 case GNU_BUILD_ATTRIBUTE_VERSION
:
21822 text
= _("<version>");
21823 expected_types
= string_expected
;
21826 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21827 text
= _("<stack prot>");
21828 expected_types
= "!+*";
21831 case GNU_BUILD_ATTRIBUTE_RELRO
:
21832 text
= _("<relro>");
21833 expected_types
= bool_expected
;
21836 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
21837 text
= _("<stack size>");
21838 expected_types
= number_expected
;
21841 case GNU_BUILD_ATTRIBUTE_TOOL
:
21842 text
= _("<tool>");
21843 expected_types
= string_expected
;
21846 case GNU_BUILD_ATTRIBUTE_ABI
:
21848 expected_types
= "$*";
21851 case GNU_BUILD_ATTRIBUTE_PIC
:
21853 expected_types
= number_expected
;
21856 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
21857 text
= _("<short enum>");
21858 expected_types
= bool_expected
;
21862 if (ISPRINT (* name
))
21864 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
21866 if (len
> left
&& ! do_wide
)
21868 printf ("%.*s:", len
, name
);
21874 static char tmpbuf
[128];
21876 error (_("unrecognised byte in name field: %d\n"), * name
);
21877 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
21881 expected_types
= "*$!+";
21886 left
-= printf ("%s", text
);
21888 if (strchr (expected_types
, name_type
) == NULL
)
21889 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
21891 if ((size_t) (name
- pnote
->namedata
) > pnote
->namesz
)
21893 error (_("corrupt name field: namesz: %lu but parsing gets to %td\n"),
21895 name
- pnote
->namedata
);
21899 if (left
< 1 && ! do_wide
)
21904 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21906 unsigned int bytes
;
21908 unsigned int shift
= 0;
21909 char *decoded
= NULL
;
21911 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
21913 /* The -1 is because the name field is always 0 terminated, and we
21914 want to be able to ensure that the shift in the while loop below
21915 will not overflow. */
21918 if (bytes
> sizeof (val
))
21920 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
21922 bytes
= sizeof (val
);
21924 /* We do not bother to warn if bytes == 0 as this can
21925 happen with some early versions of the gcc plugin. */
21929 uint64_t byte
= *name
++ & 0xff;
21931 val
|= byte
<< shift
;
21935 switch (name_attribute
)
21937 case GNU_BUILD_ATTRIBUTE_PIC
:
21940 case 0: decoded
= "static"; break;
21941 case 1: decoded
= "pic"; break;
21942 case 2: decoded
= "PIC"; break;
21943 case 3: decoded
= "pie"; break;
21944 case 4: decoded
= "PIE"; break;
21948 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21951 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
21952 case 0: decoded
= "off"; break;
21953 case 1: decoded
= "on"; break;
21954 case 2: decoded
= "all"; break;
21955 case 3: decoded
= "strong"; break;
21956 case 4: decoded
= "explicit"; break;
21964 if (decoded
!= NULL
)
21966 print_symbol (-left
, decoded
);
21977 left
-= printf ("0x%" PRIx64
, val
);
21979 left
-= printf ("0x%-.*" PRIx64
, left
, val
);
21983 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21984 left
-= print_symbol (- left
, name
);
21986 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21987 left
-= print_symbol (- left
, "true");
21989 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21990 left
-= print_symbol (- left
, "false");
21994 if (do_wide
&& left
> 0)
21995 printf ("%-*s", left
, " ");
22000 /* Print the contents of PNOTE as hex. */
22003 print_note_contents_hex (Elf_Internal_Note
*pnote
)
22009 printf (_(" description data: "));
22010 for (i
= 0; i
< pnote
->descsz
; i
++)
22011 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
22020 #if defined HAVE_MSGPACK
22023 print_indents (int n
)
22027 for (int i
= 0; i
< n
; i
++)
22031 /* Print OBJ in human-readable form. */
22034 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
22038 case MSGPACK_OBJECT_NIL
:
22042 case MSGPACK_OBJECT_BOOLEAN
:
22043 printf ("%s", obj
->via
.boolean
? "true" : "false");
22046 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
22047 printf ("%" PRIu64
, obj
->via
.u64
);
22050 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
22051 printf ("%" PRIi64
, obj
->via
.i64
);
22054 case MSGPACK_OBJECT_FLOAT32
:
22055 case MSGPACK_OBJECT_FLOAT64
:
22056 printf ("%f", obj
->via
.f64
);
22059 case MSGPACK_OBJECT_STR
:
22060 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
22063 case MSGPACK_OBJECT_ARRAY
:
22065 const msgpack_object_array
*array
= &obj
->via
.array
;
22070 for (uint32_t i
= 0; i
< array
->size
; ++i
)
22072 const msgpack_object
*item
= &array
->ptr
[i
];
22074 print_indents (indent
);
22075 dump_msgpack_obj (item
, indent
);
22080 print_indents (indent
);
22086 case MSGPACK_OBJECT_MAP
:
22088 const msgpack_object_map
*map
= &obj
->via
.map
;
22093 for (uint32_t i
= 0; i
< map
->size
; ++i
)
22095 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
22096 const msgpack_object
*key
= &kv
->key
;
22097 const msgpack_object
*val
= &kv
->val
;
22099 print_indents (indent
);
22100 dump_msgpack_obj (key
, indent
);
22102 dump_msgpack_obj (val
, indent
);
22108 print_indents (indent
);
22114 case MSGPACK_OBJECT_BIN
:
22118 case MSGPACK_OBJECT_EXT
:
22125 dump_msgpack (const msgpack_unpacked
*msg
)
22128 dump_msgpack_obj (&msg
->data
, 0);
22132 #endif /* defined HAVE_MSGPACK */
22135 print_amdgpu_note (Elf_Internal_Note
*pnote
)
22137 #if defined HAVE_MSGPACK
22138 /* If msgpack is available, decode and dump the note's content. */
22140 msgpack_unpacked msg
;
22141 msgpack_unpack_return msgpack_ret
;
22143 assert (pnote
->type
== NT_AMDGPU_METADATA
);
22145 msgpack_unpacked_init (&msg
);
22146 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
22149 switch (msgpack_ret
)
22151 case MSGPACK_UNPACK_SUCCESS
:
22152 dump_msgpack (&msg
);
22157 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
22162 msgpack_unpacked_destroy (&msg
);
22165 /* msgpack is not available, dump contents as hex. */
22166 print_note_contents_hex (pnote
);
22172 print_qnx_note (Elf_Internal_Note
*pnote
)
22174 switch (pnote
->type
)
22177 if (pnote
->descsz
!= 12)
22178 goto desc_size_fail
;
22180 printf (_(" Stack Size: 0x%" PRIx32
"\n"),
22181 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4));
22182 printf (_(" Stack allocated: %" PRIx32
"\n"),
22183 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
22184 printf (_(" Executable: %s\n"),
22185 ((unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 8, 1)) ? "no": "yes");
22189 print_note_contents_hex(pnote
);
22194 printf (_(" <corrupt - data size is too small>\n"));
22195 error (_("corrupt QNX note: data size is too small\n"));
22200 /* Note that by the ELF standard, the name field is already null byte
22201 terminated, and namesz includes the terminating null byte.
22202 I.E. the value of namesz for the name "FSF" is 4.
22204 If the value of namesz is zero, there is no name present. */
22207 process_note (Elf_Internal_Note
* pnote
,
22208 Filedata
* filedata
)
22210 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
22213 if (pnote
->namesz
== 0)
22214 /* If there is no note name, then use the default set of
22215 note type strings. */
22216 nt
= get_note_type (filedata
, pnote
->type
);
22218 else if (startswith (pnote
->namedata
, "GNU"))
22219 /* GNU-specific object file notes. */
22220 nt
= get_gnu_elf_note_type (pnote
->type
);
22222 else if (startswith (pnote
->namedata
, "AMDGPU"))
22223 /* AMDGPU-specific object file notes. */
22224 nt
= get_amdgpu_elf_note_type (pnote
->type
);
22226 else if (startswith (pnote
->namedata
, "FreeBSD"))
22227 /* FreeBSD-specific core file notes. */
22228 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
22230 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
22231 /* NetBSD-specific core file notes. */
22232 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
22234 else if (startswith (pnote
->namedata
, "NetBSD"))
22235 /* NetBSD-specific core file notes. */
22236 return process_netbsd_elf_note (pnote
);
22238 else if (startswith (pnote
->namedata
, "PaX"))
22239 /* NetBSD-specific core file notes. */
22240 return process_netbsd_elf_note (pnote
);
22242 else if (startswith (pnote
->namedata
, "OpenBSD"))
22243 /* OpenBSD-specific core file notes. */
22244 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
22246 else if (startswith (pnote
->namedata
, "QNX"))
22247 /* QNX-specific core file notes. */
22248 nt
= get_qnx_elfcore_note_type (filedata
, pnote
->type
);
22250 else if (startswith (pnote
->namedata
, "SPU/"))
22252 /* SPU-specific core file notes. */
22253 nt
= pnote
->namedata
+ 4;
22257 else if (startswith (pnote
->namedata
, "IPF/VMS"))
22258 /* VMS/ia64-specific file notes. */
22259 nt
= get_ia64_vms_note_type (pnote
->type
);
22261 else if (startswith (pnote
->namedata
, "stapsdt"))
22262 nt
= get_stapsdt_note_type (pnote
->type
);
22265 /* Don't recognize this note name; just use the default set of
22266 note type strings. */
22267 nt
= get_note_type (filedata
, pnote
->type
);
22271 if (((startswith (pnote
->namedata
, "GA")
22272 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
22273 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
22274 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
22275 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
22276 print_gnu_build_attribute_name (pnote
);
22278 print_symbol (-20, name
);
22281 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
22283 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
22285 if (startswith (pnote
->namedata
, "IPF/VMS"))
22286 return print_ia64_vms_note (pnote
);
22287 else if (startswith (pnote
->namedata
, "GNU"))
22288 return print_gnu_note (filedata
, pnote
);
22289 else if (startswith (pnote
->namedata
, "stapsdt"))
22290 return print_stapsdt_note (pnote
);
22291 else if (startswith (pnote
->namedata
, "CORE"))
22292 return print_core_note (pnote
);
22293 else if (startswith (pnote
->namedata
, "FDO"))
22294 return print_fdo_note (pnote
);
22295 else if (((startswith (pnote
->namedata
, "GA")
22296 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
22297 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
22298 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
22299 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
22300 return print_gnu_build_attribute_description (pnote
, filedata
);
22301 else if (startswith (pnote
->namedata
, "AMDGPU")
22302 && pnote
->type
== NT_AMDGPU_METADATA
)
22303 return print_amdgpu_note (pnote
);
22304 else if (startswith (pnote
->namedata
, "QNX"))
22305 return print_qnx_note (pnote
);
22307 print_note_contents_hex (pnote
);
22312 process_notes_at (Filedata
* filedata
,
22313 Elf_Internal_Shdr
* section
,
22318 Elf_External_Note
*pnotes
;
22319 Elf_External_Note
*external
;
22328 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
22331 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
22339 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22342 if (pnotes
== NULL
)
22347 if (filedata
->is_separate
)
22348 printf (_("In linked file '%s': "), filedata
->file_name
);
22352 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
22354 printf (_("Displaying notes found at file offset 0x%08" PRIx64
22355 " with length 0x%08" PRIx64
":\n"),
22358 /* NB: Some note sections may have alignment value of 0 or 1. gABI
22359 specifies that notes should be aligned to 4 bytes in 32-bit
22360 objects and to 8 bytes in 64-bit objects. As a Linux extension,
22361 we also support 4 byte alignment in 64-bit objects. If section
22362 alignment is less than 4, we treate alignment as 4 bytes. */
22365 else if (align
!= 4 && align
!= 8)
22367 warn (_("Corrupt note: alignment %" PRId64
", expecting 4 or 8\n"),
22373 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
22375 end
= (char *) pnotes
+ length
;
22376 while ((char *) external
< end
)
22378 Elf_Internal_Note inote
;
22381 char * temp
= NULL
;
22382 size_t data_remaining
= end
- (char *) external
;
22384 if (!is_ia64_vms (filedata
))
22386 /* PR binutils/15191
22387 Make sure that there is enough data to read. */
22388 min_notesz
= offsetof (Elf_External_Note
, name
);
22389 if (data_remaining
< min_notesz
)
22391 warn (ngettext ("Corrupt note: only %zd byte remains, "
22392 "not enough for a full note\n",
22393 "Corrupt note: only %zd bytes remain, "
22394 "not enough for a full note\n",
22399 data_remaining
-= min_notesz
;
22401 inote
.type
= BYTE_GET (external
->type
);
22402 inote
.namesz
= BYTE_GET (external
->namesz
);
22403 inote
.namedata
= external
->name
;
22404 inote
.descsz
= BYTE_GET (external
->descsz
);
22405 inote
.descdata
= ((char *) external
22406 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
22407 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22408 next
= ((char *) external
22409 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
22413 Elf64_External_VMS_Note
*vms_external
;
22415 /* PR binutils/15191
22416 Make sure that there is enough data to read. */
22417 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
22418 if (data_remaining
< min_notesz
)
22420 warn (ngettext ("Corrupt note: only %zd byte remains, "
22421 "not enough for a full note\n",
22422 "Corrupt note: only %zd bytes remain, "
22423 "not enough for a full note\n",
22428 data_remaining
-= min_notesz
;
22430 vms_external
= (Elf64_External_VMS_Note
*) external
;
22431 inote
.type
= BYTE_GET (vms_external
->type
);
22432 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
22433 inote
.namedata
= vms_external
->name
;
22434 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
22435 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
22436 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22437 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
22440 /* PR 17531: file: 3443835e. */
22441 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
22442 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
22443 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
22444 || (size_t) (next
- inote
.descdata
) < inote
.descsz
22445 || ((size_t) (next
- inote
.descdata
)
22446 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
22448 warn (_("note with invalid namesz and/or descsz found at offset %#tx\n"),
22449 (char *) external
- (char *) pnotes
);
22450 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx, alignment: %u\n"),
22451 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
22455 external
= (Elf_External_Note
*) next
;
22457 /* Verify that name is null terminated. It appears that at least
22458 one version of Linux (RedHat 6.0) generates corefiles that don't
22459 comply with the ELF spec by failing to include the null byte in
22461 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
22463 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
22465 temp
= (char *) malloc (inote
.namesz
+ 1);
22468 error (_("Out of memory allocating space for inote name\n"));
22473 memcpy (temp
, inote
.namedata
, inote
.namesz
);
22474 inote
.namedata
= temp
;
22476 inote
.namedata
[inote
.namesz
] = 0;
22479 if (! process_note (& inote
, filedata
))
22492 process_corefile_note_segments (Filedata
* filedata
)
22494 Elf_Internal_Phdr
*segment
;
22498 if (! get_program_headers (filedata
))
22501 for (i
= 0, segment
= filedata
->program_headers
;
22502 i
< filedata
->file_header
.e_phnum
;
22505 if (segment
->p_type
== PT_NOTE
)
22506 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
22507 segment
->p_filesz
, segment
->p_align
))
22515 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
22517 Elf_External_Note
* pnotes
;
22518 Elf_External_Note
* external
;
22525 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22527 if (pnotes
== NULL
)
22531 end
= (char*) pnotes
+ length
;
22533 printf (_("\nDisplaying contents of Renesas V850 notes section at offset"
22534 " %#" PRIx64
" with length %#" PRIx64
":\n"),
22537 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
22539 Elf_External_Note
* next
;
22540 Elf_Internal_Note inote
;
22542 inote
.type
= BYTE_GET (external
->type
);
22543 inote
.namesz
= BYTE_GET (external
->namesz
);
22544 inote
.namedata
= external
->name
;
22545 inote
.descsz
= BYTE_GET (external
->descsz
);
22546 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
22547 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22549 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
22551 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
22552 inote
.descdata
= inote
.namedata
;
22556 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
22558 if ( ((char *) next
> end
)
22559 || ((char *) next
< (char *) pnotes
))
22561 warn (_("corrupt descsz found in note at offset %#tx\n"),
22562 (char *) external
- (char *) pnotes
);
22563 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22564 inote
.type
, inote
.namesz
, inote
.descsz
);
22570 /* Prevent out-of-bounds indexing. */
22571 if ( inote
.namedata
+ inote
.namesz
> end
22572 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
22574 warn (_("corrupt namesz found in note at offset %#zx\n"),
22575 (char *) external
- (char *) pnotes
);
22576 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22577 inote
.type
, inote
.namesz
, inote
.descsz
);
22581 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
22583 if (! print_v850_note (& inote
))
22586 printf ("<corrupt sizes: namesz: %#lx, descsz: %#lx>\n",
22587 inote
.namesz
, inote
.descsz
);
22597 process_note_sections (Filedata
* filedata
)
22599 Elf_Internal_Shdr
*section
;
22601 unsigned int n
= 0;
22604 for (i
= 0, section
= filedata
->section_headers
;
22605 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
22608 if (section
->sh_type
== SHT_NOTE
)
22610 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
22611 section
->sh_size
, section
->sh_addralign
))
22616 if (( filedata
->file_header
.e_machine
== EM_V800
22617 || filedata
->file_header
.e_machine
== EM_V850
22618 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
22619 && section
->sh_type
== SHT_RENESAS_INFO
)
22621 if (! process_v850_notes (filedata
, section
->sh_offset
,
22629 /* Try processing NOTE segments instead. */
22630 return process_corefile_note_segments (filedata
);
22636 process_notes (Filedata
* filedata
)
22638 /* If we have not been asked to display the notes then do nothing. */
22642 if (filedata
->file_header
.e_type
!= ET_CORE
)
22643 return process_note_sections (filedata
);
22645 /* No program headers means no NOTE segment. */
22646 if (filedata
->file_header
.e_phnum
> 0)
22647 return process_corefile_note_segments (filedata
);
22649 if (filedata
->is_separate
)
22650 printf (_("No notes found in linked file '%s'.\n"),
22651 filedata
->file_name
);
22653 printf (_("No notes found file.\n"));
22658 static unsigned char *
22659 display_public_gnu_attributes (unsigned char * start
,
22660 const unsigned char * const end
)
22662 printf (_(" Unknown GNU attribute: %s\n"), start
);
22664 start
+= strnlen ((char *) start
, end
- start
);
22665 display_raw_attribute (start
, end
);
22667 return (unsigned char *) end
;
22670 static unsigned char *
22671 display_generic_attribute (unsigned char * start
,
22673 const unsigned char * const end
)
22676 return (unsigned char *) end
;
22678 return display_tag_value (tag
, start
, end
);
22682 process_arch_specific (Filedata
* filedata
)
22687 switch (filedata
->file_header
.e_machine
)
22690 case EM_ARC_COMPACT
:
22691 case EM_ARC_COMPACT2
:
22692 case EM_ARC_COMPACT3
:
22693 case EM_ARC_COMPACT3_64
:
22694 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
22695 display_arc_attribute
,
22696 display_generic_attribute
);
22698 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
22699 display_arm_attribute
,
22700 display_generic_attribute
);
22703 case EM_MIPS_RS3_LE
:
22704 return process_mips_specific (filedata
);
22707 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
22708 display_msp430_attribute
,
22709 display_msp430_gnu_attribute
);
22712 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
22713 display_riscv_attribute
,
22714 display_generic_attribute
);
22717 return process_nds32_specific (filedata
);
22720 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22721 display_m68k_gnu_attribute
);
22725 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22726 display_power_gnu_attribute
);
22730 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22731 display_s390_gnu_attribute
);
22734 case EM_SPARC32PLUS
:
22736 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22737 display_sparc_gnu_attribute
);
22740 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
22741 display_tic6x_attribute
,
22742 display_generic_attribute
);
22745 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
22746 display_csky_attribute
, NULL
);
22749 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
22750 display_public_gnu_attributes
,
22751 display_generic_attribute
);
22756 get_file_header (Filedata
* filedata
)
22758 /* Read in the identity array. */
22759 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
22762 /* Determine how to read the rest of the header. */
22763 switch (filedata
->file_header
.e_ident
[EI_DATA
])
22768 byte_get
= byte_get_little_endian
;
22769 byte_put
= byte_put_little_endian
;
22772 byte_get
= byte_get_big_endian
;
22773 byte_put
= byte_put_big_endian
;
22777 /* For now we only support 32 bit and 64 bit ELF files. */
22778 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
22780 /* Read in the rest of the header. */
22783 Elf32_External_Ehdr ehdr32
;
22785 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22788 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
22789 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
22790 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
22791 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
22792 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
22793 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
22794 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
22795 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
22796 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
22797 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
22798 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
22799 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
22800 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
22804 Elf64_External_Ehdr ehdr64
;
22806 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22809 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
22810 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
22811 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
22812 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
22813 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
22814 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
22815 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
22816 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
22817 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
22818 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
22819 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
22820 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
22821 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
22828 free_filedata (Filedata
*filedata
)
22830 free (filedata
->program_interpreter
);
22831 free (filedata
->program_headers
);
22832 free (filedata
->section_headers
);
22833 free (filedata
->string_table
);
22834 free (filedata
->dump
.dump_sects
);
22835 free (filedata
->dynamic_strings
);
22836 free (filedata
->dynamic_symbols
);
22837 free (filedata
->dynamic_syminfo
);
22838 free (filedata
->dynamic_section
);
22840 while (filedata
->symtab_shndx_list
!= NULL
)
22842 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
22843 free (filedata
->symtab_shndx_list
);
22844 filedata
->symtab_shndx_list
= next
;
22847 free (filedata
->section_headers_groups
);
22849 if (filedata
->section_groups
)
22852 struct group_list
* g
;
22853 struct group_list
* next
;
22855 for (i
= 0; i
< filedata
->group_count
; i
++)
22857 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
22864 free (filedata
->section_groups
);
22866 memset (&filedata
->section_headers
, 0,
22867 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
22871 close_file (Filedata
* filedata
)
22875 if (filedata
->handle
)
22876 fclose (filedata
->handle
);
22882 close_debug_file (void * data
)
22884 free_filedata ((Filedata
*) data
);
22885 close_file ((Filedata
*) data
);
22889 open_file (const char * pathname
, bool is_separate
)
22891 struct stat statbuf
;
22892 Filedata
* filedata
= NULL
;
22894 if (stat (pathname
, & statbuf
) < 0
22895 || ! S_ISREG (statbuf
.st_mode
))
22898 filedata
= calloc (1, sizeof * filedata
);
22899 if (filedata
== NULL
)
22902 filedata
->handle
= fopen (pathname
, "rb");
22903 if (filedata
->handle
== NULL
)
22906 filedata
->file_size
= statbuf
.st_size
;
22907 filedata
->file_name
= pathname
;
22908 filedata
->is_separate
= is_separate
;
22910 if (! get_file_header (filedata
))
22913 if (!get_section_headers (filedata
, false))
22921 if (filedata
->handle
)
22922 fclose (filedata
->handle
);
22929 open_debug_file (const char * pathname
)
22931 return open_file (pathname
, true);
22935 initialise_dump_sects (Filedata
* filedata
)
22937 /* Initialise the dump_sects array from the cmdline_dump_sects array.
22938 Note we do this even if cmdline_dump_sects is empty because we
22939 must make sure that the dump_sets array is zeroed out before each
22940 object file is processed. */
22941 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
22942 memset (filedata
->dump
.dump_sects
, 0,
22943 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22945 if (cmdline
.num_dump_sects
> 0)
22947 if (filedata
->dump
.num_dump_sects
== 0)
22948 /* A sneaky way of allocating the dump_sects array. */
22949 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
22951 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
22952 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
22953 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22958 might_need_separate_debug_info (Filedata
* filedata
)
22960 /* Debuginfo files do not need further separate file loading. */
22961 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
22964 /* Since do_follow_links might be enabled by default, only treat it as an
22965 indication that separate files should be loaded if setting it was a
22966 deliberate user action. */
22967 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
22970 if (process_links
|| do_syms
|| do_unwind
22971 || dump_any_debugging
|| do_dump
|| do_debugging
)
22977 /* Process one ELF object file according to the command line options.
22978 This file may actually be stored in an archive. The file is
22979 positioned at the start of the ELF object. Returns TRUE if no
22980 problems were encountered, FALSE otherwise. */
22983 process_object (Filedata
* filedata
)
22985 bool have_separate_files
;
22989 if (! get_file_header (filedata
))
22991 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
22995 /* Initialise per file variables. */
22996 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
22997 filedata
->version_info
[i
] = 0;
22999 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
23000 filedata
->dynamic_info
[i
] = 0;
23001 filedata
->dynamic_info_DT_GNU_HASH
= 0;
23002 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
23004 /* Process the file. */
23006 printf (_("\nFile: %s\n"), filedata
->file_name
);
23008 initialise_dump_sects (filedata
);
23010 /* There may be some extensions in the first section header. Don't
23011 bomb if we can't read it. */
23012 get_section_headers (filedata
, true);
23014 if (! process_file_header (filedata
))
23020 /* Throw away the single section header read above, so that we
23021 re-read the entire set. */
23022 free (filedata
->section_headers
);
23023 filedata
->section_headers
= NULL
;
23025 if (! process_section_headers (filedata
))
23027 /* Without loaded section headers we cannot process lots of things. */
23028 do_unwind
= do_version
= do_dump
= do_arch
= false;
23030 if (! do_using_dynamic
)
23031 do_syms
= do_dyn_syms
= do_reloc
= false;
23034 if (! process_section_groups (filedata
))
23035 /* Without loaded section groups we cannot process unwind. */
23038 process_program_headers (filedata
);
23040 res
= process_dynamic_section (filedata
);
23042 if (! process_relocs (filedata
))
23045 if (! process_unwind (filedata
))
23048 if (! process_symbol_table (filedata
))
23051 if (! process_lto_symbol_tables (filedata
))
23054 if (! process_syminfo (filedata
))
23057 if (! process_version_sections (filedata
))
23060 if (might_need_separate_debug_info (filedata
))
23061 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
23063 have_separate_files
= false;
23065 if (! process_section_contents (filedata
))
23068 if (have_separate_files
)
23072 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
23074 initialise_dump_sects (d
->handle
);
23076 if (process_links
&& ! process_file_header (d
->handle
))
23078 else if (! process_section_headers (d
->handle
))
23080 else if (! process_section_contents (d
->handle
))
23082 else if (process_links
)
23084 if (! process_section_groups (d
->handle
))
23086 process_program_headers (d
->handle
);
23087 if (! process_dynamic_section (d
->handle
))
23089 if (! process_relocs (d
->handle
))
23091 if (! process_unwind (d
->handle
))
23093 if (! process_symbol_table (d
->handle
))
23095 if (! process_lto_symbol_tables (d
->handle
))
23097 if (! process_syminfo (d
->handle
))
23099 if (! process_version_sections (d
->handle
))
23101 if (! process_notes (d
->handle
))
23106 /* The file handles are closed by the call to free_debug_memory() below. */
23109 if (! process_notes (filedata
))
23112 if (! process_gnu_liblist (filedata
))
23115 if (! process_arch_specific (filedata
))
23119 free_filedata (filedata
);
23121 free_debug_memory ();
23126 /* Process an ELF archive.
23127 On entry the file is positioned just after the ARMAG string.
23128 Returns TRUE upon success, FALSE otherwise. */
23131 process_archive (Filedata
* filedata
, bool is_thin_archive
)
23133 struct archive_info arch
;
23134 struct archive_info nested_arch
;
23140 /* The ARCH structure is used to hold information about this archive. */
23141 arch
.file_name
= NULL
;
23143 arch
.index_array
= NULL
;
23144 arch
.sym_table
= NULL
;
23145 arch
.longnames
= NULL
;
23147 /* The NESTED_ARCH structure is used as a single-item cache of information
23148 about a nested archive (when members of a thin archive reside within
23149 another regular archive file). */
23150 nested_arch
.file_name
= NULL
;
23151 nested_arch
.file
= NULL
;
23152 nested_arch
.index_array
= NULL
;
23153 nested_arch
.sym_table
= NULL
;
23154 nested_arch
.longnames
= NULL
;
23156 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
23157 filedata
->file_size
, is_thin_archive
,
23158 do_archive_index
) != 0)
23164 if (do_archive_index
)
23166 if (arch
.sym_table
== NULL
)
23167 error (_("%s: unable to dump the index as none was found\n"),
23168 filedata
->file_name
);
23172 uint64_t current_pos
;
23174 printf (_("Index of archive %s: (%" PRIu64
" entries,"
23175 " %#" PRIx64
" bytes in the symbol table)\n"),
23176 filedata
->file_name
, arch
.index_num
,
23179 current_pos
= ftell (filedata
->handle
);
23181 for (i
= l
= 0; i
< arch
.index_num
; i
++)
23184 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
23187 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
23190 if (member_name
!= NULL
)
23192 char * qualified_name
23193 = make_qualified_name (&arch
, &nested_arch
,
23196 if (qualified_name
!= NULL
)
23198 printf (_("Contents of binary %s at offset "),
23200 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
23202 free (qualified_name
);
23204 free (member_name
);
23208 if (l
>= arch
.sym_size
)
23210 error (_("%s: end of the symbol table reached "
23211 "before the end of the index\n"),
23212 filedata
->file_name
);
23216 /* PR 17531: file: 0b6630b2. */
23217 printf ("\t%.*s\n",
23218 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
23219 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
23222 if (arch
.uses_64bit_indices
)
23227 if (l
< arch
.sym_size
)
23229 error (ngettext ("%s: %" PRId64
" byte remains in the symbol table, "
23230 "but without corresponding entries in "
23231 "the index table\n",
23232 "%s: %" PRId64
" bytes remain in the symbol table, "
23233 "but without corresponding entries in "
23234 "the index table\n",
23235 arch
.sym_size
- l
),
23236 filedata
->file_name
, arch
.sym_size
- l
);
23240 if (fseek64 (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
23242 error (_("%s: failed to seek back to start of object files "
23243 "in the archive\n"),
23244 filedata
->file_name
);
23250 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
23251 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
23252 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
23253 && !do_section_groups
&& !do_dyn_syms
)
23255 ret
= true; /* Archive index only. */
23264 char * qualified_name
;
23266 /* Read the next archive header. */
23267 if (fseek64 (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
23269 error (_("%s: failed to seek to next archive header\n"),
23274 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
23275 if (got
!= sizeof arch
.arhdr
)
23279 /* PR 24049 - we cannot use filedata->file_name as this will
23280 have already been freed. */
23281 error (_("%s: failed to read archive header\n"), arch
.file_name
);
23286 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
23288 error (_("%s: did not find a valid archive header\n"),
23294 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
23296 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
23298 name
= get_archive_member_name (&arch
, &nested_arch
);
23301 error (_("%s: bad archive file name\n"), arch
.file_name
);
23305 namelen
= strlen (name
);
23307 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
23308 if (qualified_name
== NULL
)
23310 error (_("%s: bad archive file name\n"), arch
.file_name
);
23316 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
23318 /* This is a proxy for an external member of a thin archive. */
23319 Filedata
* member_filedata
;
23320 char * member_file_name
= adjust_relative_path
23321 (filedata
->file_name
, name
, namelen
);
23324 if (member_file_name
== NULL
)
23326 free (qualified_name
);
23331 member_filedata
= open_file (member_file_name
, false);
23332 if (member_filedata
== NULL
)
23334 error (_("Input file '%s' is not readable.\n"), member_file_name
);
23335 free (member_file_name
);
23336 free (qualified_name
);
23341 filedata
->archive_file_offset
= arch
.nested_member_origin
;
23342 member_filedata
->file_name
= qualified_name
;
23344 /* The call to process_object() expects the file to be at the beginning. */
23345 rewind (member_filedata
->handle
);
23347 if (! process_object (member_filedata
))
23350 close_file (member_filedata
);
23351 free (member_file_name
);
23353 else if (is_thin_archive
)
23355 Filedata thin_filedata
;
23357 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
23359 /* PR 15140: Allow for corrupt thin archives. */
23360 if (nested_arch
.file
== NULL
)
23362 error (_("%s: contains corrupt thin archive: %s\n"),
23363 qualified_name
, name
);
23364 free (qualified_name
);
23371 /* This is a proxy for a member of a nested archive. */
23372 filedata
->archive_file_offset
23373 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
23375 /* The nested archive file will have been opened and setup by
23376 get_archive_member_name. */
23377 if (fseek64 (nested_arch
.file
, filedata
->archive_file_offset
,
23380 error (_("%s: failed to seek to archive member.\n"),
23381 nested_arch
.file_name
);
23382 free (qualified_name
);
23387 thin_filedata
.handle
= nested_arch
.file
;
23388 thin_filedata
.file_name
= qualified_name
;
23390 if (! process_object (& thin_filedata
))
23396 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
23397 filedata
->file_name
= qualified_name
;
23398 if (! process_object (filedata
))
23400 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
23401 /* Stop looping with "negative" archive_file_size. */
23402 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
23403 arch
.next_arhdr_offset
= -1ul;
23406 free (qualified_name
);
23410 if (nested_arch
.file
!= NULL
)
23411 fclose (nested_arch
.file
);
23412 release_archive (&nested_arch
);
23413 release_archive (&arch
);
23419 process_file (char * file_name
)
23421 Filedata
* filedata
= NULL
;
23422 struct stat statbuf
;
23423 char armag
[SARMAG
];
23426 if (stat (file_name
, &statbuf
) < 0)
23428 if (errno
== ENOENT
)
23429 error (_("'%s': No such file\n"), file_name
);
23431 error (_("Could not locate '%s'. System error message: %s\n"),
23432 file_name
, strerror (errno
));
23436 if (! S_ISREG (statbuf
.st_mode
))
23438 error (_("'%s' is not an ordinary file\n"), file_name
);
23442 filedata
= calloc (1, sizeof * filedata
);
23443 if (filedata
== NULL
)
23445 error (_("Out of memory allocating file data structure\n"));
23449 filedata
->file_name
= file_name
;
23450 filedata
->handle
= fopen (file_name
, "rb");
23451 if (filedata
->handle
== NULL
)
23453 error (_("Input file '%s' is not readable.\n"), file_name
);
23458 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
23460 error (_("%s: Failed to read file's magic number\n"), file_name
);
23461 fclose (filedata
->handle
);
23466 filedata
->file_size
= statbuf
.st_size
;
23467 filedata
->is_separate
= false;
23469 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
23471 if (! process_archive (filedata
, false))
23474 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
23476 if ( ! process_archive (filedata
, true))
23481 if (do_archive_index
&& !check_all
)
23482 error (_("File %s is not an archive so its index cannot be displayed.\n"),
23485 rewind (filedata
->handle
);
23486 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
23488 if (! process_object (filedata
))
23492 fclose (filedata
->handle
);
23493 free (filedata
->section_headers
);
23494 free (filedata
->program_headers
);
23495 free (filedata
->string_table
);
23496 free (filedata
->dump
.dump_sects
);
23499 free (ba_cache
.strtab
);
23500 ba_cache
.strtab
= NULL
;
23501 free (ba_cache
.symtab
);
23502 ba_cache
.symtab
= NULL
;
23503 ba_cache
.filedata
= NULL
;
23508 #ifdef SUPPORT_DISASSEMBLY
23509 /* Needed by the i386 disassembler. For extra credit, someone could
23510 fix this so that we insert symbolic addresses here, esp for GOT/PLT
23514 print_address (unsigned int addr
, FILE * outfile
)
23516 fprintf (outfile
,"0x%8.8x", addr
);
23519 /* Needed by the i386 disassembler. */
23522 db_task_printsym (unsigned int addr
)
23524 print_address (addr
, stderr
);
23529 main (int argc
, char ** argv
)
23533 #ifdef HAVE_LC_MESSAGES
23534 setlocale (LC_MESSAGES
, "");
23536 setlocale (LC_CTYPE
, "");
23537 bindtextdomain (PACKAGE
, LOCALEDIR
);
23538 textdomain (PACKAGE
);
23540 expandargv (&argc
, &argv
);
23542 parse_args (& cmdline
, argc
, argv
);
23544 if (optind
< (argc
- 1))
23545 /* When displaying information for more than one file,
23546 prefix the information with the file name. */
23548 else if (optind
>= argc
)
23550 /* Ensure that the warning is always displayed. */
23553 warn (_("Nothing to do.\n"));
23558 while (optind
< argc
)
23559 if (! process_file (argv
[optind
++]))
23562 free (cmdline
.dump_sects
);
23564 free (dump_ctf_symtab_name
);
23565 free (dump_ctf_strtab_name
);
23566 free (dump_ctf_parent_name
);
23568 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;