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"
124 #include "elf/lm32.h"
125 #include "elf/iq2000.h"
126 #include "elf/m32c.h"
127 #include "elf/m32r.h"
128 #include "elf/m68k.h"
129 #include "elf/m68hc11.h"
130 #include "elf/s12z.h"
131 #include "elf/mcore.h"
133 #include "elf/metag.h"
134 #include "elf/microblaze.h"
135 #include "elf/mips.h"
136 #include "elf/mmix.h"
137 #include "elf/mn10200.h"
138 #include "elf/mn10300.h"
139 #include "elf/moxie.h"
141 #include "elf/msp430.h"
142 #include "elf/nds32.h"
144 #include "elf/nios2.h"
145 #include "elf/or1k.h"
148 #include "elf/ppc64.h"
150 #include "elf/riscv.h"
151 #include "elf/rl78.h"
153 #include "elf/s390.h"
154 #include "elf/score.h"
156 #include "elf/sparc.h"
158 #include "elf/tic6x.h"
159 #include "elf/tilegx.h"
160 #include "elf/tilepro.h"
161 #include "elf/v850.h"
163 #include "elf/visium.h"
164 #include "elf/wasm32.h"
165 #include "elf/x86-64.h"
166 #include "elf/xgate.h"
167 #include "elf/xstormy16.h"
168 #include "elf/xtensa.h"
170 #include "elf/loongarch.h"
173 #include "libiberty.h"
174 #include "safe-ctype.h"
175 #include "filenames.h"
178 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
181 typedef struct elf_section_list
183 Elf_Internal_Shdr
* hdr
;
184 struct elf_section_list
* next
;
187 /* Flag bits indicating particular types of dump. */
188 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
189 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
190 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
191 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
192 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
193 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
194 #define SFRAME_DUMP (1 << 6) /* The --sframe command line switch. */
196 typedef unsigned char dump_type
;
198 /* A linked list of the section names for which dumps were requested. */
199 struct dump_list_entry
203 struct dump_list_entry
* next
;
206 /* A dynamic array of flags indicating for which sections a dump
207 has been requested via command line switches. */
210 dump_type
* dump_sects
;
211 unsigned int num_dump_sects
;
214 static struct dump_data cmdline
;
216 static struct dump_list_entry
* dump_sects_byname
;
218 char * program_name
= "readelf";
220 static bool show_name
= false;
221 static bool do_dynamic
= false;
222 static bool do_syms
= false;
223 static bool do_dyn_syms
= false;
224 static bool do_lto_syms
= false;
225 static bool do_reloc
= false;
226 static bool do_sections
= false;
227 static bool do_section_groups
= false;
228 static bool do_section_details
= false;
229 static bool do_segments
= false;
230 static bool do_unwind
= false;
231 static bool do_using_dynamic
= false;
232 static bool do_header
= false;
233 static bool do_dump
= false;
234 static bool do_version
= false;
235 static bool do_histogram
= false;
236 static bool do_debugging
= false;
237 static bool do_ctf
= false;
238 static bool do_sframe
= false;
239 static bool do_arch
= false;
240 static bool do_notes
= false;
241 static bool do_archive_index
= false;
242 static bool check_all
= false;
243 static bool is_32bit_elf
= false;
244 static bool decompress_dumps
= false;
245 static bool do_not_show_symbol_truncation
= false;
246 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
247 static bool process_links
= false;
248 static bool dump_any_debugging
= false;
249 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
250 static int sym_base
= 0;
252 static char *dump_ctf_parent_name
;
253 static char *dump_ctf_symtab_name
;
254 static char *dump_ctf_strtab_name
;
258 struct group_list
* next
;
259 unsigned int section_index
;
264 struct group_list
* root
;
265 unsigned int group_index
;
268 typedef struct filedata
270 const char * file_name
;
274 Elf_Internal_Ehdr file_header
;
275 uint64_t archive_file_offset
;
276 uint64_t archive_file_size
;
277 /* Everything below this point is cleared out by free_filedata. */
278 Elf_Internal_Shdr
* section_headers
;
279 Elf_Internal_Phdr
* program_headers
;
281 uint64_t string_table_length
;
282 uint64_t dynamic_addr
;
283 uint64_t dynamic_size
;
284 uint64_t dynamic_nent
;
285 Elf_Internal_Dyn
* dynamic_section
;
286 Elf_Internal_Shdr
* dynamic_strtab_section
;
287 char * dynamic_strings
;
288 uint64_t dynamic_strings_length
;
289 Elf_Internal_Shdr
* dynamic_symtab_section
;
290 uint64_t num_dynamic_syms
;
291 Elf_Internal_Sym
* dynamic_symbols
;
292 uint64_t version_info
[16];
293 unsigned int dynamic_syminfo_nent
;
294 Elf_Internal_Syminfo
* dynamic_syminfo
;
295 uint64_t dynamic_syminfo_offset
;
300 uint64_t ngnubuckets
;
302 uint64_t * gnubuckets
;
303 uint64_t * gnuchains
;
306 char * program_interpreter
;
307 uint64_t dynamic_info
[DT_RELRENT
+ 1];
308 uint64_t dynamic_info_DT_GNU_HASH
;
309 uint64_t dynamic_info_DT_MIPS_XHASH
;
310 elf_section_list
* symtab_shndx_list
;
312 struct group
* section_groups
;
313 struct group
** section_headers_groups
;
314 /* A dynamic array of flags indicating for which sections a dump of
315 some kind has been requested. It is reset on a per-object file
316 basis and then initialised from the cmdline_dump_sects array,
317 the results of interpreting the -w switch, and the
318 dump_sects_byname list. */
319 struct dump_data dump
;
322 /* How to print a vma value. */
323 typedef enum print_mode
340 typedef enum unicode_display_type
348 } unicode_display_type
;
350 static unicode_display_type unicode_display
= unicode_default
;
360 /* Versioned symbol info. */
361 enum versioned_symbol_info
369 fseek64 (FILE *stream
, int64_t offset
, int whence
)
371 #if defined (HAVE_FSEEKO64)
378 return fseeko64 (stream
, o
, whence
);
379 #elif defined (HAVE_FSEEKO)
386 return fseeko (stream
, o
, whence
);
394 return fseek (stream
, o
, whence
);
398 static const char * get_symbol_version_string
399 (Filedata
*, bool, const char *, size_t, unsigned,
400 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
404 static inline const char *
405 section_name (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
407 return filedata
->string_table
+ hdr
->sh_name
;
411 section_name_valid (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
414 && filedata
->string_table
!= NULL
415 && hdr
->sh_name
< filedata
->string_table_length
);
418 static inline const char *
419 section_name_print (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
423 if (filedata
->string_table
== NULL
)
424 return _("<no-strings>");
425 if (hdr
->sh_name
>= filedata
->string_table_length
)
426 return _("<corrupt>");
427 return section_name (filedata
, hdr
);
430 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
433 valid_symbol_name (const char *strtab
, size_t strtab_size
, uint64_t offset
)
435 return strtab
!= NULL
&& offset
< strtab_size
;
439 valid_dynamic_name (const Filedata
*filedata
, uint64_t offset
)
441 return valid_symbol_name (filedata
->dynamic_strings
,
442 filedata
->dynamic_strings_length
, offset
);
445 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
446 already been called and verified that the string exists. */
447 static inline const char *
448 get_dynamic_name (const Filedata
*filedata
, size_t offset
)
450 return filedata
->dynamic_strings
+ offset
;
453 #define REMOVE_ARCH_BITS(ADDR) \
456 if (filedata->file_header.e_machine == EM_ARM) \
461 /* Get the correct GNU hash section name. */
462 #define GNU_HASH_SECTION_NAME(filedata) \
463 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
465 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
466 OFFSET + the offset of the current archive member, if we are examining an
467 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
468 allocate a buffer using malloc and fill that. In either case return the
469 pointer to the start of the retrieved data or NULL if something went wrong.
470 If something does go wrong and REASON is not NULL then emit an error
471 message using REASON as part of the context. */
482 uint64_t amt
= size
* nmemb
;
484 if (size
== 0 || nmemb
== 0)
487 /* If size_t is smaller than uint64_t, eg because you are building
488 on a 32-bit host, then make sure that when the sizes are cast to
489 size_t no information is lost. */
490 if ((size_t) size
!= size
491 || (size_t) nmemb
!= nmemb
492 || (size_t) amt
!= amt
493 || amt
/ size
!= nmemb
494 || (size_t) amt
+ 1 == 0)
497 error (_("Size overflow prevents reading %" PRIu64
498 " elements of size %" PRIu64
" for %s\n"),
499 nmemb
, size
, reason
);
503 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
504 attempting to allocate memory when the read is bound to fail. */
505 if (filedata
->archive_file_offset
> filedata
->file_size
506 || offset
> filedata
->file_size
- filedata
->archive_file_offset
507 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
510 error (_("Reading %" PRIu64
" bytes extends past end of file for %s\n"),
515 if (fseek64 (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
519 error (_("Unable to seek to %#" PRIx64
" for %s\n"),
520 filedata
->archive_file_offset
+ offset
, reason
);
527 /* + 1 so that we can '\0' terminate invalid string table sections. */
528 mvar
= malloc ((size_t) amt
+ 1);
533 error (_("Out of memory allocating %" PRIu64
" bytes for %s\n"),
538 ((char *) mvar
)[amt
] = '\0';
541 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
544 error (_("Unable to read in %" PRIu64
" bytes of %s\n"),
554 /* Print a VMA value in the MODE specified.
555 Returns the number of characters displayed. */
558 print_vma (uint64_t vma
, print_mode mode
)
569 return nc
+ printf ("%16.16" PRIx64
, vma
);
570 return nc
+ printf ("%8.8" PRIx64
, vma
);
574 return printf ("%5" PRId64
, vma
);
580 return nc
+ printf ("%" PRIx64
, vma
);
586 return nc
+ printf ("%05" PRIx64
, vma
);
589 return printf ("%" PRId64
, vma
);
592 return printf ("%" PRIu64
, vma
);
595 return printf ("%5" PRIu64
, vma
);
598 return printf ("%" PRIo64
, vma
);
601 return printf ("%5" PRIo64
, vma
);
604 /* FIXME: Report unrecognised mode ? */
610 /* Display a symbol on stdout. Handles the display of control characters and
611 multibye characters (assuming the host environment supports them).
613 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
615 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
616 abs(WIDTH) - 5 characters followed by "[...]".
618 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
619 padding as necessary.
621 Returns the number of emitted characters. */
624 print_symbol (signed int width
, const char * symbol
)
626 bool extra_padding
= false;
627 bool do_dots
= false;
628 signed int num_printed
= 0;
629 #ifdef HAVE_MBSTATE_T
632 unsigned int width_remaining
;
633 const void * alloced_symbol
= NULL
;
637 /* Keep the width positive. This helps the code below. */
639 extra_padding
= true;
645 /* Set the remaining width to a very large value.
646 This simplifies the code below. */
647 width_remaining
= INT_MAX
;
650 width_remaining
= width
;
651 if (! do_not_show_symbol_truncation
652 && (int) strlen (symbol
) > width
)
654 width_remaining
-= 5;
655 if ((int) width_remaining
< 0)
661 #ifdef HAVE_MBSTATE_T
662 /* Initialise the multibyte conversion state. */
663 memset (& state
, 0, sizeof (state
));
666 if (do_demangle
&& *symbol
)
668 const char * res
= cplus_demangle (symbol
, demangle_flags
);
671 alloced_symbol
= symbol
= res
;
674 while (width_remaining
)
677 const char c
= *symbol
++;
688 else if (ISCNTRL (c
))
690 /* Do not print control characters directly as they can affect terminal
691 settings. Such characters usually appear in the names generated
692 by the assembler for local labels. */
694 if (width_remaining
< 2)
697 printf ("^%c", c
+ 0x40);
698 width_remaining
-= 2;
703 if (width_remaining
< 5)
706 width_remaining
-= 5;
709 else if (unicode_display
!= unicode_locale
710 && unicode_display
!= unicode_default
)
712 /* Display unicode characters as something else. */
713 unsigned char bytes
[4];
726 bytes
[1] = *symbol
++;
728 if ((bytes
[1] & 0xc0) != 0x80)
731 /* Do not consume this character. It may only
732 be the first byte in the sequence that was
737 else if ((bytes
[0] & 0x20) == 0)
744 bytes
[2] = *symbol
++;
746 if ((bytes
[2] & 0xc0) != 0x80)
752 else if ((bytes
[0] & 0x10) == 0)
759 bytes
[3] = *symbol
++;
763 if ((bytes
[3] & 0xc0) != 0x80)
775 if (unicode_display
== unicode_invalid
)
778 if (unicode_display
== unicode_hex
|| ! is_utf8
)
782 if (width_remaining
< (nbytes
* 2) + 2)
785 putchar (is_utf8
? '<' : '{');
787 for (i
= 0; i
< nbytes
; i
++)
788 printf ("%02x", bytes
[i
]);
789 putchar (is_utf8
? '>' : '}');
793 if (unicode_display
== unicode_highlight
&& isatty (1))
794 printf ("\x1B[31;47m"); /* Red. */
799 if (width_remaining
< 6)
801 printf ("\\u%02x%02x",
802 (bytes
[0] & 0x1c) >> 2,
803 ((bytes
[0] & 0x03) << 6) | (bytes
[1] & 0x3f));
806 if (width_remaining
< 6)
808 printf ("\\u%02x%02x",
809 ((bytes
[0] & 0x0f) << 4) | ((bytes
[1] & 0x3c) >> 2),
810 ((bytes
[1] & 0x03) << 6) | (bytes
[2] & 0x3f));
813 if (width_remaining
< 8)
815 printf ("\\u%02x%02x%02x",
816 ((bytes
[0] & 0x07) << 6) | ((bytes
[1] & 0x3c) >> 2),
817 ((bytes
[1] & 0x03) << 6) | ((bytes
[2] & 0x3c) >> 2),
818 ((bytes
[2] & 0x03) << 6) | (bytes
[3] & 0x3f));
826 if (unicode_display
== unicode_highlight
&& isatty (1))
827 printf ("\033[0m"); /* Default colour. */
830 if (bytes
[nbytes
- 1] == 0)
835 #ifdef HAVE_MBSTATE_T
838 /* Let printf do the hard work of displaying multibyte characters. */
839 printf ("%.1s", symbol
- 1);
843 #ifdef HAVE_MBSTATE_T
844 /* Try to find out how many bytes made up the character that was
845 just printed. Advance the symbol pointer past the bytes that
847 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
851 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
857 num_printed
+= printf ("[...]");
859 if (extra_padding
&& num_printed
< width
)
861 /* Fill in the remaining spaces. */
862 printf ("%-*s", width
- num_printed
, " ");
866 free ((void *) alloced_symbol
);
870 /* Returns a pointer to a static buffer containing a printable version of
871 the given section's name. Like print_symbol, except that it does not try
872 to print multibyte characters, it just interprets them as hex values. */
875 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
877 #define MAX_PRINT_SEC_NAME_LEN 256
878 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
879 const char * name
= section_name_print (filedata
, sec
);
880 char * buf
= sec_name_buf
;
882 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
884 while ((c
= * name
++) != 0)
895 else if (ISPRINT (c
))
902 static char hex
[17] = "0123456789ABCDEF";
907 * buf
++ = hex
[(c
& 0xf0) >> 4];
908 * buf
++ = hex
[c
& 0x0f];
922 printable_section_name_from_index (Filedata
*filedata
, size_t ndx
)
924 if (ndx
>= filedata
->file_header
.e_shnum
)
925 return _("<corrupt>");
927 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
930 /* Return a pointer to section NAME, or NULL if no such section exists. */
932 static Elf_Internal_Shdr
*
933 find_section (Filedata
* filedata
, const char * name
)
937 if (filedata
->section_headers
== NULL
)
940 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
941 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
942 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
944 return filedata
->section_headers
+ i
;
949 /* Return a pointer to a section containing ADDR, or NULL if no such
952 static Elf_Internal_Shdr
*
953 find_section_by_address (Filedata
* filedata
, uint64_t addr
)
957 if (filedata
->section_headers
== NULL
)
960 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
962 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
964 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
971 static Elf_Internal_Shdr
*
972 find_section_by_type (Filedata
* filedata
, unsigned int type
)
976 if (filedata
->section_headers
== NULL
)
979 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
981 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
983 if (sec
->sh_type
== type
)
990 /* Return a pointer to section NAME, or NULL if no such section exists,
991 restricted to the list of sections given in SET. */
993 static Elf_Internal_Shdr
*
994 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
998 if (filedata
->section_headers
== NULL
)
1003 while ((i
= *set
++) > 0)
1005 /* See PR 21156 for a reproducer. */
1006 if (i
>= filedata
->file_header
.e_shnum
)
1007 continue; /* FIXME: Should we issue an error message ? */
1009 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1010 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1012 return filedata
->section_headers
+ i
;
1016 return find_section (filedata
, name
);
1019 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
1020 This OS has so many departures from the ELF standard that we test it at
1024 is_ia64_vms (Filedata
* filedata
)
1026 return filedata
->file_header
.e_machine
== EM_IA_64
1027 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
1030 /* Guess the relocation size commonly used by the specific machines. */
1033 guess_is_rela (unsigned int e_machine
)
1037 /* Targets that use REL relocations. */
1043 case EM_CYGNUS_D10V
:
1046 case EM_MIPS_RS3_LE
:
1047 case EM_CYGNUS_M32R
:
1054 /* Targets that use RELA relocations. */
1058 case EM_ADAPTEVA_EPIPHANY
:
1060 case EM_ALTERA_NIOS2
:
1062 case EM_ARC_COMPACT
:
1063 case EM_ARC_COMPACT2
:
1072 case EM_CYGNUS_D30V
:
1075 case EM_CYGNUS_FR30
:
1084 case EM_LATTICEMICO32
:
1093 case EM_CYGNUS_MN10200
:
1095 case EM_CYGNUS_MN10300
:
1113 case EM_SPARC32PLUS
:
1121 case EM_CYGNUS_V850
:
1131 case EM_MICROBLAZE_OLD
:
1132 case EM_WEBASSEMBLY
:
1153 warn (_("Don't know about relocations on this machine architecture\n"));
1158 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1159 Returns TRUE upon success, FALSE otherwise. If successful then a
1160 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
1161 and the number of relocs loaded is placed in *NRELASP. It is the caller's
1162 responsibility to free the allocated buffer. */
1165 slurp_rela_relocs (Filedata
*filedata
,
1166 uint64_t rel_offset
,
1168 Elf_Internal_Rela
**relasp
,
1171 Elf_Internal_Rela
* relas
;
1177 Elf32_External_Rela
* erelas
;
1179 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1180 rel_size
, _("32-bit relocation data"));
1184 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1186 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1187 sizeof (Elf_Internal_Rela
));
1192 error (_("out of memory parsing relocs\n"));
1196 for (i
= 0; i
< nrelas
; i
++)
1198 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1199 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1200 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1207 Elf64_External_Rela
* erelas
;
1209 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1210 rel_size
, _("64-bit relocation data"));
1214 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1216 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1217 sizeof (Elf_Internal_Rela
));
1222 error (_("out of memory parsing relocs\n"));
1226 for (i
= 0; i
< nrelas
; i
++)
1228 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1229 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1230 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1232 if (filedata
->file_header
.e_machine
== EM_MIPS
1233 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1235 /* In little-endian objects, r_info isn't really a
1236 64-bit little-endian value: it has a 32-bit
1237 little-endian symbol index followed by four
1238 individual byte fields. Reorder INFO
1240 uint64_t inf
= relas
[i
].r_info
;
1241 inf
= (((inf
& 0xffffffff) << 32)
1242 | ((inf
>> 56) & 0xff)
1243 | ((inf
>> 40) & 0xff00)
1244 | ((inf
>> 24) & 0xff0000)
1245 | ((inf
>> 8) & 0xff000000));
1246 relas
[i
].r_info
= inf
;
1258 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1259 Returns TRUE upon success, FALSE otherwise. If successful then a
1260 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1261 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1262 responsibility to free the allocated buffer. */
1265 slurp_rel_relocs (Filedata
*filedata
,
1266 uint64_t rel_offset
,
1268 Elf_Internal_Rela
**relsp
,
1271 Elf_Internal_Rela
* rels
;
1277 Elf32_External_Rel
* erels
;
1279 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1280 rel_size
, _("32-bit relocation data"));
1284 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1286 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1291 error (_("out of memory parsing relocs\n"));
1295 for (i
= 0; i
< nrels
; i
++)
1297 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1298 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1299 rels
[i
].r_addend
= 0;
1306 Elf64_External_Rel
* erels
;
1308 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1309 rel_size
, _("64-bit relocation data"));
1313 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1315 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1320 error (_("out of memory parsing relocs\n"));
1324 for (i
= 0; i
< nrels
; i
++)
1326 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1327 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1328 rels
[i
].r_addend
= 0;
1330 if (filedata
->file_header
.e_machine
== EM_MIPS
1331 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1333 /* In little-endian objects, r_info isn't really a
1334 64-bit little-endian value: it has a 32-bit
1335 little-endian symbol index followed by four
1336 individual byte fields. Reorder INFO
1338 uint64_t inf
= rels
[i
].r_info
;
1339 inf
= (((inf
& 0xffffffff) << 32)
1340 | ((inf
>> 56) & 0xff)
1341 | ((inf
>> 40) & 0xff00)
1342 | ((inf
>> 24) & 0xff0000)
1343 | ((inf
>> 8) & 0xff000000));
1344 rels
[i
].r_info
= inf
;
1357 slurp_relr_relocs (Filedata
*filedata
,
1358 uint64_t relr_offset
,
1364 size_t size
= 0, nentries
, i
;
1365 uint64_t base
= 0, addr
, entry
;
1367 relrs
= get_data (NULL
, filedata
, relr_offset
, 1, relr_size
,
1368 _("RELR relocation data"));
1373 nentries
= relr_size
/ sizeof (Elf32_External_Relr
);
1375 nentries
= relr_size
/ sizeof (Elf64_External_Relr
);
1376 for (i
= 0; i
< nentries
; i
++)
1379 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1381 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1382 if ((entry
& 1) == 0)
1385 while ((entry
>>= 1) != 0)
1386 if ((entry
& 1) == 1)
1390 *relrsp
= malloc (size
* sizeof (**relrsp
));
1391 if (*relrsp
== NULL
)
1394 error (_("out of memory parsing relocs\n"));
1399 for (i
= 0; i
< nentries
; i
++)
1401 const uint64_t entry_bytes
= is_32bit_elf
? 4 : 8;
1404 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1406 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1407 if ((entry
& 1) == 0)
1409 (*relrsp
)[size
++] = entry
;
1410 base
= entry
+ entry_bytes
;
1414 for (addr
= base
; (entry
>>= 1) != 0; addr
+= entry_bytes
)
1415 if ((entry
& 1) != 0)
1416 (*relrsp
)[size
++] = addr
;
1417 base
+= entry_bytes
* (entry_bytes
* CHAR_BIT
- 1);
1426 /* Returns the reloc type extracted from the reloc info field. */
1429 get_reloc_type (Filedata
* filedata
, uint64_t reloc_info
)
1432 return ELF32_R_TYPE (reloc_info
);
1434 switch (filedata
->file_header
.e_machine
)
1437 /* Note: We assume that reloc_info has already been adjusted for us. */
1438 return ELF64_MIPS_R_TYPE (reloc_info
);
1441 return ELF64_R_TYPE_ID (reloc_info
);
1444 return ELF64_R_TYPE (reloc_info
);
1448 /* Return the symbol index extracted from the reloc info field. */
1451 get_reloc_symindex (uint64_t reloc_info
)
1453 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1457 uses_msp430x_relocs (Filedata
* filedata
)
1460 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1461 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1462 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1463 /* TI compiler uses ELFOSABI_NONE. */
1464 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1467 /* Display the contents of the relocation data found at the specified
1471 dump_relocations (Filedata
*filedata
,
1472 uint64_t rel_offset
,
1474 Elf_Internal_Sym
*symtab
,
1478 relocation_type rel_type
,
1482 Elf_Internal_Rela
* rels
;
1485 if (rel_type
== reltype_unknown
)
1486 rel_type
= guess_is_rela (filedata
->file_header
.e_machine
) ? reltype_rela
: reltype_rel
;
1488 if (rel_type
== reltype_rela
)
1490 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1493 else if (rel_type
== reltype_rel
)
1495 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1498 else if (rel_type
== reltype_relr
)
1502 = is_32bit_elf
? "%08" PRIx64
"\n" : "%016" PRIx64
"\n";
1504 if (!slurp_relr_relocs (filedata
, rel_offset
, rel_size
, &relrs
,
1508 printf (ngettext (" %" PRIu64
" offset\n",
1509 " %" PRIu64
" offsets\n", rel_size
),
1511 for (i
= 0; i
< rel_size
; i
++)
1512 printf (format
, relrs
[i
]);
1519 if (rel_type
== reltype_rela
)
1522 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1524 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1529 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1531 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1536 if (rel_type
== reltype_rela
)
1539 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1541 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1546 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1548 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1552 for (i
= 0; i
< rel_size
; i
++)
1557 uint64_t symtab_index
;
1560 offset
= rels
[i
].r_offset
;
1561 inf
= rels
[i
].r_info
;
1563 type
= get_reloc_type (filedata
, inf
);
1564 symtab_index
= get_reloc_symindex (inf
);
1568 printf ("%8.8lx %8.8lx ",
1569 (unsigned long) offset
& 0xffffffff,
1570 (unsigned long) inf
& 0xffffffff);
1575 ? "%16.16" PRIx64
" %16.16" PRIx64
" "
1576 : "%12.12" PRIx64
" %12.12" PRIx64
" ",
1580 switch (filedata
->file_header
.e_machine
)
1587 rtype
= elf_aarch64_reloc_type (type
);
1591 case EM_CYGNUS_M32R
:
1592 rtype
= elf_m32r_reloc_type (type
);
1597 rtype
= elf_i386_reloc_type (type
);
1602 rtype
= elf_m68hc11_reloc_type (type
);
1606 rtype
= elf_s12z_reloc_type (type
);
1610 rtype
= elf_m68k_reloc_type (type
);
1614 rtype
= elf_i960_reloc_type (type
);
1619 rtype
= elf_avr_reloc_type (type
);
1622 case EM_OLD_SPARCV9
:
1623 case EM_SPARC32PLUS
:
1626 rtype
= elf_sparc_reloc_type (type
);
1630 rtype
= elf_spu_reloc_type (type
);
1634 rtype
= v800_reloc_type (type
);
1637 case EM_CYGNUS_V850
:
1638 rtype
= v850_reloc_type (type
);
1642 case EM_CYGNUS_D10V
:
1643 rtype
= elf_d10v_reloc_type (type
);
1647 case EM_CYGNUS_D30V
:
1648 rtype
= elf_d30v_reloc_type (type
);
1652 rtype
= elf_dlx_reloc_type (type
);
1656 rtype
= elf_sh_reloc_type (type
);
1660 case EM_CYGNUS_MN10300
:
1661 rtype
= elf_mn10300_reloc_type (type
);
1665 case EM_CYGNUS_MN10200
:
1666 rtype
= elf_mn10200_reloc_type (type
);
1670 case EM_CYGNUS_FR30
:
1671 rtype
= elf_fr30_reloc_type (type
);
1675 rtype
= elf_frv_reloc_type (type
);
1679 rtype
= elf_csky_reloc_type (type
);
1683 rtype
= elf_ft32_reloc_type (type
);
1687 rtype
= elf_mcore_reloc_type (type
);
1691 rtype
= elf_mmix_reloc_type (type
);
1695 rtype
= elf_moxie_reloc_type (type
);
1699 if (uses_msp430x_relocs (filedata
))
1701 rtype
= elf_msp430x_reloc_type (type
);
1706 rtype
= elf_msp430_reloc_type (type
);
1710 rtype
= elf_nds32_reloc_type (type
);
1714 rtype
= elf_ppc_reloc_type (type
);
1718 rtype
= elf_ppc64_reloc_type (type
);
1722 case EM_MIPS_RS3_LE
:
1723 rtype
= elf_mips_reloc_type (type
);
1727 rtype
= elf_riscv_reloc_type (type
);
1731 rtype
= elf_alpha_reloc_type (type
);
1735 rtype
= elf_arm_reloc_type (type
);
1739 case EM_ARC_COMPACT
:
1740 case EM_ARC_COMPACT2
:
1741 rtype
= elf_arc_reloc_type (type
);
1745 rtype
= elf_hppa_reloc_type (type
);
1751 rtype
= elf_h8_reloc_type (type
);
1755 rtype
= elf_or1k_reloc_type (type
);
1760 rtype
= elf_pj_reloc_type (type
);
1763 rtype
= elf_ia64_reloc_type (type
);
1767 rtype
= elf_cris_reloc_type (type
);
1771 rtype
= elf_i860_reloc_type (type
);
1777 rtype
= elf_x86_64_reloc_type (type
);
1781 rtype
= i370_reloc_type (type
);
1786 rtype
= elf_s390_reloc_type (type
);
1790 rtype
= elf_score_reloc_type (type
);
1794 rtype
= elf_xstormy16_reloc_type (type
);
1798 rtype
= elf_crx_reloc_type (type
);
1802 rtype
= elf_vax_reloc_type (type
);
1806 rtype
= elf_visium_reloc_type (type
);
1810 rtype
= elf_bpf_reloc_type (type
);
1813 case EM_ADAPTEVA_EPIPHANY
:
1814 rtype
= elf_epiphany_reloc_type (type
);
1819 rtype
= elf_ip2k_reloc_type (type
);
1823 rtype
= elf_iq2000_reloc_type (type
);
1828 rtype
= elf_xtensa_reloc_type (type
);
1831 case EM_LATTICEMICO32
:
1832 rtype
= elf_lm32_reloc_type (type
);
1837 rtype
= elf_m32c_reloc_type (type
);
1841 rtype
= elf_mt_reloc_type (type
);
1845 rtype
= elf_bfin_reloc_type (type
);
1849 rtype
= elf_mep_reloc_type (type
);
1853 rtype
= elf_cr16_reloc_type (type
);
1857 case EM_MICROBLAZE_OLD
:
1858 rtype
= elf_microblaze_reloc_type (type
);
1862 rtype
= elf_rl78_reloc_type (type
);
1866 rtype
= elf_rx_reloc_type (type
);
1870 rtype
= elf_metag_reloc_type (type
);
1874 rtype
= elf_tic6x_reloc_type (type
);
1878 rtype
= elf_tilegx_reloc_type (type
);
1882 rtype
= elf_tilepro_reloc_type (type
);
1885 case EM_WEBASSEMBLY
:
1886 rtype
= elf_wasm32_reloc_type (type
);
1890 rtype
= elf_xgate_reloc_type (type
);
1893 case EM_ALTERA_NIOS2
:
1894 rtype
= elf_nios2_reloc_type (type
);
1898 rtype
= elf_pru_reloc_type (type
);
1902 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1903 rtype
= elf_nfp3200_reloc_type (type
);
1905 rtype
= elf_nfp_reloc_type (type
);
1909 rtype
= elf_z80_reloc_type (type
);
1913 rtype
= elf_loongarch_reloc_type (type
);
1917 rtype
= elf_amdgpu_reloc_type (type
);
1922 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1924 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1926 if (filedata
->file_header
.e_machine
== EM_ALPHA
1928 && streq (rtype
, "R_ALPHA_LITUSE")
1929 && rel_type
== reltype_rela
)
1931 switch (rels
[i
].r_addend
)
1933 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1934 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1935 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1936 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1937 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1938 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1939 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1940 default: rtype
= NULL
;
1944 printf (" (%s)", rtype
);
1948 printf (_("<unknown addend: %" PRIx64
">"),
1953 else if (symtab_index
)
1955 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1957 error (_(" bad symbol index: %08lx in reloc\n"),
1958 (unsigned long) symtab_index
);
1963 Elf_Internal_Sym
* psym
;
1964 const char * version_string
;
1965 enum versioned_symbol_info sym_info
;
1966 unsigned short vna_other
;
1968 psym
= symtab
+ symtab_index
;
1971 = get_symbol_version_string (filedata
, is_dynsym
,
1980 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1984 unsigned int width
= is_32bit_elf
? 8 : 14;
1986 /* Relocations against GNU_IFUNC symbols do not use the value
1987 of the symbol as the address to relocate against. Instead
1988 they invoke the function named by the symbol and use its
1989 result as the address for relocation.
1991 To indicate this to the user, do not display the value of
1992 the symbol in the "Symbols's Value" field. Instead show
1993 its name followed by () as a hint that the symbol is
1997 || psym
->st_name
== 0
1998 || psym
->st_name
>= strtablen
)
2001 name
= strtab
+ psym
->st_name
;
2003 len
= print_symbol (width
, name
);
2005 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2007 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
2011 print_vma (psym
->st_value
, LONG_HEX
);
2013 printf (is_32bit_elf
? " " : " ");
2016 if (psym
->st_name
== 0)
2018 const char * sec_name
= "<null>";
2021 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
2023 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
2024 && filedata
->section_headers
!= NULL
)
2025 sec_name
= section_name_print (filedata
,
2026 filedata
->section_headers
2028 else if (psym
->st_shndx
== SHN_ABS
)
2030 else if (psym
->st_shndx
== SHN_COMMON
)
2031 sec_name
= "COMMON";
2032 else if ((filedata
->file_header
.e_machine
== EM_MIPS
2033 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
2034 || (filedata
->file_header
.e_machine
== EM_TI_C6000
2035 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
2036 sec_name
= "SCOMMON";
2037 else if (filedata
->file_header
.e_machine
== EM_MIPS
2038 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
2039 sec_name
= "SUNDEF";
2040 else if ((filedata
->file_header
.e_machine
== EM_X86_64
2041 || filedata
->file_header
.e_machine
== EM_L1OM
2042 || filedata
->file_header
.e_machine
== EM_K1OM
)
2043 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
2044 sec_name
= "LARGE_COMMON";
2045 else if (filedata
->file_header
.e_machine
== EM_IA_64
2046 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
2047 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
2048 sec_name
= "ANSI_COM";
2049 else if (is_ia64_vms (filedata
)
2050 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
2051 sec_name
= "VMS_SYMVEC";
2054 sprintf (name_buf
, "<section 0x%x>",
2055 (unsigned int) psym
->st_shndx
);
2056 sec_name
= name_buf
;
2059 print_symbol (22, sec_name
);
2061 else if (strtab
== NULL
)
2062 printf (_("<string table index: %3ld>"), psym
->st_name
);
2063 else if (psym
->st_name
>= strtablen
)
2065 error (_("<corrupt string table index: %3ld>\n"),
2071 print_symbol (22, strtab
+ psym
->st_name
);
2073 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2077 if (rel_type
== reltype_rela
)
2079 uint64_t off
= rels
[i
].r_addend
;
2081 if ((int64_t) off
< 0)
2082 printf (" - %" PRIx64
, -off
);
2084 printf (" + %" PRIx64
, off
);
2088 else if (rel_type
== reltype_rela
)
2090 uint64_t off
= rels
[i
].r_addend
;
2092 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
2093 if ((int64_t) off
< 0)
2094 printf ("-%" PRIx64
, -off
);
2096 printf ("%" PRIx64
, off
);
2099 if (filedata
->file_header
.e_machine
== EM_SPARCV9
2101 && streq (rtype
, "R_SPARC_OLO10"))
2102 printf (" + %" PRIx64
, ELF64_R_TYPE_DATA (inf
));
2106 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
2108 uint64_t type2
= ELF64_MIPS_R_TYPE2 (inf
);
2109 uint64_t type3
= ELF64_MIPS_R_TYPE3 (inf
);
2110 const char * rtype2
= elf_mips_reloc_type (type2
);
2111 const char * rtype3
= elf_mips_reloc_type (type3
);
2113 printf (" Type2: ");
2116 printf (_("unrecognized: %-7lx"),
2117 (unsigned long) type2
& 0xffffffff);
2119 printf ("%-17.17s", rtype2
);
2121 printf ("\n Type3: ");
2124 printf (_("unrecognized: %-7lx"),
2125 (unsigned long) type3
& 0xffffffff);
2127 printf ("%-17.17s", rtype3
);
2139 get_aarch64_dynamic_type (unsigned long type
)
2143 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
2144 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
2145 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
2152 get_mips_dynamic_type (unsigned long type
)
2156 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
2157 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
2158 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
2159 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
2160 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
2161 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
2162 case DT_MIPS_MSYM
: return "MIPS_MSYM";
2163 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2164 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2165 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
2166 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
2167 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
2168 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
2169 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
2170 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
2171 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
2172 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
2173 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
2174 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
2175 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
2176 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
2177 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
2178 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
2179 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
2180 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
2181 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
2182 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
2183 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
2184 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
2185 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
2186 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2187 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
2188 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
2189 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
2190 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
2191 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2192 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
2193 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
2194 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
2195 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
2196 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
2197 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
2198 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
2199 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
2200 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
2201 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
2202 case DT_MIPS_XHASH
: return "MIPS_XHASH";
2209 get_sparc64_dynamic_type (unsigned long type
)
2213 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
2220 get_ppc_dynamic_type (unsigned long type
)
2224 case DT_PPC_GOT
: return "PPC_GOT";
2225 case DT_PPC_OPT
: return "PPC_OPT";
2232 get_ppc64_dynamic_type (unsigned long type
)
2236 case DT_PPC64_GLINK
: return "PPC64_GLINK";
2237 case DT_PPC64_OPD
: return "PPC64_OPD";
2238 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
2239 case DT_PPC64_OPT
: return "PPC64_OPT";
2246 get_parisc_dynamic_type (unsigned long type
)
2250 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
2251 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
2252 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
2253 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
2254 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
2255 case DT_HP_PREINIT
: return "HP_PREINIT";
2256 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
2257 case DT_HP_NEEDED
: return "HP_NEEDED";
2258 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
2259 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2260 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2261 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2262 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2263 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2264 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2265 case DT_HP_FILTERED
: return "HP_FILTERED";
2266 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2267 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2268 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2269 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2270 case DT_PLT
: return "PLT";
2271 case DT_PLT_SIZE
: return "PLT_SIZE";
2272 case DT_DLT
: return "DLT";
2273 case DT_DLT_SIZE
: return "DLT_SIZE";
2280 get_ia64_dynamic_type (unsigned long type
)
2284 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2285 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2286 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2287 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2288 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2289 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2290 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2291 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2292 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2293 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2294 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2295 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2296 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2297 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2298 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2299 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2300 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2301 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2302 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2303 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2304 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2305 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2306 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2307 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2308 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2309 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2310 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2311 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2312 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2313 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2314 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2321 get_solaris_section_type (unsigned long type
)
2325 case 0x6fffffee: return "SUNW_ancillary";
2326 case 0x6fffffef: return "SUNW_capchain";
2327 case 0x6ffffff0: return "SUNW_capinfo";
2328 case 0x6ffffff1: return "SUNW_symsort";
2329 case 0x6ffffff2: return "SUNW_tlssort";
2330 case 0x6ffffff3: return "SUNW_LDYNSYM";
2331 case 0x6ffffff4: return "SUNW_dof";
2332 case 0x6ffffff5: return "SUNW_cap";
2333 case 0x6ffffff6: return "SUNW_SIGNATURE";
2334 case 0x6ffffff7: return "SUNW_ANNOTATE";
2335 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2336 case 0x6ffffff9: return "SUNW_DEBUG";
2337 case 0x6ffffffa: return "SUNW_move";
2338 case 0x6ffffffb: return "SUNW_COMDAT";
2339 case 0x6ffffffc: return "SUNW_syminfo";
2340 case 0x6ffffffd: return "SUNW_verdef";
2341 case 0x6ffffffe: return "SUNW_verneed";
2342 case 0x6fffffff: return "SUNW_versym";
2343 case 0x70000000: return "SPARC_GOTDATA";
2344 default: return NULL
;
2349 get_alpha_dynamic_type (unsigned long type
)
2353 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2354 default: return NULL
;
2359 get_score_dynamic_type (unsigned long type
)
2363 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2364 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2365 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2366 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2367 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2368 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2369 default: return NULL
;
2374 get_tic6x_dynamic_type (unsigned long type
)
2378 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2379 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2380 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2381 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2382 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2383 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2384 default: return NULL
;
2389 get_nios2_dynamic_type (unsigned long type
)
2393 case DT_NIOS2_GP
: return "NIOS2_GP";
2394 default: return NULL
;
2399 get_solaris_dynamic_type (unsigned long type
)
2403 case 0x6000000d: return "SUNW_AUXILIARY";
2404 case 0x6000000e: return "SUNW_RTLDINF";
2405 case 0x6000000f: return "SUNW_FILTER";
2406 case 0x60000010: return "SUNW_CAP";
2407 case 0x60000011: return "SUNW_SYMTAB";
2408 case 0x60000012: return "SUNW_SYMSZ";
2409 case 0x60000013: return "SUNW_SORTENT";
2410 case 0x60000014: return "SUNW_SYMSORT";
2411 case 0x60000015: return "SUNW_SYMSORTSZ";
2412 case 0x60000016: return "SUNW_TLSSORT";
2413 case 0x60000017: return "SUNW_TLSSORTSZ";
2414 case 0x60000018: return "SUNW_CAPINFO";
2415 case 0x60000019: return "SUNW_STRPAD";
2416 case 0x6000001a: return "SUNW_CAPCHAIN";
2417 case 0x6000001b: return "SUNW_LDMACH";
2418 case 0x6000001d: return "SUNW_CAPCHAINENT";
2419 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2420 case 0x60000021: return "SUNW_PARENT";
2421 case 0x60000023: return "SUNW_ASLR";
2422 case 0x60000025: return "SUNW_RELAX";
2423 case 0x60000029: return "SUNW_NXHEAP";
2424 case 0x6000002b: return "SUNW_NXSTACK";
2426 case 0x70000001: return "SPARC_REGISTER";
2427 case 0x7ffffffd: return "AUXILIARY";
2428 case 0x7ffffffe: return "USED";
2429 case 0x7fffffff: return "FILTER";
2431 default: return NULL
;
2436 get_riscv_dynamic_type (unsigned long type
)
2440 case DT_RISCV_VARIANT_CC
: return "RISCV_VARIANT_CC";
2447 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2449 static char buff
[64];
2453 case DT_NULL
: return "NULL";
2454 case DT_NEEDED
: return "NEEDED";
2455 case DT_PLTRELSZ
: return "PLTRELSZ";
2456 case DT_PLTGOT
: return "PLTGOT";
2457 case DT_HASH
: return "HASH";
2458 case DT_STRTAB
: return "STRTAB";
2459 case DT_SYMTAB
: return "SYMTAB";
2460 case DT_RELA
: return "RELA";
2461 case DT_RELASZ
: return "RELASZ";
2462 case DT_RELAENT
: return "RELAENT";
2463 case DT_STRSZ
: return "STRSZ";
2464 case DT_SYMENT
: return "SYMENT";
2465 case DT_INIT
: return "INIT";
2466 case DT_FINI
: return "FINI";
2467 case DT_SONAME
: return "SONAME";
2468 case DT_RPATH
: return "RPATH";
2469 case DT_SYMBOLIC
: return "SYMBOLIC";
2470 case DT_REL
: return "REL";
2471 case DT_RELSZ
: return "RELSZ";
2472 case DT_RELENT
: return "RELENT";
2473 case DT_RELR
: return "RELR";
2474 case DT_RELRSZ
: return "RELRSZ";
2475 case DT_RELRENT
: return "RELRENT";
2476 case DT_PLTREL
: return "PLTREL";
2477 case DT_DEBUG
: return "DEBUG";
2478 case DT_TEXTREL
: return "TEXTREL";
2479 case DT_JMPREL
: return "JMPREL";
2480 case DT_BIND_NOW
: return "BIND_NOW";
2481 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2482 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2483 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2484 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2485 case DT_RUNPATH
: return "RUNPATH";
2486 case DT_FLAGS
: return "FLAGS";
2488 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2489 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2490 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2492 case DT_CHECKSUM
: return "CHECKSUM";
2493 case DT_PLTPADSZ
: return "PLTPADSZ";
2494 case DT_MOVEENT
: return "MOVEENT";
2495 case DT_MOVESZ
: return "MOVESZ";
2496 case DT_FEATURE
: return "FEATURE";
2497 case DT_POSFLAG_1
: return "POSFLAG_1";
2498 case DT_SYMINSZ
: return "SYMINSZ";
2499 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2501 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2502 case DT_CONFIG
: return "CONFIG";
2503 case DT_DEPAUDIT
: return "DEPAUDIT";
2504 case DT_AUDIT
: return "AUDIT";
2505 case DT_PLTPAD
: return "PLTPAD";
2506 case DT_MOVETAB
: return "MOVETAB";
2507 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2509 case DT_VERSYM
: return "VERSYM";
2511 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2512 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2513 case DT_RELACOUNT
: return "RELACOUNT";
2514 case DT_RELCOUNT
: return "RELCOUNT";
2515 case DT_FLAGS_1
: return "FLAGS_1";
2516 case DT_VERDEF
: return "VERDEF";
2517 case DT_VERDEFNUM
: return "VERDEFNUM";
2518 case DT_VERNEED
: return "VERNEED";
2519 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2521 case DT_AUXILIARY
: return "AUXILIARY";
2522 case DT_USED
: return "USED";
2523 case DT_FILTER
: return "FILTER";
2525 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2526 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2527 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2528 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2529 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2530 case DT_GNU_HASH
: return "GNU_HASH";
2531 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2534 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2536 const char * result
;
2538 switch (filedata
->file_header
.e_machine
)
2541 result
= get_aarch64_dynamic_type (type
);
2544 case EM_MIPS_RS3_LE
:
2545 result
= get_mips_dynamic_type (type
);
2548 result
= get_sparc64_dynamic_type (type
);
2551 result
= get_ppc_dynamic_type (type
);
2554 result
= get_ppc64_dynamic_type (type
);
2557 result
= get_ia64_dynamic_type (type
);
2560 result
= get_alpha_dynamic_type (type
);
2563 result
= get_score_dynamic_type (type
);
2566 result
= get_tic6x_dynamic_type (type
);
2568 case EM_ALTERA_NIOS2
:
2569 result
= get_nios2_dynamic_type (type
);
2572 result
= get_riscv_dynamic_type (type
);
2575 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2576 result
= get_solaris_dynamic_type (type
);
2585 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2587 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2588 || (filedata
->file_header
.e_machine
== EM_PARISC
2589 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2591 const char * result
;
2593 switch (filedata
->file_header
.e_machine
)
2596 result
= get_parisc_dynamic_type (type
);
2599 result
= get_ia64_dynamic_type (type
);
2602 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2603 result
= get_solaris_dynamic_type (type
);
2612 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2616 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2622 static bool get_program_headers (Filedata
*);
2623 static bool get_dynamic_section (Filedata
*);
2626 locate_dynamic_section (Filedata
*filedata
)
2628 uint64_t dynamic_addr
= 0;
2629 uint64_t dynamic_size
= 0;
2631 if (filedata
->file_header
.e_phnum
!= 0
2632 && get_program_headers (filedata
))
2634 Elf_Internal_Phdr
*segment
;
2637 for (i
= 0, segment
= filedata
->program_headers
;
2638 i
< filedata
->file_header
.e_phnum
;
2641 if (segment
->p_type
== PT_DYNAMIC
)
2643 dynamic_addr
= segment
->p_offset
;
2644 dynamic_size
= segment
->p_filesz
;
2646 if (filedata
->section_headers
!= NULL
)
2648 Elf_Internal_Shdr
*sec
;
2650 sec
= find_section (filedata
, ".dynamic");
2653 if (sec
->sh_size
== 0
2654 || sec
->sh_type
== SHT_NOBITS
)
2661 dynamic_addr
= sec
->sh_offset
;
2662 dynamic_size
= sec
->sh_size
;
2667 if (dynamic_addr
> filedata
->file_size
2668 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2677 filedata
->dynamic_addr
= dynamic_addr
;
2678 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2682 is_pie (Filedata
*filedata
)
2684 Elf_Internal_Dyn
*entry
;
2686 if (filedata
->dynamic_size
== 0)
2687 locate_dynamic_section (filedata
);
2688 if (filedata
->dynamic_size
<= 1)
2691 if (!get_dynamic_section (filedata
))
2694 for (entry
= filedata
->dynamic_section
;
2695 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
2698 if (entry
->d_tag
== DT_FLAGS_1
)
2700 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
2709 get_file_type (Filedata
*filedata
)
2711 unsigned e_type
= filedata
->file_header
.e_type
;
2712 static char buff
[64];
2716 case ET_NONE
: return _("NONE (None)");
2717 case ET_REL
: return _("REL (Relocatable file)");
2718 case ET_EXEC
: return _("EXEC (Executable file)");
2720 if (is_pie (filedata
))
2721 return _("DYN (Position-Independent Executable file)");
2723 return _("DYN (Shared object file)");
2724 case ET_CORE
: return _("CORE (Core file)");
2727 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2728 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2729 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2730 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2732 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2738 get_machine_name (unsigned e_machine
)
2740 static char buff
[64]; /* XXX */
2744 /* Please keep this switch table sorted by increasing EM_ value. */
2746 case EM_NONE
: return _("None");
2747 case EM_M32
: return "WE32100";
2748 case EM_SPARC
: return "Sparc";
2749 case EM_386
: return "Intel 80386";
2750 case EM_68K
: return "MC68000";
2751 case EM_88K
: return "MC88000";
2752 case EM_IAMCU
: return "Intel MCU";
2753 case EM_860
: return "Intel 80860";
2754 case EM_MIPS
: return "MIPS R3000";
2755 case EM_S370
: return "IBM System/370";
2757 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2758 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2759 case EM_PARISC
: return "HPPA";
2760 case EM_VPP550
: return "Fujitsu VPP500";
2761 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2762 case EM_960
: return "Intel 80960";
2763 case EM_PPC
: return "PowerPC";
2765 case EM_PPC64
: return "PowerPC64";
2767 case EM_S390
: return "IBM S/390";
2768 case EM_SPU
: return "SPU";
2770 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2771 case EM_FR20
: return "Fujitsu FR20";
2772 case EM_RH32
: return "TRW RH32";
2773 case EM_MCORE
: return "MCORE";
2775 case EM_ARM
: return "ARM";
2776 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2777 case EM_SH
: return "Renesas / SuperH SH";
2778 case EM_SPARCV9
: return "Sparc v9";
2779 case EM_TRICORE
: return "Siemens Tricore";
2780 case EM_ARC
: return "ARC";
2781 case EM_H8_300
: return "Renesas H8/300";
2782 case EM_H8_300H
: return "Renesas H8/300H";
2783 case EM_H8S
: return "Renesas H8S";
2784 case EM_H8_500
: return "Renesas H8/500";
2786 case EM_IA_64
: return "Intel IA-64";
2787 case EM_MIPS_X
: return "Stanford MIPS-X";
2788 case EM_COLDFIRE
: return "Motorola Coldfire";
2789 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2790 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2791 case EM_PCP
: return "Siemens PCP";
2792 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2793 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2794 case EM_STARCORE
: return "Motorola Star*Core processor";
2795 case EM_ME16
: return "Toyota ME16 processor";
2797 case EM_ST100
: return "STMicroelectronics ST100 processor";
2798 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2799 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2800 case EM_PDSP
: return "Sony DSP processor";
2801 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2802 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2803 case EM_FX66
: return "Siemens FX66 microcontroller";
2804 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2805 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2806 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2808 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2809 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2810 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2811 case EM_SVX
: return "Silicon Graphics SVx";
2812 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2813 case EM_VAX
: return "Digital VAX";
2814 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2815 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2816 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2817 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2819 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2820 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2821 case EM_PRISM
: return "Vitesse Prism";
2823 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2824 case EM_CYGNUS_FR30
:
2825 case EM_FR30
: return "Fujitsu FR30";
2826 case EM_CYGNUS_D10V
:
2827 case EM_D10V
: return "d10v";
2828 case EM_CYGNUS_D30V
:
2829 case EM_D30V
: return "d30v";
2830 case EM_CYGNUS_V850
:
2831 case EM_V850
: return "Renesas V850";
2832 case EM_CYGNUS_M32R
:
2833 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2834 case EM_CYGNUS_MN10300
:
2835 case EM_MN10300
: return "mn10300";
2837 case EM_CYGNUS_MN10200
:
2838 case EM_MN10200
: return "mn10200";
2839 case EM_PJ
: return "picoJava";
2840 case EM_OR1K
: return "OpenRISC 1000";
2841 case EM_ARC_COMPACT
: return "ARCompact";
2843 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2844 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2845 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2846 case EM_NS32K
: return "National Semiconductor 32000 series";
2847 case EM_TPC
: return "Tenor Network TPC processor";
2848 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2850 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2852 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2853 case EM_MAX
: return "MAX Processor";
2854 case EM_CR
: return "National Semiconductor CompactRISC";
2855 case EM_F2MC16
: return "Fujitsu F2MC16";
2856 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2857 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2858 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2859 case EM_SEP
: return "Sharp embedded microprocessor";
2860 case EM_ARCA
: return "Arca RISC microprocessor";
2862 case EM_UNICORE
: return "Unicore";
2863 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2864 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2865 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2866 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2867 case EM_XGATE
: return "Motorola XGATE embedded processor";
2869 case EM_XC16X
: return "Infineon Technologies xc16x";
2870 case EM_M16C
: return "Renesas M16C series microprocessors";
2871 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2872 case EM_CE
: return "Freescale Communication Engine RISC core";
2874 case EM_M32C
: return "Renesas M32c";
2876 case EM_TSK3000
: return "Altium TSK3000 core";
2877 case EM_RS08
: return "Freescale RS08 embedded processor";
2878 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2879 case EM_SCORE
: return "SUNPLUS S+Core";
2880 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2881 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2882 case EM_LATTICEMICO32
: return "Lattice Mico32";
2883 case EM_SE_C17
: return "Seiko Epson C17 family";
2885 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2886 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2887 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2888 case EM_TI_PRU
: return "TI PRU I/O processor";
2890 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2891 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2892 case EM_R32C
: return "Renesas R32C series microprocessors";
2893 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2894 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2895 case EM_8051
: return "Intel 8051 and variants";
2896 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2897 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2898 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2899 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2901 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2902 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2903 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2904 case EM_RX
: return "Renesas RX";
2905 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2906 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2907 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2910 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2911 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2912 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2914 case EM_L1OM
: return "Intel L1OM";
2915 case EM_K1OM
: return "Intel K1OM";
2916 case EM_INTEL182
: return "Intel (reserved)";
2917 case EM_AARCH64
: return "AArch64";
2918 case EM_ARM184
: return "ARM (reserved)";
2919 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2920 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2921 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2922 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2924 case EM_CUDA
: return "NVIDIA CUDA architecture";
2925 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2926 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2927 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2928 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2929 case EM_ARC_COMPACT2
: return "ARCv2";
2930 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2931 case EM_RL78
: return "Renesas RL78";
2932 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2933 case EM_78K0R
: return "Renesas 78K0R";
2935 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2936 case EM_BA1
: return "Beyond BA1 CPU architecture";
2937 case EM_BA2
: return "Beyond BA2 CPU architecture";
2938 case EM_XCORE
: return "XMOS xCORE processor family";
2939 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2940 case EM_INTELGT
: return "Intel Graphics Technology";
2942 case EM_KM32
: return "KM211 KM32 32-bit processor";
2943 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2944 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2945 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2946 case EM_KVARC
: return "KM211 KVARC processor";
2947 case EM_CDP
: return "Paneve CDP architecture family";
2948 case EM_COGE
: return "Cognitive Smart Memory Processor";
2949 case EM_COOL
: return "Bluechip Systems CoolEngine";
2950 case EM_NORC
: return "Nanoradio Optimized RISC";
2951 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2953 case EM_Z80
: return "Zilog Z80";
2954 case EM_VISIUM
: return "CDS VISIUMcore processor";
2955 case EM_FT32
: return "FTDI Chip FT32";
2956 case EM_MOXIE
: return "Moxie";
2957 case EM_AMDGPU
: return "AMD GPU";
2958 /* 230 (all reserved) */
2960 case EM_RISCV
: return "RISC-V";
2961 case EM_LANAI
: return "Lanai 32-bit processor";
2962 case EM_CEVA
: return "CEVA Processor Architecture Family";
2963 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2964 case EM_BPF
: return "Linux BPF";
2965 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2966 case EM_IMG1
: return "Imagination Technologies";
2968 case EM_NFP
: return "Netronome Flow Processor";
2969 case EM_VE
: return "NEC Vector Engine";
2970 case EM_CSKY
: return "C-SKY";
2971 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2972 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2973 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2974 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2975 case EM_65816
: return "WDC 65816/65C816";
2976 case EM_LOONGARCH
: return "LoongArch";
2977 case EM_KF32
: return "ChipON KungFu32";
2979 /* Large numbers... */
2980 case EM_MT
: return "Morpho Techologies MT processor";
2981 case EM_ALPHA
: return "Alpha";
2982 case EM_WEBASSEMBLY
: return "Web Assembly";
2983 case EM_DLX
: return "OpenDLX";
2984 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2985 case EM_IQ2000
: return "Vitesse IQ2000";
2987 case EM_NIOS32
: return "Altera Nios";
2988 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2989 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2990 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2991 case EM_S12Z
: return "Freescale S12Z";
2994 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
3000 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
3002 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
3003 other compilers don't specify an architecture type in the e_flags, and
3004 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
3005 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
3008 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
3009 but also sets a specific architecture type in the e_flags field.
3011 However, when decoding the flags we don't worry if we see an
3012 unexpected pairing, for example EM_ARC_COMPACT machine type, with
3013 ARCEM architecture type. */
3015 switch (e_flags
& EF_ARC_MACH_MSK
)
3017 /* We only expect these to occur for EM_ARC_COMPACT2. */
3018 case EF_ARC_CPU_ARCV2EM
:
3019 strcat (buf
, ", ARC EM");
3021 case EF_ARC_CPU_ARCV2HS
:
3022 strcat (buf
, ", ARC HS");
3025 /* We only expect these to occur for EM_ARC_COMPACT. */
3026 case E_ARC_MACH_ARC600
:
3027 strcat (buf
, ", ARC600");
3029 case E_ARC_MACH_ARC601
:
3030 strcat (buf
, ", ARC601");
3032 case E_ARC_MACH_ARC700
:
3033 strcat (buf
, ", ARC700");
3036 /* The only times we should end up here are (a) A corrupt ELF, (b) A
3037 new ELF with new architecture being read by an old version of
3038 readelf, or (c) An ELF built with non-GNU compiler that does not
3039 set the architecture in the e_flags. */
3041 if (e_machine
== EM_ARC_COMPACT
)
3042 strcat (buf
, ", Unknown ARCompact");
3044 strcat (buf
, ", Unknown ARC");
3048 switch (e_flags
& EF_ARC_OSABI_MSK
)
3050 case E_ARC_OSABI_ORIG
:
3051 strcat (buf
, ", (ABI:legacy)");
3053 case E_ARC_OSABI_V2
:
3054 strcat (buf
, ", (ABI:v2)");
3056 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
3057 case E_ARC_OSABI_V3
:
3058 strcat (buf
, ", v3 no-legacy-syscalls ABI");
3060 case E_ARC_OSABI_V4
:
3061 strcat (buf
, ", v4 ABI");
3064 strcat (buf
, ", unrecognised ARC OSABI flag");
3070 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
3073 bool unknown
= false;
3075 eabi
= EF_ARM_EABI_VERSION (e_flags
);
3076 e_flags
&= ~ EF_ARM_EABIMASK
;
3078 /* Handle "generic" ARM flags. */
3079 if (e_flags
& EF_ARM_RELEXEC
)
3081 strcat (buf
, ", relocatable executable");
3082 e_flags
&= ~ EF_ARM_RELEXEC
;
3085 if (e_flags
& EF_ARM_PIC
)
3087 strcat (buf
, ", position independent");
3088 e_flags
&= ~ EF_ARM_PIC
;
3091 /* Now handle EABI specific flags. */
3095 strcat (buf
, ", <unrecognized EABI>");
3100 case EF_ARM_EABI_VER1
:
3101 strcat (buf
, ", Version1 EABI");
3106 /* Process flags one bit at a time. */
3107 flag
= e_flags
& - e_flags
;
3112 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3113 strcat (buf
, ", sorted symbol tables");
3123 case EF_ARM_EABI_VER2
:
3124 strcat (buf
, ", Version2 EABI");
3129 /* Process flags one bit at a time. */
3130 flag
= e_flags
& - e_flags
;
3135 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3136 strcat (buf
, ", sorted symbol tables");
3139 case EF_ARM_DYNSYMSUSESEGIDX
:
3140 strcat (buf
, ", dynamic symbols use segment index");
3143 case EF_ARM_MAPSYMSFIRST
:
3144 strcat (buf
, ", mapping symbols precede others");
3154 case EF_ARM_EABI_VER3
:
3155 strcat (buf
, ", Version3 EABI");
3158 case EF_ARM_EABI_VER4
:
3159 strcat (buf
, ", Version4 EABI");
3164 /* Process flags one bit at a time. */
3165 flag
= e_flags
& - e_flags
;
3171 strcat (buf
, ", BE8");
3175 strcat (buf
, ", LE8");
3185 case EF_ARM_EABI_VER5
:
3186 strcat (buf
, ", Version5 EABI");
3191 /* Process flags one bit at a time. */
3192 flag
= e_flags
& - e_flags
;
3198 strcat (buf
, ", BE8");
3202 strcat (buf
, ", LE8");
3205 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3206 strcat (buf
, ", soft-float ABI");
3209 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3210 strcat (buf
, ", hard-float ABI");
3220 case EF_ARM_EABI_UNKNOWN
:
3221 strcat (buf
, ", GNU EABI");
3226 /* Process flags one bit at a time. */
3227 flag
= e_flags
& - e_flags
;
3232 case EF_ARM_INTERWORK
:
3233 strcat (buf
, ", interworking enabled");
3236 case EF_ARM_APCS_26
:
3237 strcat (buf
, ", uses APCS/26");
3240 case EF_ARM_APCS_FLOAT
:
3241 strcat (buf
, ", uses APCS/float");
3245 strcat (buf
, ", position independent");
3249 strcat (buf
, ", 8 bit structure alignment");
3252 case EF_ARM_NEW_ABI
:
3253 strcat (buf
, ", uses new ABI");
3256 case EF_ARM_OLD_ABI
:
3257 strcat (buf
, ", uses old ABI");
3260 case EF_ARM_SOFT_FLOAT
:
3261 strcat (buf
, ", software FP");
3264 case EF_ARM_VFP_FLOAT
:
3265 strcat (buf
, ", VFP");
3268 case EF_ARM_MAVERICK_FLOAT
:
3269 strcat (buf
, ", Maverick FP");
3280 strcat (buf
,_(", <unknown>"));
3284 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3286 --size
; /* Leave space for null terminator. */
3288 switch (e_flags
& EF_AVR_MACH
)
3290 case E_AVR_MACH_AVR1
:
3291 strncat (buf
, ", avr:1", size
);
3293 case E_AVR_MACH_AVR2
:
3294 strncat (buf
, ", avr:2", size
);
3296 case E_AVR_MACH_AVR25
:
3297 strncat (buf
, ", avr:25", size
);
3299 case E_AVR_MACH_AVR3
:
3300 strncat (buf
, ", avr:3", size
);
3302 case E_AVR_MACH_AVR31
:
3303 strncat (buf
, ", avr:31", size
);
3305 case E_AVR_MACH_AVR35
:
3306 strncat (buf
, ", avr:35", size
);
3308 case E_AVR_MACH_AVR4
:
3309 strncat (buf
, ", avr:4", size
);
3311 case E_AVR_MACH_AVR5
:
3312 strncat (buf
, ", avr:5", size
);
3314 case E_AVR_MACH_AVR51
:
3315 strncat (buf
, ", avr:51", size
);
3317 case E_AVR_MACH_AVR6
:
3318 strncat (buf
, ", avr:6", size
);
3320 case E_AVR_MACH_AVRTINY
:
3321 strncat (buf
, ", avr:100", size
);
3323 case E_AVR_MACH_XMEGA1
:
3324 strncat (buf
, ", avr:101", size
);
3326 case E_AVR_MACH_XMEGA2
:
3327 strncat (buf
, ", avr:102", size
);
3329 case E_AVR_MACH_XMEGA3
:
3330 strncat (buf
, ", avr:103", size
);
3332 case E_AVR_MACH_XMEGA4
:
3333 strncat (buf
, ", avr:104", size
);
3335 case E_AVR_MACH_XMEGA5
:
3336 strncat (buf
, ", avr:105", size
);
3338 case E_AVR_MACH_XMEGA6
:
3339 strncat (buf
, ", avr:106", size
);
3341 case E_AVR_MACH_XMEGA7
:
3342 strncat (buf
, ", avr:107", size
);
3345 strncat (buf
, ", avr:<unknown>", size
);
3349 size
-= strlen (buf
);
3350 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3351 strncat (buf
, ", link-relax", size
);
3355 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3361 bool has_fpu
= false;
3364 static const char *ABI_STRINGS
[] =
3366 "ABI v0", /* use r5 as return register; only used in N1213HC */
3367 "ABI v1", /* use r0 as return register */
3368 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3369 "ABI v2fp", /* for FPU */
3373 static const char *VER_STRINGS
[] =
3375 "Andes ELF V1.3 or older",
3379 static const char *ARCH_STRINGS
[] =
3388 abi
= EF_NDS_ABI
& e_flags
;
3389 arch
= EF_NDS_ARCH
& e_flags
;
3390 config
= EF_NDS_INST
& e_flags
;
3391 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3393 memset (buf
, 0, size
);
3400 case E_NDS_ABI_V2FP
:
3401 case E_NDS_ABI_AABI
:
3402 case E_NDS_ABI_V2FP_PLUS
:
3403 /* In case there are holes in the array. */
3404 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3408 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3414 case E_NDS32_ELF_VER_1_2
:
3415 case E_NDS32_ELF_VER_1_3
:
3416 case E_NDS32_ELF_VER_1_4
:
3417 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3421 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3425 if (E_NDS_ABI_V0
== abi
)
3427 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3428 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3429 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3430 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3436 case E_NDS_ARCH_STAR_V1_0
:
3437 case E_NDS_ARCH_STAR_V2_0
:
3438 case E_NDS_ARCH_STAR_V3_0
:
3439 case E_NDS_ARCH_STAR_V3_M
:
3440 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3444 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3445 /* ARCH version determines how the e_flags are interpreted.
3446 If it is unknown, we cannot proceed. */
3450 /* Newer ABI; Now handle architecture specific flags. */
3451 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3453 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3454 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3456 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3457 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3459 if (config
& E_NDS32_HAS_DIV_INST
)
3460 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3462 if (config
& E_NDS32_HAS_16BIT_INST
)
3463 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3467 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3469 if (version
<= E_NDS32_ELF_VER_1_3
)
3470 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3472 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3475 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3476 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3478 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3479 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3481 if (config
& E_NDS32_HAS_16BIT_INST
)
3483 if (version
<= E_NDS32_ELF_VER_1_3
)
3484 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3486 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3490 if (config
& E_NDS32_HAS_EXT_INST
)
3491 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3493 if (config
& E_NDS32_HAS_EXT2_INST
)
3494 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3496 if (config
& E_NDS32_HAS_FPU_INST
)
3499 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3502 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3505 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3508 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3511 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3516 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3518 case E_NDS32_FPU_REG_8SP_4DP
:
3519 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3521 case E_NDS32_FPU_REG_16SP_8DP
:
3522 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3524 case E_NDS32_FPU_REG_32SP_16DP
:
3525 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3527 case E_NDS32_FPU_REG_32SP_32DP
:
3528 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3533 if (config
& E_NDS32_HAS_AUDIO_INST
)
3534 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3536 if (config
& E_NDS32_HAS_STRING_INST
)
3537 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3539 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3540 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3542 if (config
& E_NDS32_HAS_VIDEO_INST
)
3544 if (version
<= E_NDS32_ELF_VER_1_3
)
3545 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3547 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3550 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3551 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3553 if (config
& E_NDS32_HAS_L2C_INST
)
3554 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3558 decode_AMDGPU_machine_flags (Filedata
*filedata
, unsigned int e_flags
,
3561 unsigned char *e_ident
= filedata
->file_header
.e_ident
;
3562 unsigned char osabi
= e_ident
[EI_OSABI
];
3563 unsigned char abiversion
= e_ident
[EI_ABIVERSION
];
3566 /* HSA OS ABI v2 used a different encoding, but we don't need to support it,
3567 it has been deprecated for a while.
3569 The PAL, MESA3D and NONE OS ABIs are not properly versioned, at the time
3570 of writing, they use the same flags as HSA v3, so the code below uses that
3572 if (osabi
== ELFOSABI_AMDGPU_HSA
&& abiversion
< ELFABIVERSION_AMDGPU_HSA_V3
)
3575 mach
= e_flags
& EF_AMDGPU_MACH
;
3578 #define AMDGPU_CASE(code, string) \
3579 case code: strcat (buf, ", " string); break;
3580 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600
, "gfx600")
3581 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601
, "gfx601")
3582 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700
, "gfx700")
3583 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX701
, "gfx701")
3584 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX702
, "gfx702")
3585 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX703
, "gfx703")
3586 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX704
, "gfx704")
3587 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX801
, "gfx801")
3588 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX802
, "gfx802")
3589 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX803
, "gfx803")
3590 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX810
, "gfx810")
3591 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX900
, "gfx900")
3592 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX902
, "gfx902")
3593 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX904
, "gfx904")
3594 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX906
, "gfx906")
3595 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX908
, "gfx908")
3596 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX909
, "gfx909")
3597 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90C
, "gfx90c")
3598 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1010
, "gfx1010")
3599 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1011
, "gfx1011")
3600 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1012
, "gfx1012")
3601 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1030
, "gfx1030")
3602 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1031
, "gfx1031")
3603 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1032
, "gfx1032")
3604 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1033
, "gfx1033")
3605 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX602
, "gfx602")
3606 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX705
, "gfx705")
3607 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX805
, "gfx805")
3608 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1035
, "gfx1035")
3609 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1034
, "gfx1034")
3610 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90A
, "gfx90a")
3611 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX940
, "gfx940")
3612 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013
, "gfx1013")
3613 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036
, "gfx1036")
3615 sprintf (buf
, _(", <unknown AMDGPU GPU type: %#x>"), mach
);
3620 buf
+= strlen (buf
);
3621 e_flags
&= ~EF_AMDGPU_MACH
;
3623 if ((osabi
== ELFOSABI_AMDGPU_HSA
3624 && abiversion
== ELFABIVERSION_AMDGPU_HSA_V3
)
3625 || osabi
!= ELFOSABI_AMDGPU_HSA
)
3627 /* For HSA v3 and other OS ABIs. */
3628 if (e_flags
& EF_AMDGPU_FEATURE_XNACK_V3
)
3630 strcat (buf
, ", xnack on");
3631 buf
+= strlen (buf
);
3632 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V3
;
3635 if (e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V3
)
3637 strcat (buf
, ", sramecc on");
3638 buf
+= strlen (buf
);
3639 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V3
;
3647 xnack
= e_flags
& EF_AMDGPU_FEATURE_XNACK_V4
;
3650 case EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
:
3653 case EF_AMDGPU_FEATURE_XNACK_ANY_V4
:
3654 strcat (buf
, ", xnack any");
3657 case EF_AMDGPU_FEATURE_XNACK_OFF_V4
:
3658 strcat (buf
, ", xnack off");
3661 case EF_AMDGPU_FEATURE_XNACK_ON_V4
:
3662 strcat (buf
, ", xnack on");
3666 sprintf (buf
, _(", <unknown xnack value: %#x>"), xnack
);
3670 buf
+= strlen (buf
);
3671 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V4
;
3673 sramecc
= e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V4
;
3676 case EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
:
3679 case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
:
3680 strcat (buf
, ", sramecc any");
3683 case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
:
3684 strcat (buf
, ", sramecc off");
3687 case EF_AMDGPU_FEATURE_SRAMECC_ON_V4
:
3688 strcat (buf
, ", sramecc on");
3692 sprintf (buf
, _(", <unknown sramecc value: %#x>"), sramecc
);
3696 buf
+= strlen (buf
);
3697 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V4
;
3701 sprintf (buf
, _(", unknown flags bits: %#x"), e_flags
);
3705 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3707 static char buf
[1024];
3718 case EM_ARC_COMPACT2
:
3719 case EM_ARC_COMPACT
:
3720 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3724 decode_ARM_machine_flags (e_flags
, buf
);
3728 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3732 if (e_flags
& EF_BFIN_PIC
)
3733 strcat (buf
, ", PIC");
3735 if (e_flags
& EF_BFIN_FDPIC
)
3736 strcat (buf
, ", FDPIC");
3738 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3739 strcat (buf
, ", code in L1");
3741 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3742 strcat (buf
, ", data in L1");
3747 switch (e_flags
& EF_FRV_CPU_MASK
)
3749 case EF_FRV_CPU_GENERIC
:
3753 strcat (buf
, ", fr???");
3756 case EF_FRV_CPU_FR300
:
3757 strcat (buf
, ", fr300");
3760 case EF_FRV_CPU_FR400
:
3761 strcat (buf
, ", fr400");
3763 case EF_FRV_CPU_FR405
:
3764 strcat (buf
, ", fr405");
3767 case EF_FRV_CPU_FR450
:
3768 strcat (buf
, ", fr450");
3771 case EF_FRV_CPU_FR500
:
3772 strcat (buf
, ", fr500");
3774 case EF_FRV_CPU_FR550
:
3775 strcat (buf
, ", fr550");
3778 case EF_FRV_CPU_SIMPLE
:
3779 strcat (buf
, ", simple");
3781 case EF_FRV_CPU_TOMCAT
:
3782 strcat (buf
, ", tomcat");
3788 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3789 strcat (buf
, ", m68000");
3790 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3791 strcat (buf
, ", cpu32");
3792 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3793 strcat (buf
, ", fido_a");
3796 char const * isa
= _("unknown");
3797 char const * mac
= _("unknown mac");
3798 char const * additional
= NULL
;
3800 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3802 case EF_M68K_CF_ISA_A_NODIV
:
3804 additional
= ", nodiv";
3806 case EF_M68K_CF_ISA_A
:
3809 case EF_M68K_CF_ISA_A_PLUS
:
3812 case EF_M68K_CF_ISA_B_NOUSP
:
3814 additional
= ", nousp";
3816 case EF_M68K_CF_ISA_B
:
3819 case EF_M68K_CF_ISA_C
:
3822 case EF_M68K_CF_ISA_C_NODIV
:
3824 additional
= ", nodiv";
3827 strcat (buf
, ", cf, isa ");
3830 strcat (buf
, additional
);
3831 if (e_flags
& EF_M68K_CF_FLOAT
)
3832 strcat (buf
, ", float");
3833 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3838 case EF_M68K_CF_MAC
:
3841 case EF_M68K_CF_EMAC
:
3844 case EF_M68K_CF_EMAC_B
:
3857 decode_AMDGPU_machine_flags (filedata
, e_flags
, buf
);
3861 switch (e_flags
& EF_MEP_CPU_MASK
)
3863 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3864 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3865 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3866 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3867 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3868 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3869 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3872 switch (e_flags
& EF_MEP_COP_MASK
)
3874 case EF_MEP_COP_NONE
: break;
3875 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3876 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3877 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3878 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3879 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3882 if (e_flags
& EF_MEP_LIBRARY
)
3883 strcat (buf
, ", Built for Library");
3885 if (e_flags
& EF_MEP_INDEX_MASK
)
3886 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3887 e_flags
& EF_MEP_INDEX_MASK
);
3889 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3890 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3891 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3895 if (e_flags
& EF_PPC_EMB
)
3896 strcat (buf
, ", emb");
3898 if (e_flags
& EF_PPC_RELOCATABLE
)
3899 strcat (buf
, _(", relocatable"));
3901 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3902 strcat (buf
, _(", relocatable-lib"));
3906 if (e_flags
& EF_PPC64_ABI
)
3908 char abi
[] = ", abiv0";
3910 abi
[6] += e_flags
& EF_PPC64_ABI
;
3916 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3917 strcat (buf
, ", RH850 ABI");
3919 if (e_flags
& EF_V800_850E3
)
3920 strcat (buf
, ", V3 architecture");
3922 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3923 strcat (buf
, ", FPU not used");
3925 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3926 strcat (buf
, ", regmode: COMMON");
3928 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3929 strcat (buf
, ", r4 not used");
3931 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3932 strcat (buf
, ", r30 not used");
3934 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3935 strcat (buf
, ", r5 not used");
3937 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3938 strcat (buf
, ", r2 not used");
3940 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3942 switch (e_flags
& - e_flags
)
3944 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3945 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3946 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3947 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3948 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3949 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3950 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3951 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3952 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3953 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3954 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3955 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3962 case EM_CYGNUS_V850
:
3963 switch (e_flags
& EF_V850_ARCH
)
3965 case E_V850E3V5_ARCH
:
3966 strcat (buf
, ", v850e3v5");
3968 case E_V850E2V3_ARCH
:
3969 strcat (buf
, ", v850e2v3");
3972 strcat (buf
, ", v850e2");
3975 strcat (buf
, ", v850e1");
3978 strcat (buf
, ", v850e");
3981 strcat (buf
, ", v850");
3984 strcat (buf
, _(", unknown v850 architecture variant"));
3990 case EM_CYGNUS_M32R
:
3991 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3992 strcat (buf
, ", m32r");
3996 case EM_MIPS_RS3_LE
:
3997 if (e_flags
& EF_MIPS_NOREORDER
)
3998 strcat (buf
, ", noreorder");
4000 if (e_flags
& EF_MIPS_PIC
)
4001 strcat (buf
, ", pic");
4003 if (e_flags
& EF_MIPS_CPIC
)
4004 strcat (buf
, ", cpic");
4006 if (e_flags
& EF_MIPS_UCODE
)
4007 strcat (buf
, ", ugen_reserved");
4009 if (e_flags
& EF_MIPS_ABI2
)
4010 strcat (buf
, ", abi2");
4012 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
4013 strcat (buf
, ", odk first");
4015 if (e_flags
& EF_MIPS_32BITMODE
)
4016 strcat (buf
, ", 32bitmode");
4018 if (e_flags
& EF_MIPS_NAN2008
)
4019 strcat (buf
, ", nan2008");
4021 if (e_flags
& EF_MIPS_FP64
)
4022 strcat (buf
, ", fp64");
4024 switch ((e_flags
& EF_MIPS_MACH
))
4026 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
4027 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
4028 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
4029 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
4030 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
4031 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
4032 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
4033 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
4034 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
4035 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
4036 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
4037 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
4038 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
4039 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
4040 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
4041 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
4042 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
4043 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
4044 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
4045 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
4046 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
4047 case E_MIPS_MACH_ALLEGREX
: strcat(buf
, ", allegrex"); break;
4049 /* We simply ignore the field in this case to avoid confusion:
4050 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
4053 default: strcat (buf
, _(", unknown CPU")); break;
4056 switch ((e_flags
& EF_MIPS_ABI
))
4058 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
4059 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
4060 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
4061 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
4063 /* We simply ignore the field in this case to avoid confusion:
4064 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
4065 This means it is likely to be an o32 file, but not for
4068 default: strcat (buf
, _(", unknown ABI")); break;
4071 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
4072 strcat (buf
, ", mdmx");
4074 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
4075 strcat (buf
, ", mips16");
4077 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
4078 strcat (buf
, ", micromips");
4080 switch ((e_flags
& EF_MIPS_ARCH
))
4082 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
4083 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
4084 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
4085 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
4086 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
4087 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
4088 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
4089 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
4090 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
4091 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
4092 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
4093 default: strcat (buf
, _(", unknown ISA")); break;
4098 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
4102 switch (EF_NFP_MACH (e_flags
))
4104 case E_NFP_MACH_3200
:
4105 strcat (buf
, ", NFP-32xx");
4107 case E_NFP_MACH_6000
:
4108 strcat (buf
, ", NFP-6xxx");
4114 if (e_flags
& EF_RISCV_RVC
)
4115 strcat (buf
, ", RVC");
4117 if (e_flags
& EF_RISCV_RVE
)
4118 strcat (buf
, ", RVE");
4120 if (e_flags
& EF_RISCV_TSO
)
4121 strcat (buf
, ", TSO");
4123 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
4125 case EF_RISCV_FLOAT_ABI_SOFT
:
4126 strcat (buf
, ", soft-float ABI");
4129 case EF_RISCV_FLOAT_ABI_SINGLE
:
4130 strcat (buf
, ", single-float ABI");
4133 case EF_RISCV_FLOAT_ABI_DOUBLE
:
4134 strcat (buf
, ", double-float ABI");
4137 case EF_RISCV_FLOAT_ABI_QUAD
:
4138 strcat (buf
, ", quad-float ABI");
4144 switch ((e_flags
& EF_SH_MACH_MASK
))
4146 case EF_SH1
: strcat (buf
, ", sh1"); break;
4147 case EF_SH2
: strcat (buf
, ", sh2"); break;
4148 case EF_SH3
: strcat (buf
, ", sh3"); break;
4149 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
4150 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
4151 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
4152 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
4153 case EF_SH4
: strcat (buf
, ", sh4"); break;
4154 case EF_SH5
: strcat (buf
, ", sh5"); break;
4155 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
4156 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
4157 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
4158 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
4159 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
4160 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
4161 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
4162 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
4163 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
4164 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
4165 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
4166 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
4167 default: strcat (buf
, _(", unknown ISA")); break;
4170 if (e_flags
& EF_SH_PIC
)
4171 strcat (buf
, ", pic");
4173 if (e_flags
& EF_SH_FDPIC
)
4174 strcat (buf
, ", fdpic");
4178 if (e_flags
& EF_OR1K_NODELAY
)
4179 strcat (buf
, ", no delay");
4183 if (e_flags
& EF_SPARC_32PLUS
)
4184 strcat (buf
, ", v8+");
4186 if (e_flags
& EF_SPARC_SUN_US1
)
4187 strcat (buf
, ", ultrasparcI");
4189 if (e_flags
& EF_SPARC_SUN_US3
)
4190 strcat (buf
, ", ultrasparcIII");
4192 if (e_flags
& EF_SPARC_HAL_R1
)
4193 strcat (buf
, ", halr1");
4195 if (e_flags
& EF_SPARC_LEDATA
)
4196 strcat (buf
, ", ledata");
4198 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
4199 strcat (buf
, ", tso");
4201 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
4202 strcat (buf
, ", pso");
4204 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
4205 strcat (buf
, ", rmo");
4209 switch (e_flags
& EF_PARISC_ARCH
)
4211 case EFA_PARISC_1_0
:
4212 strcpy (buf
, ", PA-RISC 1.0");
4214 case EFA_PARISC_1_1
:
4215 strcpy (buf
, ", PA-RISC 1.1");
4217 case EFA_PARISC_2_0
:
4218 strcpy (buf
, ", PA-RISC 2.0");
4223 if (e_flags
& EF_PARISC_TRAPNIL
)
4224 strcat (buf
, ", trapnil");
4225 if (e_flags
& EF_PARISC_EXT
)
4226 strcat (buf
, ", ext");
4227 if (e_flags
& EF_PARISC_LSB
)
4228 strcat (buf
, ", lsb");
4229 if (e_flags
& EF_PARISC_WIDE
)
4230 strcat (buf
, ", wide");
4231 if (e_flags
& EF_PARISC_NO_KABP
)
4232 strcat (buf
, ", no kabp");
4233 if (e_flags
& EF_PARISC_LAZYSWAP
)
4234 strcat (buf
, ", lazyswap");
4239 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
4240 strcat (buf
, ", new calling convention");
4242 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
4243 strcat (buf
, ", gnu calling convention");
4247 if ((e_flags
& EF_IA_64_ABI64
))
4248 strcat (buf
, ", 64-bit");
4250 strcat (buf
, ", 32-bit");
4251 if ((e_flags
& EF_IA_64_REDUCEDFP
))
4252 strcat (buf
, ", reduced fp model");
4253 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4254 strcat (buf
, ", no function descriptors, constant gp");
4255 else if ((e_flags
& EF_IA_64_CONS_GP
))
4256 strcat (buf
, ", constant gp");
4257 if ((e_flags
& EF_IA_64_ABSOLUTE
))
4258 strcat (buf
, ", absolute");
4259 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4261 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
4262 strcat (buf
, ", vms_linkages");
4263 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
4265 case EF_IA_64_VMS_COMCOD_SUCCESS
:
4267 case EF_IA_64_VMS_COMCOD_WARNING
:
4268 strcat (buf
, ", warning");
4270 case EF_IA_64_VMS_COMCOD_ERROR
:
4271 strcat (buf
, ", error");
4273 case EF_IA_64_VMS_COMCOD_ABORT
:
4274 strcat (buf
, ", abort");
4277 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
4278 e_flags
& EF_IA_64_VMS_COMCOD
);
4279 strcat (buf
, ", <unknown>");
4285 if ((e_flags
& EF_VAX_NONPIC
))
4286 strcat (buf
, ", non-PIC");
4287 if ((e_flags
& EF_VAX_DFLOAT
))
4288 strcat (buf
, ", D-Float");
4289 if ((e_flags
& EF_VAX_GFLOAT
))
4290 strcat (buf
, ", G-Float");
4294 if (e_flags
& EF_VISIUM_ARCH_MCM
)
4295 strcat (buf
, ", mcm");
4296 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
4297 strcat (buf
, ", mcm24");
4298 if (e_flags
& EF_VISIUM_ARCH_GR6
)
4299 strcat (buf
, ", gr6");
4303 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4305 case E_FLAG_RL78_ANY_CPU
: break;
4306 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
4307 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
4308 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
4310 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4311 strcat (buf
, ", 64-bit doubles");
4315 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4316 strcat (buf
, ", 64-bit doubles");
4317 if (e_flags
& E_FLAG_RX_DSP
)
4318 strcat (buf
, ", dsp");
4319 if (e_flags
& E_FLAG_RX_PID
)
4320 strcat (buf
, ", pid");
4321 if (e_flags
& E_FLAG_RX_ABI
)
4322 strcat (buf
, ", RX ABI");
4323 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4324 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
4325 ? ", uses String instructions" : ", bans String instructions");
4326 if (e_flags
& E_FLAG_RX_V2
)
4327 strcat (buf
, ", V2");
4328 if (e_flags
& E_FLAG_RX_V3
)
4329 strcat (buf
, ", V3");
4333 if (e_flags
& EF_S390_HIGH_GPRS
)
4334 strcat (buf
, ", highgprs");
4338 if ((e_flags
& EF_C6000_REL
))
4339 strcat (buf
, ", relocatable module");
4343 strcat (buf
, _(": architecture variant: "));
4344 switch (e_flags
& EF_MSP430_MACH
)
4346 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
4347 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
4348 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
4349 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
4350 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
4351 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
4352 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
4353 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
4354 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
4355 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
4356 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
4357 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
4358 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
4359 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
4360 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
4362 strcat (buf
, _(": unknown")); break;
4365 if (e_flags
& ~ EF_MSP430_MACH
)
4366 strcat (buf
, _(": unknown extra flag bits also present"));
4370 switch (e_flags
& EF_Z80_MACH_MSK
)
4372 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
4373 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
4374 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
4375 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
4376 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
4377 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
4378 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
4380 strcat (buf
, _(", unknown")); break;
4384 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
4385 strcat (buf
, ", SOFT-FLOAT");
4386 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
4387 strcat (buf
, ", SINGLE-FLOAT");
4388 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
4389 strcat (buf
, ", DOUBLE-FLOAT");
4391 if (EF_LOONGARCH_IS_OBJ_V0 (e_flags
))
4392 strcat (buf
, ", OBJ-v0");
4393 else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags
))
4394 strcat (buf
, ", OBJ-v1");
4404 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
4406 static char buff
[32];
4410 case ELFOSABI_NONE
: return "UNIX - System V";
4411 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
4412 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
4413 case ELFOSABI_GNU
: return "UNIX - GNU";
4414 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
4415 case ELFOSABI_AIX
: return "UNIX - AIX";
4416 case ELFOSABI_IRIX
: return "UNIX - IRIX";
4417 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
4418 case ELFOSABI_TRU64
: return "UNIX - TRU64";
4419 case ELFOSABI_MODESTO
: return "Novell - Modesto";
4420 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
4421 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
4422 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
4423 case ELFOSABI_AROS
: return "AROS";
4424 case ELFOSABI_FENIXOS
: return "FenixOS";
4425 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
4426 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
4429 switch (filedata
->file_header
.e_machine
)
4434 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA";
4435 case ELFOSABI_AMDGPU_PAL
: return "AMD PAL";
4436 case ELFOSABI_AMDGPU_MESA3D
: return "AMD Mesa3D";
4445 case ELFOSABI_ARM
: return "ARM";
4446 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
4457 case ELFOSABI_STANDALONE
: return _("Standalone App");
4466 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4467 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4476 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4482 get_aarch64_segment_type (unsigned long type
)
4486 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4487 case PT_AARCH64_MEMTAG_MTE
: return "AARCH64_MEMTAG_MTE";
4488 default: return NULL
;
4493 get_arm_segment_type (unsigned long type
)
4497 case PT_ARM_EXIDX
: return "EXIDX";
4498 default: return NULL
;
4503 get_s390_segment_type (unsigned long type
)
4507 case PT_S390_PGSTE
: return "S390_PGSTE";
4508 default: return NULL
;
4513 get_mips_segment_type (unsigned long type
)
4517 case PT_MIPS_REGINFO
: return "REGINFO";
4518 case PT_MIPS_RTPROC
: return "RTPROC";
4519 case PT_MIPS_OPTIONS
: return "OPTIONS";
4520 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4521 default: return NULL
;
4526 get_parisc_segment_type (unsigned long type
)
4530 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4531 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4532 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4533 default: return NULL
;
4538 get_ia64_segment_type (unsigned long type
)
4542 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
4543 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
4544 default: return NULL
;
4549 get_tic6x_segment_type (unsigned long type
)
4553 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4554 default: return NULL
;
4559 get_riscv_segment_type (unsigned long type
)
4563 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4564 default: return NULL
;
4569 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4571 if (e_machine
== EM_PARISC
)
4574 case PT_HP_TLS
: return "HP_TLS";
4575 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4576 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4577 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4578 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4579 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4580 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4581 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4582 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4583 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4584 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4585 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4586 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4587 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4588 case PT_HP_STACK
: return "HP_STACK";
4589 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4590 default: return NULL
;
4593 if (e_machine
== EM_IA_64
)
4596 case PT_HP_TLS
: return "HP_TLS";
4597 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4598 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4599 case PT_IA_64_HP_STACK
: return "HP_STACK";
4600 default: return NULL
;
4607 get_solaris_segment_type (unsigned long type
)
4611 case 0x6464e550: return "PT_SUNW_UNWIND";
4612 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4613 case 0x6ffffff7: return "PT_LOSUNW";
4614 case 0x6ffffffa: return "PT_SUNWBSS";
4615 case 0x6ffffffb: return "PT_SUNWSTACK";
4616 case 0x6ffffffc: return "PT_SUNWDTRACE";
4617 case 0x6ffffffd: return "PT_SUNWCAP";
4618 case 0x6fffffff: return "PT_HISUNW";
4619 default: return NULL
;
4624 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4626 static char buff
[32];
4630 case PT_NULL
: return "NULL";
4631 case PT_LOAD
: return "LOAD";
4632 case PT_DYNAMIC
: return "DYNAMIC";
4633 case PT_INTERP
: return "INTERP";
4634 case PT_NOTE
: return "NOTE";
4635 case PT_SHLIB
: return "SHLIB";
4636 case PT_PHDR
: return "PHDR";
4637 case PT_TLS
: return "TLS";
4638 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4639 case PT_GNU_STACK
: return "GNU_STACK";
4640 case PT_GNU_RELRO
: return "GNU_RELRO";
4641 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4642 case PT_GNU_SFRAME
: return "GNU_SFRAME";
4644 case PT_OPENBSD_MUTABLE
: return "OPENBSD_MUTABLE";
4645 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4646 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4647 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4650 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4652 const char * result
;
4654 switch (filedata
->file_header
.e_machine
)
4657 result
= get_aarch64_segment_type (p_type
);
4660 result
= get_arm_segment_type (p_type
);
4663 case EM_MIPS_RS3_LE
:
4664 result
= get_mips_segment_type (p_type
);
4667 result
= get_parisc_segment_type (p_type
);
4670 result
= get_ia64_segment_type (p_type
);
4673 result
= get_tic6x_segment_type (p_type
);
4677 result
= get_s390_segment_type (p_type
);
4680 result
= get_riscv_segment_type (p_type
);
4690 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4692 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4694 const char * result
= NULL
;
4696 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4699 case ELFOSABI_FREEBSD
:
4700 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4702 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4707 result
= get_hpux_segment_type (p_type
,
4708 filedata
->file_header
.e_machine
);
4710 case ELFOSABI_SOLARIS
:
4711 result
= get_solaris_segment_type (p_type
);
4719 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4722 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4729 get_arc_section_type_name (unsigned int sh_type
)
4733 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4741 get_mips_section_type_name (unsigned int sh_type
)
4745 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4746 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4747 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4748 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4749 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4750 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4751 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4752 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4753 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4754 case SHT_MIPS_RELD
: return "MIPS_RELD";
4755 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4756 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4757 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4758 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4759 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4760 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4761 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4762 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4763 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4764 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4765 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4766 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4767 case SHT_MIPS_LINE
: return "MIPS_LINE";
4768 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4769 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4770 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4771 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4772 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4773 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4774 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4775 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4776 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4777 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4778 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4779 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4780 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4781 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4782 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4783 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4784 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4785 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4793 get_parisc_section_type_name (unsigned int sh_type
)
4797 case SHT_PARISC_EXT
: return "PARISC_EXT";
4798 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4799 case SHT_PARISC_DOC
: return "PARISC_DOC";
4800 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4801 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4802 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4803 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4804 default: return NULL
;
4809 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4811 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4812 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4813 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4817 case SHT_IA_64_EXT
: return "IA_64_EXT";
4818 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4819 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4820 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4821 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4822 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4823 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4824 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4825 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4826 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4834 get_x86_64_section_type_name (unsigned int sh_type
)
4838 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4839 default: return NULL
;
4844 get_aarch64_section_type_name (unsigned int sh_type
)
4848 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4849 default: return NULL
;
4854 get_arm_section_type_name (unsigned int sh_type
)
4858 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4859 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4860 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4861 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4862 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4863 default: return NULL
;
4868 get_tic6x_section_type_name (unsigned int sh_type
)
4872 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4873 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4874 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4875 case SHT_TI_ICODE
: return "TI_ICODE";
4876 case SHT_TI_XREF
: return "TI_XREF";
4877 case SHT_TI_HANDLER
: return "TI_HANDLER";
4878 case SHT_TI_INITINFO
: return "TI_INITINFO";
4879 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4880 default: return NULL
;
4885 get_msp430_section_type_name (unsigned int sh_type
)
4889 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4890 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4891 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4892 default: return NULL
;
4897 get_nfp_section_type_name (unsigned int sh_type
)
4901 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4902 case SHT_NFP_INITREG
: return "NFP_INITREG";
4903 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4904 default: return NULL
;
4909 get_v850_section_type_name (unsigned int sh_type
)
4913 case SHT_V850_SCOMMON
: return "V850 Small Common";
4914 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4915 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4916 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4917 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4918 default: return NULL
;
4923 get_riscv_section_type_name (unsigned int sh_type
)
4927 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4928 default: return NULL
;
4933 get_csky_section_type_name (unsigned int sh_type
)
4937 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4938 default: return NULL
;
4943 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4945 static char buff
[32];
4946 const char * result
;
4950 case SHT_NULL
: return "NULL";
4951 case SHT_PROGBITS
: return "PROGBITS";
4952 case SHT_SYMTAB
: return "SYMTAB";
4953 case SHT_STRTAB
: return "STRTAB";
4954 case SHT_RELA
: return "RELA";
4955 case SHT_RELR
: return "RELR";
4956 case SHT_HASH
: return "HASH";
4957 case SHT_DYNAMIC
: return "DYNAMIC";
4958 case SHT_NOTE
: return "NOTE";
4959 case SHT_NOBITS
: return "NOBITS";
4960 case SHT_REL
: return "REL";
4961 case SHT_SHLIB
: return "SHLIB";
4962 case SHT_DYNSYM
: return "DYNSYM";
4963 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4964 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4965 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4966 case SHT_GNU_HASH
: return "GNU_HASH";
4967 case SHT_GROUP
: return "GROUP";
4968 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4969 case SHT_GNU_verdef
: return "VERDEF";
4970 case SHT_GNU_verneed
: return "VERNEED";
4971 case SHT_GNU_versym
: return "VERSYM";
4972 case 0x6ffffff0: return "VERSYM";
4973 case 0x6ffffffc: return "VERDEF";
4974 case 0x7ffffffd: return "AUXILIARY";
4975 case 0x7fffffff: return "FILTER";
4976 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4979 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4981 switch (filedata
->file_header
.e_machine
)
4984 case EM_ARC_COMPACT
:
4985 case EM_ARC_COMPACT2
:
4986 result
= get_arc_section_type_name (sh_type
);
4989 case EM_MIPS_RS3_LE
:
4990 result
= get_mips_section_type_name (sh_type
);
4993 result
= get_parisc_section_type_name (sh_type
);
4996 result
= get_ia64_section_type_name (filedata
, sh_type
);
5001 result
= get_x86_64_section_type_name (sh_type
);
5004 result
= get_aarch64_section_type_name (sh_type
);
5007 result
= get_arm_section_type_name (sh_type
);
5010 result
= get_tic6x_section_type_name (sh_type
);
5013 result
= get_msp430_section_type_name (sh_type
);
5016 result
= get_nfp_section_type_name (sh_type
);
5020 case EM_CYGNUS_V850
:
5021 result
= get_v850_section_type_name (sh_type
);
5024 result
= get_riscv_section_type_name (sh_type
);
5027 result
= get_csky_section_type_name (sh_type
);
5037 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
5039 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
5041 switch (filedata
->file_header
.e_machine
)
5044 result
= get_ia64_section_type_name (filedata
, sh_type
);
5047 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
5048 result
= get_solaris_section_type (sh_type
);
5053 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
5054 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
5055 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
5056 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
5068 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
5070 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
5072 switch (filedata
->file_header
.e_machine
)
5076 case EM_CYGNUS_V850
:
5077 result
= get_v850_section_type_name (sh_type
);
5087 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
5090 /* This message is probably going to be displayed in a 15
5091 character wide field, so put the hex value first. */
5092 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
5098 enum long_option_values
5100 OPTION_DEBUG_DUMP
= 512,
5111 OPTION_WITH_SYMBOL_VERSIONS
,
5112 OPTION_RECURSE_LIMIT
,
5113 OPTION_NO_RECURSE_LIMIT
,
5114 OPTION_NO_DEMANGLING
,
5118 static struct option options
[] =
5120 /* Note - This table is alpha-sorted on the 'val'
5121 field in order to make adding new options easier. */
5122 {"arch-specific", no_argument
, 0, 'A'},
5123 {"all", no_argument
, 0, 'a'},
5124 {"demangle", optional_argument
, 0, 'C'},
5125 {"archive-index", no_argument
, 0, 'c'},
5126 {"use-dynamic", no_argument
, 0, 'D'},
5127 {"dynamic", no_argument
, 0, 'd'},
5128 {"headers", no_argument
, 0, 'e'},
5129 {"section-groups", no_argument
, 0, 'g'},
5130 {"help", no_argument
, 0, 'H'},
5131 {"file-header", no_argument
, 0, 'h'},
5132 {"histogram", no_argument
, 0, 'I'},
5133 {"lint", no_argument
, 0, 'L'},
5134 {"enable-checks", no_argument
, 0, 'L'},
5135 {"program-headers", no_argument
, 0, 'l'},
5136 {"segments", no_argument
, 0, 'l'},
5137 {"full-section-name",no_argument
, 0, 'N'},
5138 {"notes", no_argument
, 0, 'n'},
5139 {"process-links", no_argument
, 0, 'P'},
5140 {"string-dump", required_argument
, 0, 'p'},
5141 {"relocated-dump", required_argument
, 0, 'R'},
5142 {"relocs", no_argument
, 0, 'r'},
5143 {"section-headers", no_argument
, 0, 'S'},
5144 {"sections", no_argument
, 0, 'S'},
5145 {"symbols", no_argument
, 0, 's'},
5146 {"syms", no_argument
, 0, 's'},
5147 {"silent-truncation",no_argument
, 0, 'T'},
5148 {"section-details", no_argument
, 0, 't'},
5149 {"unicode", required_argument
, NULL
, 'U'},
5150 {"unwind", no_argument
, 0, 'u'},
5151 {"version-info", no_argument
, 0, 'V'},
5152 {"version", no_argument
, 0, 'v'},
5153 {"wide", no_argument
, 0, 'W'},
5154 {"hex-dump", required_argument
, 0, 'x'},
5155 {"decompress", no_argument
, 0, 'z'},
5157 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
5158 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
5159 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5160 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5161 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
5162 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
5163 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
5164 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
5165 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
5166 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
5167 #ifdef ENABLE_LIBCTF
5168 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
5169 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
5170 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
5171 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
5173 {"sframe", optional_argument
, 0, OPTION_SFRAME_DUMP
},
5174 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
5176 {0, no_argument
, 0, 0}
5180 usage (FILE * stream
)
5182 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
5183 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
5184 fprintf (stream
, _(" Options are:\n"));
5185 fprintf (stream
, _("\
5186 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
5187 fprintf (stream
, _("\
5188 -h --file-header Display the ELF file header\n"));
5189 fprintf (stream
, _("\
5190 -l --program-headers Display the program headers\n"));
5191 fprintf (stream
, _("\
5192 --segments An alias for --program-headers\n"));
5193 fprintf (stream
, _("\
5194 -S --section-headers Display the sections' header\n"));
5195 fprintf (stream
, _("\
5196 --sections An alias for --section-headers\n"));
5197 fprintf (stream
, _("\
5198 -g --section-groups Display the section groups\n"));
5199 fprintf (stream
, _("\
5200 -t --section-details Display the section details\n"));
5201 fprintf (stream
, _("\
5202 -e --headers Equivalent to: -h -l -S\n"));
5203 fprintf (stream
, _("\
5204 -s --syms Display the symbol table\n"));
5205 fprintf (stream
, _("\
5206 --symbols An alias for --syms\n"));
5207 fprintf (stream
, _("\
5208 --dyn-syms Display the dynamic symbol table\n"));
5209 fprintf (stream
, _("\
5210 --lto-syms Display LTO symbol tables\n"));
5211 fprintf (stream
, _("\
5212 --sym-base=[0|8|10|16] \n\
5213 Force base for symbol sizes. The options are \n\
5214 mixed (the default), octal, decimal, hexadecimal.\n"));
5215 fprintf (stream
, _("\
5216 -C --demangle[=STYLE] Decode mangled/processed symbol names\n"));
5217 display_demangler_styles (stream
, _("\
5219 fprintf (stream
, _("\
5220 --no-demangle Do not demangle low-level symbol names. (default)\n"));
5221 fprintf (stream
, _("\
5222 --recurse-limit Enable a demangling recursion limit. (default)\n"));
5223 fprintf (stream
, _("\
5224 --no-recurse-limit Disable a demangling recursion limit\n"));
5225 fprintf (stream
, _("\
5226 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
5227 Display unicode characters as determined by the current locale\n\
5228 (default), escape sequences, \"<hex sequences>\", highlighted\n\
5229 escape sequences, or treat them as invalid and display as\n\
5230 \"{hex sequences}\"\n"));
5231 fprintf (stream
, _("\
5232 -n --notes Display the core notes (if present)\n"));
5233 fprintf (stream
, _("\
5234 -r --relocs Display the relocations (if present)\n"));
5235 fprintf (stream
, _("\
5236 -u --unwind Display the unwind info (if present)\n"));
5237 fprintf (stream
, _("\
5238 -d --dynamic Display the dynamic section (if present)\n"));
5239 fprintf (stream
, _("\
5240 -V --version-info Display the version sections (if present)\n"));
5241 fprintf (stream
, _("\
5242 -A --arch-specific Display architecture specific information (if any)\n"));
5243 fprintf (stream
, _("\
5244 -c --archive-index Display the symbol/file index in an archive\n"));
5245 fprintf (stream
, _("\
5246 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
5247 fprintf (stream
, _("\
5248 -L --lint|--enable-checks\n\
5249 Display warning messages for possible problems\n"));
5250 fprintf (stream
, _("\
5251 -x --hex-dump=<number|name>\n\
5252 Dump the contents of section <number|name> as bytes\n"));
5253 fprintf (stream
, _("\
5254 -p --string-dump=<number|name>\n\
5255 Dump the contents of section <number|name> as strings\n"));
5256 fprintf (stream
, _("\
5257 -R --relocated-dump=<number|name>\n\
5258 Dump the relocated contents of section <number|name>\n"));
5259 fprintf (stream
, _("\
5260 -z --decompress Decompress section before dumping it\n"));
5261 fprintf (stream
, _("\
5262 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
5263 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
5264 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
5265 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
5267 Display the contents of DWARF debug sections\n"));
5268 fprintf (stream
, _("\
5269 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5270 debuginfo files\n"));
5271 fprintf (stream
, _("\
5272 -P --process-links Display the contents of non-debug sections in separate\n\
5273 debuginfo files. (Implies -wK)\n"));
5274 #if DEFAULT_FOR_FOLLOW_LINKS
5275 fprintf (stream
, _("\
5276 -wK --debug-dump=follow-links\n\
5277 Follow links to separate debug info files (default)\n"));
5278 fprintf (stream
, _("\
5279 -wN --debug-dump=no-follow-links\n\
5280 Do not follow links to separate debug info files\n"));
5282 fprintf (stream
, _("\
5283 -wK --debug-dump=follow-links\n\
5284 Follow links to separate debug info files\n"));
5285 fprintf (stream
, _("\
5286 -wN --debug-dump=no-follow-links\n\
5287 Do not follow links to separate debug info files\n\
5290 #if HAVE_LIBDEBUGINFOD
5291 fprintf (stream
, _("\
5292 -wD --debug-dump=use-debuginfod\n\
5293 When following links, also query debuginfod servers (default)\n"));
5294 fprintf (stream
, _("\
5295 -wE --debug-dump=do-not-use-debuginfod\n\
5296 When following links, do not query debuginfod servers\n"));
5298 fprintf (stream
, _("\
5299 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
5300 fprintf (stream
, _("\
5301 --dwarf-start=N Display DIEs starting at offset N\n"));
5302 #ifdef ENABLE_LIBCTF
5303 fprintf (stream
, _("\
5304 --ctf=<number|name> Display CTF info from section <number|name>\n"));
5305 fprintf (stream
, _("\
5306 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
5307 fprintf (stream
, _("\
5308 --ctf-symbols=<number|name>\n\
5309 Use section <number|name> as the CTF external symtab\n"));
5310 fprintf (stream
, _("\
5311 --ctf-strings=<number|name>\n\
5312 Use section <number|name> as the CTF external strtab\n"));
5314 fprintf (stream
, _("\
5315 --sframe[=NAME] Display SFrame info from section NAME, (default '.sframe')\n"));
5317 #ifdef SUPPORT_DISASSEMBLY
5318 fprintf (stream
, _("\
5319 -i --instruction-dump=<number|name>\n\
5320 Disassemble the contents of section <number|name>\n"));
5322 fprintf (stream
, _("\
5323 -I --histogram Display histogram of bucket list lengths\n"));
5324 fprintf (stream
, _("\
5325 -W --wide Allow output width to exceed 80 characters\n"));
5326 fprintf (stream
, _("\
5327 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
5328 fprintf (stream
, _("\
5329 @<file> Read options from <file>\n"));
5330 fprintf (stream
, _("\
5331 -H --help Display this information\n"));
5332 fprintf (stream
, _("\
5333 -v --version Display the version number of readelf\n"));
5335 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
5336 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
5338 exit (stream
== stdout
? 0 : 1);
5341 /* Record the fact that the user wants the contents of section number
5342 SECTION to be displayed using the method(s) encoded as flags bits
5343 in TYPE. Note, TYPE can be zero if we are creating the array for
5347 request_dump_bynumber (struct dump_data
*dumpdata
,
5348 unsigned int section
, dump_type type
)
5350 if (section
>= dumpdata
->num_dump_sects
)
5352 dump_type
* new_dump_sects
;
5354 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
5355 sizeof (* new_dump_sects
));
5357 if (new_dump_sects
== NULL
)
5358 error (_("Out of memory allocating dump request table.\n"));
5361 if (dumpdata
->dump_sects
)
5363 /* Copy current flag settings. */
5364 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
5365 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
5367 free (dumpdata
->dump_sects
);
5370 dumpdata
->dump_sects
= new_dump_sects
;
5371 dumpdata
->num_dump_sects
= section
+ 1;
5375 if (dumpdata
->dump_sects
)
5376 dumpdata
->dump_sects
[section
] |= type
;
5379 /* Request a dump by section name. */
5382 request_dump_byname (const char * section
, dump_type type
)
5384 struct dump_list_entry
* new_request
;
5386 new_request
= (struct dump_list_entry
*)
5387 malloc (sizeof (struct dump_list_entry
));
5389 error (_("Out of memory allocating dump request table.\n"));
5391 new_request
->name
= strdup (section
);
5392 if (!new_request
->name
)
5393 error (_("Out of memory allocating dump request table.\n"));
5395 new_request
->type
= type
;
5397 new_request
->next
= dump_sects_byname
;
5398 dump_sects_byname
= new_request
;
5402 request_dump (struct dump_data
*dumpdata
, dump_type type
)
5408 section
= strtoul (optarg
, & cp
, 0);
5410 if (! *cp
&& section
>= 0)
5411 request_dump_bynumber (dumpdata
, section
, type
);
5413 request_dump_byname (optarg
, type
);
5417 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
5424 while ((c
= getopt_long
5425 (argc
, argv
, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
5443 do_section_groups
= true;
5446 do_histogram
= true;
5452 do_section_groups
= true;
5457 do_section_details
= true;
5468 do_using_dynamic
= true;
5492 do_histogram
= true;
5498 do_archive_index
= true;
5504 process_links
= true;
5505 do_follow_links
= true;
5506 dump_any_debugging
= true;
5509 request_dump (dumpdata
, HEX_DUMP
);
5512 request_dump (dumpdata
, STRING_DUMP
);
5515 request_dump (dumpdata
, RELOC_DUMP
);
5518 decompress_dumps
= true;
5523 do_debugging
= true;
5525 dump_any_debugging
= true;
5526 dwarf_select_sections_all ();
5530 do_debugging
= false;
5531 if (dwarf_select_sections_by_letters (optarg
))
5534 dump_any_debugging
= true;
5538 case OPTION_DEBUG_DUMP
:
5542 do_debugging
= true;
5543 dump_any_debugging
= true;
5544 dwarf_select_sections_all ();
5548 do_debugging
= false;
5549 if (dwarf_select_sections_by_names (optarg
))
5552 dump_any_debugging
= true;
5556 case OPTION_DWARF_DEPTH
:
5560 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5563 case OPTION_DWARF_START
:
5567 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5570 case OPTION_DWARF_CHECK
:
5573 case OPTION_CTF_DUMP
:
5575 request_dump (dumpdata
, CTF_DUMP
);
5577 case OPTION_CTF_SYMBOLS
:
5578 free (dump_ctf_symtab_name
);
5579 dump_ctf_symtab_name
= strdup (optarg
);
5581 case OPTION_CTF_STRINGS
:
5582 free (dump_ctf_strtab_name
);
5583 dump_ctf_strtab_name
= strdup (optarg
);
5585 case OPTION_CTF_PARENT
:
5586 free (dump_ctf_parent_name
);
5587 dump_ctf_parent_name
= strdup (optarg
);
5589 case OPTION_SFRAME_DUMP
:
5591 /* Providing section name is optional. request_dump (), however,
5592 thrives on non NULL optarg. Handle it explicitly here. */
5594 request_dump (dumpdata
, SFRAME_DUMP
);
5598 const char *sframe_sec_name
= strdup (".sframe");
5599 request_dump_byname (sframe_sec_name
, SFRAME_DUMP
);
5602 case OPTION_DYN_SYMS
:
5605 case OPTION_LTO_SYMS
:
5608 #ifdef SUPPORT_DISASSEMBLY
5610 request_dump (dumpdata
, DISASS_DUMP
);
5614 print_version (program_name
);
5623 do_not_show_symbol_truncation
= true;
5629 enum demangling_styles style
;
5631 style
= cplus_demangle_name_to_style (optarg
);
5632 if (style
== unknown_demangling
)
5633 error (_("unknown demangling style `%s'"), optarg
);
5635 cplus_demangle_set_style (style
);
5638 case OPTION_NO_DEMANGLING
:
5639 do_demangle
= false;
5641 case OPTION_RECURSE_LIMIT
:
5642 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5644 case OPTION_NO_RECURSE_LIMIT
:
5645 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5647 case OPTION_WITH_SYMBOL_VERSIONS
:
5648 /* Ignored for backward compatibility. */
5653 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
5654 else if (streq (optarg
, "default") || streq (optarg
, "d"))
5655 unicode_display
= unicode_default
;
5656 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
5657 unicode_display
= unicode_locale
;
5658 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
5659 unicode_display
= unicode_escape
;
5660 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
5661 unicode_display
= unicode_invalid
;
5662 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
5663 unicode_display
= unicode_hex
;
5664 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
5665 unicode_display
= unicode_highlight
;
5667 error (_("invalid argument to -U/--unicode: %s"), optarg
);
5670 case OPTION_SYM_BASE
:
5674 sym_base
= strtoul (optarg
, NULL
, 0);
5691 /* xgettext:c-format */
5692 error (_("Invalid option '-%c'\n"), c
);
5699 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5700 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5701 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5702 && !do_section_groups
&& !do_archive_index
5703 && !do_dyn_syms
&& !do_lto_syms
)
5708 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5709 do_segments
= do_header
= do_dump
= do_version
= true;
5710 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5711 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5720 get_elf_class (unsigned int elf_class
)
5722 static char buff
[32];
5726 case ELFCLASSNONE
: return _("none");
5727 case ELFCLASS32
: return "ELF32";
5728 case ELFCLASS64
: return "ELF64";
5730 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5736 get_data_encoding (unsigned int encoding
)
5738 static char buff
[32];
5742 case ELFDATANONE
: return _("none");
5743 case ELFDATA2LSB
: return _("2's complement, little endian");
5744 case ELFDATA2MSB
: return _("2's complement, big endian");
5746 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5752 check_magic_number (Filedata
* filedata
, Elf_Internal_Ehdr
* header
)
5754 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
5755 && header
->e_ident
[EI_MAG1
] == ELFMAG1
5756 && header
->e_ident
[EI_MAG2
] == ELFMAG2
5757 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
5760 /* Some compilers produce object files that are not in the ELF file format.
5761 As an aid to users of readelf, try to identify these cases and suggest
5764 FIXME: It is not clear if all four bytes are used as constant magic
5765 valus by all compilers. It may be necessary to recode this function if
5766 different tools use different length sequences. */
5770 unsigned char magic
[4];
5771 const char * obj_message
;
5772 const char * ar_message
;
5776 { { 'B', 'C', 0xc0, 0xde },
5777 N_("This is a LLVM bitcode file - try using llvm-bcanalyzer\n"),
5778 N_("This is a LLVM bitcode file - try extracing and then using llvm-bcanalyzer\n")
5780 { { 'g', 'o', ' ', 'o' },
5781 N_("This is a GO binary file - try using 'go tool objdump' or 'go tool nm'\n"),
5787 for (i
= ARRAY_SIZE (known_magic
); i
--;)
5789 if (header
->e_ident
[EI_MAG0
] == known_magic
[i
].magic
[0]
5790 && header
->e_ident
[EI_MAG1
] == known_magic
[i
].magic
[1]
5791 && header
->e_ident
[EI_MAG2
] == known_magic
[i
].magic
[2]
5792 && header
->e_ident
[EI_MAG3
] == known_magic
[i
].magic
[3])
5794 /* Some compiler's analyzer tools do not handle archives,
5795 so we provide two different kinds of error message. */
5796 if (filedata
->archive_file_size
> 0
5797 && known_magic
[i
].ar_message
!= NULL
)
5798 error ("%s", known_magic
[i
].ar_message
);
5800 error ("%s", known_magic
[i
].obj_message
);
5805 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5809 /* Decode the data held in 'filedata->file_header'. */
5812 process_file_header (Filedata
* filedata
)
5814 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5816 if (! check_magic_number (filedata
, header
))
5819 if (! filedata
->is_separate
)
5820 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5826 if (filedata
->is_separate
)
5827 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5829 printf (_("ELF Header:\n"));
5830 printf (_(" Magic: "));
5831 for (i
= 0; i
< EI_NIDENT
; i
++)
5832 printf ("%2.2x ", header
->e_ident
[i
]);
5834 printf (_(" Class: %s\n"),
5835 get_elf_class (header
->e_ident
[EI_CLASS
]));
5836 printf (_(" Data: %s\n"),
5837 get_data_encoding (header
->e_ident
[EI_DATA
]));
5838 printf (_(" Version: %d%s\n"),
5839 header
->e_ident
[EI_VERSION
],
5840 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5842 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5845 printf (_(" OS/ABI: %s\n"),
5846 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5847 printf (_(" ABI Version: %d\n"),
5848 header
->e_ident
[EI_ABIVERSION
]);
5849 printf (_(" Type: %s\n"),
5850 get_file_type (filedata
));
5851 printf (_(" Machine: %s\n"),
5852 get_machine_name (header
->e_machine
));
5853 printf (_(" Version: 0x%lx\n"),
5856 printf (_(" Entry point address: "));
5857 print_vma (header
->e_entry
, PREFIX_HEX
);
5858 printf (_("\n Start of program headers: "));
5859 print_vma (header
->e_phoff
, DEC
);
5860 printf (_(" (bytes into file)\n Start of section headers: "));
5861 print_vma (header
->e_shoff
, DEC
);
5862 printf (_(" (bytes into file)\n"));
5864 printf (_(" Flags: 0x%lx%s\n"),
5866 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5867 printf (_(" Size of this header: %u (bytes)\n"),
5869 printf (_(" Size of program headers: %u (bytes)\n"),
5870 header
->e_phentsize
);
5871 printf (_(" Number of program headers: %u"),
5873 if (filedata
->section_headers
!= NULL
5874 && header
->e_phnum
== PN_XNUM
5875 && filedata
->section_headers
[0].sh_info
!= 0)
5876 printf (" (%u)", filedata
->section_headers
[0].sh_info
);
5877 putc ('\n', stdout
);
5878 printf (_(" Size of section headers: %u (bytes)\n"),
5879 header
->e_shentsize
);
5880 printf (_(" Number of section headers: %u"),
5882 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5884 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5885 printf (" (%u)", header
->e_shnum
);
5887 putc ('\n', stdout
);
5888 printf (_(" Section header string table index: %u"),
5889 header
->e_shstrndx
);
5890 if (filedata
->section_headers
!= NULL
5891 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5893 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5894 printf (" (%u)", header
->e_shstrndx
);
5896 if (header
->e_shstrndx
!= SHN_UNDEF
5897 && header
->e_shstrndx
>= header
->e_shnum
)
5899 header
->e_shstrndx
= SHN_UNDEF
;
5900 printf (_(" <corrupt: out of range>"));
5902 putc ('\n', stdout
);
5905 if (filedata
->section_headers
!= NULL
)
5907 if (header
->e_phnum
== PN_XNUM
5908 && filedata
->section_headers
[0].sh_info
!= 0)
5910 /* Throw away any cached read of PN_XNUM headers. */
5911 free (filedata
->program_headers
);
5912 filedata
->program_headers
= NULL
;
5913 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5915 if (header
->e_shnum
== SHN_UNDEF
)
5916 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5917 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5918 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5919 if (header
->e_shstrndx
>= header
->e_shnum
)
5920 header
->e_shstrndx
= SHN_UNDEF
;
5926 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5927 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5930 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5932 Elf32_External_Phdr
* phdrs
;
5933 Elf32_External_Phdr
* external
;
5934 Elf_Internal_Phdr
* internal
;
5936 unsigned int size
= filedata
->file_header
.e_phentsize
;
5937 unsigned int num
= filedata
->file_header
.e_phnum
;
5939 /* PR binutils/17531: Cope with unexpected section header sizes. */
5940 if (size
== 0 || num
== 0)
5942 if (size
< sizeof * phdrs
)
5944 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5947 if (size
> sizeof * phdrs
)
5948 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5950 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5951 size
, num
, _("program headers"));
5955 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5956 i
< filedata
->file_header
.e_phnum
;
5957 i
++, internal
++, external
++)
5959 internal
->p_type
= BYTE_GET (external
->p_type
);
5960 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5961 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5962 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5963 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5964 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5965 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5966 internal
->p_align
= BYTE_GET (external
->p_align
);
5973 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5974 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5977 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5979 Elf64_External_Phdr
* phdrs
;
5980 Elf64_External_Phdr
* external
;
5981 Elf_Internal_Phdr
* internal
;
5983 unsigned int size
= filedata
->file_header
.e_phentsize
;
5984 unsigned int num
= filedata
->file_header
.e_phnum
;
5986 /* PR binutils/17531: Cope with unexpected section header sizes. */
5987 if (size
== 0 || num
== 0)
5989 if (size
< sizeof * phdrs
)
5991 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5994 if (size
> sizeof * phdrs
)
5995 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5997 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5998 size
, num
, _("program headers"));
6002 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6003 i
< filedata
->file_header
.e_phnum
;
6004 i
++, internal
++, external
++)
6006 internal
->p_type
= BYTE_GET (external
->p_type
);
6007 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6008 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6009 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6010 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6011 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6012 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6013 internal
->p_align
= BYTE_GET (external
->p_align
);
6020 /* Returns TRUE if the program headers were read into `program_headers'. */
6023 get_program_headers (Filedata
* filedata
)
6025 Elf_Internal_Phdr
* phdrs
;
6027 /* Check cache of prior read. */
6028 if (filedata
->program_headers
!= NULL
)
6031 /* Be kind to memory checkers by looking for
6032 e_phnum values which we know must be invalid. */
6033 if (filedata
->file_header
.e_phnum
6034 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
6035 >= filedata
->file_size
)
6037 error (_("Too many program headers - %#x - the file is not that big\n"),
6038 filedata
->file_header
.e_phnum
);
6042 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
6043 sizeof (Elf_Internal_Phdr
));
6046 error (_("Out of memory reading %u program headers\n"),
6047 filedata
->file_header
.e_phnum
);
6052 ? get_32bit_program_headers (filedata
, phdrs
)
6053 : get_64bit_program_headers (filedata
, phdrs
))
6055 filedata
->program_headers
= phdrs
;
6063 /* Print program header info and locate dynamic section. */
6066 process_program_headers (Filedata
* filedata
)
6068 Elf_Internal_Phdr
* segment
;
6070 Elf_Internal_Phdr
* previous_load
= NULL
;
6072 if (filedata
->file_header
.e_phnum
== 0)
6074 /* PR binutils/12467. */
6075 if (filedata
->file_header
.e_phoff
!= 0)
6076 warn (_("possibly corrupt ELF header - it has a non-zero program"
6077 " header offset, but no program headers\n"));
6078 else if (do_segments
)
6080 if (filedata
->is_separate
)
6081 printf (_("\nThere are no program headers in linked file '%s'.\n"),
6082 filedata
->file_name
);
6084 printf (_("\nThere are no program headers in this file.\n"));
6089 if (do_segments
&& !do_header
)
6091 if (filedata
->is_separate
)
6092 printf ("\nIn linked file '%s' the ELF file type is %s\n",
6093 filedata
->file_name
, get_file_type (filedata
));
6095 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
6096 printf (_("Entry point 0x%" PRIx64
"\n"),
6097 filedata
->file_header
.e_entry
);
6098 printf (ngettext ("There is %d program header,"
6099 " starting at offset %" PRIu64
"\n",
6100 "There are %d program headers,"
6101 " starting at offset %" PRIu64
"\n",
6102 filedata
->file_header
.e_phnum
),
6103 filedata
->file_header
.e_phnum
,
6104 filedata
->file_header
.e_phoff
);
6107 if (! get_program_headers (filedata
))
6112 if (filedata
->file_header
.e_phnum
> 1)
6113 printf (_("\nProgram Headers:\n"));
6115 printf (_("\nProgram Headers:\n"));
6119 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6122 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6126 (_(" Type Offset VirtAddr PhysAddr\n"));
6128 (_(" FileSiz MemSiz Flags Align\n"));
6132 uint64_t dynamic_addr
= 0;
6133 uint64_t dynamic_size
= 0;
6134 for (i
= 0, segment
= filedata
->program_headers
;
6135 i
< filedata
->file_header
.e_phnum
;
6140 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
6144 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6145 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
6146 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
6147 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
6148 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
6150 (segment
->p_flags
& PF_R
? 'R' : ' '),
6151 (segment
->p_flags
& PF_W
? 'W' : ' '),
6152 (segment
->p_flags
& PF_X
? 'E' : ' '));
6153 printf ("%#lx", (unsigned long) segment
->p_align
);
6157 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
6158 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6161 print_vma (segment
->p_offset
, FULL_HEX
);
6165 print_vma (segment
->p_vaddr
, FULL_HEX
);
6167 print_vma (segment
->p_paddr
, FULL_HEX
);
6170 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
6171 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
6174 print_vma (segment
->p_filesz
, FULL_HEX
);
6178 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
6179 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
6182 print_vma (segment
->p_memsz
, FULL_HEX
);
6186 (segment
->p_flags
& PF_R
? 'R' : ' '),
6187 (segment
->p_flags
& PF_W
? 'W' : ' '),
6188 (segment
->p_flags
& PF_X
? 'E' : ' '));
6190 if ((unsigned long) segment
->p_align
== segment
->p_align
)
6191 printf ("%#lx", (unsigned long) segment
->p_align
);
6194 print_vma (segment
->p_align
, PREFIX_HEX
);
6199 print_vma (segment
->p_offset
, FULL_HEX
);
6201 print_vma (segment
->p_vaddr
, FULL_HEX
);
6203 print_vma (segment
->p_paddr
, FULL_HEX
);
6205 print_vma (segment
->p_filesz
, FULL_HEX
);
6207 print_vma (segment
->p_memsz
, FULL_HEX
);
6209 (segment
->p_flags
& PF_R
? 'R' : ' '),
6210 (segment
->p_flags
& PF_W
? 'W' : ' '),
6211 (segment
->p_flags
& PF_X
? 'E' : ' '));
6212 print_vma (segment
->p_align
, PREFIX_HEX
);
6215 putc ('\n', stdout
);
6218 switch (segment
->p_type
)
6221 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
6222 required by the ELF standard, several programs, including the Linux
6223 kernel, make use of non-ordered segments. */
6225 && previous_load
->p_vaddr
> segment
->p_vaddr
)
6226 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
6228 if (segment
->p_memsz
< segment
->p_filesz
)
6229 error (_("the segment's file size is larger than its memory size\n"));
6230 previous_load
= segment
;
6234 /* PR 20815 - Verify that the program header is loaded into memory. */
6235 if (i
> 0 && previous_load
!= NULL
)
6236 error (_("the PHDR segment must occur before any LOAD segment\n"));
6237 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
6241 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
6243 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
6244 if (load
->p_type
== PT_LOAD
6245 && load
->p_offset
<= segment
->p_offset
6246 && (load
->p_offset
+ load
->p_filesz
6247 >= segment
->p_offset
+ segment
->p_filesz
)
6248 && load
->p_vaddr
<= segment
->p_vaddr
6249 && (load
->p_vaddr
+ load
->p_filesz
6250 >= segment
->p_vaddr
+ segment
->p_filesz
))
6253 if (j
== filedata
->file_header
.e_phnum
)
6254 error (_("the PHDR segment is not covered by a LOAD segment\n"));
6260 error (_("more than one dynamic segment\n"));
6262 /* By default, assume that the .dynamic section is the first
6263 section in the DYNAMIC segment. */
6264 dynamic_addr
= segment
->p_offset
;
6265 dynamic_size
= segment
->p_filesz
;
6267 /* Try to locate the .dynamic section. If there is
6268 a section header table, we can easily locate it. */
6269 if (filedata
->section_headers
!= NULL
)
6271 Elf_Internal_Shdr
* sec
;
6273 sec
= find_section (filedata
, ".dynamic");
6274 if (sec
== NULL
|| sec
->sh_size
== 0)
6276 /* A corresponding .dynamic section is expected, but on
6277 IA-64/OpenVMS it is OK for it to be missing. */
6278 if (!is_ia64_vms (filedata
))
6279 error (_("no .dynamic section in the dynamic segment\n"));
6283 if (sec
->sh_type
== SHT_NOBITS
)
6290 dynamic_addr
= sec
->sh_offset
;
6291 dynamic_size
= sec
->sh_size
;
6293 /* The PT_DYNAMIC segment, which is used by the run-time
6294 loader, should exactly match the .dynamic section. */
6296 && (dynamic_addr
!= segment
->p_offset
6297 || dynamic_size
!= segment
->p_filesz
))
6299 the .dynamic section is not the same as the dynamic segment\n"));
6302 /* PR binutils/17512: Avoid corrupt dynamic section info in the
6303 segment. Check this after matching against the section headers
6304 so we don't warn on debuginfo file (which have NOBITS .dynamic
6306 if (dynamic_addr
> filedata
->file_size
6307 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
6309 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
6316 if (segment
->p_offset
>= filedata
->file_size
6317 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
6318 || segment
->p_filesz
- 1 >= (size_t) -2
6319 || fseek64 (filedata
->handle
,
6320 filedata
->archive_file_offset
+ segment
->p_offset
,
6322 error (_("Unable to find program interpreter name\n"));
6325 size_t len
= segment
->p_filesz
;
6326 free (filedata
->program_interpreter
);
6327 filedata
->program_interpreter
= xmalloc (len
+ 1);
6328 len
= fread (filedata
->program_interpreter
, 1, len
,
6330 filedata
->program_interpreter
[len
] = 0;
6333 printf (_(" [Requesting program interpreter: %s]\n"),
6334 filedata
->program_interpreter
);
6341 && filedata
->section_headers
!= NULL
6342 && filedata
->string_table
!= NULL
)
6344 printf (_("\n Section to Segment mapping:\n"));
6345 printf (_(" Segment Sections...\n"));
6347 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
6350 Elf_Internal_Shdr
* section
;
6352 segment
= filedata
->program_headers
+ i
;
6353 section
= filedata
->section_headers
+ 1;
6355 printf (" %2.2d ", i
);
6357 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
6359 if (!ELF_TBSS_SPECIAL (section
, segment
)
6360 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
6361 printf ("%s ", printable_section_name (filedata
, section
));
6368 filedata
->dynamic_addr
= dynamic_addr
;
6369 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
6373 filedata
->dynamic_addr
= 0;
6374 filedata
->dynamic_size
= 1;
6378 /* Find the file offset corresponding to VMA by using the program headers. */
6381 offset_from_vma (Filedata
* filedata
, uint64_t vma
, uint64_t size
)
6383 Elf_Internal_Phdr
* seg
;
6385 if (! get_program_headers (filedata
))
6387 warn (_("Cannot interpret virtual addresses without program headers.\n"));
6391 for (seg
= filedata
->program_headers
;
6392 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
6395 if (seg
->p_type
!= PT_LOAD
)
6398 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
6399 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
6400 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
6403 warn (_("Virtual address %#" PRIx64
6404 " not located in any PT_LOAD segment.\n"), vma
);
6409 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
6410 If PROBE is true, this is just a probe and we do not generate any error
6411 messages if the load fails. */
6414 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
6416 Elf32_External_Shdr
* shdrs
;
6417 Elf_Internal_Shdr
* internal
;
6419 unsigned int size
= filedata
->file_header
.e_shentsize
;
6420 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6422 /* PR binutils/17531: Cope with unexpected section header sizes. */
6423 if (size
== 0 || num
== 0)
6426 /* The section header cannot be at the start of the file - that is
6427 where the ELF file header is located. A file with absolutely no
6428 sections in it will use a shoff of 0. */
6429 if (filedata
->file_header
.e_shoff
== 0)
6432 if (size
< sizeof * shdrs
)
6435 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6438 if (!probe
&& size
> sizeof * shdrs
)
6439 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6441 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
6443 probe
? NULL
: _("section headers"));
6447 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6448 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6449 if (filedata
->section_headers
== NULL
)
6452 error (_("Out of memory reading %u section headers\n"), num
);
6457 for (i
= 0, internal
= filedata
->section_headers
;
6461 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6462 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6463 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6464 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6465 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6466 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6467 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6468 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6469 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6470 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6471 if (!probe
&& internal
->sh_link
> num
)
6472 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6473 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6474 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6481 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
6484 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
6486 Elf64_External_Shdr
* shdrs
;
6487 Elf_Internal_Shdr
* internal
;
6489 unsigned int size
= filedata
->file_header
.e_shentsize
;
6490 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6492 /* PR binutils/17531: Cope with unexpected section header sizes. */
6493 if (size
== 0 || num
== 0)
6496 /* The section header cannot be at the start of the file - that is
6497 where the ELF file header is located. A file with absolutely no
6498 sections in it will use a shoff of 0. */
6499 if (filedata
->file_header
.e_shoff
== 0)
6502 if (size
< sizeof * shdrs
)
6505 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6509 if (! probe
&& size
> sizeof * shdrs
)
6510 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6512 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
6513 filedata
->file_header
.e_shoff
,
6515 probe
? NULL
: _("section headers"));
6519 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6520 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6521 if (filedata
->section_headers
== NULL
)
6524 error (_("Out of memory reading %u section headers\n"), num
);
6529 for (i
= 0, internal
= filedata
->section_headers
;
6533 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6534 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6535 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6536 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6537 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6538 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6539 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6540 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6541 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6542 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6543 if (!probe
&& internal
->sh_link
> num
)
6544 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6545 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6546 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6554 get_section_headers (Filedata
*filedata
, bool probe
)
6556 if (filedata
->section_headers
!= NULL
)
6560 return get_32bit_section_headers (filedata
, probe
);
6562 return get_64bit_section_headers (filedata
, probe
);
6565 static Elf_Internal_Sym
*
6566 get_32bit_elf_symbols (Filedata
*filedata
,
6567 Elf_Internal_Shdr
*section
,
6568 uint64_t *num_syms_return
)
6570 uint64_t number
= 0;
6571 Elf32_External_Sym
* esyms
= NULL
;
6572 Elf_External_Sym_Shndx
* shndx
= NULL
;
6573 Elf_Internal_Sym
* isyms
= NULL
;
6574 Elf_Internal_Sym
* psym
;
6576 elf_section_list
* entry
;
6578 if (section
->sh_size
== 0)
6580 if (num_syms_return
!= NULL
)
6581 * num_syms_return
= 0;
6585 /* Run some sanity checks first. */
6586 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6588 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
6589 printable_section_name (filedata
, section
),
6590 section
->sh_entsize
);
6594 if (section
->sh_size
> filedata
->file_size
)
6596 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
6597 printable_section_name (filedata
, section
),
6602 number
= section
->sh_size
/ section
->sh_entsize
;
6604 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
6606 error (_("Size (%#" PRIx64
") of section %s "
6607 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
6609 printable_section_name (filedata
, section
),
6610 section
->sh_entsize
);
6614 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6615 section
->sh_size
, _("symbols"));
6620 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6622 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
6627 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6631 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6632 entry
->hdr
->sh_offset
,
6633 1, entry
->hdr
->sh_size
,
6634 _("symbol table section indices"));
6638 /* PR17531: file: heap-buffer-overflow */
6639 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6641 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
6642 printable_section_name (filedata
, entry
->hdr
),
6643 entry
->hdr
->sh_size
,
6649 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6653 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
6657 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6659 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6660 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6661 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6662 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6663 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6665 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6666 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6667 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6668 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6669 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6676 if (num_syms_return
!= NULL
)
6677 * num_syms_return
= isyms
== NULL
? 0 : number
;
6682 static Elf_Internal_Sym
*
6683 get_64bit_elf_symbols (Filedata
*filedata
,
6684 Elf_Internal_Shdr
*section
,
6685 uint64_t *num_syms_return
)
6687 uint64_t number
= 0;
6688 Elf64_External_Sym
* esyms
= NULL
;
6689 Elf_External_Sym_Shndx
* shndx
= NULL
;
6690 Elf_Internal_Sym
* isyms
= NULL
;
6691 Elf_Internal_Sym
* psym
;
6693 elf_section_list
* entry
;
6695 if (section
->sh_size
== 0)
6697 if (num_syms_return
!= NULL
)
6698 * num_syms_return
= 0;
6702 /* Run some sanity checks first. */
6703 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6705 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
6706 printable_section_name (filedata
, section
),
6707 section
->sh_entsize
);
6711 if (section
->sh_size
> filedata
->file_size
)
6713 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
6714 printable_section_name (filedata
, section
),
6719 number
= section
->sh_size
/ section
->sh_entsize
;
6721 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6723 error (_("Size (%#" PRIx64
") of section %s "
6724 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
6726 printable_section_name (filedata
, section
),
6727 section
->sh_entsize
);
6731 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6732 section
->sh_size
, _("symbols"));
6737 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6739 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
6744 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6748 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6749 entry
->hdr
->sh_offset
,
6750 1, entry
->hdr
->sh_size
,
6751 _("symbol table section indices"));
6755 /* PR17531: file: heap-buffer-overflow */
6756 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6758 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
6759 printable_section_name (filedata
, entry
->hdr
),
6760 entry
->hdr
->sh_size
,
6766 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6770 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
6774 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6776 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6777 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6778 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6779 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6781 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6783 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6784 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6785 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6787 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6788 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6795 if (num_syms_return
!= NULL
)
6796 * num_syms_return
= isyms
== NULL
? 0 : number
;
6801 static Elf_Internal_Sym
*
6802 get_elf_symbols (Filedata
*filedata
,
6803 Elf_Internal_Shdr
*section
,
6804 uint64_t *num_syms_return
)
6807 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6809 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6813 get_elf_section_flags (Filedata
* filedata
, uint64_t sh_flags
)
6815 static char buff
[1024];
6817 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6819 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6820 uint64_t os_flags
= 0;
6821 uint64_t proc_flags
= 0;
6822 uint64_t unknown_flags
= 0;
6830 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6831 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6832 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6833 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6834 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6835 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6836 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6837 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6838 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6839 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6840 /* IA-64 specific. */
6841 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6842 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6843 /* IA-64 OpenVMS specific. */
6844 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6845 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6846 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6847 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6848 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6849 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6851 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6852 /* SPARC specific. */
6853 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6854 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6856 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6857 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6858 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6860 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6862 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6864 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6867 if (do_section_details
)
6869 sprintf (buff
, "[%*.*lx]: ",
6870 field_size
, field_size
, (unsigned long) sh_flags
);
6871 p
+= field_size
+ 4;
6878 flag
= sh_flags
& - sh_flags
;
6881 if (do_section_details
)
6885 case SHF_WRITE
: sindex
= 0; break;
6886 case SHF_ALLOC
: sindex
= 1; break;
6887 case SHF_EXECINSTR
: sindex
= 2; break;
6888 case SHF_MERGE
: sindex
= 3; break;
6889 case SHF_STRINGS
: sindex
= 4; break;
6890 case SHF_INFO_LINK
: sindex
= 5; break;
6891 case SHF_LINK_ORDER
: sindex
= 6; break;
6892 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6893 case SHF_GROUP
: sindex
= 8; break;
6894 case SHF_TLS
: sindex
= 9; break;
6895 case SHF_EXCLUDE
: sindex
= 18; break;
6896 case SHF_COMPRESSED
: sindex
= 20; break;
6900 switch (filedata
->file_header
.e_machine
)
6903 if (flag
== SHF_IA_64_SHORT
)
6905 else if (flag
== SHF_IA_64_NORECOV
)
6907 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6910 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6911 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6912 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6913 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6914 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6915 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6925 case EM_OLD_SPARCV9
:
6926 case EM_SPARC32PLUS
:
6929 if (flag
== SHF_ORDERED
)
6936 case SHF_ENTRYSECT
: sindex
= 21; break;
6937 case SHF_ARM_PURECODE
: sindex
= 22; break;
6938 case SHF_COMDEF
: sindex
= 23; break;
6943 if (flag
== SHF_PPC_VLE
)
6950 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6953 case ELFOSABI_FREEBSD
:
6954 if (flag
== SHF_GNU_RETAIN
)
6958 if (flag
== SHF_GNU_MBIND
)
6959 /* We should not recognize SHF_GNU_MBIND for
6960 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6961 not set the EI_OSABI header byte. */
6972 if (p
!= buff
+ field_size
+ 4)
6974 if (size
< (10 + 2))
6976 warn (_("Internal error: not enough buffer room for section flag info"));
6977 return _("<unknown>");
6984 size
-= flags
[sindex
].len
;
6985 p
= stpcpy (p
, flags
[sindex
].str
);
6987 else if (flag
& SHF_MASKOS
)
6989 else if (flag
& SHF_MASKPROC
)
6992 unknown_flags
|= flag
;
6998 case SHF_WRITE
: *p
= 'W'; break;
6999 case SHF_ALLOC
: *p
= 'A'; break;
7000 case SHF_EXECINSTR
: *p
= 'X'; break;
7001 case SHF_MERGE
: *p
= 'M'; break;
7002 case SHF_STRINGS
: *p
= 'S'; break;
7003 case SHF_INFO_LINK
: *p
= 'I'; break;
7004 case SHF_LINK_ORDER
: *p
= 'L'; break;
7005 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
7006 case SHF_GROUP
: *p
= 'G'; break;
7007 case SHF_TLS
: *p
= 'T'; break;
7008 case SHF_EXCLUDE
: *p
= 'E'; break;
7009 case SHF_COMPRESSED
: *p
= 'C'; break;
7012 if ((filedata
->file_header
.e_machine
== EM_X86_64
7013 || filedata
->file_header
.e_machine
== EM_L1OM
7014 || filedata
->file_header
.e_machine
== EM_K1OM
)
7015 && flag
== SHF_X86_64_LARGE
)
7017 else if (filedata
->file_header
.e_machine
== EM_ARM
7018 && flag
== SHF_ARM_PURECODE
)
7020 else if (filedata
->file_header
.e_machine
== EM_PPC
7021 && flag
== SHF_PPC_VLE
)
7023 else if (flag
& SHF_MASKOS
)
7025 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7028 case ELFOSABI_FREEBSD
:
7029 if (flag
== SHF_GNU_RETAIN
)
7036 if (flag
== SHF_GNU_MBIND
)
7038 /* We should not recognize SHF_GNU_MBIND for
7039 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7040 not set the EI_OSABI header byte. */
7047 sh_flags
&= ~SHF_MASKOS
;
7051 else if (flag
& SHF_MASKPROC
)
7054 sh_flags
&= ~ SHF_MASKPROC
;
7064 if (do_section_details
)
7068 size
-= 5 + field_size
;
7069 if (p
!= buff
+ field_size
+ 4)
7073 warn (_("Internal error: not enough buffer room for section flag info"));
7074 return _("<unknown>");
7080 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
7081 (unsigned long) os_flags
);
7082 p
+= 5 + field_size
;
7086 size
-= 7 + field_size
;
7087 if (p
!= buff
+ field_size
+ 4)
7091 warn (_("Internal error: not enough buffer room for section flag info"));
7092 return _("<unknown>");
7098 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
7099 (unsigned long) proc_flags
);
7100 p
+= 7 + field_size
;
7104 size
-= 10 + field_size
;
7105 if (p
!= buff
+ field_size
+ 4)
7109 warn (_("Internal error: not enough buffer room for section flag info"));
7110 return _("<unknown>");
7116 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
7117 (unsigned long) unknown_flags
);
7118 p
+= 10 + field_size
;
7126 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
7127 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
,
7132 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
7134 if (size
< sizeof (* echdr
))
7136 error (_("Compressed section is too small even for a compression header\n"));
7140 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7141 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7142 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7143 return sizeof (*echdr
);
7147 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
7149 if (size
< sizeof (* echdr
))
7151 error (_("Compressed section is too small even for a compression header\n"));
7155 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7156 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7157 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7158 return sizeof (*echdr
);
7163 process_section_headers (Filedata
* filedata
)
7165 Elf_Internal_Shdr
* section
;
7168 if (filedata
->file_header
.e_shnum
== 0)
7170 /* PR binutils/12467. */
7171 if (filedata
->file_header
.e_shoff
!= 0)
7173 warn (_("possibly corrupt ELF file header - it has a non-zero"
7174 " section header offset, but no section headers\n"));
7177 else if (do_sections
)
7178 printf (_("\nThere are no sections in this file.\n"));
7183 if (do_sections
&& !do_header
)
7185 if (filedata
->is_separate
&& process_links
)
7186 printf (_("In linked file '%s': "), filedata
->file_name
);
7187 if (! filedata
->is_separate
|| process_links
)
7188 printf (ngettext ("There is %d section header, "
7189 "starting at offset %#" PRIx64
":\n",
7190 "There are %d section headers, "
7191 "starting at offset %#" PRIx64
":\n",
7192 filedata
->file_header
.e_shnum
),
7193 filedata
->file_header
.e_shnum
,
7194 filedata
->file_header
.e_shoff
);
7197 if (!get_section_headers (filedata
, false))
7200 /* Read in the string table, so that we have names to display. */
7201 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
7202 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
7204 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
7206 if (section
->sh_size
!= 0)
7208 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7209 1, section
->sh_size
,
7212 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
7216 /* Scan the sections for the dynamic symbol table
7217 and dynamic string table and debug sections. */
7218 eh_addr_size
= is_32bit_elf
? 4 : 8;
7219 switch (filedata
->file_header
.e_machine
)
7222 case EM_MIPS_RS3_LE
:
7223 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
7224 FDE addresses. However, the ABI also has a semi-official ILP32
7225 variant for which the normal FDE address size rules apply.
7227 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
7228 section, where XX is the size of longs in bits. Unfortunately,
7229 earlier compilers provided no way of distinguishing ILP32 objects
7230 from LP64 objects, so if there's any doubt, we should assume that
7231 the official LP64 form is being used. */
7232 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
7233 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
7239 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
7241 case E_H8_MACH_H8300
:
7242 case E_H8_MACH_H8300HN
:
7243 case E_H8_MACH_H8300SN
:
7244 case E_H8_MACH_H8300SXN
:
7247 case E_H8_MACH_H8300H
:
7248 case E_H8_MACH_H8300S
:
7249 case E_H8_MACH_H8300SX
:
7257 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
7259 case EF_M32C_CPU_M16C
:
7266 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
7269 uint64_t expected_entsize = is_32bit_elf ? size32 : size64; \
7270 if (section->sh_entsize != expected_entsize) \
7272 error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
7273 i, section->sh_entsize); \
7274 error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
7275 expected_entsize); \
7276 section->sh_entsize = expected_entsize; \
7281 #define CHECK_ENTSIZE(section, i, type) \
7282 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
7283 sizeof (Elf64_External_##type))
7285 for (i
= 0, section
= filedata
->section_headers
;
7286 i
< filedata
->file_header
.e_shnum
;
7289 const char *name
= section_name_print (filedata
, section
);
7291 /* Run some sanity checks on the headers and
7292 possibly fill in some file data as well. */
7293 switch (section
->sh_type
)
7296 if (filedata
->dynamic_symbols
!= NULL
)
7298 error (_("File contains multiple dynamic symbol tables\n"));
7302 CHECK_ENTSIZE (section
, i
, Sym
);
7303 filedata
->dynamic_symbols
7304 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
7305 filedata
->dynamic_symtab_section
= section
;
7309 if (streq (name
, ".dynstr"))
7311 if (filedata
->dynamic_strings
!= NULL
)
7313 error (_("File contains multiple dynamic string tables\n"));
7317 filedata
->dynamic_strings
7318 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7319 1, section
->sh_size
, _("dynamic strings"));
7320 filedata
->dynamic_strings_length
7321 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
7322 filedata
->dynamic_strtab_section
= section
;
7326 case SHT_SYMTAB_SHNDX
:
7328 elf_section_list
* entry
= xmalloc (sizeof * entry
);
7330 entry
->hdr
= section
;
7331 entry
->next
= filedata
->symtab_shndx_list
;
7332 filedata
->symtab_shndx_list
= entry
;
7337 CHECK_ENTSIZE (section
, i
, Sym
);
7341 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
7345 CHECK_ENTSIZE (section
, i
, Rel
);
7346 if (do_checks
&& section
->sh_size
== 0)
7347 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7351 CHECK_ENTSIZE (section
, i
, Rela
);
7352 if (do_checks
&& section
->sh_size
== 0)
7353 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7357 CHECK_ENTSIZE (section
, i
, Relr
);
7362 /* Having a zero sized section is not illegal according to the
7363 ELF standard, but it might be an indication that something
7364 is wrong. So issue a warning if we are running in lint mode. */
7365 if (do_checks
&& section
->sh_size
== 0)
7366 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
7373 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
7374 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
7375 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
7376 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
7378 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
7379 && (startswith (name
, ".debug_")
7380 || startswith (name
, ".zdebug_")))
7383 name
+= sizeof (".zdebug_") - 1;
7385 name
+= sizeof (".debug_") - 1;
7388 || (do_debug_info
&& startswith (name
, "info"))
7389 || (do_debug_info
&& startswith (name
, "types"))
7390 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
7391 || (do_debug_lines
&& strcmp (name
, "line") == 0)
7392 || (do_debug_lines
&& startswith (name
, "line."))
7393 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
7394 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
7395 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
7396 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
7397 || (do_debug_aranges
&& startswith (name
, "aranges"))
7398 || (do_debug_ranges
&& startswith (name
, "ranges"))
7399 || (do_debug_ranges
&& startswith (name
, "rnglists"))
7400 || (do_debug_frames
&& startswith (name
, "frame"))
7401 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
7402 || (do_debug_macinfo
&& startswith (name
, "macro"))
7403 || (do_debug_str
&& startswith (name
, "str"))
7404 || (do_debug_links
&& startswith (name
, "sup"))
7405 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
7406 || (do_debug_loc
&& startswith (name
, "loc"))
7407 || (do_debug_loc
&& startswith (name
, "loclists"))
7408 || (do_debug_addr
&& startswith (name
, "addr"))
7409 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
7410 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
7412 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7414 /* Linkonce section to be combined with .debug_info at link time. */
7415 else if ((do_debugging
|| do_debug_info
)
7416 && startswith (name
, ".gnu.linkonce.wi."))
7417 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7418 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
7419 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7420 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
7421 || streq (name
, ".debug_names")))
7422 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7423 /* Trace sections for Itanium VMS. */
7424 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
7425 || do_trace_aranges
)
7426 && startswith (name
, ".trace_"))
7428 name
+= sizeof (".trace_") - 1;
7431 || (do_trace_info
&& streq (name
, "info"))
7432 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
7433 || (do_trace_aranges
&& streq (name
, "aranges"))
7435 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7437 else if ((do_debugging
|| do_debug_links
)
7438 && (startswith (name
, ".gnu_debuglink")
7439 || startswith (name
, ".gnu_debugaltlink")))
7440 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7446 if (filedata
->is_separate
&& ! process_links
)
7449 if (filedata
->is_separate
)
7450 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
7451 else if (filedata
->file_header
.e_shnum
> 1)
7452 printf (_("\nSection Headers:\n"));
7454 printf (_("\nSection Header:\n"));
7458 if (do_section_details
)
7460 printf (_(" [Nr] Name\n"));
7461 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
7465 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
7469 if (do_section_details
)
7471 printf (_(" [Nr] Name\n"));
7472 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
7476 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
7480 if (do_section_details
)
7482 printf (_(" [Nr] Name\n"));
7483 printf (_(" Type Address Offset Link\n"));
7484 printf (_(" Size EntSize Info Align\n"));
7488 printf (_(" [Nr] Name Type Address Offset\n"));
7489 printf (_(" Size EntSize Flags Link Info Align\n"));
7493 if (do_section_details
)
7494 printf (_(" Flags\n"));
7496 for (i
= 0, section
= filedata
->section_headers
;
7497 i
< filedata
->file_header
.e_shnum
;
7500 /* Run some sanity checks on the section header. */
7502 /* Check the sh_link field. */
7503 switch (section
->sh_type
)
7507 if (section
->sh_link
== 0
7508 && (filedata
->file_header
.e_type
== ET_EXEC
7509 || filedata
->file_header
.e_type
== ET_DYN
))
7510 /* A dynamic relocation section where all entries use a
7511 zero symbol index need not specify a symtab section. */
7514 case SHT_SYMTAB_SHNDX
:
7518 case SHT_GNU_versym
:
7519 if (section
->sh_link
== 0
7520 || section
->sh_link
>= filedata
->file_header
.e_shnum
7521 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
7522 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
7523 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
7524 i
, section
->sh_link
);
7530 case SHT_GNU_verneed
:
7531 case SHT_GNU_verdef
:
7532 case SHT_GNU_LIBLIST
:
7533 if (section
->sh_link
== 0
7534 || section
->sh_link
>= filedata
->file_header
.e_shnum
7535 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
7536 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
7537 i
, section
->sh_link
);
7540 case SHT_INIT_ARRAY
:
7541 case SHT_FINI_ARRAY
:
7542 case SHT_PREINIT_ARRAY
:
7543 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7544 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7545 i
, section
->sh_link
);
7549 /* FIXME: Add support for target specific section types. */
7550 #if 0 /* Currently we do not check other section types as there are too
7551 many special cases. Stab sections for example have a type
7552 of SHT_PROGBITS but an sh_link field that links to the .stabstr
7554 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7555 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7556 i
, section
->sh_link
);
7561 /* Check the sh_info field. */
7562 switch (section
->sh_type
)
7566 if (section
->sh_info
== 0
7567 && (filedata
->file_header
.e_type
== ET_EXEC
7568 || filedata
->file_header
.e_type
== ET_DYN
))
7569 /* Dynamic relocations apply to segments, so they do not
7570 need to specify the section they relocate. */
7572 if (section
->sh_info
== 0
7573 || section
->sh_info
>= filedata
->file_header
.e_shnum
7574 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
7575 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
7576 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
7577 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
7578 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
7579 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
7580 /* FIXME: Are other section types valid ? */
7581 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
7582 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
7583 i
, section
->sh_info
);
7588 case SHT_SYMTAB_SHNDX
:
7589 case SHT_INIT_ARRAY
:
7590 case SHT_FINI_ARRAY
:
7591 case SHT_PREINIT_ARRAY
:
7592 if (section
->sh_info
!= 0)
7593 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7594 i
, section
->sh_info
);
7600 /* A symbol index - we assume that it is valid. */
7604 /* FIXME: Add support for target specific section types. */
7605 if (section
->sh_type
== SHT_NOBITS
)
7606 /* NOBITS section headers with non-zero sh_info fields can be
7607 created when a binary is stripped of everything but its debug
7608 information. The stripped sections have their headers
7609 preserved but their types set to SHT_NOBITS. So do not check
7610 this type of section. */
7612 else if (section
->sh_flags
& SHF_INFO_LINK
)
7614 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
7615 warn (_("[%2u]: Expected link to another section in info field"), i
);
7617 else if (section
->sh_type
< SHT_LOOS
7618 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
7619 && section
->sh_info
!= 0)
7620 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7621 i
, section
->sh_info
);
7625 /* Check the sh_size field. */
7626 if (section
->sh_size
> filedata
->file_size
7627 && section
->sh_type
!= SHT_NOBITS
7628 && section
->sh_type
!= SHT_NULL
7629 && section
->sh_type
< SHT_LOOS
)
7630 warn (_("Size of section %u is larger than the entire file!\n"), i
);
7632 printf (" [%2u] ", i
);
7633 if (do_section_details
)
7634 printf ("%s\n ", printable_section_name (filedata
, section
));
7636 print_symbol (-17, section_name_print (filedata
, section
));
7638 printf (do_wide
? " %-15s " : " %-15.15s ",
7639 get_section_type_name (filedata
, section
->sh_type
));
7643 const char * link_too_big
= NULL
;
7645 print_vma (section
->sh_addr
, LONG_HEX
);
7647 printf ( " %6.6lx %6.6lx %2.2lx",
7648 (unsigned long) section
->sh_offset
,
7649 (unsigned long) section
->sh_size
,
7650 (unsigned long) section
->sh_entsize
);
7652 if (do_section_details
)
7653 fputs (" ", stdout
);
7655 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7657 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
7660 /* The sh_link value is out of range. Normally this indicates
7661 an error but it can have special values in Solaris binaries. */
7662 switch (filedata
->file_header
.e_machine
)
7669 case EM_OLD_SPARCV9
:
7670 case EM_SPARC32PLUS
:
7673 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
7674 link_too_big
= "BEFORE";
7675 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
7676 link_too_big
= "AFTER";
7683 if (do_section_details
)
7685 if (link_too_big
!= NULL
&& * link_too_big
)
7686 printf ("<%s> ", link_too_big
);
7688 printf ("%2u ", section
->sh_link
);
7689 printf ("%3u %2lu\n", section
->sh_info
,
7690 (unsigned long) section
->sh_addralign
);
7693 printf ("%2u %3u %2lu\n",
7696 (unsigned long) section
->sh_addralign
);
7698 if (link_too_big
&& ! * link_too_big
)
7699 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7700 i
, section
->sh_link
);
7704 print_vma (section
->sh_addr
, LONG_HEX
);
7706 if ((long) section
->sh_offset
== section
->sh_offset
)
7707 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7711 print_vma (section
->sh_offset
, LONG_HEX
);
7714 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7715 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7719 print_vma (section
->sh_size
, LONG_HEX
);
7722 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7723 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7727 print_vma (section
->sh_entsize
, LONG_HEX
);
7730 if (do_section_details
)
7731 fputs (" ", stdout
);
7733 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7735 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7737 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7738 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7741 print_vma (section
->sh_addralign
, DEC
);
7745 else if (do_section_details
)
7748 print_vma (section
->sh_addr
, LONG_HEX
);
7749 if ((long) section
->sh_offset
== section
->sh_offset
)
7750 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7754 print_vma (section
->sh_offset
, LONG_HEX
);
7756 printf (" %u\n ", section
->sh_link
);
7757 print_vma (section
->sh_size
, LONG_HEX
);
7759 print_vma (section
->sh_entsize
, LONG_HEX
);
7761 printf (" %-16u %lu\n",
7763 (unsigned long) section
->sh_addralign
);
7768 print_vma (section
->sh_addr
, LONG_HEX
);
7769 if ((long) section
->sh_offset
== section
->sh_offset
)
7770 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7774 print_vma (section
->sh_offset
, LONG_HEX
);
7777 print_vma (section
->sh_size
, LONG_HEX
);
7779 print_vma (section
->sh_entsize
, LONG_HEX
);
7781 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7783 printf (" %2u %3u %lu\n",
7786 (unsigned long) section
->sh_addralign
);
7789 if (do_section_details
)
7791 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7792 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7794 /* Minimum section size is 12 bytes for 32-bit compression
7795 header + 12 bytes for compressed data header. */
7796 unsigned char buf
[24];
7798 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7799 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7800 sizeof (buf
), _("compression header")))
7802 Elf_Internal_Chdr chdr
;
7804 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7805 printf (_(" [<corrupt>]\n"));
7808 if (chdr
.ch_type
== ch_compress_zlib
)
7810 else if (chdr
.ch_type
== ch_compress_zstd
)
7813 printf (_(" [<unknown>: 0x%x], "),
7815 print_vma (chdr
.ch_size
, LONG_HEX
);
7816 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7823 if (!do_section_details
)
7825 /* The ordering of the letters shown here matches the ordering of the
7826 corresponding SHF_xxx values, and hence the order in which these
7827 letters will be displayed to the user. */
7828 printf (_("Key to Flags:\n\
7829 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7830 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7831 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7832 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7835 case ELFOSABI_FREEBSD
:
7836 printf (_("R (retain), "));
7839 printf (_("D (mbind), "));
7844 if (filedata
->file_header
.e_machine
== EM_X86_64
7845 || filedata
->file_header
.e_machine
== EM_L1OM
7846 || filedata
->file_header
.e_machine
== EM_K1OM
)
7847 printf (_("l (large), "));
7848 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7849 printf (_("y (purecode), "));
7850 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7851 printf (_("v (VLE), "));
7852 printf ("p (processor specific)\n");
7859 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7860 Elf_Internal_Sym
**symtab
, uint64_t *nsyms
,
7861 char **strtab
, uint64_t *strtablen
)
7865 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7867 if (*symtab
== NULL
)
7870 if (symsec
->sh_link
!= 0)
7872 Elf_Internal_Shdr
*strsec
;
7874 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7876 error (_("Bad sh_link in symbol table section\n"));
7883 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7885 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7886 1, strsec
->sh_size
, _("string table"));
7887 if (*strtab
== NULL
)
7894 *strtablen
= strsec
->sh_size
;
7900 get_group_flags (unsigned int flags
)
7902 static char buff
[128];
7906 else if (flags
== GRP_COMDAT
)
7909 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7911 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7912 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7913 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7914 ? _("<unknown>") : ""));
7920 process_section_groups (Filedata
* filedata
)
7922 Elf_Internal_Shdr
* section
;
7924 struct group
* group
;
7925 Elf_Internal_Shdr
* symtab_sec
;
7926 Elf_Internal_Shdr
* strtab_sec
;
7927 Elf_Internal_Sym
* symtab
;
7932 /* Don't process section groups unless needed. */
7933 if (!do_unwind
&& !do_section_groups
)
7936 if (filedata
->file_header
.e_shnum
== 0)
7938 if (do_section_groups
)
7940 if (filedata
->is_separate
)
7941 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7942 filedata
->file_name
);
7944 printf (_("\nThere are no section groups in this file.\n"));
7949 if (filedata
->section_headers
== NULL
)
7951 error (_("Section headers are not available!\n"));
7952 /* PR 13622: This can happen with a corrupt ELF header. */
7956 filedata
->section_headers_groups
7957 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7958 sizeof (struct group
*));
7960 if (filedata
->section_headers_groups
== NULL
)
7962 error (_("Out of memory reading %u section group headers\n"),
7963 filedata
->file_header
.e_shnum
);
7967 /* Scan the sections for the group section. */
7968 filedata
->group_count
= 0;
7969 for (i
= 0, section
= filedata
->section_headers
;
7970 i
< filedata
->file_header
.e_shnum
;
7972 if (section
->sh_type
== SHT_GROUP
)
7973 filedata
->group_count
++;
7975 if (filedata
->group_count
== 0)
7977 if (do_section_groups
)
7979 if (filedata
->is_separate
)
7980 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7981 filedata
->file_name
);
7983 printf (_("\nThere are no section groups in this file.\n"));
7989 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7990 sizeof (struct group
));
7992 if (filedata
->section_groups
== NULL
)
7994 error (_("Out of memory reading %zu groups\n"), filedata
->group_count
);
8005 if (filedata
->is_separate
)
8006 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
8008 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
8009 i
< filedata
->file_header
.e_shnum
;
8012 if (section
->sh_type
== SHT_GROUP
)
8014 const char * name
= printable_section_name (filedata
, section
);
8015 const char * group_name
;
8016 unsigned char * start
;
8017 unsigned char * indices
;
8018 unsigned int entry
, j
, size
;
8019 Elf_Internal_Shdr
* sec
;
8020 Elf_Internal_Sym
* sym
;
8022 /* Get the symbol table. */
8023 if (section
->sh_link
>= filedata
->file_header
.e_shnum
8024 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
8027 error (_("Bad sh_link in group section `%s'\n"), name
);
8031 if (symtab_sec
!= sec
)
8035 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
8040 error (_("Corrupt header in group section `%s'\n"), name
);
8044 if (section
->sh_info
>= num_syms
)
8046 error (_("Bad sh_info in group section `%s'\n"), name
);
8050 sym
= symtab
+ section
->sh_info
;
8052 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8054 if (sym
->st_shndx
== 0
8055 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
8057 error (_("Bad sh_info in group section `%s'\n"), name
);
8061 group_name
= section_name_print (filedata
,
8062 filedata
->section_headers
8071 /* Get the string table. */
8072 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
8080 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
8085 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
8086 1, strtab_sec
->sh_size
,
8088 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
8090 group_name
= sym
->st_name
< strtab_size
8091 ? strtab
+ sym
->st_name
: _("<corrupt>");
8094 /* PR 17531: file: loop. */
8095 if (section
->sh_entsize
> section
->sh_size
)
8097 error (_("Section %s has sh_entsize (%#" PRIx64
")"
8098 " which is larger than its size (%#" PRIx64
")\n"),
8099 printable_section_name (filedata
, section
),
8100 section
->sh_entsize
,
8105 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
8106 1, section
->sh_size
,
8112 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
8113 entry
= byte_get (indices
, 4);
8116 if (do_section_groups
)
8118 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
8119 get_group_flags (entry
), i
, name
, group_name
, size
);
8121 printf (_(" [Index] Name\n"));
8124 group
->group_index
= i
;
8126 for (j
= 0; j
< size
; j
++)
8128 struct group_list
* g
;
8130 entry
= byte_get (indices
, 4);
8133 if (entry
>= filedata
->file_header
.e_shnum
)
8135 static unsigned num_group_errors
= 0;
8137 if (num_group_errors
++ < 10)
8139 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
8140 entry
, i
, filedata
->file_header
.e_shnum
- 1);
8141 if (num_group_errors
== 10)
8142 warn (_("Further error messages about overlarge group section indices suppressed\n"));
8147 if (filedata
->section_headers_groups
[entry
] != NULL
)
8151 static unsigned num_errs
= 0;
8153 if (num_errs
++ < 10)
8155 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
8157 filedata
->section_headers_groups
[entry
]->group_index
);
8159 warn (_("Further error messages about already contained group sections suppressed\n"));
8165 /* Intel C/C++ compiler may put section 0 in a
8166 section group. We just warn it the first time
8167 and ignore it afterwards. */
8168 static bool warned
= false;
8171 error (_("section 0 in group section [%5u]\n"),
8172 filedata
->section_headers_groups
[entry
]->group_index
);
8178 filedata
->section_headers_groups
[entry
] = group
;
8180 if (do_section_groups
)
8182 sec
= filedata
->section_headers
+ entry
;
8183 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
8186 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
8187 g
->section_index
= entry
;
8188 g
->next
= group
->root
;
8203 /* Data used to display dynamic fixups. */
8205 struct ia64_vms_dynfixup
8207 uint64_t needed_ident
; /* Library ident number. */
8208 uint64_t needed
; /* Index in the dstrtab of the library name. */
8209 uint64_t fixup_needed
; /* Index of the library. */
8210 uint64_t fixup_rela_cnt
; /* Number of fixups. */
8211 uint64_t fixup_rela_off
; /* Fixups offset in the dynamic segment. */
8214 /* Data used to display dynamic relocations. */
8216 struct ia64_vms_dynimgrela
8218 uint64_t img_rela_cnt
; /* Number of relocations. */
8219 uint64_t img_rela_off
; /* Reloc offset in the dynamic segment. */
8222 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
8226 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
8227 struct ia64_vms_dynfixup
* fixup
,
8228 const char * strtab
,
8229 unsigned int strtab_sz
)
8231 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
8233 const char * lib_name
;
8235 imfs
= get_data (NULL
, filedata
,
8236 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
8237 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
8238 _("dynamic section image fixups"));
8242 if (fixup
->needed
< strtab_sz
)
8243 lib_name
= strtab
+ fixup
->needed
;
8246 warn (_("corrupt library name index of %#" PRIx64
8247 " found in dynamic entry"), fixup
->needed
);
8251 printf (_("\nImage fixups for needed library #%" PRId64
8252 ": %s - ident: %" PRIx64
"\n"),
8253 fixup
->fixup_needed
, lib_name
, fixup
->needed_ident
);
8255 (_("Seg Offset Type SymVec DataType\n"));
8257 for (i
= 0; i
< (size_t) fixup
->fixup_rela_cnt
; i
++)
8262 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
8263 printf ("%016" PRIx64
" ", BYTE_GET (imfs
[i
].fixup_offset
));
8264 type
= BYTE_GET (imfs
[i
].type
);
8265 rtype
= elf_ia64_reloc_type (type
);
8267 printf ("0x%08x ", type
);
8269 printf ("%-32s ", rtype
);
8270 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
8271 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
8278 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
8281 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
8283 Elf64_External_VMS_IMAGE_RELA
*imrs
;
8286 imrs
= get_data (NULL
, filedata
,
8287 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
8288 sizeof (*imrs
), imgrela
->img_rela_cnt
,
8289 _("dynamic section image relocations"));
8293 printf (_("\nImage relocs\n"));
8295 (_("Seg Offset Type Addend Seg Sym Off\n"));
8297 for (i
= 0; i
< (size_t) imgrela
->img_rela_cnt
; i
++)
8302 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
8303 printf ("%08" PRIx64
" ", BYTE_GET (imrs
[i
].rela_offset
));
8304 type
= BYTE_GET (imrs
[i
].type
);
8305 rtype
= elf_ia64_reloc_type (type
);
8307 printf ("0x%08x ", type
);
8309 printf ("%-31s ", rtype
);
8310 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
8311 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
8312 printf ("%08" PRIx64
"\n", BYTE_GET (imrs
[i
].sym_offset
));
8319 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
8322 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
8324 struct ia64_vms_dynfixup fixup
;
8325 struct ia64_vms_dynimgrela imgrela
;
8326 Elf_Internal_Dyn
*entry
;
8327 uint64_t strtab_off
= 0;
8328 uint64_t strtab_sz
= 0;
8329 char *strtab
= NULL
;
8332 memset (&fixup
, 0, sizeof (fixup
));
8333 memset (&imgrela
, 0, sizeof (imgrela
));
8335 /* Note: the order of the entries is specified by the OpenVMS specs. */
8336 for (entry
= filedata
->dynamic_section
;
8337 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
8340 switch (entry
->d_tag
)
8342 case DT_IA_64_VMS_STRTAB_OFFSET
:
8343 strtab_off
= entry
->d_un
.d_val
;
8346 strtab_sz
= entry
->d_un
.d_val
;
8348 strtab
= get_data (NULL
, filedata
,
8349 filedata
->dynamic_addr
+ strtab_off
,
8350 1, strtab_sz
, _("dynamic string section"));
8355 case DT_IA_64_VMS_NEEDED_IDENT
:
8356 fixup
.needed_ident
= entry
->d_un
.d_val
;
8359 fixup
.needed
= entry
->d_un
.d_val
;
8361 case DT_IA_64_VMS_FIXUP_NEEDED
:
8362 fixup
.fixup_needed
= entry
->d_un
.d_val
;
8364 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
8365 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
8367 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
8368 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
8369 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
8372 case DT_IA_64_VMS_IMG_RELA_CNT
:
8373 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
8375 case DT_IA_64_VMS_IMG_RELA_OFF
:
8376 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
8377 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
8396 relocation_type rel_type
;
8398 dynamic_relocations
[] =
8400 { "REL", DT_REL
, DT_RELSZ
, reltype_rel
},
8401 { "RELA", DT_RELA
, DT_RELASZ
, reltype_rela
},
8402 { "RELR", DT_RELR
, DT_RELRSZ
, reltype_relr
},
8403 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, reltype_unknown
}
8406 /* Process the reloc section. */
8409 process_relocs (Filedata
* filedata
)
8412 uint64_t rel_offset
;
8417 if (do_using_dynamic
)
8419 relocation_type rel_type
;
8421 bool has_dynamic_reloc
;
8424 has_dynamic_reloc
= false;
8426 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8428 rel_type
= dynamic_relocations
[i
].rel_type
;
8429 name
= dynamic_relocations
[i
].name
;
8430 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
8431 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
8434 has_dynamic_reloc
= true;
8436 if (rel_type
== reltype_unknown
)
8438 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
8439 switch (filedata
->dynamic_info
[DT_PLTREL
])
8442 rel_type
= reltype_rel
;
8445 rel_type
= reltype_rela
;
8452 if (filedata
->is_separate
)
8454 (_("\nIn linked file '%s' section '%s' at offset %#" PRIx64
8455 " contains %" PRId64
" bytes:\n"),
8456 filedata
->file_name
, name
, rel_offset
, rel_size
);
8459 (_("\n'%s' relocation section at offset %#" PRIx64
8460 " contains %" PRId64
" bytes:\n"),
8461 name
, rel_offset
, rel_size
);
8463 dump_relocations (filedata
,
8464 offset_from_vma (filedata
, rel_offset
, rel_size
),
8466 filedata
->dynamic_symbols
,
8467 filedata
->num_dynamic_syms
,
8468 filedata
->dynamic_strings
,
8469 filedata
->dynamic_strings_length
,
8470 rel_type
, true /* is_dynamic */);
8474 if (is_ia64_vms (filedata
))
8475 if (process_ia64_vms_dynamic_relocs (filedata
))
8476 has_dynamic_reloc
= true;
8478 if (! has_dynamic_reloc
)
8480 if (filedata
->is_separate
)
8481 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
8482 filedata
->file_name
);
8484 printf (_("\nThere are no dynamic relocations in this file.\n"));
8489 Elf_Internal_Shdr
* section
;
8493 for (i
= 0, section
= filedata
->section_headers
;
8494 i
< filedata
->file_header
.e_shnum
;
8497 if ( section
->sh_type
!= SHT_RELA
8498 && section
->sh_type
!= SHT_REL
8499 && section
->sh_type
!= SHT_RELR
)
8502 rel_offset
= section
->sh_offset
;
8503 rel_size
= section
->sh_size
;
8507 relocation_type rel_type
;
8510 if (filedata
->is_separate
)
8511 printf (_("\nIn linked file '%s' relocation section "),
8512 filedata
->file_name
);
8514 printf (_("\nRelocation section "));
8516 if (filedata
->string_table
== NULL
)
8517 printf ("%d", section
->sh_name
);
8519 printf ("'%s'", printable_section_name (filedata
, section
));
8521 num_rela
= rel_size
/ section
->sh_entsize
;
8522 printf (ngettext (" at offset %#" PRIx64
8523 " contains %" PRIu64
" entry:\n",
8524 " at offset %#" PRIx64
8525 " contains %" PRId64
" entries:\n",
8527 rel_offset
, num_rela
);
8529 rel_type
= section
->sh_type
== SHT_RELA
? reltype_rela
:
8530 section
->sh_type
== SHT_REL
? reltype_rel
: reltype_relr
;
8532 if (section
->sh_link
!= 0
8533 && section
->sh_link
< filedata
->file_header
.e_shnum
)
8535 Elf_Internal_Shdr
*symsec
;
8536 Elf_Internal_Sym
*symtab
;
8538 uint64_t strtablen
= 0;
8539 char *strtab
= NULL
;
8541 symsec
= filedata
->section_headers
+ section
->sh_link
;
8542 if (symsec
->sh_type
!= SHT_SYMTAB
8543 && symsec
->sh_type
!= SHT_DYNSYM
)
8546 if (!get_symtab (filedata
, symsec
,
8547 &symtab
, &nsyms
, &strtab
, &strtablen
))
8550 dump_relocations (filedata
, rel_offset
, rel_size
,
8551 symtab
, nsyms
, strtab
, strtablen
,
8553 symsec
->sh_type
== SHT_DYNSYM
);
8558 dump_relocations (filedata
, rel_offset
, rel_size
,
8559 NULL
, 0, NULL
, 0, rel_type
, false /* is_dynamic */);
8567 /* Users sometimes forget the -D option, so try to be helpful. */
8568 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8570 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
8572 if (filedata
->is_separate
)
8573 printf (_("\nThere are no static relocations in linked file '%s'."),
8574 filedata
->file_name
);
8576 printf (_("\nThere are no static relocations in this file."));
8577 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
8582 if (i
== ARRAY_SIZE (dynamic_relocations
))
8584 if (filedata
->is_separate
)
8585 printf (_("\nThere are no relocations in linked file '%s'.\n"),
8586 filedata
->file_name
);
8588 printf (_("\nThere are no relocations in this file.\n"));
8596 /* An absolute address consists of a section and an offset. If the
8597 section is NULL, the offset itself is the address, otherwise, the
8598 address equals to LOAD_ADDRESS(section) + offset. */
8602 unsigned short section
;
8606 /* Find the nearest symbol at or below ADDR. Returns the symbol
8607 name, if found, and the offset from the symbol to ADDR. */
8610 find_symbol_for_address (Filedata
*filedata
,
8611 Elf_Internal_Sym
*symtab
,
8614 uint64_t strtab_size
,
8615 struct absaddr addr
,
8616 const char **symname
,
8619 uint64_t dist
= 0x100000;
8620 Elf_Internal_Sym
* sym
;
8621 Elf_Internal_Sym
* beg
;
8622 Elf_Internal_Sym
* end
;
8623 Elf_Internal_Sym
* best
= NULL
;
8625 REMOVE_ARCH_BITS (addr
.offset
);
8627 end
= symtab
+ nsyms
;
8633 sym
= beg
+ (end
- beg
) / 2;
8635 value
= sym
->st_value
;
8636 REMOVE_ARCH_BITS (value
);
8638 if (sym
->st_name
!= 0
8639 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
8640 && addr
.offset
>= value
8641 && addr
.offset
- value
< dist
)
8644 dist
= addr
.offset
- value
;
8649 if (addr
.offset
< value
)
8657 *symname
= (best
->st_name
>= strtab_size
8658 ? _("<corrupt>") : strtab
+ best
->st_name
);
8664 *offset
= addr
.offset
;
8667 static /* signed */ int
8668 symcmp (const void *p
, const void *q
)
8670 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
8671 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
8673 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
8676 /* Process the unwind section. */
8678 #include "unwind-ia64.h"
8680 struct ia64_unw_table_entry
8682 struct absaddr start
;
8684 struct absaddr info
;
8687 struct ia64_unw_aux_info
8689 struct ia64_unw_table_entry
* table
; /* Unwind table. */
8690 uint64_t table_len
; /* Length of unwind table. */
8691 unsigned char * info
; /* Unwind info. */
8692 uint64_t info_size
; /* Size of unwind info. */
8693 uint64_t info_addr
; /* Starting address of unwind info. */
8694 uint64_t seg_base
; /* Starting address of segment. */
8695 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8696 uint64_t nsyms
; /* Number of symbols. */
8697 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8698 uint64_t nfuns
; /* Number of entries in funtab. */
8699 char * strtab
; /* The string table. */
8700 uint64_t strtab_size
; /* Size of string table. */
8704 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8706 struct ia64_unw_table_entry
* tp
;
8711 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8712 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8713 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8714 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8716 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8718 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8722 const unsigned char * dp
;
8723 const unsigned char * head
;
8724 const unsigned char * end
;
8725 const char * procname
;
8727 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8728 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8730 fputs ("\n<", stdout
);
8734 fputs (procname
, stdout
);
8737 printf ("+%" PRIx64
, offset
);
8740 fputs (">: [", stdout
);
8741 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8742 fputc ('-', stdout
);
8743 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8744 printf ("], info at +0x%" PRIx64
"\n",
8745 tp
->info
.offset
- aux
->seg_base
);
8747 /* PR 17531: file: 86232b32. */
8748 if (aux
->info
== NULL
)
8751 offset
= tp
->info
.offset
;
8752 if (tp
->info
.section
)
8754 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8756 warn (_("Invalid section %u in table entry %td\n"),
8757 tp
->info
.section
, tp
- aux
->table
);
8761 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8763 offset
-= aux
->info_addr
;
8764 /* PR 17531: file: 0997b4d1. */
8765 if (offset
>= aux
->info_size
8766 || aux
->info_size
- offset
< 8)
8768 warn (_("Invalid offset %" PRIx64
" in table entry %td\n"),
8769 tp
->info
.offset
, tp
- aux
->table
);
8774 head
= aux
->info
+ offset
;
8775 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8777 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8778 (unsigned) UNW_VER (stamp
),
8779 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8780 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8781 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8782 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8784 if (UNW_VER (stamp
) != 1)
8786 printf (_("\tUnknown version.\n"));
8791 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8792 /* PR 17531: file: 16ceda89. */
8793 if (end
> aux
->info
+ aux
->info_size
)
8794 end
= aux
->info
+ aux
->info_size
;
8795 for (dp
= head
+ 8; dp
< end
;)
8796 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8805 slurp_ia64_unwind_table (Filedata
* filedata
,
8806 struct ia64_unw_aux_info
* aux
,
8807 Elf_Internal_Shdr
* sec
)
8809 uint64_t size
, nrelas
, i
;
8810 Elf_Internal_Phdr
* seg
;
8811 struct ia64_unw_table_entry
* tep
;
8812 Elf_Internal_Shdr
* relsec
;
8813 Elf_Internal_Rela
* rela
;
8814 Elf_Internal_Rela
* rp
;
8815 unsigned char * table
;
8817 Elf_Internal_Sym
* sym
;
8818 const char * relname
;
8822 /* First, find the starting address of the segment that includes
8825 if (filedata
->file_header
.e_phnum
)
8827 if (! get_program_headers (filedata
))
8830 for (seg
= filedata
->program_headers
;
8831 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8834 if (seg
->p_type
!= PT_LOAD
)
8837 if (sec
->sh_addr
>= seg
->p_vaddr
8838 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8840 aux
->seg_base
= seg
->p_vaddr
;
8846 /* Second, build the unwind table from the contents of the unwind section: */
8847 size
= sec
->sh_size
;
8848 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8853 aux
->table_len
= size
/ (3 * eh_addr_size
);
8854 aux
->table
= (struct ia64_unw_table_entry
*)
8855 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8858 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8860 tep
->start
.section
= SHN_UNDEF
;
8861 tep
->end
.section
= SHN_UNDEF
;
8862 tep
->info
.section
= SHN_UNDEF
;
8863 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8864 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8865 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8866 tep
->start
.offset
+= aux
->seg_base
;
8867 tep
->end
.offset
+= aux
->seg_base
;
8868 tep
->info
.offset
+= aux
->seg_base
;
8872 /* Third, apply any relocations to the unwind table: */
8873 for (relsec
= filedata
->section_headers
;
8874 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8877 if (relsec
->sh_type
!= SHT_RELA
8878 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8879 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8882 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8891 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8893 unsigned int sym_ndx
;
8894 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8895 relname
= elf_ia64_reloc_type (r_type
);
8897 /* PR 17531: file: 9fa67536. */
8898 if (relname
== NULL
)
8900 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8904 if (! startswith (relname
, "R_IA64_SEGREL"))
8906 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8910 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8912 /* PR 17531: file: 5bc8d9bf. */
8913 if (i
>= aux
->table_len
)
8915 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
8920 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8921 if (sym_ndx
>= aux
->nsyms
)
8923 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8927 sym
= aux
->symtab
+ sym_ndx
;
8929 switch (rp
->r_offset
/ eh_addr_size
% 3)
8932 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8933 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8936 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8937 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8940 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8941 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8955 ia64_process_unwind (Filedata
* filedata
)
8957 Elf_Internal_Shdr
* sec
;
8958 Elf_Internal_Shdr
* unwsec
= NULL
;
8959 uint64_t i
, unwcount
= 0, unwstart
= 0;
8960 struct ia64_unw_aux_info aux
;
8963 memset (& aux
, 0, sizeof (aux
));
8965 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8967 if (sec
->sh_type
== SHT_SYMTAB
)
8971 error (_("Multiple symbol tables encountered\n"));
8977 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8978 &aux
.strtab
, &aux
.strtab_size
))
8981 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8986 printf (_("\nThere are no unwind sections in this file.\n"));
8988 while (unwcount
-- > 0)
8993 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8994 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8995 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9000 /* We have already counted the number of SHT_IA64_UNWIND
9001 sections so the loop above should never fail. */
9002 assert (unwsec
!= NULL
);
9005 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
9007 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
9009 /* We need to find which section group it is in. */
9010 struct group_list
* g
;
9012 if (filedata
->section_headers_groups
== NULL
9013 || filedata
->section_headers_groups
[i
] == NULL
)
9014 i
= filedata
->file_header
.e_shnum
;
9017 g
= filedata
->section_headers_groups
[i
]->root
;
9019 for (; g
!= NULL
; g
= g
->next
)
9021 sec
= filedata
->section_headers
+ g
->section_index
;
9023 if (section_name_valid (filedata
, sec
)
9024 && streq (section_name (filedata
, sec
),
9025 ELF_STRING_ia64_unwind_info
))
9030 i
= filedata
->file_header
.e_shnum
;
9033 else if (section_name_valid (filedata
, unwsec
)
9034 && startswith (section_name (filedata
, unwsec
),
9035 ELF_STRING_ia64_unwind_once
))
9037 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
9038 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
9039 suffix
= section_name (filedata
, unwsec
) + len
;
9040 for (i
= 0, sec
= filedata
->section_headers
;
9041 i
< filedata
->file_header
.e_shnum
;
9043 if (section_name_valid (filedata
, sec
)
9044 && startswith (section_name (filedata
, sec
),
9045 ELF_STRING_ia64_unwind_info_once
)
9046 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9051 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
9052 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
9053 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
9054 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
9056 if (section_name_valid (filedata
, unwsec
)
9057 && startswith (section_name (filedata
, unwsec
),
9058 ELF_STRING_ia64_unwind
))
9059 suffix
= section_name (filedata
, unwsec
) + len
;
9060 for (i
= 0, sec
= filedata
->section_headers
;
9061 i
< filedata
->file_header
.e_shnum
;
9063 if (section_name_valid (filedata
, sec
)
9064 && startswith (section_name (filedata
, sec
),
9065 ELF_STRING_ia64_unwind_info
)
9066 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9070 if (i
== filedata
->file_header
.e_shnum
)
9072 printf (_("\nCould not find unwind info section for "));
9074 if (filedata
->string_table
== NULL
)
9075 printf ("%d", unwsec
->sh_name
);
9077 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9081 aux
.info_addr
= sec
->sh_addr
;
9082 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
9085 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
9087 printf (_("\nUnwind section "));
9089 if (filedata
->string_table
== NULL
)
9090 printf ("%d", unwsec
->sh_name
);
9092 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9094 printf (_(" at offset %#" PRIx64
" contains %" PRIu64
" entries:\n"),
9096 unwsec
->sh_size
/ (3 * eh_addr_size
));
9098 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
9099 && aux
.table_len
> 0)
9100 dump_ia64_unwind (filedata
, & aux
);
9102 free ((char *) aux
.table
);
9103 free ((char *) aux
.info
);
9110 free ((char *) aux
.strtab
);
9115 struct hppa_unw_table_entry
9117 struct absaddr start
;
9119 unsigned int Cannot_unwind
:1; /* 0 */
9120 unsigned int Millicode
:1; /* 1 */
9121 unsigned int Millicode_save_sr0
:1; /* 2 */
9122 unsigned int Region_description
:2; /* 3..4 */
9123 unsigned int reserved1
:1; /* 5 */
9124 unsigned int Entry_SR
:1; /* 6 */
9125 unsigned int Entry_FR
:4; /* Number saved 7..10 */
9126 unsigned int Entry_GR
:5; /* Number saved 11..15 */
9127 unsigned int Args_stored
:1; /* 16 */
9128 unsigned int Variable_Frame
:1; /* 17 */
9129 unsigned int Separate_Package_Body
:1; /* 18 */
9130 unsigned int Frame_Extension_Millicode
:1; /* 19 */
9131 unsigned int Stack_Overflow_Check
:1; /* 20 */
9132 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
9133 unsigned int Ada_Region
:1; /* 22 */
9134 unsigned int cxx_info
:1; /* 23 */
9135 unsigned int cxx_try_catch
:1; /* 24 */
9136 unsigned int sched_entry_seq
:1; /* 25 */
9137 unsigned int reserved2
:1; /* 26 */
9138 unsigned int Save_SP
:1; /* 27 */
9139 unsigned int Save_RP
:1; /* 28 */
9140 unsigned int Save_MRP_in_frame
:1; /* 29 */
9141 unsigned int extn_ptr_defined
:1; /* 30 */
9142 unsigned int Cleanup_defined
:1; /* 31 */
9144 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
9145 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
9146 unsigned int Large_frame
:1; /* 2 */
9147 unsigned int Pseudo_SP_Set
:1; /* 3 */
9148 unsigned int reserved4
:1; /* 4 */
9149 unsigned int Total_frame_size
:27; /* 5..31 */
9152 struct hppa_unw_aux_info
9154 struct hppa_unw_table_entry
* table
; /* Unwind table. */
9155 uint64_t table_len
; /* Length of unwind table. */
9156 uint64_t seg_base
; /* Starting address of segment. */
9157 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9158 uint64_t nsyms
; /* Number of symbols. */
9159 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9160 uint64_t nfuns
; /* Number of entries in funtab. */
9161 char * strtab
; /* The string table. */
9162 uint64_t strtab_size
; /* Size of string table. */
9166 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
9168 struct hppa_unw_table_entry
* tp
;
9172 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9173 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9174 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9175 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9177 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9179 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9182 const char * procname
;
9184 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9185 aux
->strtab_size
, tp
->start
, &procname
,
9188 fputs ("\n<", stdout
);
9192 fputs (procname
, stdout
);
9195 printf ("+%" PRIx64
, offset
);
9198 fputs (">: [", stdout
);
9199 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9200 fputc ('-', stdout
);
9201 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9204 #define PF(_m) if (tp->_m) printf (#_m " ");
9205 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
9208 PF(Millicode_save_sr0
);
9209 /* PV(Region_description); */
9215 PF(Separate_Package_Body
);
9216 PF(Frame_Extension_Millicode
);
9217 PF(Stack_Overflow_Check
);
9218 PF(Two_Instruction_SP_Increment
);
9222 PF(sched_entry_seq
);
9225 PF(Save_MRP_in_frame
);
9226 PF(extn_ptr_defined
);
9227 PF(Cleanup_defined
);
9228 PF(MPE_XL_interrupt_marker
);
9229 PF(HP_UX_interrupt_marker
);
9232 PV(Total_frame_size
);
9245 slurp_hppa_unwind_table (Filedata
* filedata
,
9246 struct hppa_unw_aux_info
* aux
,
9247 Elf_Internal_Shdr
* sec
)
9249 uint64_t size
, unw_ent_size
, nentries
, nrelas
, i
;
9250 Elf_Internal_Phdr
* seg
;
9251 struct hppa_unw_table_entry
* tep
;
9252 Elf_Internal_Shdr
* relsec
;
9253 Elf_Internal_Rela
* rela
;
9254 Elf_Internal_Rela
* rp
;
9255 unsigned char * table
;
9257 Elf_Internal_Sym
* sym
;
9258 const char * relname
;
9260 /* First, find the starting address of the segment that includes
9262 if (filedata
->file_header
.e_phnum
)
9264 if (! get_program_headers (filedata
))
9267 for (seg
= filedata
->program_headers
;
9268 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9271 if (seg
->p_type
!= PT_LOAD
)
9274 if (sec
->sh_addr
>= seg
->p_vaddr
9275 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9277 aux
->seg_base
= seg
->p_vaddr
;
9283 /* Second, build the unwind table from the contents of the unwind
9285 size
= sec
->sh_size
;
9286 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9292 nentries
= size
/ unw_ent_size
;
9293 size
= unw_ent_size
* nentries
;
9295 aux
->table_len
= nentries
;
9296 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
9297 xcmalloc (nentries
, sizeof (aux
->table
[0]));
9299 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
9301 unsigned int tmp1
, tmp2
;
9303 tep
->start
.section
= SHN_UNDEF
;
9304 tep
->end
.section
= SHN_UNDEF
;
9306 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
9307 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
9308 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
9309 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
9311 tep
->start
.offset
+= aux
->seg_base
;
9312 tep
->end
.offset
+= aux
->seg_base
;
9314 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
9315 tep
->Millicode
= (tmp1
>> 30) & 0x1;
9316 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
9317 tep
->Region_description
= (tmp1
>> 27) & 0x3;
9318 tep
->reserved1
= (tmp1
>> 26) & 0x1;
9319 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
9320 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
9321 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
9322 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
9323 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
9324 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
9325 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
9326 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
9327 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
9328 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
9329 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
9330 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
9331 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
9332 tep
->reserved2
= (tmp1
>> 5) & 0x1;
9333 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
9334 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
9335 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
9336 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
9337 tep
->Cleanup_defined
= tmp1
& 0x1;
9339 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
9340 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
9341 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
9342 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
9343 tep
->reserved4
= (tmp2
>> 27) & 0x1;
9344 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
9348 /* Third, apply any relocations to the unwind table. */
9349 for (relsec
= filedata
->section_headers
;
9350 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9353 if (relsec
->sh_type
!= SHT_RELA
9354 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9355 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9358 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9362 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9364 unsigned int sym_ndx
;
9365 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9366 relname
= elf_hppa_reloc_type (r_type
);
9368 if (relname
== NULL
)
9370 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9374 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
9375 if (! startswith (relname
, "R_PARISC_SEGREL"))
9377 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9381 i
= rp
->r_offset
/ unw_ent_size
;
9382 if (i
>= aux
->table_len
)
9384 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9389 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9390 if (sym_ndx
>= aux
->nsyms
)
9392 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9396 sym
= aux
->symtab
+ sym_ndx
;
9398 switch ((rp
->r_offset
% unw_ent_size
) / 4)
9401 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9402 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
9405 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9406 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
9420 hppa_process_unwind (Filedata
* filedata
)
9422 struct hppa_unw_aux_info aux
;
9423 Elf_Internal_Shdr
* unwsec
= NULL
;
9424 Elf_Internal_Shdr
* sec
;
9428 if (filedata
->string_table
== NULL
)
9431 memset (& aux
, 0, sizeof (aux
));
9433 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9435 if (sec
->sh_type
== SHT_SYMTAB
)
9439 error (_("Multiple symbol tables encountered\n"));
9445 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9446 &aux
.strtab
, &aux
.strtab_size
))
9449 else if (section_name_valid (filedata
, sec
)
9450 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9455 printf (_("\nThere are no unwind sections in this file.\n"));
9457 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9459 if (section_name_valid (filedata
, sec
)
9460 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9462 uint64_t num_unwind
= sec
->sh_size
/ 16;
9464 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
9465 "contains %" PRIu64
" entry:\n",
9466 "\nUnwind section '%s' at offset %#" PRIx64
" "
9467 "contains %" PRIu64
" entries:\n",
9469 printable_section_name (filedata
, sec
),
9473 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
9476 if (res
&& aux
.table_len
> 0)
9478 if (! dump_hppa_unwind (filedata
, &aux
))
9482 free ((char *) aux
.table
);
9488 free ((char *) aux
.strtab
);
9495 unsigned char * data
; /* The unwind data. */
9496 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
9497 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
9498 uint64_t nrelas
; /* The number of relocations. */
9499 unsigned int rel_type
; /* REL or RELA ? */
9500 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
9503 struct arm_unw_aux_info
9505 Filedata
* filedata
; /* The file containing the unwind sections. */
9506 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
9507 uint64_t nsyms
; /* Number of symbols. */
9508 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9509 uint64_t nfuns
; /* Number of these symbols. */
9510 char * strtab
; /* The file's string table. */
9511 uint64_t strtab_size
; /* Size of string table. */
9515 arm_print_vma_and_name (Filedata
* filedata
,
9516 struct arm_unw_aux_info
* aux
,
9518 struct absaddr addr
)
9520 const char *procname
;
9521 uint64_t sym_offset
;
9523 if (addr
.section
== SHN_UNDEF
)
9526 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9527 aux
->strtab_size
, addr
, &procname
,
9530 print_vma (fn
, PREFIX_HEX
);
9534 fputs (" <", stdout
);
9535 fputs (procname
, stdout
);
9538 printf ("+0x%" PRIx64
, sym_offset
);
9539 fputc ('>', stdout
);
9546 arm_free_section (struct arm_section
*arm_sec
)
9548 free (arm_sec
->data
);
9549 free (arm_sec
->rela
);
9552 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
9553 cached section and install SEC instead.
9554 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
9555 and return its valued in * WORDP, relocating if necessary.
9556 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
9557 relocation's offset in ADDR.
9558 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
9559 into the string table of the symbol associated with the reloc. If no
9560 reloc was applied store -1 there.
9561 5) Return TRUE upon success, FALSE otherwise. */
9564 get_unwind_section_word (Filedata
* filedata
,
9565 struct arm_unw_aux_info
* aux
,
9566 struct arm_section
* arm_sec
,
9567 Elf_Internal_Shdr
* sec
,
9568 uint64_t word_offset
,
9569 unsigned int * wordp
,
9570 struct absaddr
* addr
,
9571 uint64_t * sym_name
)
9573 Elf_Internal_Rela
*rp
;
9574 Elf_Internal_Sym
*sym
;
9575 const char * relname
;
9579 if (sec
== NULL
|| arm_sec
== NULL
)
9582 addr
->section
= SHN_UNDEF
;
9585 if (sym_name
!= NULL
)
9586 *sym_name
= (uint64_t) -1;
9588 /* If necessary, update the section cache. */
9589 if (sec
!= arm_sec
->sec
)
9591 Elf_Internal_Shdr
*relsec
;
9593 arm_free_section (arm_sec
);
9596 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
9597 sec
->sh_size
, _("unwind data"));
9598 arm_sec
->rela
= NULL
;
9599 arm_sec
->nrelas
= 0;
9601 for (relsec
= filedata
->section_headers
;
9602 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9605 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
9606 || filedata
->section_headers
+ relsec
->sh_info
!= sec
9607 /* PR 15745: Check the section type as well. */
9608 || (relsec
->sh_type
!= SHT_REL
9609 && relsec
->sh_type
!= SHT_RELA
))
9612 arm_sec
->rel_type
= relsec
->sh_type
;
9613 if (relsec
->sh_type
== SHT_REL
)
9615 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
9617 & arm_sec
->rela
, & arm_sec
->nrelas
))
9620 else /* relsec->sh_type == SHT_RELA */
9622 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
9624 & arm_sec
->rela
, & arm_sec
->nrelas
))
9630 arm_sec
->next_rela
= arm_sec
->rela
;
9633 /* If there is no unwind data we can do nothing. */
9634 if (arm_sec
->data
== NULL
)
9637 /* If the offset is invalid then fail. */
9638 if (/* PR 21343 *//* PR 18879 */
9640 || word_offset
> sec
->sh_size
- 4)
9643 /* Get the word at the required offset. */
9644 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
9646 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
9647 if (arm_sec
->rela
== NULL
)
9653 /* Look through the relocs to find the one that applies to the provided offset. */
9655 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
9657 uint64_t prelval
, offset
;
9659 if (rp
->r_offset
> word_offset
&& !wrapped
)
9664 if (rp
->r_offset
> word_offset
)
9667 if (rp
->r_offset
& 3)
9669 warn (_("Skipping unexpected relocation at offset %#" PRIx64
"\n"),
9674 if (rp
->r_offset
< word_offset
)
9677 /* PR 17531: file: 027-161405-0.004 */
9678 if (aux
->symtab
== NULL
)
9681 if (arm_sec
->rel_type
== SHT_REL
)
9683 offset
= word
& 0x7fffffff;
9684 if (offset
& 0x40000000)
9685 offset
|= ~ (uint64_t) 0x7fffffff;
9687 else if (arm_sec
->rel_type
== SHT_RELA
)
9688 offset
= rp
->r_addend
;
9691 error (_("Unknown section relocation type %d encountered\n"),
9696 /* PR 17531 file: 027-1241568-0.004. */
9697 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
9699 error (_("Bad symbol index in unwind relocation "
9700 "(%" PRIu64
" > %" PRIu64
")\n"),
9701 ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
9705 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
9706 offset
+= sym
->st_value
;
9707 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
9709 /* Check that we are processing the expected reloc type. */
9710 if (filedata
->file_header
.e_machine
== EM_ARM
)
9712 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9713 if (relname
== NULL
)
9715 warn (_("Skipping unknown ARM relocation type: %d\n"),
9716 (int) ELF32_R_TYPE (rp
->r_info
));
9720 if (streq (relname
, "R_ARM_NONE"))
9723 if (! streq (relname
, "R_ARM_PREL31"))
9725 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9729 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9731 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9732 if (relname
== NULL
)
9734 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9735 (int) ELF32_R_TYPE (rp
->r_info
));
9739 if (streq (relname
, "R_C6000_NONE"))
9742 if (! streq (relname
, "R_C6000_PREL31"))
9744 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9752 /* This function currently only supports ARM and TI unwinders. */
9753 warn (_("Only TI and ARM unwinders are currently supported\n"));
9757 word
= (word
& ~ (uint64_t) 0x7fffffff) | (prelval
& 0x7fffffff);
9758 addr
->section
= sym
->st_shndx
;
9759 addr
->offset
= offset
;
9762 * sym_name
= sym
->st_name
;
9767 arm_sec
->next_rela
= rp
;
9772 static const char *tic6x_unwind_regnames
[16] =
9774 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9775 "A14", "A13", "A12", "A11", "A10",
9776 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9780 decode_tic6x_unwind_regmask (unsigned int mask
)
9784 for (i
= 12; mask
; mask
>>= 1, i
--)
9788 fputs (tic6x_unwind_regnames
[i
], stdout
);
9790 fputs (", ", stdout
);
9796 if (remaining == 0 && more_words) \
9799 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9800 data_offset, & word, & addr, NULL)) \
9806 #define GET_OP(OP) \
9811 (OP) = word >> 24; \
9816 printf (_("[Truncated opcode]\n")); \
9819 printf ("0x%02x ", OP)
9822 decode_arm_unwind_bytecode (Filedata
* filedata
,
9823 struct arm_unw_aux_info
* aux
,
9825 unsigned int remaining
,
9826 unsigned int more_words
,
9827 uint64_t data_offset
,
9828 Elf_Internal_Shdr
* data_sec
,
9829 struct arm_section
* data_arm_sec
)
9831 struct absaddr addr
;
9834 /* Decode the unwinding instructions. */
9837 unsigned int op
, op2
;
9846 printf (" 0x%02x ", op
);
9848 if ((op
& 0xc0) == 0x00)
9850 int offset
= ((op
& 0x3f) << 2) + 4;
9852 printf (" vsp = vsp + %d", offset
);
9854 else if ((op
& 0xc0) == 0x40)
9856 int offset
= ((op
& 0x3f) << 2) + 4;
9858 printf (" vsp = vsp - %d", offset
);
9860 else if ((op
& 0xf0) == 0x80)
9863 if (op
== 0x80 && op2
== 0)
9864 printf (_("Refuse to unwind"));
9867 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9872 for (i
= 0; i
< 12; i
++)
9873 if (mask
& (1 << i
))
9879 printf ("r%d", 4 + i
);
9884 else if ((op
& 0xf0) == 0x90)
9886 if (op
== 0x9d || op
== 0x9f)
9887 printf (_(" [Reserved]"));
9889 printf (" vsp = r%d", op
& 0x0f);
9891 else if ((op
& 0xf0) == 0xa0)
9893 int end
= 4 + (op
& 0x07);
9898 for (i
= 4; i
<= end
; i
++)
9914 else if (op
== 0xb0)
9915 printf (_(" finish"));
9916 else if (op
== 0xb1)
9919 if (op2
== 0 || (op2
& 0xf0) != 0)
9920 printf (_("[Spare]"));
9923 unsigned int mask
= op2
& 0x0f;
9928 for (i
= 0; i
< 12; i
++)
9929 if (mask
& (1 << i
))
9940 else if (op
== 0xb2)
9942 unsigned char buf
[9];
9943 unsigned int i
, len
;
9946 for (i
= 0; i
< sizeof (buf
); i
++)
9949 if ((buf
[i
] & 0x80) == 0)
9952 if (i
== sizeof (buf
))
9954 error (_("corrupt change to vsp\n"));
9959 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9960 assert (len
== i
+ 1);
9961 offset
= offset
* 4 + 0x204;
9962 printf ("vsp = vsp + %" PRId64
, offset
);
9965 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9967 unsigned int first
, last
;
9974 printf ("pop {D%d", first
);
9976 printf ("-D%d", first
+ last
);
9979 else if (op
== 0xb4)
9980 printf (_(" pop {ra_auth_code}"));
9981 else if (op
== 0xb5)
9982 printf (_(" vsp as modifier for PAC validation"));
9983 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9985 unsigned int count
= op
& 0x07;
9989 printf ("-D%d", 8 + count
);
9992 else if (op
>= 0xc0 && op
<= 0xc5)
9994 unsigned int count
= op
& 0x07;
9996 printf (" pop {wR10");
9998 printf ("-wR%d", 10 + count
);
10001 else if (op
== 0xc6)
10003 unsigned int first
, last
;
10008 printf ("pop {wR%d", first
);
10010 printf ("-wR%d", first
+ last
);
10013 else if (op
== 0xc7)
10016 if (op2
== 0 || (op2
& 0xf0) != 0)
10017 printf (_("[Spare]"));
10020 unsigned int mask
= op2
& 0x0f;
10025 for (i
= 0; i
< 4; i
++)
10026 if (mask
& (1 << i
))
10032 printf ("wCGR%d", i
);
10039 printf (_(" [unsupported opcode]"));
10050 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
10051 struct arm_unw_aux_info
* aux
,
10053 unsigned int remaining
,
10054 unsigned int more_words
,
10055 uint64_t data_offset
,
10056 Elf_Internal_Shdr
* data_sec
,
10057 struct arm_section
* data_arm_sec
)
10059 struct absaddr addr
;
10061 /* Decode the unwinding instructions. */
10064 unsigned int op
, op2
;
10067 if (remaining
== 0)
10073 printf (" 0x%02x ", op
);
10075 if ((op
& 0xc0) == 0x00)
10077 int offset
= ((op
& 0x3f) << 3) + 8;
10078 printf (" sp = sp + %d", offset
);
10080 else if ((op
& 0xc0) == 0x80)
10083 if (op
== 0x80 && op2
== 0)
10084 printf (_("Refuse to unwind"));
10087 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10089 printf ("pop compact {");
10093 decode_tic6x_unwind_regmask (mask
);
10097 else if ((op
& 0xf0) == 0xc0)
10100 unsigned int nregs
;
10105 unsigned int offset
;
10109 /* Scan entire instruction first so that GET_OP output is not
10110 interleaved with disassembly. */
10112 for (i
= 0; nregs
< (op
& 0xf); i
++)
10118 regpos
[nregs
].offset
= i
* 2;
10119 regpos
[nregs
].reg
= reg
;
10126 regpos
[nregs
].offset
= i
* 2 + 1;
10127 regpos
[nregs
].reg
= reg
;
10132 printf (_("pop frame {"));
10135 printf (_("*corrupt* - no registers specified"));
10140 for (i
= i
* 2; i
> 0; i
--)
10142 if (regpos
[reg
].offset
== i
- 1)
10144 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10151 fputs (name
, stdout
);
10159 else if (op
== 0xd0)
10160 printf (" MOV FP, SP");
10161 else if (op
== 0xd1)
10162 printf (" __c6xabi_pop_rts");
10163 else if (op
== 0xd2)
10165 unsigned char buf
[9];
10166 unsigned int i
, len
;
10169 for (i
= 0; i
< sizeof (buf
); i
++)
10172 if ((buf
[i
] & 0x80) == 0)
10175 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10176 if (i
== sizeof (buf
))
10178 warn (_("Corrupt stack pointer adjustment detected\n"));
10182 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10183 assert (len
== i
+ 1);
10184 offset
= offset
* 8 + 0x408;
10185 printf (_("sp = sp + %" PRId64
), offset
);
10187 else if ((op
& 0xf0) == 0xe0)
10189 if ((op
& 0x0f) == 7)
10190 printf (" RETURN");
10192 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10196 printf (_(" [unsupported opcode]"));
10205 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10209 offset
= word
& 0x7fffffff;
10210 if (offset
& 0x40000000)
10211 offset
|= ~ (uint64_t) 0x7fffffff;
10213 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10216 return offset
+ where
;
10220 decode_arm_unwind (Filedata
* filedata
,
10221 struct arm_unw_aux_info
* aux
,
10223 unsigned int remaining
,
10224 uint64_t data_offset
,
10225 Elf_Internal_Shdr
* data_sec
,
10226 struct arm_section
* data_arm_sec
)
10229 unsigned int more_words
= 0;
10230 struct absaddr addr
;
10231 uint64_t sym_name
= (uint64_t) -1;
10234 if (remaining
== 0)
10236 /* Fetch the first word.
10237 Note - when decoding an object file the address extracted
10238 here will always be 0. So we also pass in the sym_name
10239 parameter so that we can find the symbol associated with
10240 the personality routine. */
10241 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10242 & word
, & addr
, & sym_name
))
10249 addr
.section
= SHN_UNDEF
;
10253 if ((word
& 0x80000000) == 0)
10255 /* Expand prel31 for personality routine. */
10257 const char *procname
;
10259 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
10260 printf (_(" Personality routine: "));
10262 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
10263 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
10265 procname
= aux
->strtab
+ sym_name
;
10266 print_vma (fn
, PREFIX_HEX
);
10269 fputs (" <", stdout
);
10270 fputs (procname
, stdout
);
10271 fputc ('>', stdout
);
10275 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
10276 fputc ('\n', stdout
);
10278 /* The GCC personality routines use the standard compact
10279 encoding, starting with one byte giving the number of
10281 if (procname
!= NULL
10282 && (startswith (procname
, "__gcc_personality_v0")
10283 || startswith (procname
, "__gxx_personality_v0")
10284 || startswith (procname
, "__gcj_personality_v0")
10285 || startswith (procname
, "__gnu_objc_personality_v0")))
10292 printf (_(" [Truncated data]\n"));
10295 more_words
= word
>> 24;
10305 /* ARM EHABI Section 6.3:
10307 An exception-handling table entry for the compact model looks like:
10309 31 30-28 27-24 23-0
10310 -- ----- ----- ----
10311 1 0 index Data for personalityRoutine[index] */
10313 if (filedata
->file_header
.e_machine
== EM_ARM
10314 && (word
& 0x70000000))
10316 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
10320 per_index
= (word
>> 24) & 0x7f;
10321 printf (_(" Compact model index: %d\n"), per_index
);
10322 if (per_index
== 0)
10328 else if (per_index
< 3)
10330 more_words
= (word
>> 16) & 0xff;
10336 switch (filedata
->file_header
.e_machine
)
10341 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10342 data_offset
, data_sec
, data_arm_sec
))
10347 warn (_("Unknown ARM compact model index encountered\n"));
10348 printf (_(" [reserved]\n"));
10356 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10357 data_offset
, data_sec
, data_arm_sec
))
10360 else if (per_index
< 5)
10362 if (((word
>> 17) & 0x7f) == 0x7f)
10363 printf (_(" Restore stack from frame pointer\n"));
10365 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
10366 printf (_(" Registers restored: "));
10367 if (per_index
== 4)
10368 printf (" (compact) ");
10369 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
10371 printf (_(" Return register: %s\n"),
10372 tic6x_unwind_regnames
[word
& 0xf]);
10375 printf (_(" [reserved (%d)]\n"), per_index
);
10379 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
10380 filedata
->file_header
.e_machine
);
10384 /* Decode the descriptors. Not implemented. */
10390 dump_arm_unwind (Filedata
* filedata
,
10391 struct arm_unw_aux_info
* aux
,
10392 Elf_Internal_Shdr
* exidx_sec
)
10394 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10395 unsigned int i
, exidx_len
;
10399 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10400 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10401 exidx_len
= exidx_sec
->sh_size
/ 8;
10403 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10404 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10405 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10406 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10407 aux
->nfuns
= nfuns
;
10408 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10410 for (i
= 0; i
< exidx_len
; i
++)
10412 unsigned int exidx_fn
, exidx_entry
;
10413 struct absaddr fn_addr
, entry_addr
;
10416 fputc ('\n', stdout
);
10418 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10419 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10420 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10421 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10423 free (aux
->funtab
);
10424 arm_free_section (& exidx_arm_sec
);
10425 arm_free_section (& extab_arm_sec
);
10429 /* ARM EHABI, Section 5:
10430 An index table entry consists of 2 words.
10431 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10432 if (exidx_fn
& 0x80000000)
10434 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10438 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10440 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10441 fputs (": ", stdout
);
10443 if (exidx_entry
== 1)
10445 print_vma (exidx_entry
, PREFIX_HEX
);
10446 fputs (" [cantunwind]\n", stdout
);
10448 else if (exidx_entry
& 0x80000000)
10450 print_vma (exidx_entry
, PREFIX_HEX
);
10451 fputc ('\n', stdout
);
10452 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10456 uint64_t table
, table_offset
= 0;
10457 Elf_Internal_Shdr
*table_sec
;
10459 fputs ("@", stdout
);
10460 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10461 print_vma (table
, PREFIX_HEX
);
10464 /* Locate the matching .ARM.extab. */
10465 if (entry_addr
.section
!= SHN_UNDEF
10466 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10468 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10469 table_offset
= entry_addr
.offset
;
10471 if (table_offset
> table_sec
->sh_size
)
10473 warn (_("Unwind entry contains corrupt offset (%#" PRIx64
") into section %s\n"),
10475 printable_section_name (filedata
, table_sec
));
10482 table_sec
= find_section_by_address (filedata
, table
);
10483 if (table_sec
!= NULL
)
10484 table_offset
= table
- table_sec
->sh_addr
;
10487 if (table_sec
== NULL
)
10489 warn (_("Could not locate .ARM.extab section containing %#" PRIx64
".\n"),
10495 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10503 free (aux
->funtab
);
10504 arm_free_section (&exidx_arm_sec
);
10505 arm_free_section (&extab_arm_sec
);
10510 /* Used for both ARM and C6X unwinding tables. */
10513 arm_process_unwind (Filedata
* filedata
)
10515 struct arm_unw_aux_info aux
;
10516 Elf_Internal_Shdr
*unwsec
= NULL
;
10517 Elf_Internal_Shdr
*sec
;
10519 unsigned int sec_type
;
10522 switch (filedata
->file_header
.e_machine
)
10525 sec_type
= SHT_ARM_EXIDX
;
10529 sec_type
= SHT_C6000_UNWIND
;
10533 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
10534 filedata
->file_header
.e_machine
);
10538 if (filedata
->string_table
== NULL
)
10541 memset (& aux
, 0, sizeof (aux
));
10542 aux
.filedata
= filedata
;
10544 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10546 if (sec
->sh_type
== SHT_SYMTAB
)
10550 error (_("Multiple symbol tables encountered\n"));
10556 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10557 &aux
.strtab
, &aux
.strtab_size
))
10560 else if (sec
->sh_type
== sec_type
)
10564 if (unwsec
== NULL
)
10565 printf (_("\nThere are no unwind sections in this file.\n"));
10567 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10569 if (sec
->sh_type
== sec_type
)
10571 uint64_t num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
10572 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
10573 "contains %" PRIu64
" entry:\n",
10574 "\nUnwind section '%s' at offset %#" PRIx64
" "
10575 "contains %" PRIu64
" entries:\n",
10577 printable_section_name (filedata
, sec
),
10581 if (! dump_arm_unwind (filedata
, &aux
, sec
))
10587 free ((char *) aux
.strtab
);
10593 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
10595 printf (_("No processor specific unwind information to decode\n"));
10600 process_unwind (Filedata
* filedata
)
10602 struct unwind_handler
10604 unsigned int machtype
;
10605 bool (* handler
)(Filedata
*);
10608 { EM_ARM
, arm_process_unwind
},
10609 { EM_IA_64
, ia64_process_unwind
},
10610 { EM_PARISC
, hppa_process_unwind
},
10611 { EM_TI_C6000
, arm_process_unwind
},
10612 { EM_386
, no_processor_specific_unwind
},
10613 { EM_X86_64
, no_processor_specific_unwind
},
10621 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10622 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10623 return handlers
[i
].handler (filedata
);
10625 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10626 get_machine_name (filedata
->file_header
.e_machine
));
10631 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10633 switch (entry
->d_tag
)
10635 case DT_AARCH64_BTI_PLT
:
10636 case DT_AARCH64_PAC_PLT
:
10639 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10646 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
10648 switch (entry
->d_tag
)
10650 case DT_MIPS_FLAGS
:
10651 if (entry
->d_un
.d_val
== 0)
10652 printf (_("NONE"));
10655 static const char * opts
[] =
10657 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
10658 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
10659 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
10660 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
10666 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
10667 if (entry
->d_un
.d_val
& (1 << cnt
))
10669 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
10675 case DT_MIPS_IVERSION
:
10676 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
10677 printf (_("Interface Version: %s"),
10678 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
10680 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
10681 entry
->d_un
.d_ptr
);
10684 case DT_MIPS_TIME_STAMP
:
10688 time_t atime
= entry
->d_un
.d_val
;
10690 tmp
= gmtime (&atime
);
10691 /* PR 17531: file: 6accc532. */
10693 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
10695 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
10696 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10697 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10698 printf (_("Time Stamp: %s"), timebuf
);
10702 case DT_MIPS_RLD_VERSION
:
10703 case DT_MIPS_LOCAL_GOTNO
:
10704 case DT_MIPS_CONFLICTNO
:
10705 case DT_MIPS_LIBLISTNO
:
10706 case DT_MIPS_SYMTABNO
:
10707 case DT_MIPS_UNREFEXTNO
:
10708 case DT_MIPS_HIPAGENO
:
10709 case DT_MIPS_DELTA_CLASS_NO
:
10710 case DT_MIPS_DELTA_INSTANCE_NO
:
10711 case DT_MIPS_DELTA_RELOC_NO
:
10712 case DT_MIPS_DELTA_SYM_NO
:
10713 case DT_MIPS_DELTA_CLASSSYM_NO
:
10714 case DT_MIPS_COMPACT_SIZE
:
10715 print_vma (entry
->d_un
.d_val
, DEC
);
10718 case DT_MIPS_XHASH
:
10719 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10720 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10721 /* Falls through. */
10724 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10730 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10732 switch (entry
->d_tag
)
10734 case DT_HP_DLD_FLAGS
:
10743 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10744 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10745 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10746 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10747 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10748 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10749 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10750 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10751 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10752 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10753 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10754 { DT_HP_GST
, "HP_GST" },
10755 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10756 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10757 { DT_HP_NODELETE
, "HP_NODELETE" },
10758 { DT_HP_GROUP
, "HP_GROUP" },
10759 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10763 uint64_t val
= entry
->d_un
.d_val
;
10765 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10766 if (val
& flags
[cnt
].bit
)
10770 fputs (flags
[cnt
].str
, stdout
);
10772 val
^= flags
[cnt
].bit
;
10775 if (val
!= 0 || first
)
10779 print_vma (val
, HEX
);
10785 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10791 /* VMS vs Unix time offset and factor. */
10793 #define VMS_EPOCH_OFFSET 35067168000000000LL
10794 #define VMS_GRANULARITY_FACTOR 10000000
10796 #define INT64_MIN (-9223372036854775807LL - 1)
10799 /* Display a VMS time in a human readable format. */
10802 print_vms_time (int64_t vmstime
)
10804 struct tm
*tm
= NULL
;
10807 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10809 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10811 if (unxtime
== vmstime
)
10812 tm
= gmtime (&unxtime
);
10815 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10816 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10817 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10821 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10823 switch (entry
->d_tag
)
10825 case DT_IA_64_PLT_RESERVE
:
10826 /* First 3 slots reserved. */
10827 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10829 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10832 case DT_IA_64_VMS_LINKTIME
:
10833 print_vms_time (entry
->d_un
.d_val
);
10836 case DT_IA_64_VMS_LNKFLAGS
:
10837 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10838 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10839 printf (" CALL_DEBUG");
10840 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10841 printf (" NOP0BUFS");
10842 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10843 printf (" P0IMAGE");
10844 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10845 printf (" MKTHREADS");
10846 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10847 printf (" UPCALLS");
10848 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10849 printf (" IMGSTA");
10850 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10851 printf (" INITIALIZE");
10852 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10854 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10855 printf (" EXE_INIT");
10856 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10857 printf (" TBK_IN_IMG");
10858 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10859 printf (" DBG_IN_IMG");
10860 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10861 printf (" TBK_IN_DSF");
10862 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10863 printf (" DBG_IN_DSF");
10864 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10865 printf (" SIGNATURES");
10866 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10867 printf (" REL_SEG_OFF");
10871 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10878 get_32bit_dynamic_section (Filedata
* filedata
)
10880 Elf32_External_Dyn
* edyn
;
10881 Elf32_External_Dyn
* ext
;
10882 Elf_Internal_Dyn
* entry
;
10884 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10885 filedata
->dynamic_addr
, 1,
10886 filedata
->dynamic_size
,
10887 _("dynamic section"));
10891 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10892 might not have the luxury of section headers. Look for the DT_NULL
10893 terminator to determine the number of entries. */
10894 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10895 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10898 filedata
->dynamic_nent
++;
10899 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10903 filedata
->dynamic_section
10904 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10905 if (filedata
->dynamic_section
== NULL
)
10907 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
10908 filedata
->dynamic_nent
);
10913 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10914 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10917 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10918 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10927 get_64bit_dynamic_section (Filedata
* filedata
)
10929 Elf64_External_Dyn
* edyn
;
10930 Elf64_External_Dyn
* ext
;
10931 Elf_Internal_Dyn
* entry
;
10933 /* Read in the data. */
10934 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10935 filedata
->dynamic_addr
, 1,
10936 filedata
->dynamic_size
,
10937 _("dynamic section"));
10941 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10942 might not have the luxury of section headers. Look for the DT_NULL
10943 terminator to determine the number of entries. */
10944 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10945 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10946 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10949 filedata
->dynamic_nent
++;
10950 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10954 filedata
->dynamic_section
10955 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10956 if (filedata
->dynamic_section
== NULL
)
10958 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
10959 filedata
->dynamic_nent
);
10964 /* Convert from external to internal formats. */
10965 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10966 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10969 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10970 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10979 get_dynamic_section (Filedata
*filedata
)
10981 if (filedata
->dynamic_section
)
10985 return get_32bit_dynamic_section (filedata
);
10987 return get_64bit_dynamic_section (filedata
);
10991 print_dynamic_flags (uint64_t flags
)
10999 flag
= flags
& - flags
;
11005 putc (' ', stdout
);
11009 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
11010 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
11011 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
11012 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
11013 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
11014 default: fputs (_("unknown"), stdout
); break;
11021 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
11023 unsigned char * e_data
;
11026 /* If size_t is smaller than uint64_t, eg because you are building
11027 on a 32-bit host, then make sure that when number is cast to
11028 size_t no information is lost. */
11029 if ((size_t) number
!= number
11030 || ent_size
* number
/ ent_size
!= number
)
11032 error (_("Size overflow prevents reading %" PRIu64
11033 " elements of size %u\n"),
11038 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11039 attempting to allocate memory when the read is bound to fail. */
11040 if (ent_size
* number
> filedata
->file_size
)
11042 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
11047 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11048 if (e_data
== NULL
)
11050 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
11055 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11057 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
11058 number
* ent_size
);
11063 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11064 if (i_data
== NULL
)
11066 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11073 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11081 get_num_dynamic_syms (Filedata
* filedata
)
11083 uint64_t num_of_syms
= 0;
11085 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11086 return num_of_syms
;
11088 if (filedata
->dynamic_info
[DT_HASH
])
11090 unsigned char nb
[8];
11091 unsigned char nc
[8];
11092 unsigned int hash_ent_size
= 4;
11094 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11095 || filedata
->file_header
.e_machine
== EM_S390
11096 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11097 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11100 if (fseek64 (filedata
->handle
,
11101 (filedata
->archive_file_offset
11102 + offset_from_vma (filedata
,
11103 filedata
->dynamic_info
[DT_HASH
],
11104 sizeof nb
+ sizeof nc
)),
11107 error (_("Unable to seek to start of dynamic information\n"));
11111 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11113 error (_("Failed to read in number of buckets\n"));
11117 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11119 error (_("Failed to read in number of chains\n"));
11123 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11124 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11126 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11128 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11130 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11133 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11134 num_of_syms
= filedata
->nchains
;
11137 if (num_of_syms
== 0)
11139 free (filedata
->buckets
);
11140 filedata
->buckets
= NULL
;
11141 free (filedata
->chains
);
11142 filedata
->chains
= NULL
;
11143 filedata
->nbuckets
= 0;
11147 if (filedata
->dynamic_info_DT_GNU_HASH
)
11149 unsigned char nb
[16];
11150 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11151 uint64_t buckets_vma
;
11154 if (fseek64 (filedata
->handle
,
11155 (filedata
->archive_file_offset
11156 + offset_from_vma (filedata
,
11157 filedata
->dynamic_info_DT_GNU_HASH
,
11161 error (_("Unable to seek to start of dynamic information\n"));
11165 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11167 error (_("Failed to read in number of buckets\n"));
11171 filedata
->ngnubuckets
= byte_get (nb
, 4);
11172 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11173 bitmaskwords
= byte_get (nb
+ 8, 4);
11174 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11176 buckets_vma
+= bitmaskwords
* 4;
11178 buckets_vma
+= bitmaskwords
* 8;
11180 if (fseek64 (filedata
->handle
,
11181 (filedata
->archive_file_offset
11182 + offset_from_vma (filedata
, buckets_vma
, 4)),
11185 error (_("Unable to seek to start of dynamic information\n"));
11189 filedata
->gnubuckets
11190 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11192 if (filedata
->gnubuckets
== NULL
)
11195 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11196 if (filedata
->gnubuckets
[i
] != 0)
11198 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11201 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11202 maxchain
= filedata
->gnubuckets
[i
];
11205 if (maxchain
== 0xffffffff)
11208 maxchain
-= filedata
->gnusymidx
;
11210 if (fseek64 (filedata
->handle
,
11211 (filedata
->archive_file_offset
11212 + offset_from_vma (filedata
,
11213 buckets_vma
+ 4 * (filedata
->ngnubuckets
11218 error (_("Unable to seek to start of dynamic information\n"));
11224 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11226 error (_("Failed to determine last chain length\n"));
11230 if (maxchain
+ 1 == 0)
11235 while ((byte_get (nb
, 4) & 1) == 0);
11237 if (fseek64 (filedata
->handle
,
11238 (filedata
->archive_file_offset
11239 + offset_from_vma (filedata
, (buckets_vma
11240 + 4 * filedata
->ngnubuckets
),
11244 error (_("Unable to seek to start of dynamic information\n"));
11248 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11249 filedata
->ngnuchains
= maxchain
;
11251 if (filedata
->gnuchains
== NULL
)
11254 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11256 if (fseek64 (filedata
->handle
,
11257 (filedata
->archive_file_offset
11258 + offset_from_vma (filedata
, (buckets_vma
11259 + 4 * (filedata
->ngnubuckets
11263 error (_("Unable to seek to start of dynamic information\n"));
11267 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11268 if (filedata
->mipsxlat
== NULL
)
11272 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
11273 if (filedata
->gnubuckets
[hn
] != 0)
11275 uint64_t si
= filedata
->gnubuckets
[hn
];
11276 uint64_t off
= si
- filedata
->gnusymidx
;
11280 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11282 if (off
< filedata
->ngnuchains
11283 && filedata
->mipsxlat
[off
] >= num_of_syms
)
11284 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
11288 if (si
>= num_of_syms
)
11289 num_of_syms
= si
+ 1;
11293 while (off
< filedata
->ngnuchains
11294 && (filedata
->gnuchains
[off
++] & 1) == 0);
11297 if (num_of_syms
== 0)
11300 free (filedata
->mipsxlat
);
11301 filedata
->mipsxlat
= NULL
;
11302 free (filedata
->gnuchains
);
11303 filedata
->gnuchains
= NULL
;
11304 free (filedata
->gnubuckets
);
11305 filedata
->gnubuckets
= NULL
;
11306 filedata
->ngnubuckets
= 0;
11307 filedata
->ngnuchains
= 0;
11311 return num_of_syms
;
11314 /* Parse and display the contents of the dynamic section. */
11317 process_dynamic_section (Filedata
* filedata
)
11319 Elf_Internal_Dyn
* entry
;
11321 if (filedata
->dynamic_size
<= 1)
11325 if (filedata
->is_separate
)
11326 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
11327 filedata
->file_name
);
11329 printf (_("\nThere is no dynamic section in this file.\n"));
11335 if (!get_dynamic_section (filedata
))
11338 /* Find the appropriate symbol table. */
11339 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
11341 uint64_t num_of_syms
;
11343 for (entry
= filedata
->dynamic_section
;
11344 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11346 if (entry
->d_tag
== DT_SYMTAB
)
11347 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
11348 else if (entry
->d_tag
== DT_SYMENT
)
11349 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
11350 else if (entry
->d_tag
== DT_HASH
)
11351 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
11352 else if (entry
->d_tag
== DT_GNU_HASH
)
11353 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11354 else if ((filedata
->file_header
.e_machine
== EM_MIPS
11355 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
11356 && entry
->d_tag
== DT_MIPS_XHASH
)
11358 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11359 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11362 num_of_syms
= get_num_dynamic_syms (filedata
);
11364 if (num_of_syms
!= 0
11365 && filedata
->dynamic_symbols
== NULL
11366 && filedata
->dynamic_info
[DT_SYMTAB
]
11367 && filedata
->dynamic_info
[DT_SYMENT
])
11369 Elf_Internal_Phdr
*seg
;
11370 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
11372 if (! get_program_headers (filedata
))
11374 error (_("Cannot interpret virtual addresses "
11375 "without program headers.\n"));
11379 for (seg
= filedata
->program_headers
;
11380 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11383 if (seg
->p_type
!= PT_LOAD
)
11386 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11388 /* See PR 21379 for a reproducer. */
11389 error (_("Invalid PT_LOAD entry\n"));
11393 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11394 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11396 /* Since we do not know how big the symbol table is,
11397 we default to reading in up to the end of PT_LOAD
11398 segment and processing that. This is overkill, I
11399 know, but it should work. */
11400 Elf_Internal_Shdr section
;
11401 section
.sh_offset
= (vma
- seg
->p_vaddr
11403 section
.sh_size
= (num_of_syms
11404 * filedata
->dynamic_info
[DT_SYMENT
]);
11405 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11408 && filedata
->dynamic_symtab_section
!= NULL
11409 && ((filedata
->dynamic_symtab_section
->sh_offset
11410 != section
.sh_offset
)
11411 || (filedata
->dynamic_symtab_section
->sh_size
11412 != section
.sh_size
)
11413 || (filedata
->dynamic_symtab_section
->sh_entsize
11414 != section
.sh_entsize
)))
11416 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11418 section
.sh_name
= filedata
->string_table_length
;
11419 filedata
->dynamic_symbols
11420 = get_elf_symbols (filedata
, §ion
,
11421 &filedata
->num_dynamic_syms
);
11422 if (filedata
->dynamic_symbols
== NULL
11423 || filedata
->num_dynamic_syms
!= num_of_syms
)
11425 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11434 /* Similarly find a string table. */
11435 if (filedata
->dynamic_strings
== NULL
)
11436 for (entry
= filedata
->dynamic_section
;
11437 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11440 if (entry
->d_tag
== DT_STRTAB
)
11441 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11443 if (entry
->d_tag
== DT_STRSZ
)
11444 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11446 if (filedata
->dynamic_info
[DT_STRTAB
]
11447 && filedata
->dynamic_info
[DT_STRSZ
])
11450 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11452 offset
= offset_from_vma (filedata
,
11453 filedata
->dynamic_info
[DT_STRTAB
],
11456 && filedata
->dynamic_strtab_section
11457 && ((filedata
->dynamic_strtab_section
->sh_offset
11458 != (file_ptr
) offset
)
11459 || (filedata
->dynamic_strtab_section
->sh_size
11462 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11464 filedata
->dynamic_strings
11465 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11466 _("dynamic string table"));
11467 if (filedata
->dynamic_strings
== NULL
)
11469 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11473 filedata
->dynamic_strings_length
= str_tab_len
;
11478 /* And find the syminfo section if available. */
11479 if (filedata
->dynamic_syminfo
== NULL
)
11481 uint64_t syminsz
= 0;
11483 for (entry
= filedata
->dynamic_section
;
11484 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11487 if (entry
->d_tag
== DT_SYMINENT
)
11489 /* Note: these braces are necessary to avoid a syntax
11490 error from the SunOS4 C compiler. */
11491 /* PR binutils/17531: A corrupt file can trigger this test.
11492 So do not use an assert, instead generate an error message. */
11493 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11494 error (_("Bad value (%d) for SYMINENT entry\n"),
11495 (int) entry
->d_un
.d_val
);
11497 else if (entry
->d_tag
== DT_SYMINSZ
)
11498 syminsz
= entry
->d_un
.d_val
;
11499 else if (entry
->d_tag
== DT_SYMINFO
)
11500 filedata
->dynamic_syminfo_offset
11501 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11504 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11506 Elf_External_Syminfo
* extsyminfo
;
11507 Elf_External_Syminfo
* extsym
;
11508 Elf_Internal_Syminfo
* syminfo
;
11510 /* There is a syminfo section. Read the data. */
11511 extsyminfo
= (Elf_External_Syminfo
*)
11512 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11513 1, syminsz
, _("symbol information"));
11517 if (filedata
->dynamic_syminfo
!= NULL
)
11519 error (_("Multiple dynamic symbol information sections found\n"));
11520 free (filedata
->dynamic_syminfo
);
11522 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11523 if (filedata
->dynamic_syminfo
== NULL
)
11525 error (_("Out of memory allocating %" PRIu64
11526 " bytes for dynamic symbol info\n"),
11531 filedata
->dynamic_syminfo_nent
11532 = syminsz
/ sizeof (Elf_External_Syminfo
);
11533 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
11534 syminfo
< (filedata
->dynamic_syminfo
11535 + filedata
->dynamic_syminfo_nent
);
11536 ++syminfo
, ++extsym
)
11538 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
11539 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
11546 if (do_dynamic
&& filedata
->dynamic_addr
)
11548 if (filedata
->is_separate
)
11549 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11550 "\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11551 filedata
->dynamic_nent
),
11552 filedata
->file_name
,
11553 filedata
->dynamic_addr
,
11554 filedata
->dynamic_nent
);
11556 printf (ngettext ("\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11557 "\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11558 filedata
->dynamic_nent
),
11559 filedata
->dynamic_addr
,
11560 filedata
->dynamic_nent
);
11563 printf (_(" Tag Type Name/Value\n"));
11565 for (entry
= filedata
->dynamic_section
;
11566 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11571 const char * dtype
;
11574 print_vma (entry
->d_tag
, FULL_HEX
);
11575 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
11576 printf (" (%s)%*s", dtype
,
11577 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
11580 switch (entry
->d_tag
)
11584 print_dynamic_flags (entry
->d_un
.d_val
);
11594 switch (entry
->d_tag
)
11597 printf (_("Auxiliary library"));
11601 printf (_("Filter library"));
11605 printf (_("Configuration file"));
11609 printf (_("Dependency audit library"));
11613 printf (_("Audit library"));
11617 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11618 printf (": [%s]\n",
11619 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11623 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11632 printf (_("Flags:"));
11634 if (entry
->d_un
.d_val
== 0)
11635 printf (_(" None\n"));
11638 uint64_t val
= entry
->d_un
.d_val
;
11640 if (val
& DTF_1_PARINIT
)
11642 printf (" PARINIT");
11643 val
^= DTF_1_PARINIT
;
11645 if (val
& DTF_1_CONFEXP
)
11647 printf (" CONFEXP");
11648 val
^= DTF_1_CONFEXP
;
11651 printf (" %" PRIx64
, val
);
11660 printf (_("Flags:"));
11662 if (entry
->d_un
.d_val
== 0)
11663 printf (_(" None\n"));
11666 uint64_t val
= entry
->d_un
.d_val
;
11668 if (val
& DF_P1_LAZYLOAD
)
11670 printf (" LAZYLOAD");
11671 val
^= DF_P1_LAZYLOAD
;
11673 if (val
& DF_P1_GROUPPERM
)
11675 printf (" GROUPPERM");
11676 val
^= DF_P1_GROUPPERM
;
11679 printf (" %" PRIx64
, val
);
11688 printf (_("Flags:"));
11689 if (entry
->d_un
.d_val
== 0)
11690 printf (_(" None\n"));
11693 uint64_t val
= entry
->d_un
.d_val
;
11695 if (val
& DF_1_NOW
)
11700 if (val
& DF_1_GLOBAL
)
11702 printf (" GLOBAL");
11703 val
^= DF_1_GLOBAL
;
11705 if (val
& DF_1_GROUP
)
11710 if (val
& DF_1_NODELETE
)
11712 printf (" NODELETE");
11713 val
^= DF_1_NODELETE
;
11715 if (val
& DF_1_LOADFLTR
)
11717 printf (" LOADFLTR");
11718 val
^= DF_1_LOADFLTR
;
11720 if (val
& DF_1_INITFIRST
)
11722 printf (" INITFIRST");
11723 val
^= DF_1_INITFIRST
;
11725 if (val
& DF_1_NOOPEN
)
11727 printf (" NOOPEN");
11728 val
^= DF_1_NOOPEN
;
11730 if (val
& DF_1_ORIGIN
)
11732 printf (" ORIGIN");
11733 val
^= DF_1_ORIGIN
;
11735 if (val
& DF_1_DIRECT
)
11737 printf (" DIRECT");
11738 val
^= DF_1_DIRECT
;
11740 if (val
& DF_1_TRANS
)
11745 if (val
& DF_1_INTERPOSE
)
11747 printf (" INTERPOSE");
11748 val
^= DF_1_INTERPOSE
;
11750 if (val
& DF_1_NODEFLIB
)
11752 printf (" NODEFLIB");
11753 val
^= DF_1_NODEFLIB
;
11755 if (val
& DF_1_NODUMP
)
11757 printf (" NODUMP");
11758 val
^= DF_1_NODUMP
;
11760 if (val
& DF_1_CONFALT
)
11762 printf (" CONFALT");
11763 val
^= DF_1_CONFALT
;
11765 if (val
& DF_1_ENDFILTEE
)
11767 printf (" ENDFILTEE");
11768 val
^= DF_1_ENDFILTEE
;
11770 if (val
& DF_1_DISPRELDNE
)
11772 printf (" DISPRELDNE");
11773 val
^= DF_1_DISPRELDNE
;
11775 if (val
& DF_1_DISPRELPND
)
11777 printf (" DISPRELPND");
11778 val
^= DF_1_DISPRELPND
;
11780 if (val
& DF_1_NODIRECT
)
11782 printf (" NODIRECT");
11783 val
^= DF_1_NODIRECT
;
11785 if (val
& DF_1_IGNMULDEF
)
11787 printf (" IGNMULDEF");
11788 val
^= DF_1_IGNMULDEF
;
11790 if (val
& DF_1_NOKSYMS
)
11792 printf (" NOKSYMS");
11793 val
^= DF_1_NOKSYMS
;
11795 if (val
& DF_1_NOHDR
)
11800 if (val
& DF_1_EDITED
)
11802 printf (" EDITED");
11803 val
^= DF_1_EDITED
;
11805 if (val
& DF_1_NORELOC
)
11807 printf (" NORELOC");
11808 val
^= DF_1_NORELOC
;
11810 if (val
& DF_1_SYMINTPOSE
)
11812 printf (" SYMINTPOSE");
11813 val
^= DF_1_SYMINTPOSE
;
11815 if (val
& DF_1_GLOBAUDIT
)
11817 printf (" GLOBAUDIT");
11818 val
^= DF_1_GLOBAUDIT
;
11820 if (val
& DF_1_SINGLETON
)
11822 printf (" SINGLETON");
11823 val
^= DF_1_SINGLETON
;
11825 if (val
& DF_1_STUB
)
11830 if (val
& DF_1_PIE
)
11835 if (val
& DF_1_KMOD
)
11840 if (val
& DF_1_WEAKFILTER
)
11842 printf (" WEAKFILTER");
11843 val
^= DF_1_WEAKFILTER
;
11845 if (val
& DF_1_NOCOMMON
)
11847 printf (" NOCOMMON");
11848 val
^= DF_1_NOCOMMON
;
11851 printf (" %" PRIx64
, val
);
11858 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11860 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11881 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11887 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11888 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11894 switch (entry
->d_tag
)
11897 printf (_("Shared library: [%s]"), name
);
11899 if (filedata
->program_interpreter
11900 && streq (name
, filedata
->program_interpreter
))
11901 printf (_(" program interpreter"));
11905 printf (_("Library soname: [%s]"), name
);
11909 printf (_("Library rpath: [%s]"), name
);
11913 printf (_("Library runpath: [%s]"), name
);
11917 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11922 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11937 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11938 /* Fall through. */
11942 case DT_PREINIT_ARRAYSZ
:
11943 case DT_INIT_ARRAYSZ
:
11944 case DT_FINI_ARRAYSZ
:
11945 case DT_GNU_CONFLICTSZ
:
11946 case DT_GNU_LIBLISTSZ
:
11949 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11950 printf (_(" (bytes)\n"));
11955 case DT_VERNEEDNUM
:
11960 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11969 case DT_INIT_ARRAY
:
11970 case DT_FINI_ARRAY
:
11973 if (entry
->d_tag
== DT_USED
11974 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11977 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11981 printf (_("Not needed object: [%s]\n"), name
);
11986 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11992 /* The value of this entry is ignored. */
11997 case DT_GNU_PRELINKED
:
12001 time_t atime
= entry
->d_un
.d_val
;
12003 tmp
= gmtime (&atime
);
12004 /* PR 17533 file: 041-1244816-0.004. */
12006 printf (_("<corrupt time val: %" PRIx64
),
12009 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
12010 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12011 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12017 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12020 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12025 case DT_GNU_FLAGS_1
:
12028 printf (_("Flags:"));
12029 if (entry
->d_un
.d_val
== 0)
12030 printf (_(" None\n"));
12033 uint64_t val
= entry
->d_un
.d_val
;
12035 if (val
& DF_GNU_1_UNIQUE
)
12037 printf (" UNIQUE");
12038 val
^= DF_GNU_1_UNIQUE
;
12041 printf (" %" PRIx64
, val
);
12048 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
12049 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
12050 = entry
->d_un
.d_val
;
12054 switch (filedata
->file_header
.e_machine
)
12057 dynamic_section_aarch64_val (entry
);
12060 case EM_MIPS_RS3_LE
:
12061 dynamic_section_mips_val (filedata
, entry
);
12064 dynamic_section_parisc_val (entry
);
12067 dynamic_section_ia64_val (entry
);
12070 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12082 get_ver_flags (unsigned int flags
)
12084 static char buff
[128];
12091 if (flags
& VER_FLG_BASE
)
12092 strcat (buff
, "BASE");
12094 if (flags
& VER_FLG_WEAK
)
12096 if (flags
& VER_FLG_BASE
)
12097 strcat (buff
, " | ");
12099 strcat (buff
, "WEAK");
12102 if (flags
& VER_FLG_INFO
)
12104 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12105 strcat (buff
, " | ");
12107 strcat (buff
, "INFO");
12110 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12112 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12113 strcat (buff
, " | ");
12115 strcat (buff
, _("<unknown>"));
12121 /* Display the contents of the version sections. */
12124 process_version_sections (Filedata
* filedata
)
12126 Elf_Internal_Shdr
* section
;
12128 bool found
= false;
12133 for (i
= 0, section
= filedata
->section_headers
;
12134 i
< filedata
->file_header
.e_shnum
;
12137 switch (section
->sh_type
)
12139 case SHT_GNU_verdef
:
12141 Elf_External_Verdef
* edefs
;
12148 if (filedata
->is_separate
)
12149 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12150 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12152 filedata
->file_name
,
12153 printable_section_name (filedata
, section
),
12156 printf (ngettext ("\nVersion definition section '%s' "
12157 "contains %u entry:\n",
12158 "\nVersion definition section '%s' "
12159 "contains %u entries:\n",
12161 printable_section_name (filedata
, section
),
12164 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12165 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12166 section
->sh_offset
, section
->sh_link
,
12167 printable_section_name_from_index (filedata
, section
->sh_link
));
12169 edefs
= (Elf_External_Verdef
*)
12170 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12171 _("version definition section"));
12174 endbuf
= (char *) edefs
+ section
->sh_size
;
12176 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12179 Elf_External_Verdef
* edef
;
12180 Elf_Internal_Verdef ent
;
12181 Elf_External_Verdaux
* eaux
;
12182 Elf_Internal_Verdaux aux
;
12186 vstart
= ((char *) edefs
) + idx
;
12187 if (vstart
+ sizeof (*edef
) > endbuf
)
12190 edef
= (Elf_External_Verdef
*) vstart
;
12192 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12193 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12194 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12195 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12196 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12197 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12198 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12200 printf (_(" %#06zx: Rev: %d Flags: %s"),
12201 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12203 printf (_(" Index: %d Cnt: %d "),
12204 ent
.vd_ndx
, ent
.vd_cnt
);
12206 /* Check for overflow. */
12207 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12210 vstart
+= ent
.vd_aux
;
12212 if (vstart
+ sizeof (*eaux
) > endbuf
)
12214 eaux
= (Elf_External_Verdaux
*) vstart
;
12216 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12217 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12219 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12220 printf (_("Name: %s\n"),
12221 get_dynamic_name (filedata
, aux
.vda_name
));
12223 printf (_("Name index: %ld\n"), aux
.vda_name
);
12225 isum
= idx
+ ent
.vd_aux
;
12227 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12229 if (aux
.vda_next
< sizeof (*eaux
)
12230 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12232 warn (_("Invalid vda_next field of %lx\n"),
12237 /* Check for overflow. */
12238 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12241 isum
+= aux
.vda_next
;
12242 vstart
+= aux
.vda_next
;
12244 if (vstart
+ sizeof (*eaux
) > endbuf
)
12246 eaux
= (Elf_External_Verdaux
*) vstart
;
12248 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12249 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12251 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12252 printf (_(" %#06zx: Parent %d: %s\n"),
12254 get_dynamic_name (filedata
, aux
.vda_name
));
12256 printf (_(" %#06zx: Parent %d, name index: %ld\n"),
12257 isum
, j
, aux
.vda_name
);
12260 if (j
< ent
.vd_cnt
)
12261 printf (_(" Version def aux past end of section\n"));
12264 file: id:000001,src:000172+005151,op:splice,rep:2. */
12265 if (ent
.vd_next
< sizeof (*edef
)
12266 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
12268 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
12269 cnt
= section
->sh_info
;
12272 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
12275 idx
+= ent
.vd_next
;
12278 if (cnt
< section
->sh_info
)
12279 printf (_(" Version definition past end of section\n"));
12285 case SHT_GNU_verneed
:
12287 Elf_External_Verneed
* eneed
;
12294 if (filedata
->is_separate
)
12295 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
12296 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
12298 filedata
->file_name
,
12299 printable_section_name (filedata
, section
),
12302 printf (ngettext ("\nVersion needs section '%s' "
12303 "contains %u entry:\n",
12304 "\nVersion needs section '%s' "
12305 "contains %u entries:\n",
12307 printable_section_name (filedata
, section
),
12310 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12311 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12312 section
->sh_offset
, section
->sh_link
,
12313 printable_section_name_from_index (filedata
, section
->sh_link
));
12315 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
12316 section
->sh_offset
, 1,
12318 _("Version Needs section"));
12321 endbuf
= (char *) eneed
+ section
->sh_size
;
12323 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12325 Elf_External_Verneed
* entry
;
12326 Elf_Internal_Verneed ent
;
12331 vstart
= ((char *) eneed
) + idx
;
12332 if (vstart
+ sizeof (*entry
) > endbuf
)
12335 entry
= (Elf_External_Verneed
*) vstart
;
12337 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
12338 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
12339 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
12340 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
12341 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
12343 printf (_(" %#06zx: Version: %d"), idx
, ent
.vn_version
);
12345 if (valid_dynamic_name (filedata
, ent
.vn_file
))
12346 printf (_(" File: %s"),
12347 get_dynamic_name (filedata
, ent
.vn_file
));
12349 printf (_(" File: %lx"), ent
.vn_file
);
12351 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
12353 /* Check for overflow. */
12354 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
12356 vstart
+= ent
.vn_aux
;
12358 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
12360 Elf_External_Vernaux
* eaux
;
12361 Elf_Internal_Vernaux aux
;
12363 if (vstart
+ sizeof (*eaux
) > endbuf
)
12365 eaux
= (Elf_External_Vernaux
*) vstart
;
12367 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
12368 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
12369 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
12370 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
12371 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12373 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12374 printf (_(" %#06zx: Name: %s"),
12375 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12377 printf (_(" %#06zx: Name index: %lx"),
12378 isum
, aux
.vna_name
);
12380 printf (_(" Flags: %s Version: %d\n"),
12381 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12383 if (aux
.vna_next
< sizeof (*eaux
)
12384 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12386 warn (_("Invalid vna_next field of %lx\n"),
12391 /* Check for overflow. */
12392 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12394 isum
+= aux
.vna_next
;
12395 vstart
+= aux
.vna_next
;
12398 if (j
< ent
.vn_cnt
)
12399 warn (_("Missing Version Needs auxiliary information\n"));
12401 if (ent
.vn_next
< sizeof (*entry
)
12402 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12404 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12405 cnt
= section
->sh_info
;
12408 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12410 idx
+= ent
.vn_next
;
12413 if (cnt
< section
->sh_info
)
12414 warn (_("Missing Version Needs information\n"));
12420 case SHT_GNU_versym
:
12422 Elf_Internal_Shdr
* link_section
;
12425 unsigned char * edata
;
12426 unsigned short * data
;
12428 Elf_Internal_Sym
* symbols
;
12429 Elf_Internal_Shdr
* string_sec
;
12433 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12436 link_section
= filedata
->section_headers
+ section
->sh_link
;
12437 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12439 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12444 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12445 if (symbols
== NULL
)
12448 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12450 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12451 string_sec
->sh_size
,
12452 _("version string table"));
12459 if (filedata
->is_separate
)
12460 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entry:\n",
12461 "\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entries:\n",
12463 filedata
->file_name
,
12464 printable_section_name (filedata
, section
),
12467 printf (ngettext ("\nVersion symbols section '%s' "
12468 "contains %" PRIu64
" entry:\n",
12469 "\nVersion symbols section '%s' "
12470 "contains %" PRIu64
" entries:\n",
12472 printable_section_name (filedata
, section
),
12475 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12476 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12477 section
->sh_offset
, section
->sh_link
,
12478 printable_section_name (filedata
, link_section
));
12480 off
= offset_from_vma (filedata
,
12481 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12482 total
* sizeof (short));
12483 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12484 sizeof (short), total
,
12485 _("version symbol data"));
12493 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12495 for (cnt
= total
; cnt
--;)
12496 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12501 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12505 char *invalid
= _("*invalid*");
12507 printf (" %03x:", cnt
);
12509 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12510 switch (data
[cnt
+ j
])
12513 fputs (_(" 0 (*local*) "), stdout
);
12517 fputs (_(" 1 (*global*) "), stdout
);
12521 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12522 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12524 /* If this index value is greater than the size of the symbols
12525 array, break to avoid an out-of-bounds read. */
12526 if (cnt
+ j
>= num_syms
)
12528 warn (_("invalid index into symbol array\n"));
12533 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12535 Elf_Internal_Verneed ivn
;
12538 offset
= offset_from_vma
12540 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12541 sizeof (Elf_External_Verneed
));
12545 Elf_Internal_Vernaux ivna
;
12546 Elf_External_Verneed evn
;
12547 Elf_External_Vernaux evna
;
12550 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12551 _("version need")) == NULL
)
12554 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12555 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12557 a_off
= offset
+ ivn
.vn_aux
;
12561 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
12562 1, _("version need aux (2)")) == NULL
)
12565 ivna
.vna_other
= 0;
12569 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12570 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12573 a_off
+= ivna
.vna_next
;
12575 while (ivna
.vna_other
!= data
[cnt
+ j
]
12576 && ivna
.vna_next
!= 0);
12578 if (ivna
.vna_other
== data
[cnt
+ j
])
12580 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12582 if (ivna
.vna_name
>= string_sec
->sh_size
)
12585 name
= strtab
+ ivna
.vna_name
;
12589 offset
+= ivn
.vn_next
;
12591 while (ivn
.vn_next
);
12594 if (data
[cnt
+ j
] != 0x8001
12595 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12597 Elf_Internal_Verdef ivd
;
12598 Elf_External_Verdef evd
;
12601 offset
= offset_from_vma
12603 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12608 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12609 _("version def")) == NULL
)
12612 /* PR 17531: file: 046-1082287-0.004. */
12613 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12618 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12619 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12622 offset
+= ivd
.vd_next
;
12624 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12625 && ivd
.vd_next
!= 0);
12627 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12629 Elf_External_Verdaux evda
;
12630 Elf_Internal_Verdaux ivda
;
12632 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12634 if (get_data (&evda
, filedata
,
12635 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
12637 _("version def aux")) == NULL
)
12640 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12642 if (ivda
.vda_name
>= string_sec
->sh_size
)
12644 else if (name
!= NULL
&& name
!= invalid
)
12645 name
= _("*both*");
12647 name
= strtab
+ ivda
.vda_name
;
12651 nn
+= printf ("(%s%-*s",
12653 12 - (int) strlen (name
),
12657 printf ("%*c", 18 - nn
, ' ');
12676 if (filedata
->is_separate
)
12677 printf (_("\nNo version information found in linked file '%s'.\n"),
12678 filedata
->file_name
);
12680 printf (_("\nNo version information found in this file.\n"));
12686 static const char *
12687 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
12689 static char buff
[64];
12693 case STB_LOCAL
: return "LOCAL";
12694 case STB_GLOBAL
: return "GLOBAL";
12695 case STB_WEAK
: return "WEAK";
12697 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12698 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12700 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12702 if (binding
== STB_GNU_UNIQUE
12703 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12705 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12708 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12713 static const char *
12714 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12716 static char buff
[64];
12720 case STT_NOTYPE
: return "NOTYPE";
12721 case STT_OBJECT
: return "OBJECT";
12722 case STT_FUNC
: return "FUNC";
12723 case STT_SECTION
: return "SECTION";
12724 case STT_FILE
: return "FILE";
12725 case STT_COMMON
: return "COMMON";
12726 case STT_TLS
: return "TLS";
12727 case STT_RELC
: return "RELC";
12728 case STT_SRELC
: return "SRELC";
12730 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12732 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12733 return "THUMB_FUNC";
12735 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12738 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12739 return "PARISC_MILLI";
12741 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12743 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12745 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12747 if (type
== STT_HP_OPAQUE
)
12748 return "HP_OPAQUE";
12749 if (type
== STT_HP_STUB
)
12753 if (type
== STT_GNU_IFUNC
12754 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12755 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12758 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12761 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12766 static const char *
12767 get_symbol_visibility (unsigned int visibility
)
12769 switch (visibility
)
12771 case STV_DEFAULT
: return "DEFAULT";
12772 case STV_INTERNAL
: return "INTERNAL";
12773 case STV_HIDDEN
: return "HIDDEN";
12774 case STV_PROTECTED
: return "PROTECTED";
12776 error (_("Unrecognized visibility value: %u\n"), visibility
);
12777 return _("<unknown>");
12781 static const char *
12782 get_alpha_symbol_other (unsigned int other
)
12786 case STO_ALPHA_NOPV
: return "NOPV";
12787 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12789 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12790 return _("<unknown>");
12794 static const char *
12795 get_solaris_symbol_visibility (unsigned int visibility
)
12797 switch (visibility
)
12799 case 4: return "EXPORTED";
12800 case 5: return "SINGLETON";
12801 case 6: return "ELIMINATE";
12802 default: return get_symbol_visibility (visibility
);
12806 static const char *
12807 get_aarch64_symbol_other (unsigned int other
)
12809 static char buf
[32];
12811 if (other
& STO_AARCH64_VARIANT_PCS
)
12813 other
&= ~STO_AARCH64_VARIANT_PCS
;
12815 return "VARIANT_PCS";
12816 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12822 static const char *
12823 get_mips_symbol_other (unsigned int other
)
12827 case STO_OPTIONAL
: return "OPTIONAL";
12828 case STO_MIPS_PLT
: return "MIPS PLT";
12829 case STO_MIPS_PIC
: return "MIPS PIC";
12830 case STO_MICROMIPS
: return "MICROMIPS";
12831 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12832 case STO_MIPS16
: return "MIPS16";
12833 default: return NULL
;
12837 static const char *
12838 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12840 if (is_ia64_vms (filedata
))
12842 static char res
[32];
12846 /* Function types is for images and .STB files only. */
12847 switch (filedata
->file_header
.e_type
)
12851 switch (VMS_ST_FUNC_TYPE (other
))
12853 case VMS_SFT_CODE_ADDR
:
12854 strcat (res
, " CA");
12856 case VMS_SFT_SYMV_IDX
:
12857 strcat (res
, " VEC");
12860 strcat (res
, " FD");
12862 case VMS_SFT_RESERVE
:
12863 strcat (res
, " RSV");
12866 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12867 VMS_ST_FUNC_TYPE (other
));
12868 strcat (res
, " <unknown>");
12875 switch (VMS_ST_LINKAGE (other
))
12877 case VMS_STL_IGNORE
:
12878 strcat (res
, " IGN");
12880 case VMS_STL_RESERVE
:
12881 strcat (res
, " RSV");
12884 strcat (res
, " STD");
12887 strcat (res
, " LNK");
12890 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12891 VMS_ST_LINKAGE (other
));
12892 strcat (res
, " <unknown>");
12904 static const char *
12905 get_ppc64_symbol_other (unsigned int other
)
12907 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12910 other
>>= STO_PPC64_LOCAL_BIT
;
12913 static char buf
[64];
12915 other
= ppc64_decode_local_entry (other
);
12916 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12922 static const char *
12923 get_riscv_symbol_other (unsigned int other
)
12925 static char buf
[32];
12928 if (other
& STO_RISCV_VARIANT_CC
)
12930 strcat (buf
, _(" VARIANT_CC"));
12931 other
&= ~STO_RISCV_VARIANT_CC
;
12935 snprintf (buf
, sizeof buf
, " %x", other
);
12944 static const char *
12945 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12947 const char * result
= NULL
;
12948 static char buff
[64];
12953 switch (filedata
->file_header
.e_machine
)
12956 result
= get_alpha_symbol_other (other
);
12959 result
= get_aarch64_symbol_other (other
);
12962 result
= get_mips_symbol_other (other
);
12965 result
= get_ia64_symbol_other (filedata
, other
);
12968 result
= get_ppc64_symbol_other (other
);
12971 result
= get_riscv_symbol_other (other
);
12981 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12985 static const char *
12986 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12988 static char buff
[32];
12992 case SHN_UNDEF
: return "UND";
12993 case SHN_ABS
: return "ABS";
12994 case SHN_COMMON
: return "COM";
12996 if (type
== SHN_IA_64_ANSI_COMMON
12997 && filedata
->file_header
.e_machine
== EM_IA_64
12998 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
13000 else if ((filedata
->file_header
.e_machine
== EM_X86_64
13001 || filedata
->file_header
.e_machine
== EM_L1OM
13002 || filedata
->file_header
.e_machine
== EM_K1OM
)
13003 && type
== SHN_X86_64_LCOMMON
)
13004 return "LARGE_COM";
13005 else if ((type
== SHN_MIPS_SCOMMON
13006 && filedata
->file_header
.e_machine
== EM_MIPS
)
13007 || (type
== SHN_TIC6X_SCOMMON
13008 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
13010 else if (type
== SHN_MIPS_SUNDEFINED
13011 && filedata
->file_header
.e_machine
== EM_MIPS
)
13013 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
13014 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
13015 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
13016 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
13017 else if (type
>= SHN_LORESERVE
)
13018 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
13019 else if (filedata
->file_header
.e_shnum
!= 0
13020 && type
>= filedata
->file_header
.e_shnum
)
13021 sprintf (buff
, _("bad section index[%3d]"), type
);
13023 sprintf (buff
, "%3d", type
);
13030 static const char *
13031 get_symbol_version_string (Filedata
*filedata
,
13033 const char *strtab
,
13034 size_t strtab_size
,
13036 Elf_Internal_Sym
*psym
,
13037 enum versioned_symbol_info
*sym_info
,
13038 unsigned short *vna_other
)
13040 unsigned char data
[2];
13041 unsigned short vers_data
;
13043 unsigned short max_vd_ndx
;
13046 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
13049 offset
= offset_from_vma (filedata
,
13050 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
13051 sizeof data
+ si
* sizeof (vers_data
));
13053 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
13054 sizeof (data
), 1, _("version data")) == NULL
)
13057 vers_data
= byte_get (data
, 2);
13059 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
13062 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13065 /* Usually we'd only see verdef for defined symbols, and verneed for
13066 undefined symbols. However, symbols defined by the linker in
13067 .dynbss for variables copied from a shared library in order to
13068 avoid text relocations are defined yet have verneed. We could
13069 use a heuristic to detect the special case, for example, check
13070 for verneed first on symbols defined in SHT_NOBITS sections, but
13071 it is simpler and more reliable to just look for both verdef and
13072 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13074 if (psym
->st_shndx
!= SHN_UNDEF
13075 && vers_data
!= 0x8001
13076 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13078 Elf_Internal_Verdef ivd
;
13079 Elf_Internal_Verdaux ivda
;
13080 Elf_External_Verdaux evda
;
13083 off
= offset_from_vma (filedata
,
13084 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13085 sizeof (Elf_External_Verdef
));
13089 Elf_External_Verdef evd
;
13091 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13092 _("version def")) == NULL
)
13101 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13102 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13103 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13104 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13107 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13108 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13110 off
+= ivd
.vd_next
;
13112 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13114 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13116 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13119 off
-= ivd
.vd_next
;
13122 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13123 _("version def aux")) != NULL
)
13125 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13127 if (psym
->st_name
!= ivda
.vda_name
)
13128 return (ivda
.vda_name
< strtab_size
13129 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13134 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13136 Elf_External_Verneed evn
;
13137 Elf_Internal_Verneed ivn
;
13138 Elf_Internal_Vernaux ivna
;
13140 offset
= offset_from_vma (filedata
,
13141 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13147 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13148 _("version need")) == NULL
)
13151 ivna
.vna_other
= 0;
13156 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13157 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13159 vna_off
= offset
+ ivn
.vn_aux
;
13163 Elf_External_Vernaux evna
;
13165 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13166 _("version need aux (3)")) == NULL
)
13169 ivna
.vna_other
= 0;
13174 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13175 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13176 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13179 vna_off
+= ivna
.vna_next
;
13181 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13183 if (ivna
.vna_other
== vers_data
)
13186 offset
+= ivn
.vn_next
;
13188 while (ivn
.vn_next
!= 0);
13190 if (ivna
.vna_other
== vers_data
)
13192 *sym_info
= symbol_undefined
;
13193 *vna_other
= ivna
.vna_other
;
13194 return (ivna
.vna_name
< strtab_size
13195 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13197 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13198 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13199 return _("<corrupt>");
13204 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13206 static unsigned int
13207 print_dynamic_symbol_size (uint64_t vma
, int base
)
13212 return print_vma (vma
, OCTAL_5
);
13215 return print_vma (vma
, UNSIGNED_5
);
13218 return print_vma (vma
, PREFIX_HEX_5
);
13222 return print_vma (vma
, DEC_5
);
13227 print_dynamic_symbol (Filedata
*filedata
, uint64_t si
,
13228 Elf_Internal_Sym
*symtab
,
13229 Elf_Internal_Shdr
*section
,
13230 char *strtab
, size_t strtab_size
)
13232 const char *version_string
;
13233 enum versioned_symbol_info sym_info
;
13234 unsigned short vna_other
;
13237 Elf_Internal_Sym
*psym
= symtab
+ si
;
13239 printf ("%6" PRId64
": ", si
);
13240 print_vma (psym
->st_value
, LONG_HEX
);
13242 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
13243 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13244 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13245 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13246 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13249 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13251 printf (" %-7s", get_symbol_visibility (vis
));
13252 /* Check to see if any other bits in the st_other field are set.
13253 Note - displaying this information disrupts the layout of the
13254 table being generated, but for the moment this case is very rare. */
13255 if (psym
->st_other
^ vis
)
13256 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13258 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
13260 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
13261 && psym
->st_shndx
< filedata
->file_header
.e_shnum
13262 && filedata
->section_headers
!= NULL
13263 && psym
->st_name
== 0)
13266 = section_name_valid (filedata
,
13267 filedata
->section_headers
+ psym
->st_shndx
);
13269 section_name_print (filedata
,
13270 filedata
->section_headers
+ psym
->st_shndx
)
13275 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
13276 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
13280 = get_symbol_version_string (filedata
,
13282 || section
->sh_type
== SHT_DYNSYM
),
13283 strtab
, strtab_size
, si
,
13284 psym
, &sym_info
, &vna_other
);
13286 int len_avail
= 21;
13287 if (! do_wide
&& version_string
!= NULL
)
13291 len_avail
-= 1 + strlen (version_string
);
13293 if (sym_info
== symbol_undefined
)
13294 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
13295 else if (sym_info
!= symbol_hidden
)
13299 print_symbol (len_avail
, sstr
);
13301 if (version_string
)
13303 if (sym_info
== symbol_undefined
)
13304 printf ("@%s (%d)", version_string
, vna_other
);
13306 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
13312 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
13314 && si
>= section
->sh_info
13315 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
13316 && filedata
->file_header
.e_machine
!= EM_MIPS
13317 /* Solaris binaries have been found to violate this requirement as
13318 well. Not sure if this is a bug or an ABI requirement. */
13319 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
13320 warn (_("local symbol %" PRIu64
" found at index >= %s's sh_info value of %u\n"),
13321 si
, printable_section_name (filedata
, section
), section
->sh_info
);
13324 static const char *
13325 get_lto_kind (unsigned int kind
)
13329 case 0: return "DEF";
13330 case 1: return "WEAKDEF";
13331 case 2: return "UNDEF";
13332 case 3: return "WEAKUNDEF";
13333 case 4: return "COMMON";
13338 static char buffer
[30];
13339 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
13340 sprintf (buffer
, "<unknown: %u>", kind
);
13344 static const char *
13345 get_lto_visibility (unsigned int visibility
)
13347 switch (visibility
)
13349 case 0: return "DEFAULT";
13350 case 1: return "PROTECTED";
13351 case 2: return "INTERNAL";
13352 case 3: return "HIDDEN";
13357 static char buffer
[30];
13358 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
13359 sprintf (buffer
, "<unknown: %u>", visibility
);
13363 static const char *
13364 get_lto_sym_type (unsigned int sym_type
)
13368 case 0: return "UNKNOWN";
13369 case 1: return "FUNCTION";
13370 case 2: return "VARIABLE";
13375 static char buffer
[30];
13376 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
13377 sprintf (buffer
, "<unknown: %u>", sym_type
);
13381 /* Display an LTO format symbol table.
13382 FIXME: The format of LTO symbol tables is not formalized.
13383 So this code could need changing in the future. */
13386 display_lto_symtab (Filedata
* filedata
,
13387 Elf_Internal_Shdr
* section
)
13389 if (section
->sh_size
== 0)
13391 if (filedata
->is_separate
)
13392 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
13393 printable_section_name (filedata
, section
),
13394 filedata
->file_name
);
13396 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13397 printable_section_name (filedata
, section
));
13402 if (section
->sh_size
> filedata
->file_size
)
13404 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
13405 printable_section_name (filedata
, section
),
13410 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13411 section
->sh_size
, 1, _("LTO symbols"));
13412 if (alloced_data
== NULL
)
13415 /* Look for extended data for the symbol table. */
13416 Elf_Internal_Shdr
* ext
;
13417 void * ext_data_orig
= NULL
;
13418 char * ext_data
= NULL
;
13419 char * ext_data_end
= NULL
;
13420 char * ext_name
= NULL
;
13422 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13423 (section_name (filedata
, section
)
13424 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13425 && ext_name
!= NULL
/* Paranoia. */
13426 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13428 if (ext
->sh_size
< 3)
13429 error (_("LTO Symbol extension table '%s' is empty!\n"),
13430 printable_section_name (filedata
, ext
));
13433 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13435 _("LTO ext symbol data"));
13436 if (ext_data
!= NULL
)
13438 ext_data_end
= ext_data
+ ext
->sh_size
;
13439 if (* ext_data
++ != 1)
13440 error (_("Unexpected version number in symbol extension table\n"));
13445 const unsigned char * data
= (const unsigned char *) alloced_data
;
13446 const unsigned char * end
= data
+ section
->sh_size
;
13448 if (filedata
->is_separate
)
13449 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13453 if (ext_data_orig
!= NULL
)
13456 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13457 printable_section_name (filedata
, section
),
13458 printable_section_name (filedata
, ext
));
13461 printf (_("LTO Symbol table '%s'\n"),
13462 printable_section_name (filedata
, section
));
13463 printf (_(" and extension table '%s' contain:\n"),
13464 printable_section_name (filedata
, ext
));
13468 printf (_("LTO Symbol table '%s' contains:\n"),
13469 printable_section_name (filedata
, section
));
13471 /* FIXME: Add a wide version. */
13472 if (ext_data_orig
!= NULL
)
13473 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13475 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13477 /* FIXME: We do not handle style prefixes. */
13481 const unsigned char * sym_name
= data
;
13482 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13486 const unsigned char * comdat_key
= data
;
13487 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13491 if (data
+ 2 + 8 + 4 > end
)
13494 unsigned int kind
= *data
++;
13495 unsigned int visibility
= *data
++;
13497 uint64_t size
= byte_get (data
, 8);
13500 uint64_t slot
= byte_get (data
, 4);
13503 if (ext_data
!= NULL
)
13505 if (ext_data
< (ext_data_end
- 1))
13507 unsigned int sym_type
= * ext_data
++;
13508 unsigned int sec_kind
= * ext_data
++;
13510 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
13511 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13512 get_lto_kind (kind
),
13513 get_lto_visibility (visibility
),
13516 get_lto_sym_type (sym_type
),
13518 print_symbol (6, (const char *) sym_name
);
13522 error (_("Ran out of LTO symbol extension data\n"));
13524 /* FIXME: return FAIL result ? */
13529 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
13530 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13531 get_lto_kind (kind
),
13532 get_lto_visibility (visibility
),
13535 print_symbol (21, (const char *) sym_name
);
13540 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
13542 error (_("Data remains in the LTO symbol extension table\n"));
13546 free (alloced_data
);
13547 free (ext_data_orig
);
13552 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
13553 free (alloced_data
);
13554 free (ext_data_orig
);
13559 /* Display LTO symbol tables. */
13562 process_lto_symbol_tables (Filedata
* filedata
)
13564 Elf_Internal_Shdr
* section
;
13571 if (filedata
->section_headers
== NULL
)
13574 for (i
= 0, section
= filedata
->section_headers
;
13575 i
< filedata
->file_header
.e_shnum
;
13577 if (section_name_valid (filedata
, section
)
13578 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
13579 res
&= display_lto_symtab (filedata
, section
);
13584 /* Dump the symbol table. */
13587 process_symbol_table (Filedata
* filedata
)
13589 Elf_Internal_Shdr
* section
;
13591 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
13594 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
13596 && do_using_dynamic
13597 && filedata
->dynamic_strings
!= NULL
13598 && filedata
->dynamic_symbols
!= NULL
)
13602 if (filedata
->is_separate
)
13604 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table"
13605 " contains %" PRIu64
" entry:\n",
13606 "\nIn linked file '%s' the dynamic symbol table"
13607 " contains %" PRIu64
" entries:\n",
13608 filedata
->num_dynamic_syms
),
13609 filedata
->file_name
,
13610 filedata
->num_dynamic_syms
);
13614 printf (ngettext ("\nSymbol table for image contains %" PRIu64
13616 "\nSymbol table for image contains %" PRIu64
13618 filedata
->num_dynamic_syms
),
13619 filedata
->num_dynamic_syms
);
13622 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13624 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13626 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
13627 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
13628 filedata
->dynamic_strings
,
13629 filedata
->dynamic_strings_length
);
13631 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
13632 && filedata
->section_headers
!= NULL
)
13636 for (i
= 0, section
= filedata
->section_headers
;
13637 i
< filedata
->file_header
.e_shnum
;
13640 char * strtab
= NULL
;
13641 uint64_t strtab_size
= 0;
13642 Elf_Internal_Sym
* symtab
;
13643 uint64_t si
, num_syms
;
13645 if ((section
->sh_type
!= SHT_SYMTAB
13646 && section
->sh_type
!= SHT_DYNSYM
)
13648 && section
->sh_type
== SHT_SYMTAB
))
13651 if (section
->sh_entsize
== 0)
13653 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
13654 printable_section_name (filedata
, section
));
13658 num_syms
= section
->sh_size
/ section
->sh_entsize
;
13660 if (filedata
->is_separate
)
13661 printf (ngettext ("\nIn linked file '%s' symbol section '%s'"
13662 " contains %" PRIu64
" entry:\n",
13663 "\nIn linked file '%s' symbol section '%s'"
13664 " contains %" PRIu64
" entries:\n",
13666 filedata
->file_name
,
13667 printable_section_name (filedata
, section
),
13670 printf (ngettext ("\nSymbol table '%s' contains %" PRIu64
13672 "\nSymbol table '%s' contains %" PRIu64
13675 printable_section_name (filedata
, section
),
13679 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13681 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13683 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
13684 if (symtab
== NULL
)
13687 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
13689 strtab
= filedata
->string_table
;
13690 strtab_size
= filedata
->string_table_length
;
13692 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
13694 Elf_Internal_Shdr
* string_sec
;
13696 string_sec
= filedata
->section_headers
+ section
->sh_link
;
13698 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
13699 1, string_sec
->sh_size
,
13700 _("string table"));
13701 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
13704 for (si
= 0; si
< num_syms
; si
++)
13705 print_dynamic_symbol (filedata
, si
, symtab
, section
,
13706 strtab
, strtab_size
);
13709 if (strtab
!= filedata
->string_table
)
13715 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
13717 if (do_histogram
&& filedata
->buckets
!= NULL
)
13723 uint64_t maxlength
= 0;
13724 uint64_t nzero_counts
= 0;
13725 uint64_t nsyms
= 0;
13728 printf (ngettext ("\nHistogram for bucket list length "
13729 "(total of %" PRIu64
" bucket):\n",
13730 "\nHistogram for bucket list length "
13731 "(total of %" PRIu64
" buckets):\n",
13732 filedata
->nbuckets
),
13733 filedata
->nbuckets
);
13735 lengths
= calloc (filedata
->nbuckets
, sizeof (*lengths
));
13736 if (lengths
== NULL
)
13738 error (_("Out of memory allocating space for histogram buckets\n"));
13741 visited
= xcmalloc (filedata
->nchains
, 1);
13742 memset (visited
, 0, filedata
->nchains
);
13744 printf (_(" Length Number %% of total Coverage\n"));
13745 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13747 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13750 if (maxlength
< ++lengths
[hn
])
13752 if (si
>= filedata
->nchains
|| visited
[si
])
13754 error (_("histogram chain is corrupt\n"));
13762 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
13763 if (counts
== NULL
)
13766 error (_("Out of memory allocating space for histogram counts\n"));
13770 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13771 ++counts
[lengths
[hn
]];
13773 if (filedata
->nbuckets
> 0)
13776 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
13777 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13778 for (i
= 1; i
<= maxlength
; ++i
)
13780 nzero_counts
+= counts
[i
] * i
;
13781 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
13782 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13783 (nzero_counts
* 100.0) / nsyms
);
13791 free (filedata
->buckets
);
13792 filedata
->buckets
= NULL
;
13793 filedata
->nbuckets
= 0;
13794 free (filedata
->chains
);
13795 filedata
->chains
= NULL
;
13797 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13802 uint64_t maxlength
= 0;
13803 uint64_t nzero_counts
= 0;
13804 uint64_t nsyms
= 0;
13806 printf (ngettext ("\nHistogram for `%s' bucket list length "
13807 "(total of %" PRIu64
" bucket):\n",
13808 "\nHistogram for `%s' bucket list length "
13809 "(total of %" PRIu64
" buckets):\n",
13810 filedata
->ngnubuckets
),
13811 GNU_HASH_SECTION_NAME (filedata
),
13812 filedata
->ngnubuckets
);
13814 lengths
= calloc (filedata
->ngnubuckets
, sizeof (*lengths
));
13815 if (lengths
== NULL
)
13817 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13821 printf (_(" Length Number %% of total Coverage\n"));
13823 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13824 if (filedata
->gnubuckets
[hn
] != 0)
13826 uint64_t off
, length
= 1;
13828 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13829 /* PR 17531 file: 010-77222-0.004. */
13830 off
< filedata
->ngnuchains
13831 && (filedata
->gnuchains
[off
] & 1) == 0;
13834 lengths
[hn
] = length
;
13835 if (length
> maxlength
)
13836 maxlength
= length
;
13840 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
13841 if (counts
== NULL
)
13844 error (_("Out of memory allocating space for gnu histogram counts\n"));
13848 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13849 ++counts
[lengths
[hn
]];
13851 if (filedata
->ngnubuckets
> 0)
13854 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
13855 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13856 for (j
= 1; j
<= maxlength
; ++j
)
13858 nzero_counts
+= counts
[j
] * j
;
13859 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
13860 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13861 (nzero_counts
* 100.0) / nsyms
);
13868 free (filedata
->gnubuckets
);
13869 filedata
->gnubuckets
= NULL
;
13870 filedata
->ngnubuckets
= 0;
13871 free (filedata
->gnuchains
);
13872 filedata
->gnuchains
= NULL
;
13873 filedata
->ngnuchains
= 0;
13874 free (filedata
->mipsxlat
);
13875 filedata
->mipsxlat
= NULL
;
13879 free (filedata
->gnubuckets
);
13880 filedata
->gnubuckets
= NULL
;
13881 filedata
->ngnubuckets
= 0;
13882 free (filedata
->gnuchains
);
13883 filedata
->gnuchains
= NULL
;
13884 filedata
->ngnuchains
= 0;
13885 free (filedata
->mipsxlat
);
13886 filedata
->mipsxlat
= NULL
;
13887 free (filedata
->buckets
);
13888 filedata
->buckets
= NULL
;
13889 filedata
->nbuckets
= 0;
13890 free (filedata
->chains
);
13891 filedata
->chains
= NULL
;
13896 process_syminfo (Filedata
* filedata
)
13900 if (filedata
->dynamic_syminfo
== NULL
13902 /* No syminfo, this is ok. */
13905 /* There better should be a dynamic symbol section. */
13906 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13909 if (filedata
->is_separate
)
13910 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entry:\n",
13911 "\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entries:\n",
13912 filedata
->dynamic_syminfo_nent
),
13913 filedata
->file_name
,
13914 filedata
->dynamic_syminfo_offset
,
13915 filedata
->dynamic_syminfo_nent
);
13917 printf (ngettext ("\nDynamic info segment at offset %#" PRIx64
13918 " contains %d entry:\n",
13919 "\nDynamic info segment at offset %#" PRIx64
13920 " contains %d entries:\n",
13921 filedata
->dynamic_syminfo_nent
),
13922 filedata
->dynamic_syminfo_offset
,
13923 filedata
->dynamic_syminfo_nent
);
13925 printf (_(" Num: Name BoundTo Flags\n"));
13926 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13928 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13930 printf ("%4d: ", i
);
13931 if (i
>= filedata
->num_dynamic_syms
)
13932 printf (_("<corrupt index>"));
13933 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13934 print_symbol (30, get_dynamic_name (filedata
,
13935 filedata
->dynamic_symbols
[i
].st_name
));
13937 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13940 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13942 case SYMINFO_BT_SELF
:
13943 fputs ("SELF ", stdout
);
13945 case SYMINFO_BT_PARENT
:
13946 fputs ("PARENT ", stdout
);
13949 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13950 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13951 && valid_dynamic_name (filedata
,
13952 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13954 print_symbol (10, get_dynamic_name (filedata
,
13955 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13959 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13963 if (flags
& SYMINFO_FLG_DIRECT
)
13964 printf (" DIRECT");
13965 if (flags
& SYMINFO_FLG_PASSTHRU
)
13966 printf (" PASSTHRU");
13967 if (flags
& SYMINFO_FLG_COPY
)
13969 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13970 printf (" LAZYLOAD");
13978 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13979 is contained by the region START .. END. The types of ADDR, START
13980 and END should all be the same. Note both ADDR + NELEM and END
13981 point to just beyond the end of the regions that are being tested. */
13982 #define IN_RANGE(START,END,ADDR,NELEM) \
13983 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13985 /* Check to see if the given reloc needs to be handled in a target specific
13986 manner. If so then process the reloc and return TRUE otherwise return
13989 If called with reloc == NULL, then this is a signal that reloc processing
13990 for the current section has finished, and any saved state should be
13994 target_specific_reloc_handling (Filedata
*filedata
,
13995 Elf_Internal_Rela
*reloc
,
13996 unsigned char *start
,
13997 unsigned char *end
,
13998 Elf_Internal_Sym
*symtab
,
14001 unsigned int reloc_type
= 0;
14002 uint64_t sym_index
= 0;
14006 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
14007 sym_index
= get_reloc_symindex (reloc
->r_info
);
14010 switch (filedata
->file_header
.e_machine
)
14014 switch (reloc_type
)
14016 /* For .uleb128 .LFE1-.LFB1, loongarch write 0 to object file
14017 at assembly time. */
14018 case 107: /* R_LARCH_ADD_ULEB128. */
14019 case 108: /* R_LARCH_SUB_ULEB128. */
14021 uint64_t value
= 0;
14022 unsigned int reloc_size
= 0;
14025 if (reloc
->r_offset
< (size_t) (end
- start
))
14026 value
= read_leb128 (start
+ reloc
->r_offset
, end
, false,
14027 &reloc_size
, &leb_ret
);
14028 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14029 error (_("LoongArch ULEB128 field at 0x%lx contains invalid "
14030 "ULEB128 value\n"),
14031 (long) reloc
->r_offset
);
14033 else if (sym_index
>= num_syms
)
14034 error (_("%s reloc contains invalid symbol index "
14037 ? "R_LARCH_ADD_ULEB128"
14038 : "R_LARCH_SUB_ULEB128"),
14042 if (reloc_type
== 107)
14043 value
+= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14045 value
-= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14047 /* Write uleb128 value to p. */
14048 bfd_byte
*p
= start
+ reloc
->r_offset
;
14051 bfd_byte c
= value
& 0x7f;
14053 if (--reloc_size
!= 0)
14057 while (reloc_size
);
14067 case EM_MSP430_OLD
:
14069 static Elf_Internal_Sym
* saved_sym
= NULL
;
14077 switch (reloc_type
)
14079 case 10: /* R_MSP430_SYM_DIFF */
14080 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
14081 if (uses_msp430x_relocs (filedata
))
14083 /* Fall through. */
14084 case 21: /* R_MSP430X_SYM_DIFF */
14085 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
14087 if (sym_index
>= num_syms
)
14088 error (_("%s reloc contains invalid symbol index "
14089 "%" PRIu64
"\n"), "MSP430 SYM_DIFF", sym_index
);
14091 saved_sym
= symtab
+ sym_index
;
14094 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14095 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
14096 goto handle_sym_diff
;
14098 case 5: /* R_MSP430_16_BYTE */
14099 case 9: /* R_MSP430_8 */
14100 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14101 if (uses_msp430x_relocs (filedata
))
14103 goto handle_sym_diff
;
14105 case 2: /* R_MSP430_ABS16 */
14106 case 15: /* R_MSP430X_ABS16 */
14107 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14108 if (! uses_msp430x_relocs (filedata
))
14110 goto handle_sym_diff
;
14113 if (saved_sym
!= NULL
)
14116 unsigned int reloc_size
= 0;
14118 switch (reloc_type
)
14120 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14123 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14124 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14125 if (reloc
->r_offset
< (size_t) (end
- start
))
14126 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14127 &reloc_size
, &leb_ret
);
14134 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14135 error (_("MSP430 ULEB128 field at %#" PRIx64
14136 " contains invalid ULEB128 value\n"),
14138 else if (sym_index
>= num_syms
)
14139 error (_("%s reloc contains invalid symbol index "
14140 "%" PRIu64
"\n"), "MSP430", sym_index
);
14143 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14144 - saved_sym
->st_value
);
14146 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14147 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14150 error (_("MSP430 sym diff reloc contains invalid offset: "
14161 if (saved_sym
!= NULL
)
14162 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14169 case EM_CYGNUS_MN10300
:
14171 static Elf_Internal_Sym
* saved_sym
= NULL
;
14179 switch (reloc_type
)
14181 case 34: /* R_MN10300_ALIGN */
14183 case 33: /* R_MN10300_SYM_DIFF */
14184 if (sym_index
>= num_syms
)
14185 error (_("%s reloc contains invalid symbol index "
14186 "%" PRIu64
"\n"), "MN10300_SYM_DIFF", sym_index
);
14188 saved_sym
= symtab
+ sym_index
;
14191 case 1: /* R_MN10300_32 */
14192 case 2: /* R_MN10300_16 */
14193 if (saved_sym
!= NULL
)
14195 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14198 if (sym_index
>= num_syms
)
14199 error (_("%s reloc contains invalid symbol index "
14200 "%" PRIu64
"\n"), "MN10300", sym_index
);
14203 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14204 - saved_sym
->st_value
);
14206 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14207 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14209 error (_("MN10300 sym diff reloc contains invalid offset:"
14210 " %#" PRIx64
"\n"),
14219 if (saved_sym
!= NULL
)
14220 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
14228 static uint64_t saved_sym1
= 0;
14229 static uint64_t saved_sym2
= 0;
14230 static uint64_t value
;
14234 saved_sym1
= saved_sym2
= 0;
14238 switch (reloc_type
)
14240 case 0x80: /* R_RL78_SYM. */
14241 saved_sym1
= saved_sym2
;
14242 if (sym_index
>= num_syms
)
14243 error (_("%s reloc contains invalid symbol index "
14244 "%" PRIu64
"\n"), "RL78_SYM", sym_index
);
14247 saved_sym2
= symtab
[sym_index
].st_value
;
14248 saved_sym2
+= reloc
->r_addend
;
14252 case 0x83: /* R_RL78_OPsub. */
14253 value
= saved_sym1
- saved_sym2
;
14254 saved_sym2
= saved_sym1
= 0;
14258 case 0x41: /* R_RL78_ABS32. */
14259 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
14260 byte_put (start
+ reloc
->r_offset
, value
, 4);
14262 error (_("RL78 sym diff reloc contains invalid offset: "
14268 case 0x43: /* R_RL78_ABS16. */
14269 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
14270 byte_put (start
+ reloc
->r_offset
, value
, 2);
14272 error (_("RL78 sym diff reloc contains invalid offset: "
14288 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
14289 DWARF debug sections. This is a target specific test. Note - we do not
14290 go through the whole including-target-headers-multiple-times route, (as
14291 we have already done with <elf/h8.h>) because this would become very
14292 messy and even then this function would have to contain target specific
14293 information (the names of the relocs instead of their numeric values).
14294 FIXME: This is not the correct way to solve this problem. The proper way
14295 is to have target specific reloc sizing and typing functions created by
14296 the reloc-macros.h header, in the same way that it already creates the
14297 reloc naming functions. */
14300 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14302 /* Please keep this table alpha-sorted for ease of visual lookup. */
14303 switch (filedata
->file_header
.e_machine
)
14307 return reloc_type
== 1; /* R_386_32. */
14309 return reloc_type
== 1; /* R_68K_32. */
14311 return reloc_type
== 1; /* R_860_32. */
14313 return reloc_type
== 2; /* R_960_32. */
14315 return (reloc_type
== 258
14316 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
14318 return reloc_type
== 11; /* R_BPF_DATA_32 */
14319 case EM_ADAPTEVA_EPIPHANY
:
14320 return reloc_type
== 3;
14322 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
14324 return reloc_type
== 1; /* R_ARC_32. */
14325 case EM_ARC_COMPACT
:
14326 case EM_ARC_COMPACT2
:
14327 return reloc_type
== 4; /* R_ARC_32. */
14329 return reloc_type
== 2; /* R_ARM_ABS32 */
14332 return reloc_type
== 1;
14334 return reloc_type
== 0x12; /* R_byte4_data. */
14336 return reloc_type
== 3; /* R_CRIS_32. */
14338 return reloc_type
== 3; /* R_CR16_NUM32. */
14340 return reloc_type
== 15; /* R_CRX_NUM32. */
14342 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
14343 case EM_CYGNUS_FRV
:
14344 return reloc_type
== 1;
14345 case EM_CYGNUS_D10V
:
14347 return reloc_type
== 6; /* R_D10V_32. */
14348 case EM_CYGNUS_D30V
:
14350 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
14352 return reloc_type
== 3; /* R_DLX_RELOC_32. */
14353 case EM_CYGNUS_FR30
:
14355 return reloc_type
== 3; /* R_FR30_32. */
14357 return reloc_type
== 1; /* R_FT32_32. */
14361 return reloc_type
== 1; /* R_H8_DIR32. */
14363 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
14364 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
14365 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
14366 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
14369 return reloc_type
== 2; /* R_IP2K_32. */
14371 return reloc_type
== 2; /* R_IQ2000_32. */
14372 case EM_LATTICEMICO32
:
14373 return reloc_type
== 3; /* R_LM32_32. */
14375 return reloc_type
== 1; /* R_LARCH_32. */
14378 return reloc_type
== 3; /* R_M32C_32. */
14380 return reloc_type
== 34; /* R_M32R_32_RELA. */
14383 return reloc_type
== 6; /* R_M68HC11_32. */
14385 return reloc_type
== 7 || /* R_S12Z_EXT32 */
14386 reloc_type
== 6; /* R_S12Z_CW32. */
14388 return reloc_type
== 1; /* R_MCORE_ADDR32. */
14389 case EM_CYGNUS_MEP
:
14390 return reloc_type
== 4; /* R_MEP_32. */
14392 return reloc_type
== 2; /* R_METAG_ADDR32. */
14393 case EM_MICROBLAZE
:
14394 return reloc_type
== 1; /* R_MICROBLAZE_32. */
14396 return reloc_type
== 2; /* R_MIPS_32. */
14398 return reloc_type
== 4; /* R_MMIX_32. */
14399 case EM_CYGNUS_MN10200
:
14401 return reloc_type
== 1; /* R_MN10200_32. */
14402 case EM_CYGNUS_MN10300
:
14404 return reloc_type
== 1; /* R_MN10300_32. */
14406 return reloc_type
== 1; /* R_MOXIE_32. */
14407 case EM_MSP430_OLD
:
14409 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
14411 return reloc_type
== 2; /* R_MT_32. */
14413 return reloc_type
== 20; /* R_NDS32_32_RELA. */
14414 case EM_ALTERA_NIOS2
:
14415 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
14417 return reloc_type
== 1; /* R_NIOS_32. */
14419 return reloc_type
== 1; /* R_OR1K_32. */
14421 return (reloc_type
== 1 /* R_PARISC_DIR32. */
14422 || reloc_type
== 2 /* R_PARISC_DIR21L. */
14423 || reloc_type
== 41); /* R_PARISC_SECREL32. */
14426 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
14428 return reloc_type
== 1; /* R_PPC64_ADDR32. */
14430 return reloc_type
== 1; /* R_PPC_ADDR32. */
14432 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
14434 return reloc_type
== 1; /* R_RISCV_32. */
14436 return reloc_type
== 1; /* R_RL78_DIR32. */
14438 return reloc_type
== 1; /* R_RX_DIR32. */
14440 return reloc_type
== 1; /* R_I370_ADDR31. */
14443 return reloc_type
== 4; /* R_S390_32. */
14445 return reloc_type
== 8; /* R_SCORE_ABS32. */
14447 return reloc_type
== 1; /* R_SH_DIR32. */
14448 case EM_SPARC32PLUS
:
14451 return reloc_type
== 3 /* R_SPARC_32. */
14452 || reloc_type
== 23; /* R_SPARC_UA32. */
14454 return reloc_type
== 6; /* R_SPU_ADDR32 */
14456 return reloc_type
== 1; /* R_C6000_ABS32. */
14458 return reloc_type
== 2; /* R_TILEGX_32. */
14460 return reloc_type
== 1; /* R_TILEPRO_32. */
14461 case EM_CYGNUS_V850
:
14463 return reloc_type
== 6; /* R_V850_ABS32. */
14465 return reloc_type
== 0x33; /* R_V810_WORD. */
14467 return reloc_type
== 1; /* R_VAX_32. */
14469 return reloc_type
== 3; /* R_VISIUM_32. */
14470 case EM_WEBASSEMBLY
:
14471 return reloc_type
== 1; /* R_WASM32_32. */
14475 return reloc_type
== 10; /* R_X86_64_32. */
14477 return reloc_type
== 4; /* R_XGATE_32. */
14479 return reloc_type
== 1; /* R_XSTROMY16_32. */
14480 case EM_XTENSA_OLD
:
14482 return reloc_type
== 1; /* R_XTENSA_32. */
14484 return reloc_type
== 6; /* R_Z80_32. */
14487 static unsigned int prev_warn
= 0;
14489 /* Avoid repeating the same warning multiple times. */
14490 if (prev_warn
!= filedata
->file_header
.e_machine
)
14491 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
14492 filedata
->file_header
.e_machine
);
14493 prev_warn
= filedata
->file_header
.e_machine
;
14499 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14500 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
14503 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14505 switch (filedata
->file_header
.e_machine
)
14506 /* Please keep this table alpha-sorted for ease of visual lookup. */
14510 return reloc_type
== 2; /* R_386_PC32. */
14512 return reloc_type
== 4; /* R_68K_PC32. */
14514 return reloc_type
== 261; /* R_AARCH64_PREL32 */
14515 case EM_ADAPTEVA_EPIPHANY
:
14516 return reloc_type
== 6;
14518 return reloc_type
== 10; /* R_ALPHA_SREL32. */
14519 case EM_ARC_COMPACT
:
14520 case EM_ARC_COMPACT2
:
14521 return reloc_type
== 49; /* R_ARC_32_PCREL. */
14523 return reloc_type
== 3; /* R_ARM_REL32 */
14526 return reloc_type
== 36; /* R_AVR_32_PCREL. */
14528 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
14529 case EM_MICROBLAZE
:
14530 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
14532 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
14534 return reloc_type
== 9; /* R_PARISC_PCREL32. */
14536 return reloc_type
== 26; /* R_PPC_REL32. */
14538 return reloc_type
== 26; /* R_PPC64_REL32. */
14540 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
14543 return reloc_type
== 5; /* R_390_PC32. */
14545 return reloc_type
== 2; /* R_SH_REL32. */
14546 case EM_SPARC32PLUS
:
14549 return reloc_type
== 6; /* R_SPARC_DISP32. */
14551 return reloc_type
== 13; /* R_SPU_REL32. */
14553 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
14555 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
14557 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
14561 return reloc_type
== 2; /* R_X86_64_PC32. */
14563 return reloc_type
== 4; /* R_VAX_PCREL32. */
14564 case EM_XTENSA_OLD
:
14566 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
14568 /* Do not abort or issue an error message here. Not all targets use
14569 pc-relative 32-bit relocs in their DWARF debug information and we
14570 have already tested for target coverage in is_32bit_abs_reloc. A
14571 more helpful warning message will be generated by apply_relocations
14572 anyway, so just return. */
14577 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14578 a 64-bit absolute RELA relocation used in DWARF debug sections. */
14581 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14583 switch (filedata
->file_header
.e_machine
)
14586 return reloc_type
== 257; /* R_AARCH64_ABS64. */
14588 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
14590 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
14591 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
14593 return reloc_type
== 2; /* R_LARCH_64 */
14595 return reloc_type
== 80; /* R_PARISC_DIR64. */
14597 return reloc_type
== 38; /* R_PPC64_ADDR64. */
14599 return reloc_type
== 2; /* R_RISCV_64. */
14600 case EM_SPARC32PLUS
:
14603 return reloc_type
== 32 /* R_SPARC_64. */
14604 || reloc_type
== 54; /* R_SPARC_UA64. */
14608 return reloc_type
== 1; /* R_X86_64_64. */
14611 return reloc_type
== 22; /* R_S390_64. */
14613 return reloc_type
== 1; /* R_TILEGX_64. */
14615 return reloc_type
== 18; /* R_MIPS_64. */
14621 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
14622 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
14625 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14627 switch (filedata
->file_header
.e_machine
)
14630 return reloc_type
== 260; /* R_AARCH64_PREL64. */
14632 return reloc_type
== 11; /* R_ALPHA_SREL64. */
14634 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
14635 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
14637 return reloc_type
== 72; /* R_PARISC_PCREL64. */
14639 return reloc_type
== 44; /* R_PPC64_REL64. */
14640 case EM_SPARC32PLUS
:
14643 return reloc_type
== 46; /* R_SPARC_DISP64. */
14647 return reloc_type
== 24; /* R_X86_64_PC64. */
14650 return reloc_type
== 23; /* R_S390_PC64. */
14652 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
14658 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14659 a 24-bit absolute RELA relocation used in DWARF debug sections. */
14662 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14664 switch (filedata
->file_header
.e_machine
)
14666 case EM_CYGNUS_MN10200
:
14668 return reloc_type
== 4; /* R_MN10200_24. */
14670 return reloc_type
== 5; /* R_FT32_20. */
14672 return reloc_type
== 5; /* R_Z80_24. */
14678 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14679 a 16-bit absolute RELA relocation used in DWARF debug sections. */
14682 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14684 /* Please keep this table alpha-sorted for ease of visual lookup. */
14685 switch (filedata
->file_header
.e_machine
)
14688 case EM_ARC_COMPACT
:
14689 case EM_ARC_COMPACT2
:
14690 return reloc_type
== 2; /* R_ARC_16. */
14691 case EM_ADAPTEVA_EPIPHANY
:
14692 return reloc_type
== 5;
14695 return reloc_type
== 4; /* R_AVR_16. */
14696 case EM_CYGNUS_D10V
:
14698 return reloc_type
== 3; /* R_D10V_16. */
14700 return reloc_type
== 2; /* R_FT32_16. */
14704 return reloc_type
== R_H8_DIR16
;
14707 return reloc_type
== 1; /* R_IP2K_16. */
14710 return reloc_type
== 1; /* R_M32C_16 */
14711 case EM_CYGNUS_MN10200
:
14713 return reloc_type
== 2; /* R_MN10200_16. */
14714 case EM_CYGNUS_MN10300
:
14716 return reloc_type
== 2; /* R_MN10300_16. */
14718 if (uses_msp430x_relocs (filedata
))
14719 return reloc_type
== 2; /* R_MSP430_ABS16. */
14720 /* Fall through. */
14721 case EM_MSP430_OLD
:
14722 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
14724 return reloc_type
== 19; /* R_NDS32_16_RELA. */
14725 case EM_ALTERA_NIOS2
:
14726 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
14728 return reloc_type
== 9; /* R_NIOS_16. */
14730 return reloc_type
== 2; /* R_OR1K_16. */
14732 return reloc_type
== 55; /* R_RISCV_SET16. */
14734 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
14736 return reloc_type
== 2; /* R_C6000_ABS16. */
14738 return reloc_type
== 2; /* R_VISIUM_16. */
14740 return reloc_type
== 3; /* R_XGATE_16. */
14742 return reloc_type
== 4; /* R_Z80_16. */
14748 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14749 a 8-bit absolute RELA relocation used in DWARF debug sections. */
14752 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14754 switch (filedata
->file_header
.e_machine
)
14757 return reloc_type
== 54; /* R_RISCV_SET8. */
14759 return reloc_type
== 1; /* R_Z80_8. */
14765 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14766 a 6-bit absolute RELA relocation used in DWARF debug sections. */
14769 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14771 switch (filedata
->file_header
.e_machine
)
14774 return reloc_type
== 53; /* R_RISCV_SET6. */
14780 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14781 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
14784 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14786 /* Please keep this table alpha-sorted for ease of visual lookup. */
14787 switch (filedata
->file_header
.e_machine
)
14790 return reloc_type
== 50; /* R_LARCH_ADD32. */
14792 return reloc_type
== 35; /* R_RISCV_ADD32. */
14798 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14799 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14802 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14804 /* Please keep this table alpha-sorted for ease of visual lookup. */
14805 switch (filedata
->file_header
.e_machine
)
14808 return reloc_type
== 55; /* R_LARCH_SUB32. */
14810 return reloc_type
== 39; /* R_RISCV_SUB32. */
14816 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14817 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14820 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14822 /* Please keep this table alpha-sorted for ease of visual lookup. */
14823 switch (filedata
->file_header
.e_machine
)
14826 return reloc_type
== 51; /* R_LARCH_ADD64. */
14828 return reloc_type
== 36; /* R_RISCV_ADD64. */
14834 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14835 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14838 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14840 /* Please keep this table alpha-sorted for ease of visual lookup. */
14841 switch (filedata
->file_header
.e_machine
)
14844 return reloc_type
== 56; /* R_LARCH_SUB64. */
14846 return reloc_type
== 40; /* R_RISCV_SUB64. */
14852 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14853 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14856 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14858 /* Please keep this table alpha-sorted for ease of visual lookup. */
14859 switch (filedata
->file_header
.e_machine
)
14862 return reloc_type
== 48; /* R_LARCH_ADD16. */
14864 return reloc_type
== 34; /* R_RISCV_ADD16. */
14870 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14871 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14874 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14876 /* Please keep this table alpha-sorted for ease of visual lookup. */
14877 switch (filedata
->file_header
.e_machine
)
14880 return reloc_type
== 53; /* R_LARCH_SUB16. */
14882 return reloc_type
== 38; /* R_RISCV_SUB16. */
14888 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14889 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14892 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14894 /* Please keep this table alpha-sorted for ease of visual lookup. */
14895 switch (filedata
->file_header
.e_machine
)
14898 return reloc_type
== 47; /* R_LARCH_ADD8. */
14900 return reloc_type
== 33; /* R_RISCV_ADD8. */
14906 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14907 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14910 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14912 /* Please keep this table alpha-sorted for ease of visual lookup. */
14913 switch (filedata
->file_header
.e_machine
)
14916 return reloc_type
== 52; /* R_LARCH_SUB8. */
14918 return reloc_type
== 37; /* R_RISCV_SUB8. */
14924 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14925 a 6-bit inplace add RELA relocation used in DWARF debug sections. */
14928 is_6bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14930 switch (filedata
->file_header
.e_machine
)
14933 return reloc_type
== 105; /* R_LARCH_ADD6. */
14939 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14940 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14943 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14945 switch (filedata
->file_header
.e_machine
)
14948 return reloc_type
== 106; /* R_LARCH_SUB6. */
14950 return reloc_type
== 52; /* R_RISCV_SUB6. */
14956 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14957 relocation entries (possibly formerly used for SHT_GROUP sections). */
14960 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14962 switch (filedata
->file_header
.e_machine
)
14964 case EM_386
: /* R_386_NONE. */
14965 case EM_68K
: /* R_68K_NONE. */
14966 case EM_ADAPTEVA_EPIPHANY
:
14967 case EM_ALPHA
: /* R_ALPHA_NONE. */
14968 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14969 case EM_ARC
: /* R_ARC_NONE. */
14970 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14971 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14972 case EM_ARM
: /* R_ARM_NONE. */
14973 case EM_CRIS
: /* R_CRIS_NONE. */
14974 case EM_FT32
: /* R_FT32_NONE. */
14975 case EM_IA_64
: /* R_IA64_NONE. */
14976 case EM_K1OM
: /* R_X86_64_NONE. */
14977 case EM_L1OM
: /* R_X86_64_NONE. */
14978 case EM_M32R
: /* R_M32R_NONE. */
14979 case EM_MIPS
: /* R_MIPS_NONE. */
14980 case EM_MN10300
: /* R_MN10300_NONE. */
14981 case EM_MOXIE
: /* R_MOXIE_NONE. */
14982 case EM_NIOS32
: /* R_NIOS_NONE. */
14983 case EM_OR1K
: /* R_OR1K_NONE. */
14984 case EM_PARISC
: /* R_PARISC_NONE. */
14985 case EM_PPC64
: /* R_PPC64_NONE. */
14986 case EM_PPC
: /* R_PPC_NONE. */
14987 case EM_RISCV
: /* R_RISCV_NONE. */
14988 case EM_S390
: /* R_390_NONE. */
14990 case EM_SH
: /* R_SH_NONE. */
14991 case EM_SPARC32PLUS
:
14992 case EM_SPARC
: /* R_SPARC_NONE. */
14994 case EM_TILEGX
: /* R_TILEGX_NONE. */
14995 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14996 case EM_TI_C6000
:/* R_C6000_NONE. */
14997 case EM_X86_64
: /* R_X86_64_NONE. */
14998 case EM_Z80
: /* R_Z80_NONE. */
14999 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
15000 return reloc_type
== 0;
15003 return reloc_type
== 0 || reloc_type
== 256;
15006 return (reloc_type
== 0 /* R_AVR_NONE. */
15007 || reloc_type
== 30 /* R_AVR_DIFF8. */
15008 || reloc_type
== 31 /* R_AVR_DIFF16. */
15009 || reloc_type
== 32 /* R_AVR_DIFF32. */);
15011 return reloc_type
== 3; /* R_METAG_NONE. */
15013 return (reloc_type
== 0 /* R_NDS32_NONE. */
15014 || reloc_type
== 205 /* R_NDS32_DIFF8. */
15015 || reloc_type
== 206 /* R_NDS32_DIFF16. */
15016 || reloc_type
== 207 /* R_NDS32_DIFF32. */
15017 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
15019 return (reloc_type
== 0 /* R_PRU_NONE. */
15020 || reloc_type
== 65 /* R_PRU_DIFF8. */
15021 || reloc_type
== 66 /* R_PRU_DIFF16. */
15022 || reloc_type
== 67 /* R_PRU_DIFF32. */);
15023 case EM_XTENSA_OLD
:
15025 return (reloc_type
== 0 /* R_XTENSA_NONE. */
15026 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
15027 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
15028 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
15029 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
15030 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
15031 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
15032 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
15033 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
15034 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
15039 /* Returns TRUE if there is a relocation against
15040 section NAME at OFFSET bytes. */
15043 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
15045 Elf_Internal_Rela
* relocs
;
15046 Elf_Internal_Rela
* rp
;
15048 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
15051 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
15053 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
15054 if (rp
->r_offset
== offset
)
15060 /* Apply relocations to a section.
15061 Returns TRUE upon success, FALSE otherwise.
15062 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
15063 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
15064 will be set to the number of relocs loaded.
15066 Note: So far support has been added only for those relocations
15067 which can be found in debug sections. FIXME: Add support for
15068 more relocations ? */
15071 apply_relocations (Filedata
*filedata
,
15072 const Elf_Internal_Shdr
*section
,
15073 unsigned char *start
,
15075 void **relocs_return
,
15076 uint64_t *num_relocs_return
)
15078 Elf_Internal_Shdr
* relsec
;
15079 unsigned char * end
= start
+ size
;
15081 if (relocs_return
!= NULL
)
15083 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
15084 * num_relocs_return
= 0;
15087 if (filedata
->file_header
.e_type
!= ET_REL
)
15088 /* No relocs to apply. */
15091 /* Find the reloc section associated with the section. */
15092 for (relsec
= filedata
->section_headers
;
15093 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15097 uint64_t num_relocs
;
15098 Elf_Internal_Rela
* relocs
;
15099 Elf_Internal_Rela
* rp
;
15100 Elf_Internal_Shdr
* symsec
;
15101 Elf_Internal_Sym
* symtab
;
15103 Elf_Internal_Sym
* sym
;
15105 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15106 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15107 || filedata
->section_headers
+ relsec
->sh_info
!= section
15108 || relsec
->sh_size
== 0
15109 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15112 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
15113 if (symsec
->sh_type
!= SHT_SYMTAB
15114 && symsec
->sh_type
!= SHT_DYNSYM
)
15117 is_rela
= relsec
->sh_type
== SHT_RELA
;
15121 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
15122 relsec
->sh_size
, & relocs
, & num_relocs
))
15127 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
15128 relsec
->sh_size
, & relocs
, & num_relocs
))
15132 /* SH uses RELA but uses in place value instead of the addend field. */
15133 if (filedata
->file_header
.e_machine
== EM_SH
)
15136 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
15138 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
15141 unsigned int reloc_type
;
15142 unsigned int reloc_size
;
15143 bool reloc_inplace
= false;
15144 bool reloc_subtract
= false;
15145 unsigned char *rloc
;
15146 uint64_t sym_index
;
15148 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
15150 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
15152 else if (is_none_reloc (filedata
, reloc_type
))
15154 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
15155 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
15157 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
15158 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15160 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15162 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15164 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15165 || is_6bit_abs_reloc (filedata
, reloc_type
))
15167 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15169 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15172 reloc_inplace
= true;
15174 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15176 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15179 reloc_inplace
= true;
15181 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
15183 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
15186 reloc_inplace
= true;
15188 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
15190 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
15193 reloc_inplace
= true;
15195 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
15197 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15200 reloc_inplace
= true;
15204 static unsigned int prev_reloc
= 0;
15206 if (reloc_type
!= prev_reloc
)
15207 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
15208 reloc_type
, printable_section_name (filedata
, section
));
15209 prev_reloc
= reloc_type
;
15213 rloc
= start
+ rp
->r_offset
;
15214 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
15216 warn (_("skipping invalid relocation offset %#" PRIx64
15217 " in section %s\n"),
15219 printable_section_name (filedata
, section
));
15223 sym_index
= get_reloc_symindex (rp
->r_info
);
15224 if (sym_index
>= num_syms
)
15226 warn (_("skipping invalid relocation symbol index %#" PRIx64
15227 " in section %s\n"),
15228 sym_index
, printable_section_name (filedata
, section
));
15231 sym
= symtab
+ sym_index
;
15233 /* If the reloc has a symbol associated with it,
15234 make sure that it is of an appropriate type.
15236 Relocations against symbols without type can happen.
15237 Gcc -feliminate-dwarf2-dups may generate symbols
15238 without type for debug info.
15240 Icc generates relocations against function symbols
15241 instead of local labels.
15243 Relocations against object symbols can happen, eg when
15244 referencing a global array. For an example of this see
15245 the _clz.o binary in libgcc.a. */
15247 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
15248 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
15250 warn (_("skipping unexpected symbol type %s in section %s relocation %tu\n"),
15251 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
15252 printable_section_name (filedata
, relsec
),
15259 addend
+= rp
->r_addend
;
15260 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
15261 partial_inplace. */
15263 || (filedata
->file_header
.e_machine
== EM_XTENSA
15264 && reloc_type
== 1)
15265 || ((filedata
->file_header
.e_machine
== EM_PJ
15266 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
15267 && reloc_type
== 1)
15268 || ((filedata
->file_header
.e_machine
== EM_D30V
15269 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
15270 && reloc_type
== 12)
15273 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15274 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
15276 addend
+= byte_get (rloc
, reloc_size
);
15279 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
15280 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15282 /* On HPPA, all pc-relative relocations are biased by 8. */
15283 if (filedata
->file_header
.e_machine
== EM_PARISC
)
15285 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
15288 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
15289 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
)
15290 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15292 if (reloc_subtract
)
15293 addend
-= sym
->st_value
;
15295 addend
+= sym
->st_value
;
15296 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
15297 byte_put (rloc
, addend
, reloc_size
);
15299 else if (reloc_subtract
)
15300 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
15302 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
15306 /* Let the target specific reloc processing code know that
15307 we have finished with these relocs. */
15308 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
15312 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
15313 * num_relocs_return
= num_relocs
;
15324 #ifdef SUPPORT_DISASSEMBLY
15326 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15328 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
15330 /* FIXME: XXX -- to be done --- XXX */
15336 /* Reads in the contents of SECTION from FILE, returning a pointer
15337 to a malloc'ed buffer or NULL if something went wrong. */
15340 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15342 uint64_t num_bytes
= section
->sh_size
;
15344 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
15346 printf (_("Section '%s' has no data to dump.\n"),
15347 printable_section_name (filedata
, section
));
15351 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
15352 _("section contents"));
15355 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
15358 uncompress_section_contents (bool is_zstd
,
15359 unsigned char ** buffer
,
15360 uint64_t uncompressed_size
,
15362 uint64_t file_size
)
15364 uint64_t compressed_size
= *size
;
15365 unsigned char *compressed_buffer
= *buffer
;
15366 unsigned char *uncompressed_buffer
= NULL
;
15370 /* Similar to _bfd_section_size_insane() in the BFD library we expect an
15371 upper limit of ~10x compression. Any compression larger than that is
15372 thought to be due to fuzzing of the compression header. */
15373 if (uncompressed_size
> file_size
* 10)
15375 error (_("Uncompressed section size is suspiciously large: 0x%" PRIu64
"\n"),
15376 uncompressed_size
);
15380 uncompressed_buffer
= xmalloc (uncompressed_size
);
15385 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
15386 compressed_buffer
, compressed_size
);
15387 if (ZSTD_isError (ret
))
15393 /* It is possible the section consists of several compressed
15394 buffers concatenated together, so we uncompress in a loop. */
15395 /* PR 18313: The state field in the z_stream structure is supposed
15396 to be invisible to the user (ie us), but some compilers will
15397 still complain about it being used without initialisation. So
15398 we first zero the entire z_stream structure and then set the fields
15400 memset (&strm
, 0, sizeof strm
);
15401 strm
.avail_in
= compressed_size
;
15402 strm
.next_in
= (Bytef
*)compressed_buffer
;
15403 strm
.avail_out
= uncompressed_size
;
15405 rc
= inflateInit (&strm
);
15406 while (strm
.avail_in
> 0)
15410 strm
.next_out
= ((Bytef
*)uncompressed_buffer
15411 + (uncompressed_size
- strm
.avail_out
));
15412 rc
= inflate (&strm
, Z_FINISH
);
15413 if (rc
!= Z_STREAM_END
)
15415 rc
= inflateReset (&strm
);
15417 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
15421 *buffer
= uncompressed_buffer
;
15422 *size
= uncompressed_size
;
15426 free (uncompressed_buffer
);
15427 /* Indicate decompression failure. */
15433 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15435 Elf_Internal_Shdr
*relsec
;
15436 uint64_t num_bytes
;
15437 unsigned char *data
;
15438 unsigned char *end
;
15439 unsigned char *real_start
;
15440 unsigned char *start
;
15441 bool some_strings_shown
;
15443 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15445 /* PR 21820: Do not fail if the section was empty. */
15446 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15448 num_bytes
= section
->sh_size
;
15450 if (filedata
->is_separate
)
15451 printf (_("\nString dump of section '%s' in linked file %s:\n"),
15452 printable_section_name (filedata
, section
),
15453 filedata
->file_name
);
15455 printf (_("\nString dump of section '%s':\n"),
15456 printable_section_name (filedata
, section
));
15458 if (decompress_dumps
)
15460 uint64_t new_size
= num_bytes
;
15461 uint64_t uncompressed_size
= 0;
15462 bool is_zstd
= false;
15464 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15466 Elf_Internal_Chdr chdr
;
15467 unsigned int compression_header_size
15468 = get_compression_header (& chdr
, (unsigned char *) start
,
15470 if (compression_header_size
== 0)
15471 /* An error message will have already been generated
15472 by get_compression_header. */
15475 if (chdr
.ch_type
== ch_compress_zlib
)
15478 else if (chdr
.ch_type
== ch_compress_zstd
)
15483 warn (_("section '%s' has unsupported compress type: %d\n"),
15484 printable_section_name (filedata
, section
), chdr
.ch_type
);
15487 uncompressed_size
= chdr
.ch_size
;
15488 start
+= compression_header_size
;
15489 new_size
-= compression_header_size
;
15491 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15493 /* Read the zlib header. In this case, it should be "ZLIB"
15494 followed by the uncompressed section size, 8 bytes in
15495 big-endian order. */
15496 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15497 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15498 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15499 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15500 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15501 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15502 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15503 uncompressed_size
+= start
[11];
15508 if (uncompressed_size
)
15510 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15511 &new_size
, filedata
->file_size
))
15512 num_bytes
= new_size
;
15515 error (_("Unable to decompress section %s\n"),
15516 printable_section_name (filedata
, section
));
15521 start
= real_start
;
15524 /* If the section being dumped has relocations against it the user might
15525 be expecting these relocations to have been applied. Check for this
15526 case and issue a warning message in order to avoid confusion.
15527 FIXME: Maybe we ought to have an option that dumps a section with
15528 relocs applied ? */
15529 for (relsec
= filedata
->section_headers
;
15530 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15533 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15534 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15535 || filedata
->section_headers
+ relsec
->sh_info
!= section
15536 || relsec
->sh_size
== 0
15537 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15540 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15545 end
= start
+ num_bytes
;
15546 some_strings_shown
= false;
15548 #ifdef HAVE_MBSTATE_T
15550 /* Initialise the multibyte conversion state. */
15551 memset (& state
, 0, sizeof (state
));
15554 bool continuing
= false;
15558 while (!ISPRINT (* data
))
15559 if (++ data
>= end
)
15564 size_t maxlen
= end
- data
;
15569 continuing
= false;
15573 printf (" [%6tx] ", data
- start
);
15587 /* PR 25543: Treat new-lines as string-ending characters. */
15596 /* Do not print control characters directly as they can affect terminal
15597 settings. Such characters usually appear in the names generated
15598 by the assembler for local labels. */
15601 printf ("^%c", c
+ 0x40);
15603 else if (ISPRINT (c
))
15610 #ifdef HAVE_MBSTATE_T
15613 /* Let printf do the hard work of displaying multibyte characters. */
15614 printf ("%.1s", data
- 1);
15615 #ifdef HAVE_MBSTATE_T
15616 /* Try to find out how many bytes made up the character that was
15617 just printed. Advance the symbol pointer past the bytes that
15619 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
15623 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
15633 printf (_("<corrupt>\n"));
15636 some_strings_shown
= true;
15640 if (! some_strings_shown
)
15641 printf (_(" No strings found in this section."));
15654 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
15655 Filedata
*filedata
,
15658 Elf_Internal_Shdr
*relsec
;
15660 uint64_t section_size
;
15662 unsigned char *data
;
15663 unsigned char *real_start
;
15664 unsigned char *start
;
15666 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15668 /* PR 21820: Do not fail if the section was empty. */
15669 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15671 section_size
= section
->sh_size
;
15673 if (filedata
->is_separate
)
15674 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
15675 printable_section_name (filedata
, section
),
15676 filedata
->file_name
);
15678 printf (_("\nHex dump of section '%s':\n"),
15679 printable_section_name (filedata
, section
));
15681 if (decompress_dumps
)
15683 uint64_t new_size
= section_size
;
15684 uint64_t uncompressed_size
= 0;
15685 bool is_zstd
= false;
15687 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15689 Elf_Internal_Chdr chdr
;
15690 unsigned int compression_header_size
15691 = get_compression_header (& chdr
, start
, section_size
);
15693 if (compression_header_size
== 0)
15694 /* An error message will have already been generated
15695 by get_compression_header. */
15698 if (chdr
.ch_type
== ch_compress_zlib
)
15701 else if (chdr
.ch_type
== ch_compress_zstd
)
15706 warn (_("section '%s' has unsupported compress type: %d\n"),
15707 printable_section_name (filedata
, section
), chdr
.ch_type
);
15710 uncompressed_size
= chdr
.ch_size
;
15711 start
+= compression_header_size
;
15712 new_size
-= compression_header_size
;
15714 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15716 /* Read the zlib header. In this case, it should be "ZLIB"
15717 followed by the uncompressed section size, 8 bytes in
15718 big-endian order. */
15719 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15720 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15721 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15722 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15723 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15724 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15725 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15726 uncompressed_size
+= start
[11];
15731 if (uncompressed_size
)
15733 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15734 &new_size
, filedata
->file_size
))
15736 section_size
= new_size
;
15740 error (_("Unable to decompress section %s\n"),
15741 printable_section_name (filedata
, section
));
15742 /* FIXME: Print the section anyway ? */
15747 start
= real_start
;
15752 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
15757 /* If the section being dumped has relocations against it the user might
15758 be expecting these relocations to have been applied. Check for this
15759 case and issue a warning message in order to avoid confusion.
15760 FIXME: Maybe we ought to have an option that dumps a section with
15761 relocs applied ? */
15762 for (relsec
= filedata
->section_headers
;
15763 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15766 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15767 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15768 || filedata
->section_headers
+ relsec
->sh_info
!= section
15769 || relsec
->sh_size
== 0
15770 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15773 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15778 addr
= section
->sh_addr
;
15779 bytes
= section_size
;
15788 lbytes
= (bytes
> 16 ? 16 : bytes
);
15790 printf (" 0x%8.8" PRIx64
" ", addr
);
15792 for (j
= 0; j
< 16; j
++)
15795 printf ("%2.2x", data
[j
]);
15803 for (j
= 0; j
< lbytes
; j
++)
15806 if (k
>= ' ' && k
< 0x7f)
15829 #ifdef ENABLE_LIBCTF
15830 static ctf_sect_t
*
15831 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
15833 buf
->cts_name
= section_name_print (filedata
, shdr
);
15834 buf
->cts_size
= shdr
->sh_size
;
15835 buf
->cts_entsize
= shdr
->sh_entsize
;
15840 /* Formatting callback function passed to ctf_dump. Returns either the pointer
15841 it is passed, or a pointer to newly-allocated storage, in which case
15842 dump_ctf() will free it when it no longer needs it. */
15845 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
15846 char *s
, void *arg
)
15848 const char *blanks
= arg
;
15851 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
15856 /* Dump CTF errors/warnings. */
15858 dump_ctf_errs (ctf_dict_t
*fp
)
15860 ctf_next_t
*it
= NULL
;
15865 /* Dump accumulated errors and warnings. */
15866 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15868 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15872 if (err
!= ECTF_NEXT_END
)
15873 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15876 /* Dump one CTF archive member. */
15879 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
15882 const char *things
[] = {"Header", "Labels", "Data objects",
15883 "Function objects", "Variables", "Types", "Strings",
15885 const char **thing
;
15888 /* Don't print out the name of the default-named archive member if it appears
15889 first in the list. The name .ctf appears everywhere, even for things that
15890 aren't really archives, so printing it out is liable to be confusing; also,
15891 the common case by far is for only one archive member to exist, and hiding
15892 it in that case seems worthwhile. */
15894 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
15895 printf (_("\nCTF archive member: %s:\n"), name
);
15897 if (ctf_parent_name (ctf
) != NULL
)
15898 ctf_import (ctf
, parent
);
15900 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15902 ctf_dump_state_t
*s
= NULL
;
15905 printf ("\n %s:\n", *thing
);
15906 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15907 (void *) " ")) != NULL
)
15909 printf ("%s\n", item
);
15913 if (ctf_errno (ctf
))
15915 error (_("Iteration failed: %s, %s\n"), *thing
,
15916 ctf_errmsg (ctf_errno (ctf
)));
15921 dump_ctf_errs (ctf
);
15925 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15927 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15928 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15929 void * data
= NULL
;
15930 void * symdata
= NULL
;
15931 void * strdata
= NULL
;
15932 ctf_sect_t ctfsect
, symsect
, strsect
;
15933 ctf_sect_t
* symsectp
= NULL
;
15934 ctf_sect_t
* strsectp
= NULL
;
15935 ctf_archive_t
* ctfa
= NULL
;
15936 ctf_dict_t
* parent
= NULL
;
15939 ctf_next_t
*i
= NULL
;
15945 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15946 data
= get_section_contents (section
, filedata
);
15947 ctfsect
.cts_data
= data
;
15949 if (!dump_ctf_symtab_name
)
15950 dump_ctf_symtab_name
= strdup (".dynsym");
15952 if (!dump_ctf_strtab_name
)
15953 dump_ctf_strtab_name
= strdup (".dynstr");
15955 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15957 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15959 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15962 if ((symdata
= (void *) get_data (NULL
, filedata
,
15963 symtab_sec
->sh_offset
, 1,
15964 symtab_sec
->sh_size
,
15965 _("symbols"))) == NULL
)
15967 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15968 symsect
.cts_data
= symdata
;
15971 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15973 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15975 error (_("No string table section named %s\n"),
15976 dump_ctf_strtab_name
);
15979 if ((strdata
= (void *) get_data (NULL
, filedata
,
15980 strtab_sec
->sh_offset
, 1,
15981 strtab_sec
->sh_size
,
15982 _("strings"))) == NULL
)
15984 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15985 strsect
.cts_data
= strdata
;
15988 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15989 libctf papers over the difference, so we can pretend it is always an
15992 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15994 dump_ctf_errs (NULL
);
15995 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15999 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
16002 /* Preload the parent dict, since it will need to be imported into every
16004 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
16006 dump_ctf_errs (NULL
);
16007 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16013 if (filedata
->is_separate
)
16014 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
16015 printable_section_name (filedata
, section
),
16016 filedata
->file_name
);
16018 printf (_("\nDump of CTF section '%s':\n"),
16019 printable_section_name (filedata
, section
));
16021 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
16022 dump_ctf_archive_member (fp
, name
, parent
, member
++);
16023 if (err
!= ECTF_NEXT_END
)
16025 dump_ctf_errs (NULL
);
16026 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
16031 ctf_dict_close (parent
);
16041 dump_section_as_sframe (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16043 void * data
= NULL
;
16044 sframe_decoder_ctx
*sfd_ctx
= NULL
;
16045 const char *print_name
= printable_section_name (filedata
, section
);
16051 if (strcmp (print_name
, "") == 0)
16053 error (_("Section name must be provided \n"));
16058 data
= get_section_contents (section
, filedata
);
16059 sf_size
= section
->sh_size
;
16060 /* Decode the contents of the section. */
16061 sfd_ctx
= sframe_decode ((const char*)data
, sf_size
, &err
);
16065 error (_("SFrame decode failure: %s\n"), sframe_errmsg (err
));
16069 printf (_("Contents of the SFrame section %s:"), print_name
);
16070 /* Dump the contents as text. */
16071 dump_sframe (sfd_ctx
, section
->sh_addr
);
16079 load_specific_debug_section (enum dwarf_section_display_enum debug
,
16080 const Elf_Internal_Shdr
* sec
,
16083 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16085 Filedata
* filedata
= (Filedata
*) data
;
16087 if (section
->start
!= NULL
)
16089 /* If it is already loaded, do nothing. */
16090 if (streq (section
->filename
, filedata
->file_name
))
16092 free (section
->start
);
16095 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
16096 section
->address
= sec
->sh_addr
;
16097 section
->filename
= filedata
->file_name
;
16098 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
16100 sec
->sh_size
, buf
);
16101 if (section
->start
== NULL
)
16105 unsigned char *start
= section
->start
;
16106 uint64_t size
= sec
->sh_size
;
16107 uint64_t uncompressed_size
= 0;
16108 bool is_zstd
= false;
16110 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
16112 Elf_Internal_Chdr chdr
;
16113 unsigned int compression_header_size
;
16115 if (size
< (is_32bit_elf
16116 ? sizeof (Elf32_External_Chdr
)
16117 : sizeof (Elf64_External_Chdr
)))
16119 warn (_("compressed section %s is too small to contain a compression header\n"),
16124 compression_header_size
= get_compression_header (&chdr
, start
, size
);
16125 if (compression_header_size
== 0)
16126 /* An error message will have already been generated
16127 by get_compression_header. */
16130 if (chdr
.ch_type
== ch_compress_zlib
)
16133 else if (chdr
.ch_type
== ch_compress_zstd
)
16138 warn (_("section '%s' has unsupported compress type: %d\n"),
16139 section
->name
, chdr
.ch_type
);
16142 uncompressed_size
= chdr
.ch_size
;
16143 start
+= compression_header_size
;
16144 size
-= compression_header_size
;
16146 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
16148 /* Read the zlib header. In this case, it should be "ZLIB"
16149 followed by the uncompressed section size, 8 bytes in
16150 big-endian order. */
16151 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16152 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16153 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16154 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16155 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16156 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16157 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16158 uncompressed_size
+= start
[11];
16163 if (uncompressed_size
)
16165 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16166 &size
, filedata
->file_size
))
16168 /* Free the compressed buffer, update the section buffer
16169 and the section size if uncompress is successful. */
16170 free (section
->start
);
16171 section
->start
= start
;
16175 error (_("Unable to decompress section %s\n"),
16176 printable_section_name (filedata
, sec
));
16181 section
->size
= size
;
16184 if (section
->start
== NULL
)
16187 if (debug_displays
[debug
].relocate
)
16189 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
16190 & section
->reloc_info
, & section
->num_relocs
))
16195 section
->reloc_info
= NULL
;
16196 section
->num_relocs
= 0;
16202 #if HAVE_LIBDEBUGINFOD
16203 /* Return a hex string representation of the build-id. */
16205 get_build_id (void * data
)
16207 Filedata
* filedata
= (Filedata
*) data
;
16208 Elf_Internal_Shdr
* shdr
;
16211 /* Iterate through notes to find note.gnu.build-id.
16212 FIXME: Only the first note in any note section is examined. */
16213 for (i
= 0, shdr
= filedata
->section_headers
;
16214 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
16217 if (shdr
->sh_type
!= SHT_NOTE
)
16222 size_t data_remaining
;
16224 Elf_External_Note
* enote
;
16225 Elf_Internal_Note inote
;
16227 uint64_t offset
= shdr
->sh_offset
;
16228 uint64_t align
= shdr
->sh_addralign
;
16229 uint64_t length
= shdr
->sh_size
;
16231 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16237 else if (align
!= 4 && align
!= 8)
16243 end
= (char *) enote
+ length
;
16244 data_remaining
= end
- (char *) enote
;
16246 if (!is_ia64_vms (filedata
))
16248 min_notesz
= offsetof (Elf_External_Note
, name
);
16249 if (data_remaining
< min_notesz
)
16252 malformed note encountered in section %s whilst scanning for build-id note\n"),
16253 printable_section_name (filedata
, shdr
));
16257 data_remaining
-= min_notesz
;
16259 inote
.type
= BYTE_GET (enote
->type
);
16260 inote
.namesz
= BYTE_GET (enote
->namesz
);
16261 inote
.namedata
= enote
->name
;
16262 inote
.descsz
= BYTE_GET (enote
->descsz
);
16263 inote
.descdata
= ((char *) enote
16264 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
16265 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16266 next
= ((char *) enote
16267 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
16271 Elf64_External_VMS_Note
*vms_enote
;
16273 /* PR binutils/15191
16274 Make sure that there is enough data to read. */
16275 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16276 if (data_remaining
< min_notesz
)
16279 malformed note encountered in section %s whilst scanning for build-id note\n"),
16280 printable_section_name (filedata
, shdr
));
16284 data_remaining
-= min_notesz
;
16286 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
16287 inote
.type
= BYTE_GET (vms_enote
->type
);
16288 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
16289 inote
.namedata
= vms_enote
->name
;
16290 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
16291 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16292 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16293 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16296 /* Skip malformed notes. */
16297 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
16298 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
16299 || (size_t) (next
- inote
.descdata
) < inote
.descsz
16300 || ((size_t) (next
- inote
.descdata
)
16301 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
16304 malformed note encountered in section %s whilst scanning for build-id note\n"),
16305 printable_section_name (filedata
, shdr
));
16310 /* Check if this is the build-id note. If so then convert the build-id
16311 bytes to a hex string. */
16312 if (inote
.namesz
> 0
16313 && startswith (inote
.namedata
, "GNU")
16314 && inote
.type
== NT_GNU_BUILD_ID
)
16319 build_id
= malloc (inote
.descsz
* 2 + 1);
16320 if (build_id
== NULL
)
16326 for (j
= 0; j
< inote
.descsz
; ++j
)
16327 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
16328 build_id
[inote
.descsz
* 2] = '\0';
16331 return (unsigned char *) build_id
;
16338 #endif /* HAVE_LIBDEBUGINFOD */
16340 /* If this is not NULL, load_debug_section will only look for sections
16341 within the list of sections given here. */
16342 static unsigned int * section_subset
= NULL
;
16345 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
16347 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16348 Elf_Internal_Shdr
* sec
;
16349 Filedata
* filedata
= (Filedata
*) data
;
16351 if (!dump_any_debugging
)
16354 /* Without section headers we cannot find any sections. */
16355 if (filedata
->section_headers
== NULL
)
16358 if (filedata
->string_table
== NULL
16359 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
16360 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
16362 Elf_Internal_Shdr
* strs
;
16364 /* Read in the string table, so that we have section names to scan. */
16365 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
16367 if (strs
!= NULL
&& strs
->sh_size
!= 0)
16369 filedata
->string_table
16370 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
16371 1, strs
->sh_size
, _("string table"));
16373 filedata
->string_table_length
16374 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
16378 /* Locate the debug section. */
16379 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
16381 section
->name
= section
->uncompressed_name
;
16384 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
16386 section
->name
= section
->compressed_name
;
16391 /* If we're loading from a subset of sections, and we've loaded
16392 a section matching this name before, it's likely that it's a
16394 if (section_subset
!= NULL
)
16395 free_debug_section (debug
);
16397 return load_specific_debug_section (debug
, sec
, data
);
16401 free_debug_section (enum dwarf_section_display_enum debug
)
16403 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16405 if (section
->start
== NULL
)
16408 free ((char *) section
->start
);
16409 section
->start
= NULL
;
16410 section
->address
= 0;
16413 free (section
->reloc_info
);
16414 section
->reloc_info
= NULL
;
16415 section
->num_relocs
= 0;
16419 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16421 const char *name
= (section_name_valid (filedata
, section
)
16422 ? section_name (filedata
, section
) : "");
16423 const char *print_name
= printable_section_name (filedata
, section
);
16425 bool result
= true;
16428 length
= section
->sh_size
;
16431 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
16434 if (section
->sh_type
== SHT_NOBITS
)
16436 /* There is no point in dumping the contents of a debugging section
16437 which has the NOBITS type - the bits in the file will be random.
16438 This can happen when a file containing a .eh_frame section is
16439 stripped with the --only-keep-debug command line option. */
16440 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
16445 if (startswith (name
, ".gnu.linkonce.wi."))
16446 name
= ".debug_info";
16448 /* See if we know how to display the contents of this section. */
16449 for (i
= 0; i
< max
; i
++)
16451 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
16452 struct dwarf_section_display
* display
= debug_displays
+ i
;
16453 struct dwarf_section
* sec
= & display
->section
;
16455 if (streq (sec
->uncompressed_name
, name
)
16456 || (id
== line
&& startswith (name
, ".debug_line."))
16457 || streq (sec
->compressed_name
, name
))
16459 bool secondary
= (section
!= find_section (filedata
, name
));
16462 free_debug_section (id
);
16464 if (i
== line
&& startswith (name
, ".debug_line."))
16466 else if (streq (sec
->uncompressed_name
, name
))
16467 sec
->name
= sec
->uncompressed_name
;
16469 sec
->name
= sec
->compressed_name
;
16471 if (load_specific_debug_section (id
, section
, filedata
))
16473 /* If this debug section is part of a CU/TU set in a .dwp file,
16474 restrict load_debug_section to the sections in that set. */
16475 section_subset
= find_cu_tu_set (filedata
, shndx
);
16477 result
&= display
->display (sec
, filedata
);
16479 section_subset
= NULL
;
16481 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
16482 free_debug_section (id
);
16490 printf (_("Unrecognized debug section: %s\n"), print_name
);
16497 /* Set DUMP_SECTS for all sections where dumps were requested
16498 based on section name. */
16501 initialise_dumps_byname (Filedata
* filedata
)
16503 struct dump_list_entry
* cur
;
16505 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
16510 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
16511 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
16512 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
16515 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
16519 if (!any
&& !filedata
->is_separate
)
16520 warn (_("Section '%s' was not dumped because it does not exist\n"),
16526 process_section_contents (Filedata
* filedata
)
16528 Elf_Internal_Shdr
* section
;
16535 initialise_dumps_byname (filedata
);
16537 for (i
= 0, section
= filedata
->section_headers
;
16538 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
16541 dump_type dump
= filedata
->dump
.dump_sects
[i
];
16543 if (filedata
->is_separate
&& ! process_links
)
16544 dump
&= DEBUG_DUMP
;
16546 #ifdef SUPPORT_DISASSEMBLY
16547 if (dump
& DISASS_DUMP
)
16549 if (! disassemble_section (section
, filedata
))
16553 if (dump
& HEX_DUMP
)
16555 if (! dump_section_as_bytes (section
, filedata
, false))
16559 if (dump
& RELOC_DUMP
)
16561 if (! dump_section_as_bytes (section
, filedata
, true))
16565 if (dump
& STRING_DUMP
)
16567 if (! dump_section_as_strings (section
, filedata
))
16571 if (dump
& DEBUG_DUMP
)
16573 if (! display_debug_section (i
, section
, filedata
))
16577 #ifdef ENABLE_LIBCTF
16578 if (dump
& CTF_DUMP
)
16580 if (! dump_section_as_ctf (section
, filedata
))
16584 if (dump
& SFRAME_DUMP
)
16586 if (! dump_section_as_sframe (section
, filedata
))
16591 if (! filedata
->is_separate
)
16593 /* Check to see if the user requested a
16594 dump of a section that does not exist. */
16595 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
16596 if (filedata
->dump
.dump_sects
[i
])
16598 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
16607 process_mips_fpe_exception (int mask
)
16613 if (mask
& OEX_FPU_INEX
)
16614 fputs ("INEX", stdout
), first
= false;
16615 if (mask
& OEX_FPU_UFLO
)
16616 printf ("%sUFLO", first
? "" : "|"), first
= false;
16617 if (mask
& OEX_FPU_OFLO
)
16618 printf ("%sOFLO", first
? "" : "|"), first
= false;
16619 if (mask
& OEX_FPU_DIV0
)
16620 printf ("%sDIV0", first
? "" : "|"), first
= false;
16621 if (mask
& OEX_FPU_INVAL
)
16622 printf ("%sINVAL", first
? "" : "|");
16625 fputs ("0", stdout
);
16628 /* Display's the value of TAG at location P. If TAG is
16629 greater than 0 it is assumed to be an unknown tag, and
16630 a message is printed to this effect. Otherwise it is
16631 assumed that a message has already been printed.
16633 If the bottom bit of TAG is set it assumed to have a
16634 string value, otherwise it is assumed to have an integer
16637 Returns an updated P pointing to the first unread byte
16638 beyond the end of TAG's value.
16640 Reads at or beyond END will not be made. */
16642 static unsigned char *
16643 display_tag_value (signed int tag
,
16645 const unsigned char * const end
)
16650 printf (" Tag_unknown_%d: ", tag
);
16654 warn (_("<corrupt tag>\n"));
16658 /* PR 17531 file: 027-19978-0.004. */
16659 size_t maxlen
= (end
- p
) - 1;
16664 print_symbol ((int) maxlen
, (const char *) p
);
16665 p
+= strnlen ((char *) p
, maxlen
) + 1;
16669 printf (_("<corrupt string tag>"));
16670 p
= (unsigned char *) end
;
16676 READ_ULEB (val
, p
, end
);
16677 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
16684 /* ARC ABI attributes section. */
16686 static unsigned char *
16687 display_arc_attribute (unsigned char * p
,
16688 const unsigned char * const end
)
16693 READ_ULEB (tag
, p
, end
);
16697 case Tag_ARC_PCS_config
:
16698 READ_ULEB (val
, p
, end
);
16699 printf (" Tag_ARC_PCS_config: ");
16703 printf (_("Absent/Non standard\n"));
16706 printf (_("Bare metal/mwdt\n"));
16709 printf (_("Bare metal/newlib\n"));
16712 printf (_("Linux/uclibc\n"));
16715 printf (_("Linux/glibc\n"));
16718 printf (_("Unknown\n"));
16723 case Tag_ARC_CPU_base
:
16724 READ_ULEB (val
, p
, end
);
16725 printf (" Tag_ARC_CPU_base: ");
16730 printf (_("Absent\n"));
16732 case TAG_CPU_ARC6xx
:
16733 printf ("ARC6xx\n");
16735 case TAG_CPU_ARC7xx
:
16736 printf ("ARC7xx\n");
16738 case TAG_CPU_ARCEM
:
16739 printf ("ARCEM\n");
16741 case TAG_CPU_ARCHS
:
16742 printf ("ARCHS\n");
16747 case Tag_ARC_CPU_variation
:
16748 READ_ULEB (val
, p
, end
);
16749 printf (" Tag_ARC_CPU_variation: ");
16753 if (val
> 0 && val
< 16)
16754 printf ("Core%d\n", val
);
16756 printf ("Unknown\n");
16760 printf (_("Absent\n"));
16765 case Tag_ARC_CPU_name
:
16766 printf (" Tag_ARC_CPU_name: ");
16767 p
= display_tag_value (-1, p
, end
);
16770 case Tag_ARC_ABI_rf16
:
16771 READ_ULEB (val
, p
, end
);
16772 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
16775 case Tag_ARC_ABI_osver
:
16776 READ_ULEB (val
, p
, end
);
16777 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
16780 case Tag_ARC_ABI_pic
:
16781 case Tag_ARC_ABI_sda
:
16782 READ_ULEB (val
, p
, end
);
16783 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
16784 : " Tag_ARC_ABI_pic: ");
16788 printf (_("Absent\n"));
16797 printf (_("Unknown\n"));
16802 case Tag_ARC_ABI_tls
:
16803 READ_ULEB (val
, p
, end
);
16804 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
16807 case Tag_ARC_ABI_enumsize
:
16808 READ_ULEB (val
, p
, end
);
16809 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
16813 case Tag_ARC_ABI_exceptions
:
16814 READ_ULEB (val
, p
, end
);
16815 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
16819 case Tag_ARC_ABI_double_size
:
16820 READ_ULEB (val
, p
, end
);
16821 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
16824 case Tag_ARC_ISA_config
:
16825 printf (" Tag_ARC_ISA_config: ");
16826 p
= display_tag_value (-1, p
, end
);
16829 case Tag_ARC_ISA_apex
:
16830 printf (" Tag_ARC_ISA_apex: ");
16831 p
= display_tag_value (-1, p
, end
);
16834 case Tag_ARC_ISA_mpy_option
:
16835 READ_ULEB (val
, p
, end
);
16836 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
16839 case Tag_ARC_ATR_version
:
16840 READ_ULEB (val
, p
, end
);
16841 printf (" Tag_ARC_ATR_version: %d\n", val
);
16845 return display_tag_value (tag
& 1, p
, end
);
16851 /* ARM EABI attributes section. */
16856 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
16858 const char *const *table
;
16859 } arm_attr_public_tag
;
16861 static const char *const arm_attr_tag_CPU_arch
[] =
16862 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
16863 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
16864 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
16865 "v8.1-M.mainline", "v9"};
16866 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
16867 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
16868 {"No", "Thumb-1", "Thumb-2", "Yes"};
16869 static const char *const arm_attr_tag_FP_arch
[] =
16870 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
16871 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
16872 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
16873 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
16874 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
16875 "NEON for ARMv8.1"};
16876 static const char *const arm_attr_tag_PCS_config
[] =
16877 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
16878 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
16879 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
16880 {"V6", "SB", "TLS", "Unused"};
16881 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16882 {"Absolute", "PC-relative", "SB-relative", "None"};
16883 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16884 {"Absolute", "PC-relative", "None"};
16885 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16886 {"None", "direct", "GOT-indirect"};
16887 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16888 {"None", "??? 1", "2", "??? 3", "4"};
16889 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16890 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16891 {"Unused", "Needed", "Sign only"};
16892 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16893 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16894 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16895 {"Unused", "Finite", "RTABI", "IEEE 754"};
16896 static const char *const arm_attr_tag_ABI_enum_size
[] =
16897 {"Unused", "small", "int", "forced to int"};
16898 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16899 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16900 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16901 {"AAPCS", "VFP registers", "custom", "compatible"};
16902 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16903 {"AAPCS", "WMMX registers", "custom"};
16904 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16905 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16906 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16907 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16908 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16909 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16910 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16911 static const char *const arm_attr_tag_FP_HP_extension
[] =
16912 {"Not Allowed", "Allowed"};
16913 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16914 {"None", "IEEE 754", "Alternative Format"};
16915 static const char *const arm_attr_tag_DSP_extension
[] =
16916 {"Follow architecture", "Allowed"};
16917 static const char *const arm_attr_tag_MPextension_use
[] =
16918 {"Not Allowed", "Allowed"};
16919 static const char *const arm_attr_tag_DIV_use
[] =
16920 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16921 "Allowed in v7-A with integer division extension"};
16922 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16923 static const char *const arm_attr_tag_Virtualization_use
[] =
16924 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16925 "TrustZone and Virtualization Extensions"};
16926 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16927 {"Not Allowed", "Allowed"};
16929 static const char *const arm_attr_tag_MVE_arch
[] =
16930 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16932 static const char * arm_attr_tag_PAC_extension
[] =
16933 {"No PAC/AUT instructions",
16934 "PAC/AUT instructions permitted in the NOP space",
16935 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
16937 static const char * arm_attr_tag_BTI_extension
[] =
16938 {"BTI instructions not permitted",
16939 "BTI instructions permitted in the NOP space",
16940 "BTI instructions permitted in the NOP and in the non-NOP space"};
16942 static const char * arm_attr_tag_BTI_use
[] =
16943 {"Compiled without branch target enforcement",
16944 "Compiled with branch target enforcement"};
16946 static const char * arm_attr_tag_PACRET_use
[] =
16947 {"Compiled without return address signing and authentication",
16948 "Compiled with return address signing and authentication"};
16950 #define LOOKUP(id, name) \
16951 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16952 static arm_attr_public_tag arm_attr_public_tags
[] =
16954 {4, "CPU_raw_name", 1, NULL
},
16955 {5, "CPU_name", 1, NULL
},
16956 LOOKUP(6, CPU_arch
),
16957 {7, "CPU_arch_profile", 0, NULL
},
16958 LOOKUP(8, ARM_ISA_use
),
16959 LOOKUP(9, THUMB_ISA_use
),
16960 LOOKUP(10, FP_arch
),
16961 LOOKUP(11, WMMX_arch
),
16962 LOOKUP(12, Advanced_SIMD_arch
),
16963 LOOKUP(13, PCS_config
),
16964 LOOKUP(14, ABI_PCS_R9_use
),
16965 LOOKUP(15, ABI_PCS_RW_data
),
16966 LOOKUP(16, ABI_PCS_RO_data
),
16967 LOOKUP(17, ABI_PCS_GOT_use
),
16968 LOOKUP(18, ABI_PCS_wchar_t
),
16969 LOOKUP(19, ABI_FP_rounding
),
16970 LOOKUP(20, ABI_FP_denormal
),
16971 LOOKUP(21, ABI_FP_exceptions
),
16972 LOOKUP(22, ABI_FP_user_exceptions
),
16973 LOOKUP(23, ABI_FP_number_model
),
16974 {24, "ABI_align_needed", 0, NULL
},
16975 {25, "ABI_align_preserved", 0, NULL
},
16976 LOOKUP(26, ABI_enum_size
),
16977 LOOKUP(27, ABI_HardFP_use
),
16978 LOOKUP(28, ABI_VFP_args
),
16979 LOOKUP(29, ABI_WMMX_args
),
16980 LOOKUP(30, ABI_optimization_goals
),
16981 LOOKUP(31, ABI_FP_optimization_goals
),
16982 {32, "compatibility", 0, NULL
},
16983 LOOKUP(34, CPU_unaligned_access
),
16984 LOOKUP(36, FP_HP_extension
),
16985 LOOKUP(38, ABI_FP_16bit_format
),
16986 LOOKUP(42, MPextension_use
),
16987 LOOKUP(44, DIV_use
),
16988 LOOKUP(46, DSP_extension
),
16989 LOOKUP(48, MVE_arch
),
16990 LOOKUP(50, PAC_extension
),
16991 LOOKUP(52, BTI_extension
),
16992 LOOKUP(74, BTI_use
),
16993 LOOKUP(76, PACRET_use
),
16994 {64, "nodefaults", 0, NULL
},
16995 {65, "also_compatible_with", 0, NULL
},
16996 LOOKUP(66, T2EE_use
),
16997 {67, "conformance", 1, NULL
},
16998 LOOKUP(68, Virtualization_use
),
16999 LOOKUP(70, MPextension_use_legacy
)
17003 static unsigned char *
17004 display_arm_attribute (unsigned char * p
,
17005 const unsigned char * const end
)
17009 arm_attr_public_tag
* attr
;
17013 READ_ULEB (tag
, p
, end
);
17015 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
17017 if (arm_attr_public_tags
[i
].tag
== tag
)
17019 attr
= &arm_attr_public_tags
[i
];
17026 printf (" Tag_%s: ", attr
->name
);
17027 switch (attr
->type
)
17032 case 7: /* Tag_CPU_arch_profile. */
17033 READ_ULEB (val
, p
, end
);
17036 case 0: printf (_("None\n")); break;
17037 case 'A': printf (_("Application\n")); break;
17038 case 'R': printf (_("Realtime\n")); break;
17039 case 'M': printf (_("Microcontroller\n")); break;
17040 case 'S': printf (_("Application or Realtime\n")); break;
17041 default: printf ("??? (%d)\n", val
); break;
17045 case 24: /* Tag_align_needed. */
17046 READ_ULEB (val
, p
, end
);
17049 case 0: printf (_("None\n")); break;
17050 case 1: printf (_("8-byte\n")); break;
17051 case 2: printf (_("4-byte\n")); break;
17052 case 3: printf ("??? 3\n"); break;
17055 printf (_("8-byte and up to %d-byte extended\n"),
17058 printf ("??? (%d)\n", val
);
17063 case 25: /* Tag_align_preserved. */
17064 READ_ULEB (val
, p
, end
);
17067 case 0: printf (_("None\n")); break;
17068 case 1: printf (_("8-byte, except leaf SP\n")); break;
17069 case 2: printf (_("8-byte\n")); break;
17070 case 3: printf ("??? 3\n"); break;
17073 printf (_("8-byte and up to %d-byte extended\n"),
17076 printf ("??? (%d)\n", val
);
17081 case 32: /* Tag_compatibility. */
17083 READ_ULEB (val
, p
, end
);
17084 printf (_("flag = %d, vendor = "), val
);
17087 size_t maxlen
= (end
- p
) - 1;
17089 print_symbol ((int) maxlen
, (const char *) p
);
17090 p
+= strnlen ((char *) p
, maxlen
) + 1;
17094 printf (_("<corrupt>"));
17095 p
= (unsigned char *) end
;
17101 case 64: /* Tag_nodefaults. */
17102 /* PR 17531: file: 001-505008-0.01. */
17105 printf (_("True\n"));
17108 case 65: /* Tag_also_compatible_with. */
17109 READ_ULEB (val
, p
, end
);
17110 if (val
== 6 /* Tag_CPU_arch. */)
17112 READ_ULEB (val
, p
, end
);
17113 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
17114 printf ("??? (%d)\n", val
);
17116 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
17120 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
17125 printf (_("<unknown: %d>\n"), tag
);
17131 return display_tag_value (-1, p
, end
);
17133 return display_tag_value (0, p
, end
);
17136 assert (attr
->type
& 0x80);
17137 READ_ULEB (val
, p
, end
);
17138 type
= attr
->type
& 0x7f;
17140 printf ("??? (%d)\n", val
);
17142 printf ("%s\n", attr
->table
[val
]);
17147 return display_tag_value (tag
, p
, end
);
17150 static unsigned char *
17151 display_gnu_attribute (unsigned char * p
,
17152 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
17153 const unsigned char * const end
)
17158 READ_ULEB (tag
, p
, end
);
17160 /* Tag_compatibility is the only generic GNU attribute defined at
17164 READ_ULEB (val
, p
, end
);
17166 printf (_("flag = %d, vendor = "), val
);
17169 printf (_("<corrupt>\n"));
17170 warn (_("corrupt vendor attribute\n"));
17176 size_t maxlen
= (end
- p
) - 1;
17178 print_symbol ((int) maxlen
, (const char *) p
);
17179 p
+= strnlen ((char *) p
, maxlen
) + 1;
17183 printf (_("<corrupt>"));
17184 p
= (unsigned char *) end
;
17191 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
17192 return display_proc_gnu_attribute (p
, tag
, end
);
17194 return display_tag_value (tag
, p
, end
);
17197 static unsigned char *
17198 display_m68k_gnu_attribute (unsigned char * p
,
17200 const unsigned char * const end
)
17204 if (tag
== Tag_GNU_M68K_ABI_FP
)
17206 printf (" Tag_GNU_M68K_ABI_FP: ");
17209 printf (_("<corrupt>\n"));
17212 READ_ULEB (val
, p
, end
);
17215 printf ("(%#x), ", val
);
17220 printf (_("unspecified hard/soft float\n"));
17223 printf (_("hard float\n"));
17226 printf (_("soft float\n"));
17232 return display_tag_value (tag
& 1, p
, end
);
17235 static unsigned char *
17236 display_power_gnu_attribute (unsigned char * p
,
17238 const unsigned char * const end
)
17242 if (tag
== Tag_GNU_Power_ABI_FP
)
17244 printf (" Tag_GNU_Power_ABI_FP: ");
17247 printf (_("<corrupt>\n"));
17250 READ_ULEB (val
, p
, end
);
17253 printf ("(%#x), ", val
);
17258 printf (_("unspecified hard/soft float, "));
17261 printf (_("hard float, "));
17264 printf (_("soft float, "));
17267 printf (_("single-precision hard float, "));
17274 printf (_("unspecified long double\n"));
17277 printf (_("128-bit IBM long double\n"));
17280 printf (_("64-bit long double\n"));
17283 printf (_("128-bit IEEE long double\n"));
17289 if (tag
== Tag_GNU_Power_ABI_Vector
)
17291 printf (" Tag_GNU_Power_ABI_Vector: ");
17294 printf (_("<corrupt>\n"));
17297 READ_ULEB (val
, p
, end
);
17300 printf ("(%#x), ", val
);
17305 printf (_("unspecified\n"));
17308 printf (_("generic\n"));
17311 printf ("AltiVec\n");
17320 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
17322 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
17325 printf (_("<corrupt>\n"));
17328 READ_ULEB (val
, p
, end
);
17331 printf ("(%#x), ", val
);
17336 printf (_("unspecified\n"));
17339 printf ("r3/r4\n");
17342 printf (_("memory\n"));
17351 return display_tag_value (tag
& 1, p
, end
);
17354 static unsigned char *
17355 display_s390_gnu_attribute (unsigned char * p
,
17357 const unsigned char * const end
)
17361 if (tag
== Tag_GNU_S390_ABI_Vector
)
17363 printf (" Tag_GNU_S390_ABI_Vector: ");
17364 READ_ULEB (val
, p
, end
);
17369 printf (_("any\n"));
17372 printf (_("software\n"));
17375 printf (_("hardware\n"));
17378 printf ("??? (%d)\n", val
);
17384 return display_tag_value (tag
& 1, p
, end
);
17388 display_sparc_hwcaps (unsigned int mask
)
17394 if (mask
& ELF_SPARC_HWCAP_MUL32
)
17395 fputs ("mul32", stdout
), first
= false;
17396 if (mask
& ELF_SPARC_HWCAP_DIV32
)
17397 printf ("%sdiv32", first
? "" : "|"), first
= false;
17398 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
17399 printf ("%sfsmuld", first
? "" : "|"), first
= false;
17400 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
17401 printf ("%sv8plus", first
? "" : "|"), first
= false;
17402 if (mask
& ELF_SPARC_HWCAP_POPC
)
17403 printf ("%spopc", first
? "" : "|"), first
= false;
17404 if (mask
& ELF_SPARC_HWCAP_VIS
)
17405 printf ("%svis", first
? "" : "|"), first
= false;
17406 if (mask
& ELF_SPARC_HWCAP_VIS2
)
17407 printf ("%svis2", first
? "" : "|"), first
= false;
17408 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
17409 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
17410 if (mask
& ELF_SPARC_HWCAP_FMAF
)
17411 printf ("%sfmaf", first
? "" : "|"), first
= false;
17412 if (mask
& ELF_SPARC_HWCAP_VIS3
)
17413 printf ("%svis3", first
? "" : "|"), first
= false;
17414 if (mask
& ELF_SPARC_HWCAP_HPC
)
17415 printf ("%shpc", first
? "" : "|"), first
= false;
17416 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
17417 printf ("%srandom", first
? "" : "|"), first
= false;
17418 if (mask
& ELF_SPARC_HWCAP_TRANS
)
17419 printf ("%strans", first
? "" : "|"), first
= false;
17420 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
17421 printf ("%sfjfmau", first
? "" : "|"), first
= false;
17422 if (mask
& ELF_SPARC_HWCAP_IMA
)
17423 printf ("%sima", first
? "" : "|"), first
= false;
17424 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
17425 printf ("%scspare", first
? "" : "|"), first
= false;
17428 fputc ('0', stdout
);
17429 fputc ('\n', stdout
);
17433 display_sparc_hwcaps2 (unsigned int mask
)
17439 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
17440 fputs ("fjathplus", stdout
), first
= false;
17441 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
17442 printf ("%svis3b", first
? "" : "|"), first
= false;
17443 if (mask
& ELF_SPARC_HWCAP2_ADP
)
17444 printf ("%sadp", first
? "" : "|"), first
= false;
17445 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
17446 printf ("%ssparc5", first
? "" : "|"), first
= false;
17447 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
17448 printf ("%smwait", first
? "" : "|"), first
= false;
17449 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
17450 printf ("%sxmpmul", first
? "" : "|"), first
= false;
17451 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
17452 printf ("%sxmont2", first
? "" : "|"), first
= false;
17453 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
17454 printf ("%snsec", first
? "" : "|"), first
= false;
17455 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
17456 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
17457 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
17458 printf ("%sfjdes", first
? "" : "|"), first
= false;
17459 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
17460 printf ("%sfjaes", first
? "" : "|"), first
= false;
17463 fputc ('0', stdout
);
17464 fputc ('\n', stdout
);
17467 static unsigned char *
17468 display_sparc_gnu_attribute (unsigned char * p
,
17470 const unsigned char * const end
)
17474 if (tag
== Tag_GNU_Sparc_HWCAPS
)
17476 READ_ULEB (val
, p
, end
);
17477 printf (" Tag_GNU_Sparc_HWCAPS: ");
17478 display_sparc_hwcaps (val
);
17481 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
17483 READ_ULEB (val
, p
, end
);
17484 printf (" Tag_GNU_Sparc_HWCAPS2: ");
17485 display_sparc_hwcaps2 (val
);
17489 return display_tag_value (tag
, p
, end
);
17493 print_mips_fp_abi_value (unsigned int val
)
17497 case Val_GNU_MIPS_ABI_FP_ANY
:
17498 printf (_("Hard or soft float\n"));
17500 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
17501 printf (_("Hard float (double precision)\n"));
17503 case Val_GNU_MIPS_ABI_FP_SINGLE
:
17504 printf (_("Hard float (single precision)\n"));
17506 case Val_GNU_MIPS_ABI_FP_SOFT
:
17507 printf (_("Soft float\n"));
17509 case Val_GNU_MIPS_ABI_FP_OLD_64
:
17510 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
17512 case Val_GNU_MIPS_ABI_FP_XX
:
17513 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
17515 case Val_GNU_MIPS_ABI_FP_64
:
17516 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
17518 case Val_GNU_MIPS_ABI_FP_64A
:
17519 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
17521 case Val_GNU_MIPS_ABI_FP_NAN2008
:
17522 printf (_("NaN 2008 compatibility\n"));
17525 printf ("??? (%d)\n", val
);
17530 static unsigned char *
17531 display_mips_gnu_attribute (unsigned char * p
,
17533 const unsigned char * const end
)
17535 if (tag
== Tag_GNU_MIPS_ABI_FP
)
17539 printf (" Tag_GNU_MIPS_ABI_FP: ");
17540 READ_ULEB (val
, p
, end
);
17541 print_mips_fp_abi_value (val
);
17545 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
17549 printf (" Tag_GNU_MIPS_ABI_MSA: ");
17550 READ_ULEB (val
, p
, end
);
17554 case Val_GNU_MIPS_ABI_MSA_ANY
:
17555 printf (_("Any MSA or not\n"));
17557 case Val_GNU_MIPS_ABI_MSA_128
:
17558 printf (_("128-bit MSA\n"));
17561 printf ("??? (%d)\n", val
);
17567 return display_tag_value (tag
& 1, p
, end
);
17570 static unsigned char *
17571 display_tic6x_attribute (unsigned char * p
,
17572 const unsigned char * const end
)
17577 READ_ULEB (tag
, p
, end
);
17582 printf (" Tag_ISA: ");
17583 READ_ULEB (val
, p
, end
);
17587 case C6XABI_Tag_ISA_none
:
17588 printf (_("None\n"));
17590 case C6XABI_Tag_ISA_C62X
:
17593 case C6XABI_Tag_ISA_C67X
:
17596 case C6XABI_Tag_ISA_C67XP
:
17597 printf ("C67x+\n");
17599 case C6XABI_Tag_ISA_C64X
:
17602 case C6XABI_Tag_ISA_C64XP
:
17603 printf ("C64x+\n");
17605 case C6XABI_Tag_ISA_C674X
:
17606 printf ("C674x\n");
17609 printf ("??? (%d)\n", val
);
17614 case Tag_ABI_wchar_t
:
17615 printf (" Tag_ABI_wchar_t: ");
17616 READ_ULEB (val
, p
, end
);
17620 printf (_("Not used\n"));
17623 printf (_("2 bytes\n"));
17626 printf (_("4 bytes\n"));
17629 printf ("??? (%d)\n", val
);
17634 case Tag_ABI_stack_align_needed
:
17635 printf (" Tag_ABI_stack_align_needed: ");
17636 READ_ULEB (val
, p
, end
);
17640 printf (_("8-byte\n"));
17643 printf (_("16-byte\n"));
17646 printf ("??? (%d)\n", val
);
17651 case Tag_ABI_stack_align_preserved
:
17652 READ_ULEB (val
, p
, end
);
17653 printf (" Tag_ABI_stack_align_preserved: ");
17657 printf (_("8-byte\n"));
17660 printf (_("16-byte\n"));
17663 printf ("??? (%d)\n", val
);
17669 READ_ULEB (val
, p
, end
);
17670 printf (" Tag_ABI_DSBT: ");
17674 printf (_("DSBT addressing not used\n"));
17677 printf (_("DSBT addressing used\n"));
17680 printf ("??? (%d)\n", val
);
17686 READ_ULEB (val
, p
, end
);
17687 printf (" Tag_ABI_PID: ");
17691 printf (_("Data addressing position-dependent\n"));
17694 printf (_("Data addressing position-independent, GOT near DP\n"));
17697 printf (_("Data addressing position-independent, GOT far from DP\n"));
17700 printf ("??? (%d)\n", val
);
17706 READ_ULEB (val
, p
, end
);
17707 printf (" Tag_ABI_PIC: ");
17711 printf (_("Code addressing position-dependent\n"));
17714 printf (_("Code addressing position-independent\n"));
17717 printf ("??? (%d)\n", val
);
17722 case Tag_ABI_array_object_alignment
:
17723 READ_ULEB (val
, p
, end
);
17724 printf (" Tag_ABI_array_object_alignment: ");
17728 printf (_("8-byte\n"));
17731 printf (_("4-byte\n"));
17734 printf (_("16-byte\n"));
17737 printf ("??? (%d)\n", val
);
17742 case Tag_ABI_array_object_align_expected
:
17743 READ_ULEB (val
, p
, end
);
17744 printf (" Tag_ABI_array_object_align_expected: ");
17748 printf (_("8-byte\n"));
17751 printf (_("4-byte\n"));
17754 printf (_("16-byte\n"));
17757 printf ("??? (%d)\n", val
);
17762 case Tag_ABI_compatibility
:
17764 READ_ULEB (val
, p
, end
);
17765 printf (" Tag_ABI_compatibility: ");
17766 printf (_("flag = %d, vendor = "), val
);
17769 size_t maxlen
= (end
- p
) - 1;
17771 print_symbol ((int) maxlen
, (const char *) p
);
17772 p
+= strnlen ((char *) p
, maxlen
) + 1;
17776 printf (_("<corrupt>"));
17777 p
= (unsigned char *) end
;
17783 case Tag_ABI_conformance
:
17785 printf (" Tag_ABI_conformance: \"");
17788 size_t maxlen
= (end
- p
) - 1;
17790 print_symbol ((int) maxlen
, (const char *) p
);
17791 p
+= strnlen ((char *) p
, maxlen
) + 1;
17795 printf (_("<corrupt>"));
17796 p
= (unsigned char *) end
;
17803 return display_tag_value (tag
, p
, end
);
17807 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
17810 size_t bytes
= end
- p
;
17817 int lbytes
= (bytes
> 16 ? 16 : bytes
);
17819 printf (" 0x%8.8" PRIx64
" ", addr
);
17821 for (j
= 0; j
< 16; j
++)
17824 printf ("%2.2x", p
[j
]);
17832 for (j
= 0; j
< lbytes
; j
++)
17835 if (k
>= ' ' && k
< 0x7f)
17851 static unsigned char *
17852 display_msp430_attribute (unsigned char * p
,
17853 const unsigned char * const end
)
17858 READ_ULEB (tag
, p
, end
);
17862 case OFBA_MSPABI_Tag_ISA
:
17863 printf (" Tag_ISA: ");
17864 READ_ULEB (val
, p
, end
);
17867 case 0: printf (_("None\n")); break;
17868 case 1: printf (_("MSP430\n")); break;
17869 case 2: printf (_("MSP430X\n")); break;
17870 default: printf ("??? (%" PRId64
")\n", val
); break;
17874 case OFBA_MSPABI_Tag_Code_Model
:
17875 printf (" Tag_Code_Model: ");
17876 READ_ULEB (val
, p
, end
);
17879 case 0: printf (_("None\n")); break;
17880 case 1: printf (_("Small\n")); break;
17881 case 2: printf (_("Large\n")); break;
17882 default: printf ("??? (%" PRId64
")\n", val
); break;
17886 case OFBA_MSPABI_Tag_Data_Model
:
17887 printf (" Tag_Data_Model: ");
17888 READ_ULEB (val
, p
, end
);
17891 case 0: printf (_("None\n")); break;
17892 case 1: printf (_("Small\n")); break;
17893 case 2: printf (_("Large\n")); break;
17894 case 3: printf (_("Restricted Large\n")); break;
17895 default: printf ("??? (%" PRId64
")\n", val
); break;
17900 printf (_(" <unknown tag %" PRId64
">: "), tag
);
17907 size_t maxlen
= (end
- p
) - 1;
17909 print_symbol ((int) maxlen
, (const char *) p
);
17910 p
+= strnlen ((char *) p
, maxlen
) + 1;
17914 printf (_("<corrupt>"));
17915 p
= (unsigned char *) end
;
17921 READ_ULEB (val
, p
, end
);
17922 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
17931 static unsigned char *
17932 display_msp430_gnu_attribute (unsigned char * p
,
17934 const unsigned char * const end
)
17936 if (tag
== Tag_GNU_MSP430_Data_Region
)
17940 printf (" Tag_GNU_MSP430_Data_Region: ");
17941 READ_ULEB (val
, p
, end
);
17945 case Val_GNU_MSP430_Data_Region_Any
:
17946 printf (_("Any Region\n"));
17948 case Val_GNU_MSP430_Data_Region_Lower
:
17949 printf (_("Lower Region Only\n"));
17952 printf ("??? (%" PRIu64
")\n", val
);
17956 return display_tag_value (tag
& 1, p
, end
);
17959 struct riscv_attr_tag_t
{
17964 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17966 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17969 T(priv_spec_minor
),
17970 T(priv_spec_revision
),
17971 T(unaligned_access
),
17976 static unsigned char *
17977 display_riscv_attribute (unsigned char *p
,
17978 const unsigned char * const end
)
17982 struct riscv_attr_tag_t
*attr
= NULL
;
17985 READ_ULEB (tag
, p
, end
);
17987 /* Find the name of attribute. */
17988 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17990 if (riscv_attr_tag
[i
].tag
== tag
)
17992 attr
= &riscv_attr_tag
[i
];
17998 printf (" %s: ", attr
->name
);
18000 return display_tag_value (tag
, p
, end
);
18004 case Tag_RISCV_priv_spec
:
18005 case Tag_RISCV_priv_spec_minor
:
18006 case Tag_RISCV_priv_spec_revision
:
18007 READ_ULEB (val
, p
, end
);
18008 printf ("%" PRIu64
"\n", val
);
18010 case Tag_RISCV_unaligned_access
:
18011 READ_ULEB (val
, p
, end
);
18015 printf (_("No unaligned access\n"));
18018 printf (_("Unaligned access\n"));
18022 case Tag_RISCV_stack_align
:
18023 READ_ULEB (val
, p
, end
);
18024 printf (_("%" PRIu64
"-bytes\n"), val
);
18026 case Tag_RISCV_arch
:
18027 p
= display_tag_value (-1, p
, end
);
18030 return display_tag_value (tag
, p
, end
);
18036 static unsigned char *
18037 display_csky_attribute (unsigned char * p
,
18038 const unsigned char * const end
)
18042 READ_ULEB (tag
, p
, end
);
18044 if (tag
>= Tag_CSKY_MAX
)
18046 return display_tag_value (-1, p
, end
);
18051 case Tag_CSKY_ARCH_NAME
:
18052 printf (" Tag_CSKY_ARCH_NAME:\t\t");
18053 return display_tag_value (-1, p
, end
);
18054 case Tag_CSKY_CPU_NAME
:
18055 printf (" Tag_CSKY_CPU_NAME:\t\t");
18056 return display_tag_value (-1, p
, end
);
18058 case Tag_CSKY_ISA_FLAGS
:
18059 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
18060 return display_tag_value (0, p
, end
);
18061 case Tag_CSKY_ISA_EXT_FLAGS
:
18062 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
18063 return display_tag_value (0, p
, end
);
18065 case Tag_CSKY_DSP_VERSION
:
18066 printf (" Tag_CSKY_DSP_VERSION:\t\t");
18067 READ_ULEB (val
, p
, end
);
18068 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
18069 printf ("DSP Extension\n");
18070 else if (val
== VAL_CSKY_DSP_VERSION_2
)
18071 printf ("DSP 2.0\n");
18074 case Tag_CSKY_VDSP_VERSION
:
18075 printf (" Tag_CSKY_VDSP_VERSION:\t");
18076 READ_ULEB (val
, p
, end
);
18077 printf ("VDSP Version %" PRId64
"\n", val
);
18080 case Tag_CSKY_FPU_VERSION
:
18081 printf (" Tag_CSKY_FPU_VERSION:\t\t");
18082 READ_ULEB (val
, p
, end
);
18083 if (val
== VAL_CSKY_FPU_VERSION_1
)
18084 printf ("ABIV1 FPU Version 1\n");
18085 else if (val
== VAL_CSKY_FPU_VERSION_2
)
18086 printf ("FPU Version 2\n");
18089 case Tag_CSKY_FPU_ABI
:
18090 printf (" Tag_CSKY_FPU_ABI:\t\t");
18091 READ_ULEB (val
, p
, end
);
18092 if (val
== VAL_CSKY_FPU_ABI_HARD
)
18094 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
18095 printf ("SoftFP\n");
18096 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
18099 case Tag_CSKY_FPU_ROUNDING
:
18100 READ_ULEB (val
, p
, end
);
18103 printf (" Tag_CSKY_FPU_ROUNDING:\t");
18104 printf ("Needed\n");
18107 case Tag_CSKY_FPU_DENORMAL
:
18108 READ_ULEB (val
, p
, end
);
18111 printf (" Tag_CSKY_FPU_DENORMAL:\t");
18112 printf ("Needed\n");
18115 case Tag_CSKY_FPU_Exception
:
18116 READ_ULEB (val
, p
, end
);
18119 printf (" Tag_CSKY_FPU_Exception:\t");
18120 printf ("Needed\n");
18123 case Tag_CSKY_FPU_NUMBER_MODULE
:
18124 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
18125 return display_tag_value (-1, p
, end
);
18126 case Tag_CSKY_FPU_HARDFP
:
18127 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
18128 READ_ULEB (val
, p
, end
);
18129 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
18131 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
18132 printf (" Single");
18133 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
18134 printf (" Double");
18138 return display_tag_value (tag
, p
, end
);
18144 process_attributes (Filedata
* filedata
,
18145 const char * public_name
,
18146 unsigned int proc_type
,
18147 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
18148 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
18150 Elf_Internal_Shdr
* sect
;
18154 /* Find the section header so that we get the size. */
18155 for (i
= 0, sect
= filedata
->section_headers
;
18156 i
< filedata
->file_header
.e_shnum
;
18159 unsigned char * contents
;
18162 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
18165 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18166 sect
->sh_size
, _("attributes"));
18167 if (contents
== NULL
)
18174 /* The first character is the version of the attributes.
18175 Currently only version 1, (aka 'A') is recognised here. */
18178 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
18183 uint64_t section_len
;
18185 section_len
= sect
->sh_size
- 1;
18188 while (section_len
> 0)
18191 unsigned int namelen
;
18192 bool public_section
;
18195 if (section_len
<= 4)
18197 error (_("Tag section ends prematurely\n"));
18201 attr_len
= byte_get (p
, 4);
18204 if (attr_len
> section_len
)
18206 error (_("Bad attribute length (%u > %u)\n"),
18207 (unsigned) attr_len
, (unsigned) section_len
);
18208 attr_len
= section_len
;
18211 /* PR 17531: file: 001-101425-0.004 */
18212 else if (attr_len
< 5)
18214 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
18219 section_len
-= attr_len
;
18222 namelen
= strnlen ((char *) p
, attr_len
) + 1;
18223 if (namelen
== 0 || namelen
>= attr_len
)
18225 error (_("Corrupt attribute section name\n"));
18230 printf (_("Attribute Section: "));
18231 print_symbol (INT_MAX
, (const char *) p
);
18234 if (public_name
&& streq ((char *) p
, public_name
))
18235 public_section
= true;
18237 public_section
= false;
18239 if (streq ((char *) p
, "gnu"))
18240 gnu_section
= true;
18242 gnu_section
= false;
18245 attr_len
-= namelen
;
18247 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
18252 unsigned char * end
;
18254 /* PR binutils/17531: Safe handling of corrupt files. */
18257 error (_("Unused bytes at end of section\n"));
18264 size
= byte_get (p
, 4);
18265 if (size
> attr_len
)
18267 error (_("Bad subsection length (%u > %u)\n"),
18268 (unsigned) size
, (unsigned) attr_len
);
18272 /* PR binutils/17531: Safe handling of corrupt files. */
18275 error (_("Bad subsection length (%u < 6)\n"),
18283 end
= p
+ size
- 1;
18284 assert (end
<= contents
+ sect
->sh_size
);
18290 printf (_("File Attributes\n"));
18293 printf (_("Section Attributes:"));
18296 printf (_("Symbol Attributes:"));
18297 /* Fall through. */
18301 READ_ULEB (val
, p
, end
);
18304 printf (" %d", val
);
18309 printf (_("Unknown tag: %d\n"), tag
);
18310 public_section
= false;
18314 if (public_section
&& display_pub_attribute
!= NULL
)
18317 p
= display_pub_attribute (p
, end
);
18320 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
18323 p
= display_gnu_attribute (p
,
18324 display_proc_gnu_attribute
,
18330 printf (_(" Unknown attribute:\n"));
18331 display_raw_attribute (p
, end
);
18346 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
18347 Print the Address, Access and Initial fields of an entry at VMA ADDR
18348 and return the VMA of the next entry, or -1 if there was a problem.
18349 Does not read from DATA_END or beyond. */
18352 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
18353 unsigned char * data_end
)
18356 print_vma (addr
, LONG_HEX
);
18358 if (addr
< pltgot
+ 0xfff0)
18359 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
18361 printf ("%10s", "");
18364 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18368 unsigned char * from
= data
+ addr
- pltgot
;
18370 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
18372 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
18373 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
18374 return (uint64_t) -1;
18378 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18379 print_vma (entry
, LONG_HEX
);
18382 return addr
+ (is_32bit_elf
? 4 : 8);
18385 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
18386 PLTGOT. Print the Address and Initial fields of an entry at VMA
18387 ADDR and return the VMA of the next entry. */
18390 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
18393 print_vma (addr
, LONG_HEX
);
18396 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18401 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18402 print_vma (entry
, LONG_HEX
);
18404 return addr
+ (is_32bit_elf
? 4 : 8);
18408 print_mips_ases (unsigned int mask
)
18410 if (mask
& AFL_ASE_DSP
)
18411 fputs ("\n\tDSP ASE", stdout
);
18412 if (mask
& AFL_ASE_DSPR2
)
18413 fputs ("\n\tDSP R2 ASE", stdout
);
18414 if (mask
& AFL_ASE_DSPR3
)
18415 fputs ("\n\tDSP R3 ASE", stdout
);
18416 if (mask
& AFL_ASE_EVA
)
18417 fputs ("\n\tEnhanced VA Scheme", stdout
);
18418 if (mask
& AFL_ASE_MCU
)
18419 fputs ("\n\tMCU (MicroController) ASE", stdout
);
18420 if (mask
& AFL_ASE_MDMX
)
18421 fputs ("\n\tMDMX ASE", stdout
);
18422 if (mask
& AFL_ASE_MIPS3D
)
18423 fputs ("\n\tMIPS-3D ASE", stdout
);
18424 if (mask
& AFL_ASE_MT
)
18425 fputs ("\n\tMT ASE", stdout
);
18426 if (mask
& AFL_ASE_SMARTMIPS
)
18427 fputs ("\n\tSmartMIPS ASE", stdout
);
18428 if (mask
& AFL_ASE_VIRT
)
18429 fputs ("\n\tVZ ASE", stdout
);
18430 if (mask
& AFL_ASE_MSA
)
18431 fputs ("\n\tMSA ASE", stdout
);
18432 if (mask
& AFL_ASE_MIPS16
)
18433 fputs ("\n\tMIPS16 ASE", stdout
);
18434 if (mask
& AFL_ASE_MICROMIPS
)
18435 fputs ("\n\tMICROMIPS ASE", stdout
);
18436 if (mask
& AFL_ASE_XPA
)
18437 fputs ("\n\tXPA ASE", stdout
);
18438 if (mask
& AFL_ASE_MIPS16E2
)
18439 fputs ("\n\tMIPS16e2 ASE", stdout
);
18440 if (mask
& AFL_ASE_CRC
)
18441 fputs ("\n\tCRC ASE", stdout
);
18442 if (mask
& AFL_ASE_GINV
)
18443 fputs ("\n\tGINV ASE", stdout
);
18444 if (mask
& AFL_ASE_LOONGSON_MMI
)
18445 fputs ("\n\tLoongson MMI ASE", stdout
);
18446 if (mask
& AFL_ASE_LOONGSON_CAM
)
18447 fputs ("\n\tLoongson CAM ASE", stdout
);
18448 if (mask
& AFL_ASE_LOONGSON_EXT
)
18449 fputs ("\n\tLoongson EXT ASE", stdout
);
18450 if (mask
& AFL_ASE_LOONGSON_EXT2
)
18451 fputs ("\n\tLoongson EXT2 ASE", stdout
);
18453 fprintf (stdout
, "\n\t%s", _("None"));
18454 else if ((mask
& ~AFL_ASE_MASK
) != 0)
18455 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
18459 print_mips_isa_ext (unsigned int isa_ext
)
18464 fputs (_("None"), stdout
);
18467 fputs ("RMI XLR", stdout
);
18469 case AFL_EXT_OCTEON3
:
18470 fputs ("Cavium Networks Octeon3", stdout
);
18472 case AFL_EXT_OCTEON2
:
18473 fputs ("Cavium Networks Octeon2", stdout
);
18475 case AFL_EXT_OCTEONP
:
18476 fputs ("Cavium Networks OcteonP", stdout
);
18478 case AFL_EXT_OCTEON
:
18479 fputs ("Cavium Networks Octeon", stdout
);
18482 fputs ("Toshiba R5900", stdout
);
18485 fputs ("MIPS R4650", stdout
);
18488 fputs ("LSI R4010", stdout
);
18491 fputs ("NEC VR4100", stdout
);
18494 fputs ("Toshiba R3900", stdout
);
18496 case AFL_EXT_10000
:
18497 fputs ("MIPS R10000", stdout
);
18500 fputs ("Broadcom SB-1", stdout
);
18503 fputs ("NEC VR4111/VR4181", stdout
);
18506 fputs ("NEC VR4120", stdout
);
18509 fputs ("NEC VR5400", stdout
);
18512 fputs ("NEC VR5500", stdout
);
18514 case AFL_EXT_LOONGSON_2E
:
18515 fputs ("ST Microelectronics Loongson 2E", stdout
);
18517 case AFL_EXT_LOONGSON_2F
:
18518 fputs ("ST Microelectronics Loongson 2F", stdout
);
18520 case AFL_EXT_INTERAPTIV_MR2
:
18521 fputs ("Imagination interAptiv MR2", stdout
);
18524 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
18529 get_mips_reg_size (int reg_size
)
18531 return (reg_size
== AFL_REG_NONE
) ? 0
18532 : (reg_size
== AFL_REG_32
) ? 32
18533 : (reg_size
== AFL_REG_64
) ? 64
18534 : (reg_size
== AFL_REG_128
) ? 128
18539 process_mips_specific (Filedata
* filedata
)
18541 Elf_Internal_Dyn
* entry
;
18542 Elf_Internal_Shdr
*sect
= NULL
;
18543 size_t liblist_offset
= 0;
18544 size_t liblistno
= 0;
18545 size_t conflictsno
= 0;
18546 size_t options_offset
= 0;
18547 size_t conflicts_offset
= 0;
18548 size_t pltrelsz
= 0;
18550 uint64_t pltgot
= 0;
18551 uint64_t mips_pltgot
= 0;
18552 uint64_t jmprel
= 0;
18553 uint64_t local_gotno
= 0;
18554 uint64_t gotsym
= 0;
18555 uint64_t symtabno
= 0;
18558 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18559 display_mips_gnu_attribute
))
18562 sect
= find_section (filedata
, ".MIPS.abiflags");
18566 Elf_External_ABIFlags_v0
*abiflags_ext
;
18567 Elf_Internal_ABIFlags_v0 abiflags_in
;
18569 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
18571 error (_("Corrupt MIPS ABI Flags section.\n"));
18576 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18577 sect
->sh_size
, _("MIPS ABI Flags section"));
18580 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
18581 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
18582 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
18583 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
18584 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
18585 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
18586 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
18587 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
18588 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
18589 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
18590 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
18592 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
18593 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
18594 if (abiflags_in
.isa_rev
> 1)
18595 printf ("r%d", abiflags_in
.isa_rev
);
18596 printf ("\nGPR size: %d",
18597 get_mips_reg_size (abiflags_in
.gpr_size
));
18598 printf ("\nCPR1 size: %d",
18599 get_mips_reg_size (abiflags_in
.cpr1_size
));
18600 printf ("\nCPR2 size: %d",
18601 get_mips_reg_size (abiflags_in
.cpr2_size
));
18602 fputs ("\nFP ABI: ", stdout
);
18603 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
18604 fputs ("ISA Extension: ", stdout
);
18605 print_mips_isa_ext (abiflags_in
.isa_ext
);
18606 fputs ("\nASEs:", stdout
);
18607 print_mips_ases (abiflags_in
.ases
);
18608 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
18609 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
18610 fputc ('\n', stdout
);
18611 free (abiflags_ext
);
18616 /* We have a lot of special sections. Thanks SGI! */
18617 if (filedata
->dynamic_section
== NULL
)
18619 /* No dynamic information available. See if there is static GOT. */
18620 sect
= find_section (filedata
, ".got");
18623 unsigned char *data_end
;
18624 unsigned char *data
;
18628 pltgot
= sect
->sh_addr
;
18631 addr_size
= (is_32bit_elf
? 4 : 8);
18632 end
= pltgot
+ sect
->sh_size
;
18634 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
18636 _("Global Offset Table data"));
18637 /* PR 12855: Null data is handled gracefully throughout. */
18638 data_end
= data
+ (end
- pltgot
);
18640 printf (_("\nStatic GOT:\n"));
18641 printf (_(" Canonical gp value: "));
18642 print_vma (ent
+ 0x7ff0, LONG_HEX
);
18645 /* In a dynamic binary GOT[0] is reserved for the dynamic
18646 loader to store the lazy resolver pointer, however in
18647 a static binary it may well have been omitted and GOT
18648 reduced to a table of addresses.
18649 PR 21344: Check for the entry being fully available
18650 before fetching it. */
18652 && data
+ ent
- pltgot
+ addr_size
<= data_end
18653 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
18655 printf (_(" Reserved entries:\n"));
18656 printf (_(" %*s %10s %*s\n"),
18657 addr_size
* 2, _("Address"), _("Access"),
18658 addr_size
* 2, _("Value"));
18659 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18661 if (ent
== (uint64_t) -1)
18662 goto sgot_print_fail
;
18664 /* Check for the MSB of GOT[1] being set, identifying a
18665 GNU object. This entry will be used by some runtime
18666 loaders, to store the module pointer. Otherwise this
18667 is an ordinary local entry.
18668 PR 21344: Check for the entry being fully available
18669 before fetching it. */
18671 && data
+ ent
- pltgot
+ addr_size
<= data_end
18672 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18673 >> (addr_size
* 8 - 1)) != 0)
18675 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18677 if (ent
== (uint64_t) -1)
18678 goto sgot_print_fail
;
18683 if (data
!= NULL
&& ent
< end
)
18685 printf (_(" Local entries:\n"));
18686 printf (" %*s %10s %*s\n",
18687 addr_size
* 2, _("Address"), _("Access"),
18688 addr_size
* 2, _("Value"));
18691 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18693 if (ent
== (uint64_t) -1)
18694 goto sgot_print_fail
;
18705 for (entry
= filedata
->dynamic_section
;
18706 /* PR 17531 file: 012-50589-0.004. */
18707 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
18708 && entry
->d_tag
!= DT_NULL
);
18710 switch (entry
->d_tag
)
18712 case DT_MIPS_LIBLIST
:
18714 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18715 liblistno
* sizeof (Elf32_External_Lib
));
18717 case DT_MIPS_LIBLISTNO
:
18718 liblistno
= entry
->d_un
.d_val
;
18720 case DT_MIPS_OPTIONS
:
18721 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
18723 case DT_MIPS_CONFLICT
:
18725 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18726 conflictsno
* sizeof (Elf32_External_Conflict
));
18728 case DT_MIPS_CONFLICTNO
:
18729 conflictsno
= entry
->d_un
.d_val
;
18732 pltgot
= entry
->d_un
.d_ptr
;
18734 case DT_MIPS_LOCAL_GOTNO
:
18735 local_gotno
= entry
->d_un
.d_val
;
18737 case DT_MIPS_GOTSYM
:
18738 gotsym
= entry
->d_un
.d_val
;
18740 case DT_MIPS_SYMTABNO
:
18741 symtabno
= entry
->d_un
.d_val
;
18743 case DT_MIPS_PLTGOT
:
18744 mips_pltgot
= entry
->d_un
.d_ptr
;
18747 pltrel
= entry
->d_un
.d_val
;
18750 pltrelsz
= entry
->d_un
.d_val
;
18753 jmprel
= entry
->d_un
.d_ptr
;
18759 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
18761 Elf32_External_Lib
* elib
;
18764 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
18765 sizeof (Elf32_External_Lib
),
18767 _("liblist section data"));
18770 printf (ngettext ("\nSection '.liblist' contains %zu entry:\n",
18771 "\nSection '.liblist' contains %zu entries:\n",
18774 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
18777 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
18784 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18785 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18786 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18787 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18788 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18790 tmp
= gmtime (&atime
);
18791 snprintf (timebuf
, sizeof (timebuf
),
18792 "%04u-%02u-%02uT%02u:%02u:%02u",
18793 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18794 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18796 printf ("%3zu: ", cnt
);
18797 if (valid_dynamic_name (filedata
, liblist
.l_name
))
18798 print_symbol (20, get_dynamic_name (filedata
, liblist
.l_name
));
18800 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
18801 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
18802 liblist
.l_version
);
18804 if (liblist
.l_flags
== 0)
18808 static const struct
18815 { " EXACT_MATCH", LL_EXACT_MATCH
},
18816 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
18817 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
18818 { " EXPORTS", LL_EXPORTS
},
18819 { " DELAY_LOAD", LL_DELAY_LOAD
},
18820 { " DELTA", LL_DELTA
}
18822 int flags
= liblist
.l_flags
;
18825 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
18826 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
18828 fputs (l_flags_vals
[fcnt
].name
, stdout
);
18829 flags
^= l_flags_vals
[fcnt
].bit
;
18832 printf (" %#x", (unsigned int) flags
);
18844 if (options_offset
!= 0)
18846 Elf_External_Options
* eopt
;
18850 /* Find the section header so that we get the size. */
18851 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
18852 /* PR 17533 file: 012-277276-0.004. */
18855 error (_("No MIPS_OPTIONS header found\n"));
18859 if (sect
->sh_size
< sizeof (* eopt
))
18861 error (_("The MIPS options section is too small.\n"));
18865 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
18866 sect
->sh_size
, _("options"));
18869 Elf_Internal_Options option
;
18872 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
18874 Elf_External_Options
* eoption
;
18875 unsigned int optsize
;
18877 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18879 optsize
= BYTE_GET (eoption
->size
);
18881 /* PR 17531: file: ffa0fa3b. */
18882 if (optsize
< sizeof (* eopt
)
18883 || optsize
> sect
->sh_size
- offset
)
18885 error (_("Invalid size (%u) for MIPS option\n"),
18894 printf (ngettext ("\nSection '%s' contains %d entry:\n",
18895 "\nSection '%s' contains %d entries:\n",
18897 printable_section_name (filedata
, sect
), cnt
);
18903 Elf_External_Options
* eoption
;
18905 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18907 option
.kind
= BYTE_GET (eoption
->kind
);
18908 option
.size
= BYTE_GET (eoption
->size
);
18909 option
.section
= BYTE_GET (eoption
->section
);
18910 option
.info
= BYTE_GET (eoption
->info
);
18912 switch (option
.kind
)
18915 /* This shouldn't happen. */
18916 printf (" NULL %" PRId16
" %" PRIx32
,
18917 option
.section
, option
.info
);
18921 printf (" REGINFO ");
18922 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18924 Elf32_External_RegInfo
* ereg
;
18925 Elf32_RegInfo reginfo
;
18928 if (option
.size
< (sizeof (Elf_External_Options
)
18929 + sizeof (Elf32_External_RegInfo
)))
18931 printf (_("<corrupt>\n"));
18932 error (_("Truncated MIPS REGINFO option\n"));
18937 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18939 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18940 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18941 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18942 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18943 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18944 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18946 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18947 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18949 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18950 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18951 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18952 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18957 Elf64_External_RegInfo
* ereg
;
18958 Elf64_Internal_RegInfo reginfo
;
18960 if (option
.size
< (sizeof (Elf_External_Options
)
18961 + sizeof (Elf64_External_RegInfo
)))
18963 printf (_("<corrupt>\n"));
18964 error (_("Truncated MIPS REGINFO option\n"));
18969 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18970 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18971 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18972 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18973 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18974 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18975 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18977 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18978 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18980 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18981 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18982 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18983 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18985 offset
+= option
.size
;
18988 case ODK_EXCEPTIONS
:
18989 fputs (" EXCEPTIONS fpe_min(", stdout
);
18990 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18991 fputs (") fpe_max(", stdout
);
18992 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18993 fputs (")", stdout
);
18995 if (option
.info
& OEX_PAGE0
)
18996 fputs (" PAGE0", stdout
);
18997 if (option
.info
& OEX_SMM
)
18998 fputs (" SMM", stdout
);
18999 if (option
.info
& OEX_FPDBUG
)
19000 fputs (" FPDBUG", stdout
);
19001 if (option
.info
& OEX_DISMISS
)
19002 fputs (" DISMISS", stdout
);
19006 fputs (" PAD ", stdout
);
19007 if (option
.info
& OPAD_PREFIX
)
19008 fputs (" PREFIX", stdout
);
19009 if (option
.info
& OPAD_POSTFIX
)
19010 fputs (" POSTFIX", stdout
);
19011 if (option
.info
& OPAD_SYMBOL
)
19012 fputs (" SYMBOL", stdout
);
19016 fputs (" HWPATCH ", stdout
);
19017 if (option
.info
& OHW_R4KEOP
)
19018 fputs (" R4KEOP", stdout
);
19019 if (option
.info
& OHW_R8KPFETCH
)
19020 fputs (" R8KPFETCH", stdout
);
19021 if (option
.info
& OHW_R5KEOP
)
19022 fputs (" R5KEOP", stdout
);
19023 if (option
.info
& OHW_R5KCVTL
)
19024 fputs (" R5KCVTL", stdout
);
19028 fputs (" FILL ", stdout
);
19029 /* XXX Print content of info word? */
19033 fputs (" TAGS ", stdout
);
19034 /* XXX Print content of info word? */
19038 fputs (" HWAND ", stdout
);
19039 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19040 fputs (" R4KEOP_CHECKED", stdout
);
19041 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19042 fputs (" R4KEOP_CLEAN", stdout
);
19046 fputs (" HWOR ", stdout
);
19047 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19048 fputs (" R4KEOP_CHECKED", stdout
);
19049 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19050 fputs (" R4KEOP_CLEAN", stdout
);
19054 printf (" GP_GROUP %#06x self-contained %#06x",
19055 option
.info
& OGP_GROUP
,
19056 (option
.info
& OGP_SELF
) >> 16);
19060 printf (" IDENT %#06x self-contained %#06x",
19061 option
.info
& OGP_GROUP
,
19062 (option
.info
& OGP_SELF
) >> 16);
19066 /* This shouldn't happen. */
19067 printf (" %3d ??? %" PRId16
" %" PRIx32
,
19068 option
.kind
, option
.section
, option
.info
);
19072 len
= sizeof (* eopt
);
19073 while (len
< option
.size
)
19075 unsigned char datum
= *((unsigned char *) eoption
+ len
);
19077 if (ISPRINT (datum
))
19078 printf ("%c", datum
);
19080 printf ("\\%03o", datum
);
19083 fputs ("\n", stdout
);
19085 offset
+= option
.size
;
19093 if (conflicts_offset
!= 0 && conflictsno
!= 0)
19095 Elf32_Conflict
* iconf
;
19098 if (filedata
->dynamic_symbols
== NULL
)
19100 error (_("conflict list found without a dynamic symbol table\n"));
19104 /* PR 21345 - print a slightly more helpful error message
19105 if we are sure that the cmalloc will fail. */
19106 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
19108 error (_("Overlarge number of conflicts detected: %zx\n"),
19113 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
19116 error (_("Out of memory allocating space for dynamic conflicts\n"));
19122 Elf32_External_Conflict
* econf32
;
19124 econf32
= (Elf32_External_Conflict
*)
19125 get_data (NULL
, filedata
, conflicts_offset
,
19126 sizeof (*econf32
), conflictsno
, _("conflict"));
19133 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19134 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
19140 Elf64_External_Conflict
* econf64
;
19142 econf64
= (Elf64_External_Conflict
*)
19143 get_data (NULL
, filedata
, conflicts_offset
,
19144 sizeof (*econf64
), conflictsno
, _("conflict"));
19151 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19152 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
19157 printf (ngettext ("\nSection '.conflict' contains %zu entry:\n",
19158 "\nSection '.conflict' contains %zu entries:\n",
19161 puts (_(" Num: Index Value Name"));
19163 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19165 printf ("%5zu: %8lu ", cnt
, iconf
[cnt
]);
19167 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
19168 printf (_("<corrupt symbol index>"));
19171 Elf_Internal_Sym
* psym
;
19173 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
19174 print_vma (psym
->st_value
, FULL_HEX
);
19176 if (valid_dynamic_name (filedata
, psym
->st_name
))
19177 print_symbol (25, get_dynamic_name (filedata
, psym
->st_name
));
19179 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19187 if (pltgot
!= 0 && local_gotno
!= 0)
19189 uint64_t ent
, local_end
, global_end
;
19191 unsigned char * data
;
19192 unsigned char * data_end
;
19196 addr_size
= (is_32bit_elf
? 4 : 8);
19197 local_end
= pltgot
+ local_gotno
* addr_size
;
19199 /* PR binutils/17533 file: 012-111227-0.004 */
19200 if (symtabno
< gotsym
)
19202 error (_("The GOT symbol offset (%" PRIu64
19203 ") is greater than the symbol table size (%" PRIu64
")\n"),
19208 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
19209 /* PR 17531: file: 54c91a34. */
19210 if (global_end
< local_end
)
19212 error (_("Too many GOT symbols: %" PRIu64
"\n"), symtabno
);
19216 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
19217 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
19218 global_end
- pltgot
, 1,
19219 _("Global Offset Table data"));
19220 /* PR 12855: Null data is handled gracefully throughout. */
19221 data_end
= data
+ (global_end
- pltgot
);
19223 printf (_("\nPrimary GOT:\n"));
19224 printf (_(" Canonical gp value: "));
19225 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
19228 printf (_(" Reserved entries:\n"));
19229 printf (_(" %*s %10s %*s Purpose\n"),
19230 addr_size
* 2, _("Address"), _("Access"),
19231 addr_size
* 2, _("Initial"));
19232 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19233 printf (_(" Lazy resolver\n"));
19234 if (ent
== (uint64_t) -1)
19235 goto got_print_fail
;
19237 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
19238 This entry will be used by some runtime loaders, to store the
19239 module pointer. Otherwise this is an ordinary local entry.
19240 PR 21344: Check for the entry being fully available before
19243 && data
+ ent
- pltgot
+ addr_size
<= data_end
19244 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19245 >> (addr_size
* 8 - 1)) != 0)
19247 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19248 printf (_(" Module pointer (GNU extension)\n"));
19249 if (ent
== (uint64_t) -1)
19250 goto got_print_fail
;
19254 if (data
!= NULL
&& ent
< local_end
)
19256 printf (_(" Local entries:\n"));
19257 printf (" %*s %10s %*s\n",
19258 addr_size
* 2, _("Address"), _("Access"),
19259 addr_size
* 2, _("Initial"));
19260 while (ent
< local_end
)
19262 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19264 if (ent
== (uint64_t) -1)
19265 goto got_print_fail
;
19270 if (data
!= NULL
&& gotsym
< symtabno
)
19274 printf (_(" Global entries:\n"));
19275 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
19276 addr_size
* 2, _("Address"),
19278 addr_size
* 2, _("Initial"),
19279 addr_size
* 2, _("Sym.Val."),
19281 /* Note for translators: "Ndx" = abbreviated form of "Index". */
19282 _("Ndx"), _("Name"));
19284 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
19286 for (i
= gotsym
; i
< symtabno
; i
++)
19288 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19291 if (filedata
->dynamic_symbols
== NULL
)
19292 printf (_("<no dynamic symbols>"));
19293 else if (i
< filedata
->num_dynamic_syms
)
19295 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
19297 print_vma (psym
->st_value
, LONG_HEX
);
19298 printf (" %-7s %3s ",
19299 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19300 get_symbol_index_type (filedata
, psym
->st_shndx
));
19302 if (valid_dynamic_name (filedata
, psym
->st_name
))
19303 print_symbol (sym_width
,
19304 get_dynamic_name (filedata
, psym
->st_name
));
19306 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19309 printf (_("<symbol index %zu exceeds number of dynamic symbols>"),
19313 if (ent
== (uint64_t) -1)
19323 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
19326 uint64_t offset
, rel_offset
;
19328 unsigned char * data
;
19329 int addr_size
, sym_width
;
19330 Elf_Internal_Rela
* rels
;
19332 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
19333 if (pltrel
== DT_RELA
)
19335 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19340 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19345 addr_size
= (is_32bit_elf
? 4 : 8);
19346 end
= mips_pltgot
+ (2 + count
) * addr_size
;
19348 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
19349 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
19350 1, _("Procedure Linkage Table data"));
19357 printf ("\nPLT GOT:\n\n");
19358 printf (_(" Reserved entries:\n"));
19359 printf (_(" %*s %*s Purpose\n"),
19360 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
19361 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19362 printf (_(" PLT lazy resolver\n"));
19363 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19364 printf (_(" Module pointer\n"));
19367 printf (_(" Entries:\n"));
19368 printf (" %*s %*s %*s %-7s %3s %s\n",
19369 addr_size
* 2, _("Address"),
19370 addr_size
* 2, _("Initial"),
19371 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
19372 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
19373 for (i
= 0; i
< count
; i
++)
19375 uint64_t idx
= get_reloc_symindex (rels
[i
].r_info
);
19377 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19380 if (idx
>= filedata
->num_dynamic_syms
)
19381 printf (_("<corrupt symbol index: %" PRIu64
">"), idx
);
19384 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
19386 print_vma (psym
->st_value
, LONG_HEX
);
19387 printf (" %-7s %3s ",
19388 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19389 get_symbol_index_type (filedata
, psym
->st_shndx
));
19390 if (valid_dynamic_name (filedata
, psym
->st_name
))
19391 print_symbol (sym_width
,
19392 get_dynamic_name (filedata
, psym
->st_name
));
19394 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19408 process_nds32_specific (Filedata
* filedata
)
19410 Elf_Internal_Shdr
*sect
= NULL
;
19412 sect
= find_section (filedata
, ".nds32_e_flags");
19413 if (sect
!= NULL
&& sect
->sh_size
>= 4)
19415 unsigned char *buf
;
19418 printf ("\nNDS32 elf flags section:\n");
19419 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
19420 _("NDS32 elf flags section"));
19425 flag
= byte_get (buf
, 4);
19427 switch (flag
& 0x3)
19430 printf ("(VEC_SIZE):\tNo entry.\n");
19433 printf ("(VEC_SIZE):\t4 bytes\n");
19436 printf ("(VEC_SIZE):\t16 bytes\n");
19439 printf ("(VEC_SIZE):\treserved\n");
19448 process_gnu_liblist (Filedata
* filedata
)
19450 Elf_Internal_Shdr
* section
;
19451 Elf_Internal_Shdr
* string_sec
;
19452 Elf32_External_Lib
* elib
;
19454 size_t strtab_size
;
19456 uint64_t num_liblist
;
19463 for (i
= 0, section
= filedata
->section_headers
;
19464 i
< filedata
->file_header
.e_shnum
;
19467 switch (section
->sh_type
)
19469 case SHT_GNU_LIBLIST
:
19470 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
19473 elib
= (Elf32_External_Lib
*)
19474 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
19475 _("liblist section data"));
19483 string_sec
= filedata
->section_headers
+ section
->sh_link
;
19484 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
19485 string_sec
->sh_size
,
19486 _("liblist string table"));
19488 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
19495 strtab_size
= string_sec
->sh_size
;
19497 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
19498 printf (ngettext ("\nLibrary list section '%s' contains %" PRIu64
19500 "\nLibrary list section '%s' contains %" PRIu64
19503 printable_section_name (filedata
, section
),
19506 puts (_(" Library Time Stamp Checksum Version Flags"));
19508 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
19516 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19517 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19518 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19519 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19520 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19522 tmp
= gmtime (&atime
);
19523 snprintf (timebuf
, sizeof (timebuf
),
19524 "%04u-%02u-%02uT%02u:%02u:%02u",
19525 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19526 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19528 printf ("%3zu: ", cnt
);
19530 printf ("%-20s", liblist
.l_name
< strtab_size
19531 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19533 printf ("%-20.20s", liblist
.l_name
< strtab_size
19534 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19535 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
19536 liblist
.l_version
, liblist
.l_flags
);
19547 static const char *
19548 get_note_type (Filedata
* filedata
, unsigned e_type
)
19550 static char buff
[64];
19552 if (filedata
->file_header
.e_type
== ET_CORE
)
19556 return _("NT_AUXV (auxiliary vector)");
19558 return _("NT_PRSTATUS (prstatus structure)");
19560 return _("NT_FPREGSET (floating point registers)");
19562 return _("NT_PRPSINFO (prpsinfo structure)");
19563 case NT_TASKSTRUCT
:
19564 return _("NT_TASKSTRUCT (task structure)");
19566 return _("NT_GDB_TDESC (GDB XML target description)");
19568 return _("NT_PRXFPREG (user_xfpregs structure)");
19570 return _("NT_PPC_VMX (ppc Altivec registers)");
19572 return _("NT_PPC_VSX (ppc VSX registers)");
19574 return _("NT_PPC_TAR (ppc TAR register)");
19576 return _("NT_PPC_PPR (ppc PPR register)");
19578 return _("NT_PPC_DSCR (ppc DSCR register)");
19580 return _("NT_PPC_EBB (ppc EBB registers)");
19582 return _("NT_PPC_PMU (ppc PMU registers)");
19583 case NT_PPC_TM_CGPR
:
19584 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
19585 case NT_PPC_TM_CFPR
:
19586 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
19587 case NT_PPC_TM_CVMX
:
19588 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
19589 case NT_PPC_TM_CVSX
:
19590 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
19591 case NT_PPC_TM_SPR
:
19592 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
19593 case NT_PPC_TM_CTAR
:
19594 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
19595 case NT_PPC_TM_CPPR
:
19596 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
19597 case NT_PPC_TM_CDSCR
:
19598 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
19600 return _("NT_386_TLS (x86 TLS information)");
19601 case NT_386_IOPERM
:
19602 return _("NT_386_IOPERM (x86 I/O permissions)");
19603 case NT_X86_XSTATE
:
19604 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
19606 return _("NT_X86_CET (x86 CET state)");
19607 case NT_S390_HIGH_GPRS
:
19608 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
19609 case NT_S390_TIMER
:
19610 return _("NT_S390_TIMER (s390 timer register)");
19611 case NT_S390_TODCMP
:
19612 return _("NT_S390_TODCMP (s390 TOD comparator register)");
19613 case NT_S390_TODPREG
:
19614 return _("NT_S390_TODPREG (s390 TOD programmable register)");
19616 return _("NT_S390_CTRS (s390 control registers)");
19617 case NT_S390_PREFIX
:
19618 return _("NT_S390_PREFIX (s390 prefix register)");
19619 case NT_S390_LAST_BREAK
:
19620 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
19621 case NT_S390_SYSTEM_CALL
:
19622 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
19624 return _("NT_S390_TDB (s390 transaction diagnostic block)");
19625 case NT_S390_VXRS_LOW
:
19626 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
19627 case NT_S390_VXRS_HIGH
:
19628 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
19629 case NT_S390_GS_CB
:
19630 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
19631 case NT_S390_GS_BC
:
19632 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
19634 return _("NT_ARM_VFP (arm VFP registers)");
19636 return _("NT_ARM_TLS (AArch TLS registers)");
19637 case NT_ARM_HW_BREAK
:
19638 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
19639 case NT_ARM_HW_WATCH
:
19640 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
19641 case NT_ARM_SYSTEM_CALL
:
19642 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
19644 return _("NT_ARM_SVE (AArch SVE registers)");
19645 case NT_ARM_PAC_MASK
:
19646 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
19647 case NT_ARM_PACA_KEYS
:
19648 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
19649 case NT_ARM_PACG_KEYS
:
19650 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
19651 case NT_ARM_TAGGED_ADDR_CTRL
:
19652 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
19654 return _("NT_ARM_SSVE (AArch64 streaming SVE registers)");
19656 return _("NT_ARM_ZA (AArch64 SME ZA register)");
19657 case NT_ARM_PAC_ENABLED_KEYS
:
19658 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
19660 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
19662 return _("NT_RISCV_CSR (RISC-V control and status registers)");
19664 return _("NT_PSTATUS (pstatus structure)");
19666 return _("NT_FPREGS (floating point registers)");
19668 return _("NT_PSINFO (psinfo structure)");
19670 return _("NT_LWPSTATUS (lwpstatus_t structure)");
19672 return _("NT_LWPSINFO (lwpsinfo_t structure)");
19673 case NT_WIN32PSTATUS
:
19674 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
19676 return _("NT_SIGINFO (siginfo_t data)");
19678 return _("NT_FILE (mapped files)");
19686 return _("NT_VERSION (version)");
19688 return _("NT_ARCH (architecture)");
19689 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19691 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19693 case NT_GO_BUILDID
:
19694 return _("GO BUILDID");
19695 case FDO_PACKAGING_METADATA
:
19696 return _("FDO_PACKAGING_METADATA");
19701 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19706 print_core_note (Elf_Internal_Note
*pnote
)
19708 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
19709 uint64_t count
, page_size
;
19710 unsigned char *descdata
, *filenames
, *descend
;
19712 if (pnote
->type
!= NT_FILE
)
19721 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
19722 /* Still "successful". */
19726 if (pnote
->descsz
< 2 * addr_size
)
19728 error (_(" Malformed note - too short for header\n"));
19732 descdata
= (unsigned char *) pnote
->descdata
;
19733 descend
= descdata
+ pnote
->descsz
;
19735 if (descdata
[pnote
->descsz
- 1] != '\0')
19737 error (_(" Malformed note - does not end with \\0\n"));
19741 count
= byte_get (descdata
, addr_size
);
19742 descdata
+= addr_size
;
19744 page_size
= byte_get (descdata
, addr_size
);
19745 descdata
+= addr_size
;
19747 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
19748 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
19750 error (_(" Malformed note - too short for supplied file count\n"));
19754 printf (_(" Page size: "));
19755 print_vma (page_size
, DEC
);
19758 printf (_(" %*s%*s%*s\n"),
19759 (int) (2 + 2 * addr_size
), _("Start"),
19760 (int) (4 + 2 * addr_size
), _("End"),
19761 (int) (4 + 2 * addr_size
), _("Page Offset"));
19762 filenames
= descdata
+ count
* 3 * addr_size
;
19763 while (count
-- > 0)
19765 uint64_t start
, end
, file_ofs
;
19767 if (filenames
== descend
)
19769 error (_(" Malformed note - filenames end too early\n"));
19773 start
= byte_get (descdata
, addr_size
);
19774 descdata
+= addr_size
;
19775 end
= byte_get (descdata
, addr_size
);
19776 descdata
+= addr_size
;
19777 file_ofs
= byte_get (descdata
, addr_size
);
19778 descdata
+= addr_size
;
19781 print_vma (start
, FULL_HEX
);
19783 print_vma (end
, FULL_HEX
);
19785 print_vma (file_ofs
, FULL_HEX
);
19786 printf ("\n %s\n", filenames
);
19788 filenames
+= 1 + strlen ((char *) filenames
);
19794 static const char *
19795 get_gnu_elf_note_type (unsigned e_type
)
19797 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
19800 case NT_GNU_ABI_TAG
:
19801 return _("NT_GNU_ABI_TAG (ABI version tag)");
19803 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
19804 case NT_GNU_BUILD_ID
:
19805 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
19806 case NT_GNU_GOLD_VERSION
:
19807 return _("NT_GNU_GOLD_VERSION (gold version)");
19808 case NT_GNU_PROPERTY_TYPE_0
:
19809 return _("NT_GNU_PROPERTY_TYPE_0");
19810 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19811 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
19812 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19813 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
19816 static char buff
[64];
19818 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19825 decode_x86_compat_isa (unsigned int bitmask
)
19829 unsigned int bit
= bitmask
& (- bitmask
);
19834 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
19837 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
19840 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
19843 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
19846 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
19849 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
19852 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
19855 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
19858 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
19861 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
19864 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
19867 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
19868 printf ("AVX512F");
19870 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
19871 printf ("AVX512CD");
19873 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
19874 printf ("AVX512ER");
19876 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
19877 printf ("AVX512PF");
19879 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
19880 printf ("AVX512VL");
19882 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
19883 printf ("AVX512DQ");
19885 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
19886 printf ("AVX512BW");
19889 printf (_("<unknown: %x>"), bit
);
19898 decode_x86_compat_2_isa (unsigned int bitmask
)
19902 printf (_("<None>"));
19908 unsigned int bit
= bitmask
& (- bitmask
);
19913 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
19916 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
19919 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19922 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19925 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19928 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19931 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19934 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19937 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19940 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19943 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19944 printf ("AVX512F");
19946 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19947 printf ("AVX512CD");
19949 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19950 printf ("AVX512ER");
19952 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19953 printf ("AVX512PF");
19955 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19956 printf ("AVX512VL");
19958 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19959 printf ("AVX512DQ");
19961 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19962 printf ("AVX512BW");
19964 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19965 printf ("AVX512_4FMAPS");
19967 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19968 printf ("AVX512_4VNNIW");
19970 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19971 printf ("AVX512_BITALG");
19973 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19974 printf ("AVX512_IFMA");
19976 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19977 printf ("AVX512_VBMI");
19979 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19980 printf ("AVX512_VBMI2");
19982 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19983 printf ("AVX512_VNNI");
19985 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19986 printf ("AVX512_BF16");
19989 printf (_("<unknown: %x>"), bit
);
19997 static const char *
19998 get_amdgpu_elf_note_type (unsigned int e_type
)
20002 case NT_AMDGPU_METADATA
:
20003 return _("NT_AMDGPU_METADATA (code object metadata)");
20006 static char buf
[64];
20007 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
20014 decode_x86_isa (unsigned int bitmask
)
20018 unsigned int bit
= bitmask
& (- bitmask
);
20023 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
20024 printf ("x86-64-baseline");
20026 case GNU_PROPERTY_X86_ISA_1_V2
:
20027 printf ("x86-64-v2");
20029 case GNU_PROPERTY_X86_ISA_1_V3
:
20030 printf ("x86-64-v3");
20032 case GNU_PROPERTY_X86_ISA_1_V4
:
20033 printf ("x86-64-v4");
20036 printf (_("<unknown: %x>"), bit
);
20045 decode_x86_feature_1 (unsigned int bitmask
)
20049 printf (_("<None>"));
20055 unsigned int bit
= bitmask
& (- bitmask
);
20060 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
20063 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
20066 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
20067 printf ("LAM_U48");
20069 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
20070 printf ("LAM_U57");
20073 printf (_("<unknown: %x>"), bit
);
20082 decode_x86_feature_2 (unsigned int bitmask
)
20086 printf (_("<None>"));
20092 unsigned int bit
= bitmask
& (- bitmask
);
20097 case GNU_PROPERTY_X86_FEATURE_2_X86
:
20100 case GNU_PROPERTY_X86_FEATURE_2_X87
:
20103 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
20106 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
20109 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
20112 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
20115 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
20118 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
20121 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
20124 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
20127 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
20128 printf ("XSAVEOPT");
20130 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
20134 printf (_("<unknown: %x>"), bit
);
20143 decode_aarch64_feature_1_and (unsigned int bitmask
)
20147 unsigned int bit
= bitmask
& (- bitmask
);
20152 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
20156 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
20161 printf (_("<unknown: %x>"), bit
);
20170 decode_1_needed (unsigned int bitmask
)
20174 unsigned int bit
= bitmask
& (- bitmask
);
20179 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
20180 printf ("indirect external access");
20183 printf (_("<unknown: %x>"), bit
);
20192 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
20194 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
20195 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
20196 unsigned int size
= is_32bit_elf
? 4 : 8;
20198 printf (_(" Properties: "));
20200 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
20202 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
20206 while (ptr
< ptr_end
)
20210 unsigned int datasz
;
20212 if ((size_t) (ptr_end
- ptr
) < 8)
20214 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
20218 type
= byte_get (ptr
, 4);
20219 datasz
= byte_get (ptr
+ 4, 4);
20223 if (datasz
> (size_t) (ptr_end
- ptr
))
20225 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
20230 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
20232 if (filedata
->file_header
.e_machine
== EM_X86_64
20233 || filedata
->file_header
.e_machine
== EM_IAMCU
20234 || filedata
->file_header
.e_machine
== EM_386
)
20236 unsigned int bitmask
;
20239 bitmask
= byte_get (ptr
, 4);
20245 case GNU_PROPERTY_X86_ISA_1_USED
:
20247 printf (_("x86 ISA used: <corrupt length: %#x> "),
20251 printf ("x86 ISA used: ");
20252 decode_x86_isa (bitmask
);
20256 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
20258 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20262 printf ("x86 ISA needed: ");
20263 decode_x86_isa (bitmask
);
20267 case GNU_PROPERTY_X86_FEATURE_1_AND
:
20269 printf (_("x86 feature: <corrupt length: %#x> "),
20273 printf ("x86 feature: ");
20274 decode_x86_feature_1 (bitmask
);
20278 case GNU_PROPERTY_X86_FEATURE_2_USED
:
20280 printf (_("x86 feature used: <corrupt length: %#x> "),
20284 printf ("x86 feature used: ");
20285 decode_x86_feature_2 (bitmask
);
20289 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
20291 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
20294 printf ("x86 feature needed: ");
20295 decode_x86_feature_2 (bitmask
);
20299 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
20301 printf (_("x86 ISA used: <corrupt length: %#x> "),
20305 printf ("x86 ISA used: ");
20306 decode_x86_compat_isa (bitmask
);
20310 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
20312 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20316 printf ("x86 ISA needed: ");
20317 decode_x86_compat_isa (bitmask
);
20321 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
20323 printf (_("x86 ISA used: <corrupt length: %#x> "),
20327 printf ("x86 ISA used: ");
20328 decode_x86_compat_2_isa (bitmask
);
20332 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
20334 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20338 printf ("x86 ISA needed: ");
20339 decode_x86_compat_2_isa (bitmask
);
20347 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
20349 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
20351 printf ("AArch64 feature: ");
20353 printf (_("<corrupt length: %#x> "), datasz
);
20355 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
20364 case GNU_PROPERTY_STACK_SIZE
:
20365 printf (_("stack size: "));
20366 if (datasz
!= size
)
20367 printf (_("<corrupt length: %#x> "), datasz
);
20369 printf ("%#" PRIx64
, byte_get (ptr
, size
));
20372 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
20373 printf ("no copy on protected ");
20375 printf (_("<corrupt length: %#x> "), datasz
);
20379 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
20380 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
20381 || (type
>= GNU_PROPERTY_UINT32_OR_LO
20382 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
20386 case GNU_PROPERTY_1_NEEDED
:
20388 printf (_("1_needed: <corrupt length: %#x> "),
20392 unsigned int bitmask
= byte_get (ptr
, 4);
20393 printf ("1_needed: ");
20394 decode_1_needed (bitmask
);
20401 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
20402 printf (_("UINT32_AND (%#x): "), type
);
20404 printf (_("UINT32_OR (%#x): "), type
);
20406 printf (_("<corrupt length: %#x> "), datasz
);
20408 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
20415 if (type
< GNU_PROPERTY_LOPROC
)
20416 printf (_("<unknown type %#x data: "), type
);
20417 else if (type
< GNU_PROPERTY_LOUSER
)
20418 printf (_("<processor-specific type %#x data: "), type
);
20420 printf (_("<application-specific type %#x data: "), type
);
20421 for (j
= 0; j
< datasz
; ++j
)
20422 printf ("%02x ", ptr
[j
] & 0xff);
20426 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
20427 if (ptr
== ptr_end
)
20440 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
20442 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
20443 switch (pnote
->type
)
20445 case NT_GNU_BUILD_ID
:
20449 printf (_(" Build ID: "));
20450 for (i
= 0; i
< pnote
->descsz
; ++i
)
20451 printf ("%02x", pnote
->descdata
[i
] & 0xff);
20456 case NT_GNU_ABI_TAG
:
20458 unsigned int os
, major
, minor
, subminor
;
20459 const char *osname
;
20461 /* PR 17531: file: 030-599401-0.004. */
20462 if (pnote
->descsz
< 16)
20464 printf (_(" <corrupt GNU_ABI_TAG>\n"));
20468 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20469 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20470 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
20471 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
20475 case GNU_ABI_TAG_LINUX
:
20478 case GNU_ABI_TAG_HURD
:
20481 case GNU_ABI_TAG_SOLARIS
:
20482 osname
= "Solaris";
20484 case GNU_ABI_TAG_FREEBSD
:
20485 osname
= "FreeBSD";
20487 case GNU_ABI_TAG_NETBSD
:
20490 case GNU_ABI_TAG_SYLLABLE
:
20491 osname
= "Syllable";
20493 case GNU_ABI_TAG_NACL
:
20497 osname
= "Unknown";
20501 printf (_(" OS: %s, ABI: %d.%d.%d\n"), osname
,
20502 major
, minor
, subminor
);
20506 case NT_GNU_GOLD_VERSION
:
20510 printf (_(" Version: "));
20511 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
20512 printf ("%c", pnote
->descdata
[i
]);
20519 unsigned int num_entries
, mask
;
20521 /* Hardware capabilities information. Word 0 is the number of entries.
20522 Word 1 is a bitmask of enabled entries. The rest of the descriptor
20523 is a series of entries, where each entry is a single byte followed
20524 by a nul terminated string. The byte gives the bit number to test
20525 if enabled in the bitmask. */
20526 printf (_(" Hardware Capabilities: "));
20527 if (pnote
->descsz
< 8)
20529 error (_("<corrupt GNU_HWCAP>\n"));
20532 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20533 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20534 printf (_("num entries: %d, enabled mask: %x\n"), num_entries
, mask
);
20535 /* FIXME: Add code to display the entries... */
20539 case NT_GNU_PROPERTY_TYPE_0
:
20540 print_gnu_property_note (filedata
, pnote
);
20544 /* Handle unrecognised types. An error message should have already been
20545 created by get_gnu_elf_note_type(), so all that we need to do is to
20546 display the data. */
20550 printf (_(" Description data: "));
20551 for (i
= 0; i
< pnote
->descsz
; ++i
)
20552 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20561 static const char *
20562 get_v850_elf_note_type (enum v850_notes n_type
)
20564 static char buff
[64];
20568 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
20569 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
20570 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
20571 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
20572 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
20573 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
20575 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
20581 print_v850_note (Elf_Internal_Note
* pnote
)
20585 if (pnote
->descsz
!= 4)
20588 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
20592 printf (_("not set\n"));
20596 switch (pnote
->type
)
20598 case V850_NOTE_ALIGNMENT
:
20601 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
20602 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
20606 case V850_NOTE_DATA_SIZE
:
20609 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
20610 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
20614 case V850_NOTE_FPU_INFO
:
20617 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
20618 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
20622 case V850_NOTE_MMU_INFO
:
20623 case V850_NOTE_CACHE_INFO
:
20624 case V850_NOTE_SIMD_INFO
:
20625 if (val
== EF_RH850_SIMD
)
20627 printf (_("yes\n"));
20633 /* An 'unknown note type' message will already have been displayed. */
20637 printf (_("unknown value: %x\n"), val
);
20642 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
20644 unsigned int version
;
20646 switch (pnote
->type
)
20648 case NT_NETBSD_IDENT
:
20649 if (pnote
->descsz
< 1)
20651 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20652 if ((version
/ 10000) % 100)
20653 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
20654 version
, version
/ 100000000, (version
/ 1000000) % 100,
20655 (version
/ 10000) % 100 > 26 ? "Z" : "",
20656 'A' + (version
/ 10000) % 26);
20658 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
20659 version
, version
/ 100000000, (version
/ 1000000) % 100,
20660 (version
/ 100) % 100);
20663 case NT_NETBSD_MARCH
:
20664 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
20668 case NT_NETBSD_PAX
:
20669 if (pnote
->descsz
< 1)
20671 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20672 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
20673 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
20674 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
20675 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
20676 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
20677 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
20678 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
20682 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
20683 pnote
->descsz
, pnote
->type
);
20687 static const char *
20688 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20692 case NT_FREEBSD_THRMISC
:
20693 return _("NT_THRMISC (thrmisc structure)");
20694 case NT_FREEBSD_PROCSTAT_PROC
:
20695 return _("NT_PROCSTAT_PROC (proc data)");
20696 case NT_FREEBSD_PROCSTAT_FILES
:
20697 return _("NT_PROCSTAT_FILES (files data)");
20698 case NT_FREEBSD_PROCSTAT_VMMAP
:
20699 return _("NT_PROCSTAT_VMMAP (vmmap data)");
20700 case NT_FREEBSD_PROCSTAT_GROUPS
:
20701 return _("NT_PROCSTAT_GROUPS (groups data)");
20702 case NT_FREEBSD_PROCSTAT_UMASK
:
20703 return _("NT_PROCSTAT_UMASK (umask data)");
20704 case NT_FREEBSD_PROCSTAT_RLIMIT
:
20705 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
20706 case NT_FREEBSD_PROCSTAT_OSREL
:
20707 return _("NT_PROCSTAT_OSREL (osreldate data)");
20708 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
20709 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
20710 case NT_FREEBSD_PROCSTAT_AUXV
:
20711 return _("NT_PROCSTAT_AUXV (auxv data)");
20712 case NT_FREEBSD_PTLWPINFO
:
20713 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
20714 case NT_FREEBSD_X86_SEGBASES
:
20715 return _("NT_X86_SEGBASES (x86 segment base registers)");
20717 return get_note_type (filedata
, e_type
);
20720 static const char *
20721 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20723 static char buff
[64];
20727 case NT_NETBSDCORE_PROCINFO
:
20728 /* NetBSD core "procinfo" structure. */
20729 return _("NetBSD procinfo structure");
20731 case NT_NETBSDCORE_AUXV
:
20732 return _("NetBSD ELF auxiliary vector data");
20734 case NT_NETBSDCORE_LWPSTATUS
:
20735 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
20738 /* As of Jan 2020 there are no other machine-independent notes
20739 defined for NetBSD core files. If the note type is less
20740 than the start of the machine-dependent note types, we don't
20743 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
20745 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20751 switch (filedata
->file_header
.e_machine
)
20753 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
20754 and PT_GETFPREGS == mach+2. */
20759 case EM_SPARC32PLUS
:
20763 case NT_NETBSDCORE_FIRSTMACH
+ 0:
20764 return _("PT_GETREGS (reg structure)");
20765 case NT_NETBSDCORE_FIRSTMACH
+ 2:
20766 return _("PT_GETFPREGS (fpreg structure)");
20772 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
20773 There's also old PT___GETREGS40 == mach + 1 for old reg
20774 structure which lacks GBR. */
20778 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20779 return _("PT___GETREGS40 (old reg structure)");
20780 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20781 return _("PT_GETREGS (reg structure)");
20782 case NT_NETBSDCORE_FIRSTMACH
+ 5:
20783 return _("PT_GETFPREGS (fpreg structure)");
20789 /* On all other arch's, PT_GETREGS == mach+1 and
20790 PT_GETFPREGS == mach+3. */
20794 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20795 return _("PT_GETREGS (reg structure)");
20796 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20797 return _("PT_GETFPREGS (fpreg structure)");
20803 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
20804 e_type
- NT_NETBSDCORE_FIRSTMACH
);
20808 static const char *
20809 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20813 case NT_OPENBSD_PROCINFO
:
20814 return _("OpenBSD procinfo structure");
20815 case NT_OPENBSD_AUXV
:
20816 return _("OpenBSD ELF auxiliary vector data");
20817 case NT_OPENBSD_REGS
:
20818 return _("OpenBSD regular registers");
20819 case NT_OPENBSD_FPREGS
:
20820 return _("OpenBSD floating point registers");
20821 case NT_OPENBSD_WCOOKIE
:
20822 return _("OpenBSD window cookie");
20825 return get_note_type (filedata
, e_type
);
20828 static const char *
20829 get_qnx_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20833 case QNT_DEBUG_FULLPATH
:
20834 return _("QNX debug fullpath");
20835 case QNT_DEBUG_RELOC
:
20836 return _("QNX debug relocation");
20838 return _("QNX stack");
20839 case QNT_GENERATOR
:
20840 return _("QNX generator");
20841 case QNT_DEFAULT_LIB
:
20842 return _("QNX default library");
20843 case QNT_CORE_SYSINFO
:
20844 return _("QNX core sysinfo");
20845 case QNT_CORE_INFO
:
20846 return _("QNX core info");
20847 case QNT_CORE_STATUS
:
20848 return _("QNX core status");
20849 case QNT_CORE_GREG
:
20850 return _("QNX general registers");
20851 case QNT_CORE_FPREG
:
20852 return _("QNX floating point registers");
20854 return _("QNX link map");
20857 return get_note_type (filedata
, e_type
);
20860 static const char *
20861 get_stapsdt_note_type (unsigned e_type
)
20863 static char buff
[64];
20868 return _("NT_STAPSDT (SystemTap probe descriptors)");
20874 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20879 print_stapsdt_note (Elf_Internal_Note
*pnote
)
20881 size_t len
, maxlen
;
20882 size_t addr_size
= is_32bit_elf
? 4 : 8;
20883 char *data
= pnote
->descdata
;
20884 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
20885 uint64_t pc
, base_addr
, semaphore
;
20886 char *provider
, *probe
, *arg_fmt
;
20888 if (pnote
->descsz
< (addr_size
* 3))
20889 goto stapdt_note_too_small
;
20891 pc
= byte_get ((unsigned char *) data
, addr_size
);
20894 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
20897 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
20900 if (data
>= data_end
)
20901 goto stapdt_note_too_small
;
20902 maxlen
= data_end
- data
;
20903 len
= strnlen (data
, maxlen
);
20910 goto stapdt_note_too_small
;
20912 if (data
>= data_end
)
20913 goto stapdt_note_too_small
;
20914 maxlen
= data_end
- data
;
20915 len
= strnlen (data
, maxlen
);
20922 goto stapdt_note_too_small
;
20924 if (data
>= data_end
)
20925 goto stapdt_note_too_small
;
20926 maxlen
= data_end
- data
;
20927 len
= strnlen (data
, maxlen
);
20934 goto stapdt_note_too_small
;
20936 printf (_(" Provider: %s\n"), provider
);
20937 printf (_(" Name: %s\n"), probe
);
20938 printf (_(" Location: "));
20939 print_vma (pc
, FULL_HEX
);
20940 printf (_(", Base: "));
20941 print_vma (base_addr
, FULL_HEX
);
20942 printf (_(", Semaphore: "));
20943 print_vma (semaphore
, FULL_HEX
);
20945 printf (_(" Arguments: %s\n"), arg_fmt
);
20947 return data
== data_end
;
20949 stapdt_note_too_small
:
20950 printf (_(" <corrupt - note is too small>\n"));
20951 error (_("corrupt stapdt note - the data size is too small\n"));
20956 print_fdo_note (Elf_Internal_Note
* pnote
)
20958 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
20960 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
20966 static const char *
20967 get_ia64_vms_note_type (unsigned e_type
)
20969 static char buff
[64];
20974 return _("NT_VMS_MHD (module header)");
20976 return _("NT_VMS_LNM (language name)");
20978 return _("NT_VMS_SRC (source files)");
20980 return "NT_VMS_TITLE";
20982 return _("NT_VMS_EIDC (consistency check)");
20983 case NT_VMS_FPMODE
:
20984 return _("NT_VMS_FPMODE (FP mode)");
20985 case NT_VMS_LINKTIME
:
20986 return "NT_VMS_LINKTIME";
20987 case NT_VMS_IMGNAM
:
20988 return _("NT_VMS_IMGNAM (image name)");
20990 return _("NT_VMS_IMGID (image id)");
20991 case NT_VMS_LINKID
:
20992 return _("NT_VMS_LINKID (link id)");
20993 case NT_VMS_IMGBID
:
20994 return _("NT_VMS_IMGBID (build id)");
20995 case NT_VMS_GSTNAM
:
20996 return _("NT_VMS_GSTNAM (sym table name)");
20997 case NT_VMS_ORIG_DYN
:
20998 return "NT_VMS_ORIG_DYN";
20999 case NT_VMS_PATCHTIME
:
21000 return "NT_VMS_PATCHTIME";
21002 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21008 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
21010 unsigned int maxlen
= pnote
->descsz
;
21012 if (maxlen
< 2 || maxlen
!= pnote
->descsz
)
21013 goto desc_size_fail
;
21015 switch (pnote
->type
)
21019 goto desc_size_fail
;
21021 size_t l
= strnlen (pnote
->descdata
+ 34, maxlen
- 34);
21023 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
21024 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
21025 if (l
+ 34 < maxlen
)
21027 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
21028 if (l
+ 35 < maxlen
)
21029 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
21031 printf (_(" Module version : <missing>\n"));
21035 printf (_(" Module name : <missing>\n"));
21036 printf (_(" Module version : <missing>\n"));
21041 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
21044 case NT_VMS_FPMODE
:
21045 printf (_(" Floating Point mode: "));
21047 goto desc_size_fail
;
21048 /* FIXME: Generate an error if descsz > 8 ? */
21050 printf ("0x%016" PRIx64
"\n",
21051 byte_get ((unsigned char *) pnote
->descdata
, 8));
21054 case NT_VMS_LINKTIME
:
21055 printf (_(" Link time: "));
21057 goto desc_size_fail
;
21058 /* FIXME: Generate an error if descsz > 8 ? */
21060 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21064 case NT_VMS_PATCHTIME
:
21065 printf (_(" Patch time: "));
21067 goto desc_size_fail
;
21068 /* FIXME: Generate an error if descsz > 8 ? */
21070 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21074 case NT_VMS_ORIG_DYN
:
21076 goto desc_size_fail
;
21078 printf (_(" Major id: %u, minor id: %u\n"),
21079 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
21080 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
21081 printf (_(" Last modified : "));
21082 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
21083 printf (_("\n Link flags : "));
21084 printf ("0x%016" PRIx64
"\n",
21085 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
21086 printf (_(" Header flags: 0x%08x\n"),
21087 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
21088 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
21091 case NT_VMS_IMGNAM
:
21092 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
21095 case NT_VMS_GSTNAM
:
21096 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
21100 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
21103 case NT_VMS_LINKID
:
21104 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
21114 printf (_(" <corrupt - data size is too small>\n"));
21115 error (_("corrupt IA64 note: data size is too small\n"));
21119 struct build_attr_cache
{
21120 Filedata
*filedata
;
21122 uint64_t strtablen
;
21123 Elf_Internal_Sym
*symtab
;
21127 /* Find the symbol associated with a build attribute that is attached
21128 to address OFFSET. If PNAME is non-NULL then store the name of
21129 the symbol (if found) in the provided pointer, Returns NULL if a
21130 symbol could not be found. */
21132 static Elf_Internal_Sym
*
21133 get_symbol_for_build_attribute (Filedata
*filedata
,
21136 const char **pname
)
21138 Elf_Internal_Sym
*saved_sym
= NULL
;
21139 Elf_Internal_Sym
*sym
;
21141 if (filedata
->section_headers
!= NULL
21142 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
21144 Elf_Internal_Shdr
* symsec
;
21146 free (ba_cache
.strtab
);
21147 ba_cache
.strtab
= NULL
;
21148 free (ba_cache
.symtab
);
21149 ba_cache
.symtab
= NULL
;
21151 /* Load the symbol and string sections. */
21152 for (symsec
= filedata
->section_headers
;
21153 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
21156 if (symsec
->sh_type
== SHT_SYMTAB
21157 && get_symtab (filedata
, symsec
,
21158 &ba_cache
.symtab
, &ba_cache
.nsyms
,
21159 &ba_cache
.strtab
, &ba_cache
.strtablen
))
21162 ba_cache
.filedata
= filedata
;
21165 if (ba_cache
.symtab
== NULL
)
21168 /* Find a symbol whose value matches offset. */
21169 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
21170 if (sym
->st_value
== offset
)
21172 if (sym
->st_name
>= ba_cache
.strtablen
)
21173 /* Huh ? This should not happen. */
21176 if (ba_cache
.strtab
[sym
->st_name
] == 0)
21179 /* The AArch64, ARM and RISC-V architectures define mapping symbols
21180 (eg $d, $x, $t) which we want to ignore. */
21181 if (ba_cache
.strtab
[sym
->st_name
] == '$'
21182 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
21183 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
21188 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
21189 and FILE or OBJECT symbols over NOTYPE symbols. We skip
21190 FUNC symbols entirely. */
21191 switch (ELF_ST_TYPE (sym
->st_info
))
21198 /* If the symbol has a size associated
21199 with it then we can stop searching. */
21200 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
21205 /* Ignore function symbols. */
21212 switch (ELF_ST_BIND (sym
->st_info
))
21215 if (saved_sym
== NULL
21216 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
21221 if (saved_sym
== NULL
)
21231 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
21239 if (saved_sym
&& pname
)
21240 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
21245 /* Returns true iff addr1 and addr2 are in the same section. */
21248 same_section (Filedata
* filedata
, uint64_t addr1
, uint64_t addr2
)
21250 Elf_Internal_Shdr
* a1
;
21251 Elf_Internal_Shdr
* a2
;
21253 a1
= find_section_by_address (filedata
, addr1
);
21254 a2
= find_section_by_address (filedata
, addr2
);
21256 return a1
== a2
&& a1
!= NULL
;
21260 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
21261 Filedata
* filedata
)
21263 static uint64_t global_offset
= 0;
21264 static uint64_t global_end
= 0;
21265 static uint64_t func_offset
= 0;
21266 static uint64_t func_end
= 0;
21268 Elf_Internal_Sym
*sym
;
21272 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
21274 switch (pnote
->descsz
)
21277 /* A zero-length description means that the range of
21278 the previous note of the same type should be used. */
21281 if (global_end
> global_offset
)
21282 printf (_(" Applies to region from %#" PRIx64
21283 " to %#" PRIx64
"\n"), global_offset
, global_end
);
21285 printf (_(" Applies to region from %#" PRIx64
21286 "\n"), global_offset
);
21290 if (func_end
> func_offset
)
21291 printf (_(" Applies to region from %#" PRIx64
21292 " to %#" PRIx64
"\n"), func_offset
, func_end
);
21294 printf (_(" Applies to region from %#" PRIx64
21295 "\n"), func_offset
);
21300 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21305 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21306 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21310 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
21311 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
21315 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
21316 printf (_(" <invalid descsz>"));
21321 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
21322 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
21323 in order to avoid them being confused with the start address of the
21324 first function in the file... */
21325 if (sym
== NULL
&& is_open_attr
)
21326 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
21329 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
21330 end
= start
+ sym
->st_size
;
21334 /* FIXME: Need to properly allow for section alignment.
21335 16 is just the alignment used on x86_64. */
21337 && start
> BFD_ALIGN (global_end
, 16)
21338 /* Build notes are not guaranteed to be organised in order of
21339 increasing address, but we should find the all of the notes
21340 for one section in the same place. */
21341 && same_section (filedata
, start
, global_end
))
21342 warn (_("Gap in build notes detected from %#" PRIx64
21343 " to %#" PRIx64
"\n"),
21344 global_end
+ 1, start
- 1);
21346 printf (_(" Applies to region from %#" PRIx64
), start
);
21347 global_offset
= start
;
21351 printf (_(" to %#" PRIx64
), end
);
21357 printf (_(" Applies to region from %#" PRIx64
), start
);
21358 func_offset
= start
;
21362 printf (_(" to %#" PRIx64
), end
);
21368 printf (_(" (%s)"), name
);
21375 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
21377 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
21378 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
21379 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
21381 char name_attribute
;
21382 const char * expected_types
;
21383 const char * name
= pnote
->namedata
;
21387 if (name
== NULL
|| pnote
->namesz
< 2)
21389 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21390 print_symbol (-20, _(" <corrupt name>"));
21399 /* Version 2 of the spec adds a "GA" prefix to the name field. */
21400 if (name
[0] == 'G' && name
[1] == 'A')
21402 if (pnote
->namesz
< 4)
21404 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21405 print_symbol (-20, _(" <corrupt name>"));
21414 switch ((name_type
= * name
))
21416 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21417 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21418 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21419 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21420 printf ("%c", * name
);
21424 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
21425 print_symbol (-20, _("<unknown name type>"));
21432 switch ((name_attribute
= * name
))
21434 case GNU_BUILD_ATTRIBUTE_VERSION
:
21435 text
= _("<version>");
21436 expected_types
= string_expected
;
21439 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21440 text
= _("<stack prot>");
21441 expected_types
= "!+*";
21444 case GNU_BUILD_ATTRIBUTE_RELRO
:
21445 text
= _("<relro>");
21446 expected_types
= bool_expected
;
21449 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
21450 text
= _("<stack size>");
21451 expected_types
= number_expected
;
21454 case GNU_BUILD_ATTRIBUTE_TOOL
:
21455 text
= _("<tool>");
21456 expected_types
= string_expected
;
21459 case GNU_BUILD_ATTRIBUTE_ABI
:
21461 expected_types
= "$*";
21464 case GNU_BUILD_ATTRIBUTE_PIC
:
21466 expected_types
= number_expected
;
21469 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
21470 text
= _("<short enum>");
21471 expected_types
= bool_expected
;
21475 if (ISPRINT (* name
))
21477 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
21479 if (len
> left
&& ! do_wide
)
21481 printf ("%.*s:", len
, name
);
21487 static char tmpbuf
[128];
21489 error (_("unrecognised byte in name field: %d\n"), * name
);
21490 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
21494 expected_types
= "*$!+";
21499 left
-= printf ("%s", text
);
21501 if (strchr (expected_types
, name_type
) == NULL
)
21502 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
21504 if ((size_t) (name
- pnote
->namedata
) > pnote
->namesz
)
21506 error (_("corrupt name field: namesz: %lu but parsing gets to %td\n"),
21508 name
- pnote
->namedata
);
21512 if (left
< 1 && ! do_wide
)
21517 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21519 unsigned int bytes
;
21521 unsigned int shift
= 0;
21522 char *decoded
= NULL
;
21524 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
21526 /* The -1 is because the name field is always 0 terminated, and we
21527 want to be able to ensure that the shift in the while loop below
21528 will not overflow. */
21531 if (bytes
> sizeof (val
))
21533 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
21535 bytes
= sizeof (val
);
21537 /* We do not bother to warn if bytes == 0 as this can
21538 happen with some early versions of the gcc plugin. */
21542 uint64_t byte
= *name
++ & 0xff;
21544 val
|= byte
<< shift
;
21548 switch (name_attribute
)
21550 case GNU_BUILD_ATTRIBUTE_PIC
:
21553 case 0: decoded
= "static"; break;
21554 case 1: decoded
= "pic"; break;
21555 case 2: decoded
= "PIC"; break;
21556 case 3: decoded
= "pie"; break;
21557 case 4: decoded
= "PIE"; break;
21561 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21564 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
21565 case 0: decoded
= "off"; break;
21566 case 1: decoded
= "on"; break;
21567 case 2: decoded
= "all"; break;
21568 case 3: decoded
= "strong"; break;
21569 case 4: decoded
= "explicit"; break;
21577 if (decoded
!= NULL
)
21579 print_symbol (-left
, decoded
);
21590 left
-= printf ("0x%" PRIx64
, val
);
21592 left
-= printf ("0x%-.*" PRIx64
, left
, val
);
21596 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21597 left
-= print_symbol (- left
, name
);
21599 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21600 left
-= print_symbol (- left
, "true");
21602 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21603 left
-= print_symbol (- left
, "false");
21607 if (do_wide
&& left
> 0)
21608 printf ("%-*s", left
, " ");
21613 /* Print the contents of PNOTE as hex. */
21616 print_note_contents_hex (Elf_Internal_Note
*pnote
)
21622 printf (_(" description data: "));
21623 for (i
= 0; i
< pnote
->descsz
; i
++)
21624 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21633 #if defined HAVE_MSGPACK
21636 print_indents (int n
)
21640 for (int i
= 0; i
< n
; i
++)
21644 /* Print OBJ in human-readable form. */
21647 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
21651 case MSGPACK_OBJECT_NIL
:
21655 case MSGPACK_OBJECT_BOOLEAN
:
21656 printf ("%s", obj
->via
.boolean
? "true" : "false");
21659 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
21660 printf ("%" PRIu64
, obj
->via
.u64
);
21663 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
21664 printf ("%" PRIi64
, obj
->via
.i64
);
21667 case MSGPACK_OBJECT_FLOAT32
:
21668 case MSGPACK_OBJECT_FLOAT64
:
21669 printf ("%f", obj
->via
.f64
);
21672 case MSGPACK_OBJECT_STR
:
21673 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
21676 case MSGPACK_OBJECT_ARRAY
:
21678 const msgpack_object_array
*array
= &obj
->via
.array
;
21683 for (uint32_t i
= 0; i
< array
->size
; ++i
)
21685 const msgpack_object
*item
= &array
->ptr
[i
];
21687 print_indents (indent
);
21688 dump_msgpack_obj (item
, indent
);
21693 print_indents (indent
);
21699 case MSGPACK_OBJECT_MAP
:
21701 const msgpack_object_map
*map
= &obj
->via
.map
;
21706 for (uint32_t i
= 0; i
< map
->size
; ++i
)
21708 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
21709 const msgpack_object
*key
= &kv
->key
;
21710 const msgpack_object
*val
= &kv
->val
;
21712 print_indents (indent
);
21713 dump_msgpack_obj (key
, indent
);
21715 dump_msgpack_obj (val
, indent
);
21721 print_indents (indent
);
21727 case MSGPACK_OBJECT_BIN
:
21731 case MSGPACK_OBJECT_EXT
:
21738 dump_msgpack (const msgpack_unpacked
*msg
)
21741 dump_msgpack_obj (&msg
->data
, 0);
21745 #endif /* defined HAVE_MSGPACK */
21748 print_amdgpu_note (Elf_Internal_Note
*pnote
)
21750 #if defined HAVE_MSGPACK
21751 /* If msgpack is available, decode and dump the note's content. */
21753 msgpack_unpacked msg
;
21754 msgpack_unpack_return msgpack_ret
;
21756 assert (pnote
->type
== NT_AMDGPU_METADATA
);
21758 msgpack_unpacked_init (&msg
);
21759 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
21762 switch (msgpack_ret
)
21764 case MSGPACK_UNPACK_SUCCESS
:
21765 dump_msgpack (&msg
);
21770 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
21775 msgpack_unpacked_destroy (&msg
);
21778 /* msgpack is not available, dump contents as hex. */
21779 print_note_contents_hex (pnote
);
21785 print_qnx_note (Elf_Internal_Note
*pnote
)
21787 switch (pnote
->type
)
21790 if (pnote
->descsz
!= 12)
21791 goto desc_size_fail
;
21793 printf (_(" Stack Size: 0x%" PRIx32
"\n"),
21794 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4));
21795 printf (_(" Stack allocated: %" PRIx32
"\n"),
21796 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
21797 printf (_(" Executable: %s\n"),
21798 ((unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 8, 1)) ? "no": "yes");
21802 print_note_contents_hex(pnote
);
21807 printf (_(" <corrupt - data size is too small>\n"));
21808 error (_("corrupt QNX note: data size is too small\n"));
21813 /* Note that by the ELF standard, the name field is already null byte
21814 terminated, and namesz includes the terminating null byte.
21815 I.E. the value of namesz for the name "FSF" is 4.
21817 If the value of namesz is zero, there is no name present. */
21820 process_note (Elf_Internal_Note
* pnote
,
21821 Filedata
* filedata
)
21823 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
21826 if (pnote
->namesz
== 0)
21827 /* If there is no note name, then use the default set of
21828 note type strings. */
21829 nt
= get_note_type (filedata
, pnote
->type
);
21831 else if (startswith (pnote
->namedata
, "GNU"))
21832 /* GNU-specific object file notes. */
21833 nt
= get_gnu_elf_note_type (pnote
->type
);
21835 else if (startswith (pnote
->namedata
, "AMDGPU"))
21836 /* AMDGPU-specific object file notes. */
21837 nt
= get_amdgpu_elf_note_type (pnote
->type
);
21839 else if (startswith (pnote
->namedata
, "FreeBSD"))
21840 /* FreeBSD-specific core file notes. */
21841 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
21843 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
21844 /* NetBSD-specific core file notes. */
21845 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
21847 else if (startswith (pnote
->namedata
, "NetBSD"))
21848 /* NetBSD-specific core file notes. */
21849 return process_netbsd_elf_note (pnote
);
21851 else if (startswith (pnote
->namedata
, "PaX"))
21852 /* NetBSD-specific core file notes. */
21853 return process_netbsd_elf_note (pnote
);
21855 else if (startswith (pnote
->namedata
, "OpenBSD"))
21856 /* OpenBSD-specific core file notes. */
21857 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
21859 else if (startswith (pnote
->namedata
, "QNX"))
21860 /* QNX-specific core file notes. */
21861 nt
= get_qnx_elfcore_note_type (filedata
, pnote
->type
);
21863 else if (startswith (pnote
->namedata
, "SPU/"))
21865 /* SPU-specific core file notes. */
21866 nt
= pnote
->namedata
+ 4;
21870 else if (startswith (pnote
->namedata
, "IPF/VMS"))
21871 /* VMS/ia64-specific file notes. */
21872 nt
= get_ia64_vms_note_type (pnote
->type
);
21874 else if (startswith (pnote
->namedata
, "stapsdt"))
21875 nt
= get_stapsdt_note_type (pnote
->type
);
21878 /* Don't recognize this note name; just use the default set of
21879 note type strings. */
21880 nt
= get_note_type (filedata
, pnote
->type
);
21884 if (((startswith (pnote
->namedata
, "GA")
21885 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21886 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21887 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21888 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21889 print_gnu_build_attribute_name (pnote
);
21891 print_symbol (-20, name
);
21894 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
21896 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
21898 if (startswith (pnote
->namedata
, "IPF/VMS"))
21899 return print_ia64_vms_note (pnote
);
21900 else if (startswith (pnote
->namedata
, "GNU"))
21901 return print_gnu_note (filedata
, pnote
);
21902 else if (startswith (pnote
->namedata
, "stapsdt"))
21903 return print_stapsdt_note (pnote
);
21904 else if (startswith (pnote
->namedata
, "CORE"))
21905 return print_core_note (pnote
);
21906 else if (startswith (pnote
->namedata
, "FDO"))
21907 return print_fdo_note (pnote
);
21908 else if (((startswith (pnote
->namedata
, "GA")
21909 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21910 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21911 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21912 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21913 return print_gnu_build_attribute_description (pnote
, filedata
);
21914 else if (startswith (pnote
->namedata
, "AMDGPU")
21915 && pnote
->type
== NT_AMDGPU_METADATA
)
21916 return print_amdgpu_note (pnote
);
21917 else if (startswith (pnote
->namedata
, "QNX"))
21918 return print_qnx_note (pnote
);
21920 print_note_contents_hex (pnote
);
21925 process_notes_at (Filedata
* filedata
,
21926 Elf_Internal_Shdr
* section
,
21931 Elf_External_Note
*pnotes
;
21932 Elf_External_Note
*external
;
21941 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
21944 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
21952 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21955 if (pnotes
== NULL
)
21960 if (filedata
->is_separate
)
21961 printf (_("In linked file '%s': "), filedata
->file_name
);
21965 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
21967 printf (_("Displaying notes found at file offset 0x%08" PRIx64
21968 " with length 0x%08" PRIx64
":\n"),
21971 /* NB: Some note sections may have alignment value of 0 or 1. gABI
21972 specifies that notes should be aligned to 4 bytes in 32-bit
21973 objects and to 8 bytes in 64-bit objects. As a Linux extension,
21974 we also support 4 byte alignment in 64-bit objects. If section
21975 alignment is less than 4, we treate alignment as 4 bytes. */
21978 else if (align
!= 4 && align
!= 8)
21980 warn (_("Corrupt note: alignment %" PRId64
", expecting 4 or 8\n"),
21986 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
21988 end
= (char *) pnotes
+ length
;
21989 while ((char *) external
< end
)
21991 Elf_Internal_Note inote
;
21994 char * temp
= NULL
;
21995 size_t data_remaining
= end
- (char *) external
;
21997 if (!is_ia64_vms (filedata
))
21999 /* PR binutils/15191
22000 Make sure that there is enough data to read. */
22001 min_notesz
= offsetof (Elf_External_Note
, name
);
22002 if (data_remaining
< min_notesz
)
22004 warn (ngettext ("Corrupt note: only %zd byte remains, "
22005 "not enough for a full note\n",
22006 "Corrupt note: only %zd bytes remain, "
22007 "not enough for a full note\n",
22012 data_remaining
-= min_notesz
;
22014 inote
.type
= BYTE_GET (external
->type
);
22015 inote
.namesz
= BYTE_GET (external
->namesz
);
22016 inote
.namedata
= external
->name
;
22017 inote
.descsz
= BYTE_GET (external
->descsz
);
22018 inote
.descdata
= ((char *) external
22019 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
22020 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22021 next
= ((char *) external
22022 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
22026 Elf64_External_VMS_Note
*vms_external
;
22028 /* PR binutils/15191
22029 Make sure that there is enough data to read. */
22030 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
22031 if (data_remaining
< min_notesz
)
22033 warn (ngettext ("Corrupt note: only %zd byte remains, "
22034 "not enough for a full note\n",
22035 "Corrupt note: only %zd bytes remain, "
22036 "not enough for a full note\n",
22041 data_remaining
-= min_notesz
;
22043 vms_external
= (Elf64_External_VMS_Note
*) external
;
22044 inote
.type
= BYTE_GET (vms_external
->type
);
22045 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
22046 inote
.namedata
= vms_external
->name
;
22047 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
22048 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
22049 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22050 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
22053 /* PR 17531: file: 3443835e. */
22054 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
22055 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
22056 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
22057 || (size_t) (next
- inote
.descdata
) < inote
.descsz
22058 || ((size_t) (next
- inote
.descdata
)
22059 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
22061 warn (_("note with invalid namesz and/or descsz found at offset %#tx\n"),
22062 (char *) external
- (char *) pnotes
);
22063 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx, alignment: %u\n"),
22064 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
22068 external
= (Elf_External_Note
*) next
;
22070 /* Verify that name is null terminated. It appears that at least
22071 one version of Linux (RedHat 6.0) generates corefiles that don't
22072 comply with the ELF spec by failing to include the null byte in
22074 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
22076 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
22078 temp
= (char *) malloc (inote
.namesz
+ 1);
22081 error (_("Out of memory allocating space for inote name\n"));
22086 memcpy (temp
, inote
.namedata
, inote
.namesz
);
22087 inote
.namedata
= temp
;
22089 inote
.namedata
[inote
.namesz
] = 0;
22092 if (! process_note (& inote
, filedata
))
22105 process_corefile_note_segments (Filedata
* filedata
)
22107 Elf_Internal_Phdr
*segment
;
22111 if (! get_program_headers (filedata
))
22114 for (i
= 0, segment
= filedata
->program_headers
;
22115 i
< filedata
->file_header
.e_phnum
;
22118 if (segment
->p_type
== PT_NOTE
)
22119 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
22120 segment
->p_filesz
, segment
->p_align
))
22128 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
22130 Elf_External_Note
* pnotes
;
22131 Elf_External_Note
* external
;
22138 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22140 if (pnotes
== NULL
)
22144 end
= (char*) pnotes
+ length
;
22146 printf (_("\nDisplaying contents of Renesas V850 notes section at offset"
22147 " %#" PRIx64
" with length %#" PRIx64
":\n"),
22150 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
22152 Elf_External_Note
* next
;
22153 Elf_Internal_Note inote
;
22155 inote
.type
= BYTE_GET (external
->type
);
22156 inote
.namesz
= BYTE_GET (external
->namesz
);
22157 inote
.namedata
= external
->name
;
22158 inote
.descsz
= BYTE_GET (external
->descsz
);
22159 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
22160 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22162 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
22164 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
22165 inote
.descdata
= inote
.namedata
;
22169 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
22171 if ( ((char *) next
> end
)
22172 || ((char *) next
< (char *) pnotes
))
22174 warn (_("corrupt descsz found in note at offset %#tx\n"),
22175 (char *) external
- (char *) pnotes
);
22176 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22177 inote
.type
, inote
.namesz
, inote
.descsz
);
22183 /* Prevent out-of-bounds indexing. */
22184 if ( inote
.namedata
+ inote
.namesz
> end
22185 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
22187 warn (_("corrupt namesz found in note at offset %#zx\n"),
22188 (char *) external
- (char *) pnotes
);
22189 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22190 inote
.type
, inote
.namesz
, inote
.descsz
);
22194 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
22196 if (! print_v850_note (& inote
))
22199 printf ("<corrupt sizes: namesz: %#lx, descsz: %#lx>\n",
22200 inote
.namesz
, inote
.descsz
);
22210 process_note_sections (Filedata
* filedata
)
22212 Elf_Internal_Shdr
*section
;
22214 unsigned int n
= 0;
22217 for (i
= 0, section
= filedata
->section_headers
;
22218 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
22221 if (section
->sh_type
== SHT_NOTE
)
22223 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
22224 section
->sh_size
, section
->sh_addralign
))
22229 if (( filedata
->file_header
.e_machine
== EM_V800
22230 || filedata
->file_header
.e_machine
== EM_V850
22231 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
22232 && section
->sh_type
== SHT_RENESAS_INFO
)
22234 if (! process_v850_notes (filedata
, section
->sh_offset
,
22242 /* Try processing NOTE segments instead. */
22243 return process_corefile_note_segments (filedata
);
22249 process_notes (Filedata
* filedata
)
22251 /* If we have not been asked to display the notes then do nothing. */
22255 if (filedata
->file_header
.e_type
!= ET_CORE
)
22256 return process_note_sections (filedata
);
22258 /* No program headers means no NOTE segment. */
22259 if (filedata
->file_header
.e_phnum
> 0)
22260 return process_corefile_note_segments (filedata
);
22262 if (filedata
->is_separate
)
22263 printf (_("No notes found in linked file '%s'.\n"),
22264 filedata
->file_name
);
22266 printf (_("No notes found file.\n"));
22271 static unsigned char *
22272 display_public_gnu_attributes (unsigned char * start
,
22273 const unsigned char * const end
)
22275 printf (_(" Unknown GNU attribute: %s\n"), start
);
22277 start
+= strnlen ((char *) start
, end
- start
);
22278 display_raw_attribute (start
, end
);
22280 return (unsigned char *) end
;
22283 static unsigned char *
22284 display_generic_attribute (unsigned char * start
,
22286 const unsigned char * const end
)
22289 return (unsigned char *) end
;
22291 return display_tag_value (tag
, start
, end
);
22295 process_arch_specific (Filedata
* filedata
)
22300 switch (filedata
->file_header
.e_machine
)
22303 case EM_ARC_COMPACT
:
22304 case EM_ARC_COMPACT2
:
22305 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
22306 display_arc_attribute
,
22307 display_generic_attribute
);
22309 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
22310 display_arm_attribute
,
22311 display_generic_attribute
);
22314 case EM_MIPS_RS3_LE
:
22315 return process_mips_specific (filedata
);
22318 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
22319 display_msp430_attribute
,
22320 display_msp430_gnu_attribute
);
22323 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
22324 display_riscv_attribute
,
22325 display_generic_attribute
);
22328 return process_nds32_specific (filedata
);
22331 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22332 display_m68k_gnu_attribute
);
22336 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22337 display_power_gnu_attribute
);
22341 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22342 display_s390_gnu_attribute
);
22345 case EM_SPARC32PLUS
:
22347 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22348 display_sparc_gnu_attribute
);
22351 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
22352 display_tic6x_attribute
,
22353 display_generic_attribute
);
22356 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
22357 display_csky_attribute
, NULL
);
22360 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
22361 display_public_gnu_attributes
,
22362 display_generic_attribute
);
22367 get_file_header (Filedata
* filedata
)
22369 /* Read in the identity array. */
22370 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
22373 /* Determine how to read the rest of the header. */
22374 switch (filedata
->file_header
.e_ident
[EI_DATA
])
22379 byte_get
= byte_get_little_endian
;
22380 byte_put
= byte_put_little_endian
;
22383 byte_get
= byte_get_big_endian
;
22384 byte_put
= byte_put_big_endian
;
22388 /* For now we only support 32 bit and 64 bit ELF files. */
22389 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
22391 /* Read in the rest of the header. */
22394 Elf32_External_Ehdr ehdr32
;
22396 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22399 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
22400 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
22401 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
22402 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
22403 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
22404 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
22405 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
22406 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
22407 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
22408 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
22409 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
22410 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
22411 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
22415 Elf64_External_Ehdr ehdr64
;
22417 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22420 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
22421 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
22422 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
22423 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
22424 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
22425 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
22426 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
22427 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
22428 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
22429 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
22430 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
22431 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
22432 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
22439 free_filedata (Filedata
*filedata
)
22441 free (filedata
->program_interpreter
);
22442 free (filedata
->program_headers
);
22443 free (filedata
->section_headers
);
22444 free (filedata
->string_table
);
22445 free (filedata
->dump
.dump_sects
);
22446 free (filedata
->dynamic_strings
);
22447 free (filedata
->dynamic_symbols
);
22448 free (filedata
->dynamic_syminfo
);
22449 free (filedata
->dynamic_section
);
22451 while (filedata
->symtab_shndx_list
!= NULL
)
22453 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
22454 free (filedata
->symtab_shndx_list
);
22455 filedata
->symtab_shndx_list
= next
;
22458 free (filedata
->section_headers_groups
);
22460 if (filedata
->section_groups
)
22463 struct group_list
* g
;
22464 struct group_list
* next
;
22466 for (i
= 0; i
< filedata
->group_count
; i
++)
22468 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
22475 free (filedata
->section_groups
);
22477 memset (&filedata
->section_headers
, 0,
22478 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
22482 close_file (Filedata
* filedata
)
22486 if (filedata
->handle
)
22487 fclose (filedata
->handle
);
22493 close_debug_file (void * data
)
22495 free_filedata ((Filedata
*) data
);
22496 close_file ((Filedata
*) data
);
22500 open_file (const char * pathname
, bool is_separate
)
22502 struct stat statbuf
;
22503 Filedata
* filedata
= NULL
;
22505 if (stat (pathname
, & statbuf
) < 0
22506 || ! S_ISREG (statbuf
.st_mode
))
22509 filedata
= calloc (1, sizeof * filedata
);
22510 if (filedata
== NULL
)
22513 filedata
->handle
= fopen (pathname
, "rb");
22514 if (filedata
->handle
== NULL
)
22517 filedata
->file_size
= statbuf
.st_size
;
22518 filedata
->file_name
= pathname
;
22519 filedata
->is_separate
= is_separate
;
22521 if (! get_file_header (filedata
))
22524 if (!get_section_headers (filedata
, false))
22532 if (filedata
->handle
)
22533 fclose (filedata
->handle
);
22540 open_debug_file (const char * pathname
)
22542 return open_file (pathname
, true);
22546 initialise_dump_sects (Filedata
* filedata
)
22548 /* Initialise the dump_sects array from the cmdline_dump_sects array.
22549 Note we do this even if cmdline_dump_sects is empty because we
22550 must make sure that the dump_sets array is zeroed out before each
22551 object file is processed. */
22552 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
22553 memset (filedata
->dump
.dump_sects
, 0,
22554 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22556 if (cmdline
.num_dump_sects
> 0)
22558 if (filedata
->dump
.num_dump_sects
== 0)
22559 /* A sneaky way of allocating the dump_sects array. */
22560 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
22562 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
22563 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
22564 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22569 might_need_separate_debug_info (Filedata
* filedata
)
22571 /* Debuginfo files do not need further separate file loading. */
22572 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
22575 /* Since do_follow_links might be enabled by default, only treat it as an
22576 indication that separate files should be loaded if setting it was a
22577 deliberate user action. */
22578 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
22581 if (process_links
|| do_syms
|| do_unwind
22582 || dump_any_debugging
|| do_dump
|| do_debugging
)
22588 /* Process one ELF object file according to the command line options.
22589 This file may actually be stored in an archive. The file is
22590 positioned at the start of the ELF object. Returns TRUE if no
22591 problems were encountered, FALSE otherwise. */
22594 process_object (Filedata
* filedata
)
22596 bool have_separate_files
;
22600 if (! get_file_header (filedata
))
22602 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
22606 /* Initialise per file variables. */
22607 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
22608 filedata
->version_info
[i
] = 0;
22610 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
22611 filedata
->dynamic_info
[i
] = 0;
22612 filedata
->dynamic_info_DT_GNU_HASH
= 0;
22613 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
22615 /* Process the file. */
22617 printf (_("\nFile: %s\n"), filedata
->file_name
);
22619 initialise_dump_sects (filedata
);
22621 /* There may be some extensions in the first section header. Don't
22622 bomb if we can't read it. */
22623 get_section_headers (filedata
, true);
22625 if (! process_file_header (filedata
))
22631 /* Throw away the single section header read above, so that we
22632 re-read the entire set. */
22633 free (filedata
->section_headers
);
22634 filedata
->section_headers
= NULL
;
22636 if (! process_section_headers (filedata
))
22638 /* Without loaded section headers we cannot process lots of things. */
22639 do_unwind
= do_version
= do_dump
= do_arch
= false;
22641 if (! do_using_dynamic
)
22642 do_syms
= do_dyn_syms
= do_reloc
= false;
22645 if (! process_section_groups (filedata
))
22646 /* Without loaded section groups we cannot process unwind. */
22649 process_program_headers (filedata
);
22651 res
= process_dynamic_section (filedata
);
22653 if (! process_relocs (filedata
))
22656 if (! process_unwind (filedata
))
22659 if (! process_symbol_table (filedata
))
22662 if (! process_lto_symbol_tables (filedata
))
22665 if (! process_syminfo (filedata
))
22668 if (! process_version_sections (filedata
))
22671 if (might_need_separate_debug_info (filedata
))
22672 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
22674 have_separate_files
= false;
22676 if (! process_section_contents (filedata
))
22679 if (have_separate_files
)
22683 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
22685 initialise_dump_sects (d
->handle
);
22687 if (process_links
&& ! process_file_header (d
->handle
))
22689 else if (! process_section_headers (d
->handle
))
22691 else if (! process_section_contents (d
->handle
))
22693 else if (process_links
)
22695 if (! process_section_groups (d
->handle
))
22697 process_program_headers (d
->handle
);
22698 if (! process_dynamic_section (d
->handle
))
22700 if (! process_relocs (d
->handle
))
22702 if (! process_unwind (d
->handle
))
22704 if (! process_symbol_table (d
->handle
))
22706 if (! process_lto_symbol_tables (d
->handle
))
22708 if (! process_syminfo (d
->handle
))
22710 if (! process_version_sections (d
->handle
))
22712 if (! process_notes (d
->handle
))
22717 /* The file handles are closed by the call to free_debug_memory() below. */
22720 if (! process_notes (filedata
))
22723 if (! process_gnu_liblist (filedata
))
22726 if (! process_arch_specific (filedata
))
22730 free_filedata (filedata
);
22732 free_debug_memory ();
22737 /* Process an ELF archive.
22738 On entry the file is positioned just after the ARMAG string.
22739 Returns TRUE upon success, FALSE otherwise. */
22742 process_archive (Filedata
* filedata
, bool is_thin_archive
)
22744 struct archive_info arch
;
22745 struct archive_info nested_arch
;
22751 /* The ARCH structure is used to hold information about this archive. */
22752 arch
.file_name
= NULL
;
22754 arch
.index_array
= NULL
;
22755 arch
.sym_table
= NULL
;
22756 arch
.longnames
= NULL
;
22758 /* The NESTED_ARCH structure is used as a single-item cache of information
22759 about a nested archive (when members of a thin archive reside within
22760 another regular archive file). */
22761 nested_arch
.file_name
= NULL
;
22762 nested_arch
.file
= NULL
;
22763 nested_arch
.index_array
= NULL
;
22764 nested_arch
.sym_table
= NULL
;
22765 nested_arch
.longnames
= NULL
;
22767 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
22768 filedata
->file_size
, is_thin_archive
,
22769 do_archive_index
) != 0)
22775 if (do_archive_index
)
22777 if (arch
.sym_table
== NULL
)
22778 error (_("%s: unable to dump the index as none was found\n"),
22779 filedata
->file_name
);
22783 uint64_t current_pos
;
22785 printf (_("Index of archive %s: (%" PRIu64
" entries,"
22786 " %#" PRIx64
" bytes in the symbol table)\n"),
22787 filedata
->file_name
, arch
.index_num
,
22790 current_pos
= ftell (filedata
->handle
);
22792 for (i
= l
= 0; i
< arch
.index_num
; i
++)
22795 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
22798 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
22801 if (member_name
!= NULL
)
22803 char * qualified_name
22804 = make_qualified_name (&arch
, &nested_arch
,
22807 if (qualified_name
!= NULL
)
22809 printf (_("Contents of binary %s at offset "),
22811 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
22813 free (qualified_name
);
22815 free (member_name
);
22819 if (l
>= arch
.sym_size
)
22821 error (_("%s: end of the symbol table reached "
22822 "before the end of the index\n"),
22823 filedata
->file_name
);
22827 /* PR 17531: file: 0b6630b2. */
22828 printf ("\t%.*s\n",
22829 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
22830 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
22833 if (arch
.uses_64bit_indices
)
22838 if (l
< arch
.sym_size
)
22840 error (ngettext ("%s: %" PRId64
" byte remains in the symbol table, "
22841 "but without corresponding entries in "
22842 "the index table\n",
22843 "%s: %" PRId64
" bytes remain in the symbol table, "
22844 "but without corresponding entries in "
22845 "the index table\n",
22846 arch
.sym_size
- l
),
22847 filedata
->file_name
, arch
.sym_size
- l
);
22851 if (fseek64 (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
22853 error (_("%s: failed to seek back to start of object files "
22854 "in the archive\n"),
22855 filedata
->file_name
);
22861 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
22862 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
22863 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
22864 && !do_section_groups
&& !do_dyn_syms
)
22866 ret
= true; /* Archive index only. */
22875 char * qualified_name
;
22877 /* Read the next archive header. */
22878 if (fseek64 (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
22880 error (_("%s: failed to seek to next archive header\n"),
22885 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
22886 if (got
!= sizeof arch
.arhdr
)
22890 /* PR 24049 - we cannot use filedata->file_name as this will
22891 have already been freed. */
22892 error (_("%s: failed to read archive header\n"), arch
.file_name
);
22897 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
22899 error (_("%s: did not find a valid archive header\n"),
22905 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
22907 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
22909 name
= get_archive_member_name (&arch
, &nested_arch
);
22912 error (_("%s: bad archive file name\n"), arch
.file_name
);
22916 namelen
= strlen (name
);
22918 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
22919 if (qualified_name
== NULL
)
22921 error (_("%s: bad archive file name\n"), arch
.file_name
);
22927 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
22929 /* This is a proxy for an external member of a thin archive. */
22930 Filedata
* member_filedata
;
22931 char * member_file_name
= adjust_relative_path
22932 (filedata
->file_name
, name
, namelen
);
22935 if (member_file_name
== NULL
)
22937 free (qualified_name
);
22942 member_filedata
= open_file (member_file_name
, false);
22943 if (member_filedata
== NULL
)
22945 error (_("Input file '%s' is not readable.\n"), member_file_name
);
22946 free (member_file_name
);
22947 free (qualified_name
);
22952 filedata
->archive_file_offset
= arch
.nested_member_origin
;
22953 member_filedata
->file_name
= qualified_name
;
22955 /* The call to process_object() expects the file to be at the beginning. */
22956 rewind (member_filedata
->handle
);
22958 if (! process_object (member_filedata
))
22961 close_file (member_filedata
);
22962 free (member_file_name
);
22964 else if (is_thin_archive
)
22966 Filedata thin_filedata
;
22968 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
22970 /* PR 15140: Allow for corrupt thin archives. */
22971 if (nested_arch
.file
== NULL
)
22973 error (_("%s: contains corrupt thin archive: %s\n"),
22974 qualified_name
, name
);
22975 free (qualified_name
);
22982 /* This is a proxy for a member of a nested archive. */
22983 filedata
->archive_file_offset
22984 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
22986 /* The nested archive file will have been opened and setup by
22987 get_archive_member_name. */
22988 if (fseek64 (nested_arch
.file
, filedata
->archive_file_offset
,
22991 error (_("%s: failed to seek to archive member.\n"),
22992 nested_arch
.file_name
);
22993 free (qualified_name
);
22998 thin_filedata
.handle
= nested_arch
.file
;
22999 thin_filedata
.file_name
= qualified_name
;
23001 if (! process_object (& thin_filedata
))
23007 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
23008 filedata
->file_name
= qualified_name
;
23009 if (! process_object (filedata
))
23011 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
23012 /* Stop looping with "negative" archive_file_size. */
23013 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
23014 arch
.next_arhdr_offset
= -1ul;
23017 free (qualified_name
);
23021 if (nested_arch
.file
!= NULL
)
23022 fclose (nested_arch
.file
);
23023 release_archive (&nested_arch
);
23024 release_archive (&arch
);
23030 process_file (char * file_name
)
23032 Filedata
* filedata
= NULL
;
23033 struct stat statbuf
;
23034 char armag
[SARMAG
];
23037 if (stat (file_name
, &statbuf
) < 0)
23039 if (errno
== ENOENT
)
23040 error (_("'%s': No such file\n"), file_name
);
23042 error (_("Could not locate '%s'. System error message: %s\n"),
23043 file_name
, strerror (errno
));
23047 if (! S_ISREG (statbuf
.st_mode
))
23049 error (_("'%s' is not an ordinary file\n"), file_name
);
23053 filedata
= calloc (1, sizeof * filedata
);
23054 if (filedata
== NULL
)
23056 error (_("Out of memory allocating file data structure\n"));
23060 filedata
->file_name
= file_name
;
23061 filedata
->handle
= fopen (file_name
, "rb");
23062 if (filedata
->handle
== NULL
)
23064 error (_("Input file '%s' is not readable.\n"), file_name
);
23069 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
23071 error (_("%s: Failed to read file's magic number\n"), file_name
);
23072 fclose (filedata
->handle
);
23077 filedata
->file_size
= statbuf
.st_size
;
23078 filedata
->is_separate
= false;
23080 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
23082 if (! process_archive (filedata
, false))
23085 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
23087 if ( ! process_archive (filedata
, true))
23092 if (do_archive_index
&& !check_all
)
23093 error (_("File %s is not an archive so its index cannot be displayed.\n"),
23096 rewind (filedata
->handle
);
23097 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
23099 if (! process_object (filedata
))
23103 fclose (filedata
->handle
);
23104 free (filedata
->section_headers
);
23105 free (filedata
->program_headers
);
23106 free (filedata
->string_table
);
23107 free (filedata
->dump
.dump_sects
);
23110 free (ba_cache
.strtab
);
23111 ba_cache
.strtab
= NULL
;
23112 free (ba_cache
.symtab
);
23113 ba_cache
.symtab
= NULL
;
23114 ba_cache
.filedata
= NULL
;
23119 #ifdef SUPPORT_DISASSEMBLY
23120 /* Needed by the i386 disassembler. For extra credit, someone could
23121 fix this so that we insert symbolic addresses here, esp for GOT/PLT
23125 print_address (unsigned int addr
, FILE * outfile
)
23127 fprintf (outfile
,"0x%8.8x", addr
);
23130 /* Needed by the i386 disassembler. */
23133 db_task_printsym (unsigned int addr
)
23135 print_address (addr
, stderr
);
23140 main (int argc
, char ** argv
)
23144 #ifdef HAVE_LC_MESSAGES
23145 setlocale (LC_MESSAGES
, "");
23147 setlocale (LC_CTYPE
, "");
23148 bindtextdomain (PACKAGE
, LOCALEDIR
);
23149 textdomain (PACKAGE
);
23151 expandargv (&argc
, &argv
);
23153 parse_args (& cmdline
, argc
, argv
);
23155 if (optind
< (argc
- 1))
23156 /* When displaying information for more than one file,
23157 prefix the information with the file name. */
23159 else if (optind
>= argc
)
23161 /* Ensure that the warning is always displayed. */
23164 warn (_("Nothing to do.\n"));
23169 while (optind
< argc
)
23170 if (! process_file (argv
[optind
++]))
23173 free (cmdline
.dump_sects
);
23175 free (dump_ctf_symtab_name
);
23176 free (dump_ctf_strtab_name
);
23177 free (dump_ctf_parent_name
);
23179 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;